motion-ui-skill 2.0.0

package/components/motion/availability-scheduler/day-row.tsx

@@ -0,0 +1,231 @@
+"use client";
+
+import { Plus, X } from "lucide-react";
+import { AnimatePresence, motion } from "motion/react";
+import { useRef, useState } from "react";
+import { Switch } from "@/components/motion/switch";
+import { Tooltip } from "@/components/motion/tooltip";
+import { SPRING_LAYOUT } from "@/lib/ease";
+import { CopyMenu } from "./copy-menu";
+import { IconButton } from "./icon-button";
+import { TimeSelect } from "./time-select";
+import {
+  clampRange,
+  type DayAvailability,
+  type DayKey,
+  endOptions,
+  panelKey,
+  startOptions,
+  type TimeOption,
+  type TimeRange,
+  toMinutes,
+  toValue,
+} from "./types";
+
+export function DayRow({
+  day,
+  label,
+  state,
+  options,
+  reduce,
+  elevated,
+  openPanel,
+  onChange,
+  onCopy,
+  onPanelOpenChange,
+}: {
+  day: DayKey;
+  label: string;
+  state: DayAvailability;
+  options: TimeOption[];
+  reduce: boolean;
+  // True while this row holds the dropdown that opened last, which paints it
+  // above every other row. A time panel opens downward when there is room and
+  // upward when there isn't, so it has to clear the rows on either side of it
+  // — no fixed paint order can satisfy both directions. The flag stays on
+  // after the panel closes so the collapse animation stays on top too.
+  elevated: boolean;
+  /** Id of the one time panel the scheduler is holding open, if any. */
+  openPanel: string | null;
+  onChange: (next: DayAvailability) => void;
+  onCopy: (targets: DayKey[]) => void;
+  onPanelOpenChange: (panelId: string, open: boolean) => void;
+}) {
+  const idRef = useRef(0);
+  const nextId = () => `${day}-n${idRef.current++}`;
+  // Same rule one level down: ranges stack against each other inside the row.
+  const [openRangeId, setOpenRangeId] = useState<string | null>(null);
+
+  const panelId = (rangeId: string, edge: "start" | "end") =>
+    panelKey(day, rangeId, edge);
+
+  const onRangePanelOpenChange = (
+    rangeId: string,
+    id: string,
+    open: boolean,
+  ) => {
+    if (open) setOpenRangeId(rangeId);
+    onPanelOpenChange(id, open);
+  };
+
+  const setEnabled = (enabled: boolean) => {
+    if (enabled && state.ranges.length === 0) {
+      onChange({
+        enabled,
+        ranges: [{ id: nextId(), start: "09:00", end: "17:00" }],
+      });
+    } else {
+      onChange({ ...state, enabled });
+    }
+  };
+
+  const updateRange = (id: string, patch: Partial<TimeRange>) => {
+    const changed: "start" | "end" = patch.start !== undefined ? "start" : "end";
+    onChange({
+      ...state,
+      ranges: state.ranges.map((r) => {
+        if (r.id !== id) return r;
+        const next = { ...r, ...patch };
+        return { ...next, ...clampRange(next.start, next.end, options, changed) };
+      }),
+    });
+  };
+
+  const addRange = () => {
+    const last = state.ranges[state.ranges.length - 1];
+    const start = last ? Math.min(toMinutes(last.end) + 60, 24 * 60 - 60) : 540;
+    onChange({
+      enabled: true,
+      ranges: [
+        ...state.ranges,
+        { id: nextId(), start: toValue(start), end: toValue(start + 60) },
+      ],
+    });
+  };
+
+  const removeRange = (id: string) => {
+    const ranges = state.ranges.filter((r) => r.id !== id);
+    // Removing the last slot marks the day unavailable.
+    onChange({ enabled: ranges.length > 0, ranges });
+  };
+
+  const actions = (
+    <>
+      <Tooltip content="Add time">
+        <IconButton
+          label={`Add time range to ${label}`}
+          reduce={reduce}
+          onClick={addRange}
+        >
+          <Plus className="h-4 w-4" />
+        </IconButton>
+      </Tooltip>
+      <CopyMenu fromLabel={label} reduce={reduce} onApply={onCopy} />
+    </>
+  );
+
+  return (
+    <motion.div
+      layout={reduce ? false : "position"}
+      transition={SPRING_LAYOUT}
+      style={{ zIndex: elevated ? 1 : undefined }}
+      className="relative flex flex-col gap-3 py-4 sm:flex-row sm:items-start sm:gap-4"
+    >
+      {/* toggle + label; actions ride along on mobile */}
+      <div className="flex items-center justify-between sm:w-36 sm:shrink-0 sm:justify-start sm:pt-1">
+        <div className="flex items-center gap-2.5">
+          <Switch
+            checked={state.enabled}
+            onCheckedChange={setEnabled}
+            ariaLabel={`Toggle ${label} availability`}
+            className="scale-90"
+          />
+          <span className="text-sm font-medium text-foreground">{label}</span>
+        </div>
+        <div className="flex items-center gap-1 sm:hidden">{actions}</div>
+      </div>
+
+      {/* ranges or unavailable */}
+      <div className="flex min-w-0 flex-1 flex-col gap-2">
+        <AnimatePresence initial={false} mode="popLayout">
+          {state.enabled ? (
+            state.ranges.map((r) => (
+              <motion.div
+                key={r.id}
+                layout={reduce ? false : "position"}
+                style={{ zIndex: openRangeId === r.id ? 1 : undefined }}
+                initial={
+                  reduce
+                    ? { opacity: 0 }
+                    : { opacity: 0, y: -6, filter: "blur(4px)" }
+                }
+                animate={
+                  reduce
+                    ? { opacity: 1 }
+                    : { opacity: 1, y: 0, filter: "blur(0px)" }
+                }
+                exit={
+                  reduce
+                    ? { opacity: 0 }
+                    : { opacity: 0, y: -4, filter: "blur(4px)" }
+                }
+                transition={SPRING_LAYOUT}
+                className="relative flex items-center gap-2"
+              >
+                <div className="min-w-0 flex-1 sm:max-w-[132px]">
+                  <TimeSelect
+                    value={r.start}
+                    options={startOptions(options, r.end, r.start)}
+                    onChange={(v) => updateRange(r.id, { start: v })}
+                    open={openPanel === panelId(r.id, "start")}
+                    onOpenChange={(open) =>
+                      onRangePanelOpenChange(r.id, panelId(r.id, "start"), open)
+                    }
+                  />
+                </div>
+                <span className="text-muted-foreground">–</span>
+                <div className="min-w-0 flex-1 sm:max-w-[132px]">
+                  <TimeSelect
+                    value={r.end}
+                    options={endOptions(options, r.start, r.end)}
+                    onChange={(v) => updateRange(r.id, { end: v })}
+                    open={openPanel === panelId(r.id, "end")}
+                    onOpenChange={(open) =>
+                      onRangePanelOpenChange(r.id, panelId(r.id, "end"), open)
+                    }
+                  />
+                </div>
+                <Tooltip content="Remove">
+                  <IconButton
+                    label="Remove time range"
+                    reduce={reduce}
+                    onClick={() => removeRange(r.id)}
+                  >
+                    <X className="h-4 w-4" />
+                  </IconButton>
+                </Tooltip>
+              </motion.div>
+            ))
+          ) : (
+            <motion.span
+              key="unavailable"
+              layout={reduce ? false : "position"}
+              initial={reduce ? { opacity: 0 } : { opacity: 0, y: -4 }}
+              animate={reduce ? { opacity: 1 } : { opacity: 1, y: 0 }}
+              exit={reduce ? { opacity: 0 } : { opacity: 0, y: -4 }}
+              transition={SPRING_LAYOUT}
+              className="py-1 text-sm text-muted-foreground sm:py-2"
+            >
+              Unavailable
+            </motion.span>
+          )}
+        </AnimatePresence>
+      </div>
+
+      {/* actions (desktop) */}
+      <div className="hidden shrink-0 items-center gap-1 pt-0.5 sm:flex">
+        {actions}
+      </div>
+    </motion.div>
+  );
+}

