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.

14.1 KB
Raw Blame
import {
  FullCalendar,
  type FullCalendarContextValue,
  useFullCalendar,
} from '@app/lib/fullcalendar-solid';
import type {
  DateSelectArg,
  DatesSetArg,
  EventInput,
} from '@fullcalendar/core';
import dayGridPlugin from '@fullcalendar/daygrid';
import interactionPlugin from '@fullcalendar/interaction';
import timeGridPlugin from '@fullcalendar/timegrid';
import {
  type Accessor,
  createEffect,
  createMemo,
  createSignal,
  type JSX,
  Show,
  untrack,
} from 'solid-js';
import { useTimeGridOpeningScroll } from '../hooks/use-time-grid-opening-scroll';
import {
  type CalendarEvent,
  type CalendarPeriodView,
  type CalendarTimeFormat,
  type CalendarWeekStart,
  mapCalendarEventToFullCalendar,
} from '../types';
import { isSameLocalDate } from '../utils/calendar-date';
import {
  type CalendarEventTimeChange,
  calendarEventRenderId,
  calendarEventRenderIds,
} from '../utils/event-interaction';
import {
  isMultiDaySelectionPreview,
  multiDaySelectionRenderingPlugin,
} from '../utils/fullcalendar-multi-day-selection';
import {
  CALENDAR_TIME_FORMAT_OPTIONS,
  formatCalendarTime,
  formatCompactCalendarTime,
} from '../utils/time-format';
import { TIME_GRID_OPENING_SCROLL_TIME } from '../utils/time-grid-scroller';
import { mergeWorkingLocationEvents } from '../utils/working-location-events';
import { EventContent } from './EventContent';
import '../calendar.css';

const formatWeekdayHeader = {
  narrow: new Intl.DateTimeFormat(undefined, {
    weekday: 'narrow',
  }).format,
  short: new Intl.DateTimeFormat(undefined, {
    weekday: 'short',
  }).format,
};

const formatDayNumber = new Intl.DateTimeFormat(undefined, {
  day: 'numeric',
}).format;

function CurrentTimeAxisIndicator(props: {
  date: Date;
  timeFormat: CalendarTimeFormat;
}) {
  return (
    <span class="calendar-now-axis-indicator">
      <span class="calendar-now-time">
        {formatCalendarTime(props.date, props.timeFormat)}
      </span>
    </span>
  );
}

export interface CalendarGridHandle extends FullCalendarContextValue {
  element: Accessor<HTMLDivElement | undefined>;
  eventElements: Map<string, HTMLElement>;
  chipMounts: Accessor<undefined>;
}

export interface CalendarGridSettings {
  initialView: CalendarPeriodView;
  /** Consecutive visible days for time-grid embeds. */
  dayCount?: number;
  showDayHeaders?: boolean;
  showAllDaySlot?: boolean;
  showWeekends: boolean;
  weekStartsOn: CalendarWeekStart;
  timeFormat: CalendarTimeFormat;
  useNarrowDayHeaders: boolean;
  useNarrowEventContent: boolean;
}

export interface CalendarGridSelection {
  color: string;
  eventId?: string;
  onDateSelect?: (selection: DateSelectArg) => void;
  onEventSelect?: (event: CalendarEvent, element: HTMLElement) => void;
  /** The selected event's chip mounted, replacing the element it had. */
  onSelectedEventMount?: (event: CalendarEvent, element: HTMLElement) => void;
}

export interface CalendarGridProps {
  initialDate: Date;
  events: CalendarEvent[];
  eventsById: Map<string, CalendarEvent>;
  settings: CalendarGridSettings;
  selection: CalendarGridSelection;
  /** Rendered occurrence ids that should visually stand out from nearby events. */
  emphasizedEventIds?: ReadonlySet<string>;
  eventTimeChangePending?: boolean;
  onDatesSet?: (info: DatesSetArg) => void;
  onEventTimeChange?: (
    change: CalendarEventTimeChange,
    event: CalendarEvent | undefined
  ) => void;
  children?: (handle: CalendarGridHandle) => JSX.Element;
}

function CalendarGridHost(props: {
  selectionColor: string;
  eventElements: Map<string, HTMLElement>;
  chipMounts: Accessor<undefined>;
  children?: CalendarGridProps['children'];
}) {
  const calendar = useFullCalendar();
  const [element, setElement] = createSignal<HTMLDivElement>();

  useTimeGridOpeningScroll(element, calendar.api);

  const handle: CalendarGridHandle = {
    api: calendar.api,
    dateInfo: calendar.dateInfo,
    element,
    eventElements: props.eventElements,
    chipMounts: props.chipMounts,
  };

  return (
    <>
      <div class="calendar-view size-full min-w-0 min-h-0 overflow-hidden">
        <FullCalendar.Host
          tabIndex={-1}
          ref={setElement}
          style={{ '--calendar-selection-color': props.selectionColor }}
          class="calendar-view-host size-full min-w-0 min-h-0 overflow-hidden"
        />
      </div>
      {props.children?.(handle)}
    </>
  );
}

