Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

5.1 KB
Raw Blame
import { html, nothing, type TemplateResult } from "lit";
import { Directive, directive } from "lit/directive.js";
import { repeat } from "lit/directives/repeat.js";
import { X } from "lucide";
import { icon } from "./icons";
import type { SuggestedActivity } from "../../chassis/src/suggested-activities.ts";

const icons: Record<string, string> = {
  schedule: "⏰",
  app: "πŸ› οΈ",
  deck: "πŸ“Š",
  people: "πŸ‘₯",
  calendar: "πŸ“…",
  book: "πŸ“š",
};

const VISIBLE_COUNT = 3;
const MOTION_MS = 220;

type Motion = "" | "is-entering" | "is-leaving";

class SuggestionRows extends Directive {
  private shown: SuggestedActivity[] | null = null;
  private readonly leaving = new Map<string, { activity: SuggestedActivity; index: number }>();
  private readonly entering = new Set<string>();

  render(
    visible: SuggestedActivity[],
    row: (activity: SuggestedActivity, motion: Motion) => TemplateResult,
    redraw: () => void,
  ) {
    const ids = new Set(visible.map((activity) => activity.id));
    for (const id of this.leaving.keys()) if (ids.has(id)) this.leaving.delete(id);
    if (this.shown) {
      const previous = new Set(this.shown.map((activity) => activity.id));
      this.shown.forEach((activity, index) => {
        if (ids.has(activity.id) || this.leaving.has(activity.id)) return;
        this.entering.delete(activity.id);
        this.leaving.set(activity.id, { activity, index });
        setTimeout(() => {
          if (this.leaving.get(activity.id)?.activity !== activity) return;
          this.leaving.delete(activity.id);
          redraw();
        }, MOTION_MS);
      });
      for (const id of ids) {
        if (previous.has(id)) continue;
        this.entering.add(id);
        setTimeout(() => this.entering.delete(id), MOTION_MS);
      }
    }
    this.shown = visible;
    const rows = [...visible];
    for (const { activity, index } of [...this.leaving.values()].sort((a, b) => a.index - b.index)) {
      rows.splice(Math.min(index, rows.length), 0, activity);
    }
    return repeat(
      rows,
      (activity) => activity.id,
      (activity) => row(activity, this.motion(activity.id)),
    );
  }

  private motion(id: string): Motion {
    if (this.leaving.has(id)) return "is-leaving";
    return this.entering.has(id) ? "is-entering" : "";
  }
}

const suggestionRows = directive(SuggestionRows);

function dismiss(event: Event, activity: SuggestedActivity, onDismiss: (activity: SuggestedActivity) => void) {
  const button = event.currentTarget as HTMLElement;
  const row = button.closest(".suggested-activity-row");
  const list = row?.parentElement;
  const hadFocus = document.activeElement === button;
  onDismiss(activity);
  if (!hadFocus || !list) return;
  const rows = [...list.querySelectorAll(".suggested-activity-row:not(.is-leaving)")];
  const next =
    rows.find((candidate) => row.compareDocumentPosition(candidate) & Node.DOCUMENT_POSITION_FOLLOWING) ?? rows.at(-1);
  next?.querySelector<HTMLElement>(".suggested-activity-dismiss")?.focus();
}

export function suggestedActivities(
  activities: SuggestedActivity[] | undefined,
  {
    onSelect,
    onDismiss,
    redraw,
    collapsed = false,
  }: {
    onSelect: (activity: SuggestedActivity) => void;
    onDismiss?: (activity: SuggestedActivity) => void;
    redraw: () => void;
    collapsed?: boolean;
  },
): TemplateResult | typeof nothing {
  if (!activities || (!activities.length && !onDismiss)) return nothing;
  const empty = !activities.length;
  return html`<section
    class="suggested-activities ${collapsed ? "is-collapsed" : ""} ${empty ? "is-empty" : ""}"
    aria-label="Suggested activities"
    aria-hidden=${collapsed || empty ? "true" : "false"}
    ?inert=${collapsed}
  >
    <div class="suggested-activities-list">
      ${suggestionRows(
        activities.slice(0, VISIBLE_COUNT),
        (activity, motion) =>
          html`<div class="suggested-activity-row ${motion}" ?inert=${motion === "is-leaving"}>
            <div class="suggested-activity-row-inner">
              <button
                type="button"
                class="suggested-activity"
                ?disabled=${collapsed}
                @click=${() => onSelect(activity)}
              >
                <span class="suggested-activity-icon" data-icon=${activity.icon} aria-hidden="true"
                  >${activity.icon === "yc" ? html`<span class="suggested-activity-yc">Y</span>` : (icons[activity.icon] ?? activity.icon)}</span
                >
                <span class="suggested-activity-title">${activity.title}</span>
              </button>
              ${
                onDismiss
                  ? html`<button
                      type="button"
                      class="suggested-activity-dismiss"
                      aria-label="Dismiss suggestion: ${activity.title}"
                      title="Dismiss"
                      ?disabled=${collapsed}
                      @click=${(event: Event) => dismiss(event, activity, onDismiss)}
                    >
                      ${icon(X, 14)}
                    </button>`
                  : nothing
              }
            </div>
          </div>`,
        redraw,
      )}
    </div>
  </section>`;
}