package/components/motion/availability-scheduler/icon-button.tsx

@@ -0,0 +1,46 @@
+"use client";
+
+import { motion } from "motion/react";
+import type { ReactNode } from "react";
+import { SPRING_PRESS } from "@/lib/ease";
+import { cn } from "@/lib/utils";
+
+export function IconButton({
+  onClick,
+  label,
+  disabled,
+  expanded,
+  reduce,
+  children,
+  className,
+  // Rest props let a wrapping Tooltip inject its hover/focus handlers.
+  ...rest
+}: {
+  onClick: () => void;
+  label: string;
+  disabled?: boolean;
+  expanded?: boolean;
+  reduce: boolean;
+  children: ReactNode;
+  className?: string;
+  [key: string]: unknown;
+}) {
+  return (
+    <motion.button
+      {...rest}
+      type="button"
+      aria-label={label}
+      aria-expanded={expanded}
+      onClick={onClick}
+      disabled={disabled}
+      whileTap={reduce || disabled ? undefined : { scale: 0.86 }}
+      transition={SPRING_PRESS}
+      className={cn(
+        "inline-flex h-8 w-8 shrink-0 items-center justify-center rounded-lg text-muted-foreground outline-none transition-colors hover:bg-muted hover:text-foreground focus-visible:ring-2 focus-visible:ring-ring disabled:pointer-events-none disabled:opacity-40",
+        className,
+      )}
+    >
+      {children}
+    </motion.button>
+  );
+}

