@tensor_1/react 2.12.0 → 2.13.0

package/dist/components/SchedulingCalendar.js

@@ -0,0 +1,124 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { addCalendarDays, addCalendarMonths, buildMonthGrid, startOfMonth, zonedDateSpan } from "../calendar-model.js";
+import { cx } from "../cx.js";
+import { StatusPill } from "./StatusPill.js";
+const stateLabel = { scheduled: "Scheduled", conflicted: "Conflicted", "in-progress": "In progress", "blackout-violation": "Blackout violation" };
+const stateTone = (state) => state === "scheduled" ? "info" : state === "in-progress" ? "success" : "danger";
+const dateLabel = (date, locale) => new Intl.DateTimeFormat(locale, { dateStyle: "full", timeZone: "UTC" }).format(/* @__PURE__ */ new Date(`${date}T00:00:00Z`));
+const EMPTY_OVERLAYS = [];
+function SchedulingCalendar({
+  entries,
+  anchorDate,
+  timeZone,
+  view: controlledView,
+  onViewChange,
+  onAnchorDateChange,
+  onSelectEntry,
+  overlays = EMPTY_OVERLAYS,
+  filter,
+  renderEntry,
+  locale,
+  loading,
+  error,
+  onRetry,
+  className
+}) {
+  const [internalView, setInternalView] = useState("month");
+  const view = controlledView ?? internalView;
+  const [activeDate, setActiveDate] = useState(anchorDate);
+  const gridRef = useRef(null);
+  const visibleEntries = useMemo(() => entries.filter((entry) => filter?.(entry) ?? true), [entries, filter]);
+  const entrySpans = useMemo(() => new Map(visibleEntries.map((entry) => [entry.id, zonedDateSpan(entry.start, entry.end, timeZone)])), [visibleEntries, timeZone]);
+  const overlaySpans = useMemo(() => new Map(overlays.map((overlay) => [overlay.id, { start: overlay.start.slice(0, 10), end: overlay.end.slice(0, 10) }])), [overlays]);
+  const monthDays = useMemo(() => buildMonthGrid(startOfMonth(anchorDate)), [anchorDate]);
+  const weekday = ((/* @__PURE__ */ new Date(`${anchorDate}T00:00:00Z`)).getUTCDay() + 6) % 7;
+  const weekStart = addCalendarDays(anchorDate, -weekday);
+  const weekDays = useMemo(() => Array.from({ length: 7 }, (_, index) => addCalendarDays(weekStart, index)), [weekStart]);
+  const days = useMemo(() => view === "month" ? monthDays.map((day) => day.date) : weekDays, [view, monthDays, weekDays]);
+  useEffect(() => {
+    if (view !== "agenda" && !days.includes(activeDate)) setActiveDate(days[0]);
+  }, [activeDate, days, view]);
+  const setView = (next) => {
+    if (controlledView === void 0) setInternalView(next);
+    onViewChange?.(next);
+  };
+  const movePeriod = (direction) => onAnchorDateChange?.(view === "month" ? addCalendarMonths(anchorDate, direction) : addCalendarDays(anchorDate, direction * 7));
+  const focusDate = (date) => {
+    setActiveDate(date);
+    requestAnimationFrame(() => gridRef.current?.querySelector(`[data-calendar-date="${date}"]`)?.focus());
+  };
+  const onDayKeyDown = (event, date) => {
+    const offset = { ArrowLeft: -1, ArrowRight: 1, ArrowUp: -7, ArrowDown: 7 }[event.key];
+    if (offset) {
+      event.preventDefault();
+      focusDate(addCalendarDays(date, offset));
+    } else if (event.key === "Home") {
+      event.preventDefault();
+      focusDate(days[0]);
+    } else if (event.key === "End") {
+      event.preventDefault();
+      focusDate(days[days.length - 1]);
+    }
+  };
+  const entriesFor = (date) => visibleEntries.filter((entry) => {
+    const span = entrySpans.get(entry.id);
+    return date >= span.start && date <= span.end;
+  });
+  const overlaysFor = (date) => overlays.filter((overlay) => {
+    const span = overlaySpans.get(overlay.id);
+    return date >= span.start && date <= span.end;
+  });
+  const formatInstant = (instant) => new Intl.DateTimeFormat(locale, { timeZone, dateStyle: "medium", timeStyle: "short" }).format(new Date(instant));
+  return /* @__PURE__ */ jsxs("section", { className: cx("uix-scheduling-calendar", className), "aria-label": `Scheduling calendar in ${timeZone}`, children: [
+    /* @__PURE__ */ jsxs("div", { className: "uix-scheduling-calendar__header", children: [
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: () => movePeriod(-1), disabled: !onAnchorDateChange, children: "Previous" }),
+        /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--ghost uix-btn--sm", onClick: () => movePeriod(1), disabled: !onAnchorDateChange, children: "Next" })
+      ] }),
+      /* @__PURE__ */ jsx("strong", { children: view === "month" ? new Intl.DateTimeFormat(locale, { month: "long", year: "numeric", timeZone: "UTC" }).format(/* @__PURE__ */ new Date(`${anchorDate}T00:00:00Z`)) : `${dateLabel(weekStart, locale)} \u2013 ${dateLabel(weekDays[weekDays.length - 1], locale)}` }),
+      /* @__PURE__ */ jsx("div", { className: "uix-segmented", role: "group", "aria-label": "Calendar view", children: ["month", "week", "agenda"].map((option) => /* @__PURE__ */ jsxs("button", { type: "button", className: "uix-segmented__option", "aria-pressed": view === option, "data-selected": view === option || void 0, onClick: () => setView(option), children: [
+        option[0].toUpperCase(),
+        option.slice(1)
+      ] }, option)) })
+    ] }),
+    loading ? /* @__PURE__ */ jsx("div", { className: "uix-scheduling-calendar__state", role: "status", children: "Loading schedule\u2026" }) : error ? /* @__PURE__ */ jsxs("div", { className: "uix-scheduling-calendar__state", role: "alert", children: [
+      /* @__PURE__ */ jsx("p", { children: error }),
+      onRetry && /* @__PURE__ */ jsx("button", { type: "button", className: "uix-btn uix-btn--secondary", onClick: onRetry, children: "Try again" })
+    ] }) : view === "agenda" ? /* @__PURE__ */ jsx("div", { className: "uix-scheduling-calendar__agenda", role: "region", "aria-label": "Schedule agenda", children: visibleEntries.length === 0 ? /* @__PURE__ */ jsx("p", { children: "No scheduled entries match the current filters." }) : /* @__PURE__ */ jsx("ol", { children: [...visibleEntries].sort((a, b) => a.start.localeCompare(b.start)).map((entry) => {
+      const state = entry.state ?? "scheduled";
+      return /* @__PURE__ */ jsx("li", { children: /* @__PURE__ */ jsxs("button", { type: "button", onClick: () => onSelectEntry?.(entry), children: [
+        /* @__PURE__ */ jsxs("span", { children: [
+          /* @__PURE__ */ jsx("strong", { children: renderEntry?.(entry) ?? entry.title }),
+          /* @__PURE__ */ jsxs("span", { children: [
+            formatInstant(entry.start),
+            " \u2013 ",
+            formatInstant(entry.end)
+          ] }),
+          entry.meta && /* @__PURE__ */ jsx("span", { children: entry.meta })
+        ] }),
+        /* @__PURE__ */ jsx(StatusPill, { tone: stateTone(state), children: stateLabel[state] })
+      ] }) }, entry.id);
+    }) }) }) : /* @__PURE__ */ jsx("div", { ref: gridRef, className: cx("uix-scheduling-calendar__grid", view === "week" && "uix-scheduling-calendar__grid--week"), role: "group", "aria-label": `${view} schedule`, children: days.map((date, index) => {
+      const dayEntries = entriesFor(date);
+      const dayOverlays = overlaysFor(date);
+      return /* @__PURE__ */ jsxs("div", { className: "uix-scheduling-calendar__day", "data-outside": view === "month" && !monthDays[index].inMonth || void 0, children: [
+        /* @__PURE__ */ jsx("button", { type: "button", className: "uix-scheduling-calendar__date", "data-calendar-date": date, tabIndex: activeDate === date ? 0 : -1, onFocus: () => setActiveDate(date), onKeyDown: (event) => onDayKeyDown(event, date), "aria-label": dateLabel(date, locale), children: Number(date.slice(-2)) }),
+        dayOverlays.map((overlay) => /* @__PURE__ */ jsx("span", { className: "uix-scheduling-calendar__overlay", "data-kind": overlay.kind, children: overlay.label }, overlay.id)),
+        /* @__PURE__ */ jsx("div", { className: "uix-scheduling-calendar__entries", children: dayEntries.map((entry) => {
+          const span = entrySpans.get(entry.id);
+          const state = entry.state ?? "scheduled";
+          return /* @__PURE__ */ jsxs("button", { type: "button", className: "uix-scheduling-calendar__entry", "data-state": state, "data-range-start": date === span.start || void 0, "data-range-end": date === span.end || void 0, onClick: () => onSelectEntry?.(entry), "aria-label": `${entry.title}, ${stateLabel[state]}, ${formatInstant(entry.start)} to ${formatInstant(entry.end)}`, children: [
+            /* @__PURE__ */ jsx("span", { children: renderEntry?.(entry) ?? entry.title }),
+            /* @__PURE__ */ jsx("span", { className: "uix-visually-hidden", children: stateLabel[state] })
+          ] }, entry.id);
+        }) })
+      ] }, date);
+    }) }),
+    /* @__PURE__ */ jsx("div", { className: "uix-scheduling-calendar__legend", "aria-label": "Schedule state legend", children: ["scheduled", "conflicted", "in-progress", "blackout-violation"].map((state) => /* @__PURE__ */ jsx("span", { "data-state": state, children: stateLabel[state] }, state)) })
+  ] });
+}
+export {
+  SchedulingCalendar
+};