/** Query-free, single-page calendar grid. */
export function CalendarGrid(props: CalendarGridProps) {
  // FullCalendar only consumes initialView on mount. Tracking route changes
  // here resets every page's options before the pager can schedule changeView.
  const initialView = untrack(() => props.settings.initialView);
  const mappedEvents = createMemo<EventInput[]>(() =>
    mergeWorkingLocationEvents(props.events).map(({ event, occurrenceIds }) => {
      const mapped = mapCalendarEventToFullCalendar(event);
      const emphasized = occurrenceIds.some((id) =>
        props.emphasizedEventIds?.has(id)
      );
      const classNames = [
        ...(emphasized ? ['calendar-event-emphasized'] : []),
        ...(event.eventType === 'out_of_office'
          ? ['calendar-event-out-of-office']
          : []),
      ];
      return {
        ...mapped,
        classNames: classNames.length > 0 ? classNames : undefined,
        startEditable: props.onEventTimeChange ? mapped.startEditable : false,
        durationEditable: props.onEventTimeChange
          ? mapped.durationEditable
          : false,
        extendedProps:
          occurrenceIds.length > 1
            ? { ...mapped.extendedProps, mergedOccurrenceIds: occurrenceIds }
            : mapped.extendedProps,
      };
    })
  );
  const [eventInteractionActive, setEventInteractionActive] =
    createSignal(false);
  const renderedEvents = createMemo<EventInput[]>(
    (current) => (eventInteractionActive() ? current : mappedEvents()),
    mappedEvents()
  );
  let interactionEventsById: Map<string, CalendarEvent> | undefined;

  const eventByRenderId = (id: string) =>
    interactionEventsById?.get(id) ?? props.eventsById.get(id);
  const handleEventInteractionStart = () => {
    interactionEventsById = props.eventsById;
    setEventInteractionActive(true);
  };
  const handleEventInteractionStop = () => {
    queueMicrotask(() => {
      interactionEventsById = undefined;
      setEventInteractionActive(false);
    });
  };

  const eventElements = new Map<string, HTMLElement>();
  const [chipMounts, notifyChipMount] = createSignal(undefined, {
    equals: false,
  });

  // A chip keeps its element across data changes, so a calendar color change
  // recolors it here rather than through a remount. The map is read before
  // the loop because the element map is empty on the first run and the
  // effect would otherwise never subscribe.
  createEffect(() => {
    const eventsById = props.eventsById;
    for (const [id, el] of eventElements) {
      const event = eventsById.get(id);
      if (event) {
        el.style.setProperty('--event-calendar-color', event.calendar.color);
      }
    }
  });

  return (
    <FullCalendar.Root
      plugins={[
        dayGridPlugin,
        interactionPlugin,
        timeGridPlugin,
        multiDaySelectionRenderingPlugin,
      ]}
      initialView={initialView}
      initialDate={props.initialDate}
      dayCount={props.settings.dayCount}
      dateIncrement={
        props.settings.dayCount === undefined
          ? undefined
          : { days: props.settings.dayCount }
      }
      dateAlignment={props.settings.dayCount === undefined ? undefined : 'day'}
      dayHeaders={props.settings.showDayHeaders ?? true}
      allDaySlot={props.settings.showAllDaySlot ?? true}
      height="100%"
      expandRows
      fixedWeekCount={false}
      handleWindowResize={false}
      allDayText="All day"
      nowIndicator
      headerToolbar={false}
      scrollTime={TIME_GRID_OPENING_SCROLL_TIME}
      scrollTimeReset={false}
      weekends={props.settings.showWeekends}
      firstDay={props.settings.weekStartsOn}
      slotLabelFormat={CALENDAR_TIME_FORMAT_OPTIONS[props.settings.timeFormat]}
      eventTimeFormat={CALENDAR_TIME_FORMAT_OPTIONS[props.settings.timeFormat]}
      events={renderedEvents()}
      eventAllow={() =>
        props.onEventTimeChange !== undefined &&
        props.eventTimeChangePending !== true
      }
      eventResizableFromStart
      eventDragStart={handleEventInteractionStart}
      eventDragStop={handleEventInteractionStop}
      eventDrop={(change) =>
        props.onEventTimeChange?.(
          change,
          eventByRenderId(calendarEventRenderId(change.event))
        )
      }
      eventResizeStart={handleEventInteractionStart}
      eventResizeStop={handleEventInteractionStop}
      eventResize={(change) =>
        props.onEventTimeChange?.(
          change,
          eventByRenderId(calendarEventRenderId(change.event))
        )
      }
      selectable={props.selection.onDateSelect !== undefined}
      unselectAuto={false}
      selectMirror
      // A zero-distance selection lets a click create one snapped time slot,
      // while pointer movement still supports selecting a longer range.
      selectMinDistance={0}
      snapDuration="00:30:00"
      select={(selection) => props.selection.onDateSelect?.(selection)}
      eventClick={
        props.selection.onEventSelect
          ? ({ el, event, jsEvent }) => {
              jsEvent.preventDefault();
              const selectedEvent = eventByRenderId(
                calendarEventRenderId(event)
              );
              if (selectedEvent)
                props.selection.onEventSelect?.(selectedEvent, el);
            }
          : undefined
      }
      eventDidMount={({ el, event, isMirror }) => {
        const eventId = calendarEventRenderId(event);
        const calendarEvent = eventByRenderId(eventId);
        if (calendarEvent) {
          el.style.setProperty(
            '--event-calendar-color',
            calendarEvent.calendar.color
          );
        }
        if (isMirror || isMultiDaySelectionPreview(event)) return;

        const occurrenceIds = calendarEventRenderIds(event);
        for (const id of occurrenceIds) eventElements.set(id, el);
        const selectedId = props.selection.eventId;
        if (selectedId !== undefined && occurrenceIds.includes(selectedId)) {
          const selected = eventByRenderId(selectedId);
          if (selected) props.selection.onSelectedEventMount?.(selected, el);
        }
        notifyChipMount();
      }}
      eventWillUnmount={({ el, event, isMirror }) => {
        if (isMirror || isMultiDaySelectionPreview(event)) return;

        for (const id of calendarEventRenderIds(event)) {
          if (eventElements.get(id) === el) {
            eventElements.delete(id);
          }
        }
      }}
      datesSet={(info) => props.onDatesSet?.(info)}
      dayHeaderFormat={{
        weekday: props.settings.useNarrowDayHeaders ? 'narrow' : 'short',
      }}
      dayCellClassNames={({ date, view }) =>
        isSameLocalDate(date, view.calendar.getDate())
          ? ['calendar-day-selected']
          : []
      }
    >
      <FullCalendar.DayHeaderContent>
        {({ date, text, view }) => {
          if (view.type === 'timeGridWeek' || view.type === 'timeGridDay') {
            const isSingleDayView =
              view.type === 'timeGridDay' &&
              (props.settings.dayCount ?? 1) === 1;
            const weekday = isSingleDayView
              ? formatWeekdayHeader.short(date)
              : formatWeekdayHeader[
                  props.settings.useNarrowDayHeaders ? 'narrow' : 'short'
                ](date);

            return (
              <>
                <span class="calendar-day-header-weekday">{weekday}</span>{' '}
                <span
                  class="calendar-day-header-date"
                  classList={{
                    'calendar-day-header-date-selected': isSameLocalDate(
                      date,
                      view.calendar.getDate()
                    ),
                  }}
                >
                  {formatDayNumber(date)}
                </span>
              </>
            );
          }
          return text;
        }}
      </FullCalendar.DayHeaderContent>

      <FullCalendar.SlotLabelContent>
        {({ date }) =>
          formatCompactCalendarTime(date, props.settings.timeFormat)
        }
      </FullCalendar.SlotLabelContent>

      <FullCalendar.EventContent>
        {(renderProps) => {
          const event = eventByRenderId(
            calendarEventRenderId(renderProps.event)
          );
          if (
            !event &&
            (isMultiDaySelectionPreview(renderProps.event) ||
              (renderProps.isMirror &&
                !renderProps.isDragging &&
                !renderProps.isResizing))
          ) {
            return (
              <div class="calendar-event-selection-preview flex h-full min-w-0 flex-col overflow-hidden px-1 py-0.5 text-xs leading-tight">
                <span class="truncate font-semibold">New event</span>
                <Show when={renderProps.timeText}>
                  <span class="truncate">{renderProps.timeText}</span>
                </Show>
              </div>
            );
          }
          if (!event) return null;

          const selectedId = props.selection.eventId;
          return (
            <EventContent
              event={event}
              renderProps={renderProps}
              isSelected={
                selectedId !== undefined &&
                calendarEventRenderIds(renderProps.event).includes(selectedId)
              }
              timeFormat={props.settings.timeFormat}
              isNarrow={props.settings.useNarrowEventContent}
            />
          );
        }}
      </FullCalendar.EventContent>

      <FullCalendar.NowIndicatorContent>
        {({ isAxis }) => {
          if (isAxis) return null;

          return (
            <CurrentTimeAxisIndicator
              date={new Date()}
              timeFormat={props.settings.timeFormat}
            />
          );
        }}
      </FullCalendar.NowIndicatorContent>

      <CalendarGridHost
        selectionColor={props.selection.color}
        eventElements={eventElements}
        chipMounts={chipMounts}
        children={props.children}
      />
    </FullCalendar.Root>
  );
}