package/components/motion/availability-scheduler/index.tsx

@@ -0,0 +1,154 @@
+"use client";
+
+import { LayoutGroup, useReducedMotion } from "motion/react";
+import {
+  useCallback,
+  useEffect,
+  useId,
+  useMemo,
+  useRef,
+  useState,
+} from "react";
+import { cn } from "@/lib/utils";
+import { DayRow } from "./day-row";
+import {
+  buildOptions,
+  type DayAvailability,
+  type DayKey,
+  defaultWeek,
+  panelKey,
+  WEEKDAYS,
+  type WeekAvailability,
+} from "./types";
+
+export type {
+  DayAvailability,
+  DayKey,
+  TimeRange,
+  WeekAvailability,
+} from "./types";
+export { defaultWeek } from "./types";
+
+export interface AvailabilitySchedulerProps {
+  value?: WeekAvailability;
+  defaultValue?: WeekAvailability;
+  onChange?: (value: WeekAvailability) => void;
+  /** Minutes between selectable times. Default 30. */
+  step?: number;
+  className?: string;
+}
+
+export function AvailabilityScheduler({
+  value,
+  defaultValue,
+  onChange,
+  step = 30,
+  className,
+}: AvailabilitySchedulerProps) {
+  const reduce = useReducedMotion() ?? false;
+  const groupId = useId();
+  const options = useMemo(() => buildOptions(step), [step]);
+  const idRef = useRef(0);
+
+  const [internal, setInternal] = useState<WeekAvailability>(
+    () => defaultValue ?? defaultWeek(),
+  );
+  // The row that last opened a dropdown paints above the rest — see DayRow.
+  const [openDay, setOpenDay] = useState<DayKey | null>(null);
+  // Exactly one time panel is open at a time, and the scheduler is the one that
+  // knows which. A panel is absolutely positioned inside its own field, so two
+  // open at once paint over each other's options — and nothing else can close
+  // the first: a Select only dismisses on an outside *pointerdown*, which
+  // keyboard and assistive-technology activation never fires.
+  const [openPanel, setOpenPanel] = useState<string | null>(null);
+  const controlled = value !== undefined;
+  const week = controlled ? value : internal;
+
+  // Which panels the week currently puts on screen. A field that leaves — its
+  // day switched off, its range removed — never reports its panel closed: the
+  // only thing that dismisses a controlled Select is an outside pointerdown,
+  // and a field on its way out is no longer there to hear one. Keeping its id
+  // would reopen the panel the moment the same range came back.
+  const livePanels = useMemo(() => {
+    const ids = new Set<string>();
+    for (const { key } of WEEKDAYS) {
+      if (!week[key].enabled) continue;
+      for (const range of week[key].ranges) {
+        ids.add(panelKey(key, range.id, "start"));
+        ids.add(panelKey(key, range.id, "end"));
+      }
+    }
+    return ids;
+  }, [week]);
+
+  useEffect(() => {
+    if (openPanel !== null && !livePanels.has(openPanel)) setOpenPanel(null);
+  }, [livePanels, openPanel]);
+
+  const commit = useCallback(
+    (next: WeekAvailability) => {
+      if (!controlled) setInternal(next);
+      onChange?.(next);
+    },
+    [controlled, onChange],
+  );
+
+  const setDay = useCallback(
+    (day: DayKey, next: DayAvailability) => {
+      commit({ ...week, [day]: next });
+    },
+    [commit, week],
+  );
+
+  const panelOpenChange = useCallback(
+    (day: DayKey, id: string, open: boolean) => {
+      setOpenPanel((current) =>
+        open ? id : current === id ? null : current,
+      );
+      // Elevation stays on the row that opened last so the panel's collapse
+      // animation finishes above its neighbours.
+      if (open) setOpenDay(day);
+    },
+    [],
+  );
+
+  const copyDay = useCallback(
+    (from: DayKey, targets: DayKey[]) => {
+      const source = week[from];
+      const next = { ...week };
+      for (const t of targets) {
+        next[t] = {
+          enabled: source.enabled,
+          ranges: source.ranges.map((r) => ({
+            ...r,
+            id: `${t}-c${idRef.current++}`,
+          })),
+        };
+      }
+      commit(next);
+    },
+    [commit, week],
+  );
+
+  return (
+    <LayoutGroup id={groupId}>
+      <div className={cn("w-full max-w-xl divide-y divide-border", className)}>
+        {WEEKDAYS.map(({ key, label }) => (
+          <DayRow
+            key={key}
+            day={key}
+            label={label}
+            state={week[key]}
+            options={options}
+            reduce={reduce}
+            elevated={openDay === key}
+            openPanel={openPanel}
+            onChange={(next) => setDay(key, next)}
+            onCopy={(targets) => copyDay(key, targets)}
+            onPanelOpenChange={(id, open) => panelOpenChange(key, id, open)}
+          />
+        ))}
+      </div>
+    </LayoutGroup>
+  );
+}

