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.9 KB
Raw Blame
import { toast } from '@core/component/Toast/Toast';
import { useUserId } from '@core/context/user';
import { useDateSearch } from '@core/util/dateSearch/useDateSearch';
import { fireAndForget } from '@core/util/fireAndForget';
import { Telemetry } from '@macro-inc/observability';
import { useBulkNotificationPreferencesMutation } from '@queries/notification/unsubscribes';
import type { UserUnsubscribe } from '@service-notification/generated/schemas/userUnsubscribe';
import {
  type ManagedDialogProps,
  type OpenDialogOptions,
  openDialog,
} from '@ui';
import { createSignal } from 'solid-js';
import { SnoozePicker } from './components/SnoozePicker';
import {
  formatSnoozeDeadline,
  type SnoozeOption,
  snoozePresets,
} from './core/snooze';
import { createSnoozeController } from './primitives/create-snooze-controller';

function SnoozeNotificationsDialog(
  props: ManagedDialogProps & { items: UserUnsubscribe[] }
) {
  const userId = useUserId();
  const actorId = userId();
  const mutation = useBulkNotificationPreferencesMutation();
  const [query, setQuery] = createSignal('');
  const dates = useDateSearch({ query, defaultTime: { hours: 9, minutes: 0 } });
  const options = (): SnoozeOption[] => {
    const presets = snoozePresets(new Date());
    const search = query().trim().toLowerCase();
    if (!search) return presets;
    const matches = presets.filter(
      (preset) =>
        preset.label.toLowerCase().includes(search) ||
        preset.id.includes(search)
    );
    const parsed = dates()
      .filter((date) => date.date.getTime() > Date.now())
      .map((date) => ({
        id: date.id,
        label: date.displayText,
        until: date.date,
      }));
    const seen = new Set<number>();
    return [...matches, ...parsed].filter((option) => {
      const time = option.until.getTime();
      if (seen.has(time)) return false;
      seen.add(time);
      return true;
    });
  };
  const controller = createSnoozeController({
    items: props.items,
    saveItems: async (items, until) => {
      if (!actorId || actorId !== userId()) {
        return [...items];
      }
      const result = await mutation.mutateAsync({
        actorId,
        items,
        muted: true,
        snoozedUntil: until,
      });
      return result.failed;
    },
    onSaved: (until, count) => {
      if (actorId !== userId()) return;
      props.onOpenChange(false);
      toast.success(
        `Snoozed ${count} ${count === 1 ? 'item' : 'items'} until ${formatSnoozeDeadline(until)}`
      );
    },
  });

  const submit = (until: Date) =>
    Telemetry.span('notifications.snooze', async (span) => {
      span.setAttr(
        'notification.item_ids',
        props.items.map((item) => item.item_id)
      );
      span.setAttr('notification.count', controller.remainingCount());

      await controller.submit(until);

      const error = controller.error();

      if (error) {
        span.error(error);
      } else {
        span.setAttr('notification.snoozed_until', until.toISOString());
      }
    });

  return (
    <SnoozePicker
      {...props}
      count={controller.remainingCount()}
      query={query()}
      onQueryChange={setQuery}
      options={options()}
      pending={controller.pending()}
      error={controller.error()}
      onSelect={(until) => fireAndForget(submit(until), 'notifications')}
    />
  );
}

/** Shared entry point for entity commands, context menus, and notification settings. */
export function openSnoozeNotifications(
  items: UserUnsubscribe[],
  options?: OpenDialogOptions
) {
  const unique = [
    ...new Map(
      items.map((item) => [`${item.item_type}:${item.item_id}`, item])
    ).values(),
  ];
  // Context menus use the app host's lifetime; persistent hosts can supply
  // their owner so mobile drawers inherit the parent's dismissal layer.
  if (unique.length)
    openDialog(SnoozeNotificationsDialog, { items: unique }, options);
}