package/dist/diff-model.d.ts

@@ -0,0 +1,23 @@
+import { JsonValue } from './json-value.js';
+
+type DiffKind = 'added' | 'removed' | 'changed' | 'conflicted';
+type DiffResolution = 'accept' | 'skip' | 'pending';
+interface DiffEntry {
+    path: string;
+    kind: DiffKind;
+    base?: JsonValue;
+    current?: JsonValue;
+    incoming?: JsonValue;
+}
+interface DiffSummary {
+    added: number;
+    removed: number;
+    changed: number;
+    conflicted: number;
+    resolved: number;
+    pending: number;
+}
+declare function buildThreeWayDiff(base: JsonValue | undefined, current: JsonValue | undefined, incoming: JsonValue | undefined, path?: string): DiffEntry[];
+declare function summarizeDiff(entries: DiffEntry[], resolutions?: Record<string, DiffResolution>): DiffSummary;
+
+export { type DiffEntry, type DiffKind, type DiffResolution, type DiffSummary, buildThreeWayDiff, summarizeDiff };

package/dist/diff-model.js

@@ -0,0 +1,50 @@
+function isJsonObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function jsonEqual(a, b) {
+  if (a === b) return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    return a.length === b.length && a.every((value, index) => jsonEqual(value, b[index]));
+  }
+  if (isJsonObject(a) && isJsonObject(b)) {
+    const aKeys = Object.keys(a).sort();
+    const bKeys = Object.keys(b).sort();
+    return aKeys.length === bKeys.length && aKeys.every((key, index) => key === bKeys[index] && jsonEqual(a[key], b[key]));
+  }
+  return false;
+}
+function classify(base, current, incoming) {
+  if (base === void 0) return "added";
+  if (incoming === void 0) return "removed";
+  const currentChanged = !jsonEqual(base, current);
+  const incomingChanged = !jsonEqual(base, incoming);
+  if (currentChanged && incomingChanged && !jsonEqual(current, incoming)) return "conflicted";
+  return "changed";
+}
+function buildThreeWayDiff(base, current, incoming, path = "$") {
+  if (jsonEqual(current, incoming)) return [];
+  if (isJsonObject(base) || isJsonObject(current) || isJsonObject(incoming)) {
+    const objects = [base, current, incoming].filter(isJsonObject);
+    const keys = [...new Set(objects.flatMap((value) => Object.keys(value)))].sort();
+    return keys.flatMap((key) => buildThreeWayDiff(
+      isJsonObject(base) ? base[key] : void 0,
+      isJsonObject(current) ? current[key] : void 0,
+      isJsonObject(incoming) ? incoming[key] : void 0,
+      `${path}.${key}`
+    ));
+  }
+  return [{ path, kind: classify(base, current, incoming), base, current, incoming }];
+}
+function summarizeDiff(entries, resolutions = {}) {
+  const summary = { added: 0, removed: 0, changed: 0, conflicted: 0, resolved: 0, pending: 0 };
+  entries.forEach((entry) => {
+    summary[entry.kind] += 1;
+    if ((resolutions[entry.path] ?? "pending") === "pending") summary.pending += 1;
+    else summary.resolved += 1;
+  });
+  return summary;
+}
+export {
+  buildThreeWayDiff,
+  summarizeDiff
+};