package/components/motion/availability-scheduler/time-select.tsx

@@ -0,0 +1,49 @@
+"use client";
+
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/motion/select";
+import type { TimeOption } from "./types";
+
+// Time field: the library Select, with the option list capped so the panel
+// measures a small height and scrolls instead of unfolding all 48 options.
+export function TimeSelect({
+  value,
+  onChange,
+  open,
+  onOpenChange,
+  options,
+}: {
+  value: string;
+  onChange: (v: string) => void;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  options: TimeOption[];
+}) {
+  return (
+    <Select
+      value={value}
+      onValueChange={onChange}
+      open={open}
+      onOpenChange={onOpenChange}
+      className="w-full"
+    >
+      <SelectTrigger className="tabular-nums">
+        <SelectValue className="whitespace-nowrap" />
+      </SelectTrigger>
+      <SelectContent>
+        <div className="max-h-56 overflow-y-auto overscroll-contain">
+          {options.map((o) => (
+            <SelectItem key={o.value} value={o.value} className="tabular-nums">
+              {o.label}
+            </SelectItem>
+          ))}
+        </div>
+      </SelectContent>
+    </Select>
+  );
+}

package/components/motion/availability-scheduler/types.ts

@@ -0,0 +1,189 @@
+export type DayKey = "mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun";
+
+export type TimeRange = { id: string; start: string; end: string };
+export type DayAvailability = { enabled: boolean; ranges: TimeRange[] };
+export type WeekAvailability = Record<DayKey, DayAvailability>;
+export type TimeOption = { value: string; label: string };
+
+export const WEEKDAYS: { key: DayKey; label: string }[] = [
+  { key: "mon", label: "Monday" },
+  { key: "tue", label: "Tuesday" },
+  { key: "wed", label: "Wednesday" },
+  { key: "thu", label: "Thursday" },
+  { key: "fri", label: "Friday" },
+  { key: "sat", label: "Saturday" },
+  { key: "sun", label: "Sunday" },
+];
+
+// ─── panels ──────────────────────────────────────────────────────────────────
+
+/**
+ * Names one time field week-wide, because the scheduler holds a single open
+ * panel for the whole week. Range ids belong to the value and are only unique
+ * within a day, so the day is part of the name — and the scheduler builds the
+ * same keys to ask whether the panel it is holding is still on screen.
+ */
+export const panelKey = (day: DayKey, rangeId: string, edge: "start" | "end") =>
+  `${day}:${rangeId}:${edge}`;
+
+// ─── time helpers ────────────────────────────────────────────────────────────
+
+export const toMinutes = (v: string) => {
+  const [h, m] = v.split(":").map(Number);
+  return h * 60 + m;
+};
+
+export const toValue = (mins: number) => {
+  const clamped = Math.max(0, Math.min(24 * 60 - 1, mins));
+  const h = Math.floor(clamped / 60);
+  const m = clamped % 60;
+  return `${String(h).padStart(2, "0")}:${String(m).padStart(2, "0")}`;
+};
+
+export const label12 = (v: string) => {
+  const [h, m] = v.split(":").map(Number);
+  const ap = h < 12 ? "AM" : "PM";
+  const h12 = h % 12 === 0 ? 12 : h % 12;
+  return `${h12}:${String(m).padStart(2, "0")} ${ap}`;
+};
+
+export function buildOptions(step: number): TimeOption[] {
+  const out: TimeOption[] = [];
+  for (let m = 0; m < 24 * 60; m += step) {
+    const value = toValue(m);
+    out.push({ value, label: label12(value) });
+  }
+  return out;
+}
+
+function snapToOption(mins: number, slots: number[]) {
+  let best = slots[0];
+  for (const slot of slots) {
+    if (Math.abs(slot - mins) < Math.abs(best - mins)) best = slot;
+  }
+  return best;
+}
+
+function withCurrentOption(
+  filtered: TimeOption[],
+  all: TimeOption[],
+  current?: string,
+) {
+  if (!current || filtered.some((o) => o.value === current)) return filtered;
+  const extra =
+    all.find((o) => o.value === current) ??
+    ({ value: current, label: label12(current) } satisfies TimeOption);
+  return [...filtered, extra].sort(
+    (a, b) => toMinutes(a.value) - toMinutes(b.value),
+  );
+}
+
+/**
+ * Same-day ranges only. A valid pair is left alone so an off-grid persisted
+ * end (17:00 with `step={720}`) is not rewritten. When the invariant fails,
+ * the just-selected endpoint stays and only the opposite side moves onto a
+ * neighboring generated option.
+ */
+export function clampRange(
+  start: string,
+  end: string,
+  options: TimeOption[],
+  changed: "start" | "end" = "start",
+): { start: string; end: string } {
+  const slots = options.map((o) => toMinutes(o.value));
+  if (slots.length === 0) return { start, end };
+
+  const startM = toMinutes(start);
+  const endM = toMinutes(end);
+  if (endM > startM) return { start, end };
+
+  const keepOrSnap = (value: string) => {
+    const mins = toMinutes(value);
+    return slots.includes(mins) ? mins : snapToOption(mins, slots);
+  };
+
+  if (changed === "end") {
+    const e = keepOrSnap(end);
+    const earlier = [...slots].reverse().find((slot) => slot < e);
+    if (earlier === undefined && slots.length > 1) {
+      // Midnight cannot end a positive same-day range, so use the first pair.
+      return { start: toValue(slots[0]), end: toValue(slots[1]) };
+    }
+    return {
+      start: toValue(earlier ?? keepOrSnap(start)),
+      end: toValue(e),
+    };
+  }
+
+  const s = keepOrSnap(start);
+  const later = slots.find((slot) => slot > s);
+  if (later === undefined && slots.length > 1) {
+    // The last slot cannot start a positive range, so use the final pair.
+    return {
+      start: toValue(slots[slots.length - 2]),
+      end: toValue(slots[slots.length - 1]),
+    };
+  }
+  return {
+    start: toValue(s),
+    end: toValue(later ?? keepOrSnap(end)),
+  };
+}
+
+export function startOptions(
+  options: TimeOption[],
+  end: string,
+  current?: string,
+) {
+  const filtered = options.filter(
+    (o) => toMinutes(o.value) < toMinutes(end),
+  );
+  // An invalid midnight end has no earlier option; expose midnight so choosing
+  // it can move the end forward through clampRange instead of trapping the row.
+  const recovery = filtered.length === 0 ? options.slice(0, 1) : filtered;
+  return withCurrentOption(
+    recovery,
+    options,
+    current,
+  );
+}
+
+export function endOptions(
+  options: TimeOption[],
+  start: string,
+  current?: string,
+) {
+  const filtered = options.filter(
+    (o) => toMinutes(o.value) > toMinutes(start),
+  );
+  // An invalid last-slot start has no later option; expose the last slot so
+  // choosing it can move the start backward through clampRange.
+  const recovery = filtered.length === 0 ? options.slice(-1) : filtered;
+  return withCurrentOption(
+    recovery,
+    options,
+    current,
+  );
+}
+
+// Default: Mon–Fri 9–5, weekend off. Fixed ids so SSR and first client render
+// agree (new ranges get counter ids afterwards).
+export function defaultWeek(): WeekAvailability {
+  const workday = (day: DayKey): DayAvailability => ({
+    enabled: true,
+    ranges: [{ id: `${day}-0`, start: "09:00", end: "17:00" }],
+  });
+  const off = (day: DayKey): DayAvailability => ({
+    enabled: false,
+    ranges: [{ id: `${day}-0`, start: "09:00", end: "17:00" }],
+  });
+  return {
+    mon: workday("mon"),
+    tue: workday("tue"),
+    wed: workday("wed"),
+    thu: workday("thu"),
+    fri: workday("fri"),
+    sat: off("sat"),
+    sun: off("sun"),
+  };
+}