Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

3.5 KB
Raw Blame
import { useUserId } from '@core/context/user';
import { fireAndForget } from '@core/util/fireAndForget';
import { calendarKeys } from '@queries/calendar/keys';
import {
  type CalendarOccurrenceQueryRange,
  createCalendarOccurrenceQueryRange,
  fetchCalendarOccurrences,
  useCalendarOccurrencesQuery,
} from '@queries/calendar/occurrences';
import { queryClient } from '@queries/client';
import { CalendarSyncStatus } from '@service-storage/generated/schemas/calendarSyncStatus';
import { queryOptions } from '@tanstack/solid-query';
import { createMemo, createSignal, onCleanup, onMount } from 'solid-js';
import {
  AVAILABILITY_RANGE_OPTIONS,
  type AvailabilityDay,
  type AvailabilityRangeKey,
  type AvailabilitySettings,
  busyIntervalsFromOccurrences,
  computeAvailability,
  resolveAvailabilityWindow,
} from './availability';

function currentOccurrencesQueryOptions(
  userId: string | undefined,
  range: CalendarOccurrenceQueryRange
) {
  return queryOptions({
    queryKey: calendarKeys.occurrences(userId ?? '', range).queryKey,
    queryFn: ({ signal }) => fetchCalendarOccurrences(range, signal),
    staleTime: 0,
  });
}

/** Evaluates every copy range against the same occurrence snapshot and settings. */
export function useAvailabilityRanges(settings: () => AvailabilitySettings) {
  const userId = useUserId();
  const [now, setNow] = createSignal(new Date());
  const query = useCalendarOccurrencesQuery(() => {
    const window = resolveAvailabilityWindow('next14Days', now());
    return {
      userId: userId(),
      range: createCalendarOccurrenceQueryRange(
        window.start,
        window.endExclusive
      ),
    };
  });

  // Keep the remaining portion of today current while the dialog is open.
  // The query key changes at local midnight to cover the new last day.
  onMount(() => {
    const timer = setInterval(() => setNow(new Date()), 60_000);
    onCleanup(() => clearInterval(timer));
  });

  const days = createMemo(() => {
    const data = query.isSuccess ? query.data : undefined;
    if (!data || data.syncStatus === CalendarSyncStatus.syncing) return;

    const busyIntervals = busyIntervalsFromOccurrences(data.items);
    const currentSettings = settings();
    const currentTime = now();
    return Object.fromEntries(
      AVAILABILITY_RANGE_OPTIONS.map(({ key }) => [
        key,
        computeAvailability({
          rangeKey: key,
          settings: currentSettings,
          busyIntervals,
          now: currentTime,
        }),
      ])
    ) as Record<AvailabilityRangeKey, AvailabilityDay[]>;
  });

  const refreshRange = async (rangeKey: AvailabilityRangeKey) => {
    const window = resolveAvailabilityWindow('next14Days', new Date());
    const range = createCalendarOccurrenceQueryRange(
      window.start,
      window.endExclusive
    );
    // A copy must use current occurrences, even when the initial query's
    // 60-second cache window has not expired yet.
    const data = await queryClient.fetchQuery(
      currentOccurrencesQueryOptions(userId(), range)
    );
    if (data.syncStatus === CalendarSyncStatus.syncing) return;

    const currentTime = new Date();
    return {
      days: computeAvailability({
        rangeKey,
        settings: settings(),
        busyIntervals: busyIntervalsFromOccurrences(data.items),
        now: currentTime,
      }),
      now: currentTime,
    };
  };
  return {
    days,
    refreshRange,
    isError: () => query.isError,
    retry: () => fireAndForget(query.refetch(), 'calendar-availability'),
  };
}