@tensor_1/react 2.31.0 → 2.33.0

package/dist/scheduling-calendar-model.js

@@ -0,0 +1,176 @@
+import { addCalendarDays, addZonedDays, buildMonthGrid, packLanes, startOfMonth, zonedDateKey, zonedDayBounds, zonedDaySpan } from "./calendar-model.js";
+const DEFAULT_LANE_CAP = 2;
+function itemDaySpan(start, end, timeZone) {
+  const from = new Date(start);
+  const to = new Date(end);
+  if (from.getTime() === to.getTime()) {
+    const day = zonedDateKey(from, timeZone);
+    return { start: day, end: addCalendarDays(day, 1) };
+  }
+  return zonedDaySpan(from, to, timeZone);
+}
+function schedulingGridDays(anchorDate, view, weekStartsOn = 1) {
+  if (view === "month") return buildMonthGrid(startOfMonth(anchorDate), weekStartsOn).map((day) => day.date);
+  const weekday = (/* @__PURE__ */ new Date(`${anchorDate}T00:00:00Z`)).getUTCDay();
+  const first = addCalendarDays(anchorDate, -((weekday - weekStartsOn + 7) % 7));
+  return Array.from({ length: 7 }, (_, index) => addCalendarDays(first, index));
+}
+function layoutMonthSpans(spans, days, options) {
+  if (days.length === 0 || days.length % 7 !== 0) throw new RangeError(`layoutMonthSpans: days must be whole weeks, got ${days.length} day(s)`);
+  for (let index = 1; index < days.length; index++) {
+    if (days[index] !== addCalendarDays(days[index - 1], 1)) throw new RangeError(`layoutMonthSpans: days must be consecutive (${days[index - 1]} \u2192 ${days[index]})`);
+  }
+  if (options.weekStartsOn !== void 0 && (/* @__PURE__ */ new Date(`${days[0]}T00:00:00Z`)).getUTCDay() !== options.weekStartsOn) {
+    throw new RangeError(`layoutMonthSpans: days[0] (${days[0]}) does not fall on weekday ${options.weekStartsOn}`);
+  }
+  const capFor = (group) => {
+    const cap = typeof options.laneCap === "number" ? options.laneCap : options.laneCap?.[group] ?? DEFAULT_LANE_CAP;
+    if (!(cap === Infinity || Number.isInteger(cap) && cap >= 0)) throw new RangeError(`layoutMonthSpans: laneCap for ${group} must be a non-negative integer, got ${cap}`);
+    return cap;
+  };
+  const caps = { window: capFor("window"), item: capFor("item") };
+  const rows = days.length / 7;
+  const gridEnd = addCalendarDays(days[days.length - 1], 1);
+  const seen = /* @__PURE__ */ new Set();
+  const covered = spans.map((span) => {
+    const group = span.group ?? "item";
+    if (seen.has(`${group} ${span.id}`)) throw new TypeError(`layoutMonthSpans: duplicate ${group} id ${span.id}`);
+    seen.add(`${group} ${span.id}`);
+    return { id: span.id, group, days: itemDaySpan(span.start, span.end, options.timeZone) };
+  });
+  const placed = [];
+  const hiddenByRow = {};
+  const firstHiddenDayByRow = {};
+  for (let row = 0; row < rows; row++) {
+    const rowStart = days[row * 7];
+    const rowEnd = row + 1 < rows ? days[(row + 1) * 7] : gridEnd;
+    for (const group of ["window", "item"]) {
+      const inRow = covered.filter((span) => span.group === group && span.days.start < rowEnd && span.days.end > rowStart).map((span) => {
+        const from = span.days.start > rowStart ? span.days.start : rowStart;
+        const to = span.days.end < rowEnd ? span.days.end : rowEnd;
+        const startCol = days.indexOf(from, row * 7) - row * 7;
+        const endCol = days.indexOf(addCalendarDays(to, -1), row * 7) - row * 7;
+        return { span, from, startCol, endCol };
+      });
+      const packed = packLanes(inRow.map(({ span, startCol, endCol }) => ({ id: span.id, start: startCol, end: endCol + 1 })), caps[group], { order: "given" });
+      for (const { span, from, startCol, endCol } of inRow) {
+        const lane = packed.lanes[span.id].lane;
+        if (lane === null) {
+          (hiddenByRow[row] ?? (hiddenByRow[row] = [])).push(span.id);
+          if (firstHiddenDayByRow[row] === void 0 || from < firstHiddenDayByRow[row]) firstHiddenDayByRow[row] = from;
+          continue;
+        }
+        placed.push({
+          id: span.id,
+          group,
+          weekRow: row,
+          lane,
+          startCol,
+          endCol,
+          continuesBefore: span.days.start < rowStart,
+          continuesAfter: span.days.end > rowEnd
+        });
+      }
+    }
+  }
+  return { placed, hiddenByRow, firstHiddenDayByRow };
+}
+const MINUTE_MS = 6e4;
+const HOUR_MS = 36e5;
+const instantMs = (value) => new Date(value).getTime();
+const TOP_LANE_CROSS_MIDNIGHT_MINUTES = 360;
+function placesInTopLane(entry, timeZone, options = {}) {
+  if (entry.allDay) return true;
+  const start = instantMs(entry.start);
+  const end = instantMs(entry.end);
+  if (!(end > start)) return false;
+  if (end > addZonedDays(new Date(start), 1, timeZone).instant.getTime()) return true;
+  const firstMidnight = zonedDayBounds(zonedDateKey(new Date(start), timeZone), timeZone).end.getTime();
+  return end > firstMidnight + (options.crossMidnightMinutes ?? TOP_LANE_CROSS_MIDNIGHT_MINUTES) * MINUTE_MS;
+}
+function layoutTimeGridDay(entries, date, timeZone, options = {}) {
+  const bounds = zonedDayBounds(date, timeZone);
+  const dayStart = bounds.start.getTime();
+  const dayEnd = bounds.end.getTime();
+  const parts = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const start = instantMs(entry.start);
+    const end = Math.max(instantMs(entry.end), start);
+    const touches = end > start ? start < dayEnd && end > dayStart : start >= dayStart && start < dayEnd;
+    if (!touches || placesInTopLane(entry, timeZone, options)) continue;
+    parts.set(entry.id, {
+      start: Math.max(start, dayStart),
+      end: Math.min(end, dayEnd),
+      part: start < dayStart ? "continuation" : end > dayEnd ? "start" : "whole"
+    });
+  }
+  const packed = packLanes([...parts].map(([id, part]) => ({ id, start: part.start, end: part.end })), options.maxLanes ?? Infinity);
+  const segments = [];
+  const hidden = [];
+  for (const cluster of packed.clusters) {
+    for (const id of cluster.ids) {
+      const part = parts.get(id);
+      const lane = packed.lanes[id].lane;
+      if (lane === null) {
+        hidden.push(id);
+        continue;
+      }
+      segments.push({
+        id,
+        part: part.part,
+        start: part.start,
+        end: part.end,
+        offsetHours: (part.start - dayStart) / HOUR_MS,
+        lengthHours: (part.end - part.start) / HOUR_MS,
+        lane,
+        laneCount: Math.max(cluster.laneCount, 1)
+      });
+    }
+  }
+  return { date, dayStart, dayHours: (dayEnd - dayStart) / HOUR_MS, segments, hidden };
+}
+function layoutDaySpans(spans, days, options) {
+  if (days.length === 0) throw new RangeError("layoutDaySpans: days is empty");
+  const rowStart = days[0];
+  const rowEnd = addCalendarDays(days[days.length - 1], 1);
+  const seen = /* @__PURE__ */ new Set();
+  const inRow = spans.filter((span) => seen.has(span.id) ? false : (seen.add(span.id), true)).map((span) => ({ id: span.id, days: itemDaySpan(span.start, instantMs(span.end) < instantMs(span.start) ? span.start : span.end, options.timeZone) })).filter((span) => span.days.start < rowEnd && span.days.end > rowStart).map((span) => {
+    const from = span.days.start > rowStart ? span.days.start : rowStart;
+    const to = span.days.end < rowEnd ? span.days.end : rowEnd;
+    return { span, from, startCol: days.indexOf(from), endCol: days.indexOf(addCalendarDays(to, -1)) };
+  });
+  const packed = packLanes(inRow.map(({ span, startCol, endCol }) => ({ id: span.id, start: startCol, end: endCol + 1 })), options.laneCap ?? Infinity, { order: "given" });
+  const layout = { placed: [], hidden: [] };
+  for (const { span, from, startCol, endCol } of inRow) {
+    const lane = packed.lanes[span.id].lane;
+    if (lane === null) {
+      layout.hidden.push(span.id);
+      if (layout.firstHiddenDay === void 0 || from < layout.firstHiddenDay) layout.firstHiddenDay = from;
+      continue;
+    }
+    layout.placed.push({ id: span.id, lane, startCol, endCol, continuesBefore: span.days.start < rowStart, continuesAfter: span.days.end > rowEnd });
+  }
+  return layout;
+}
+function proposeMove(span, delta, timeZone) {
+  const shift = (delta.minutes ?? 0) * MINUTE_MS;
+  const start = new Date(instantMs(span.start) + shift);
+  const end = new Date(instantMs(span.end) + shift);
+  if (!delta.days) return { start: start.toISOString(), end: end.toISOString(), adjusted: null };
+  const movedStart = addZonedDays(start, delta.days, timeZone);
+  const movedEnd = addZonedDays(end, delta.days, timeZone);
+  const length = end.getTime() - start.getTime();
+  const collapsed = length > 0 && movedEnd.instant.getTime() <= movedStart.instant.getTime();
+  const proposedEnd = collapsed ? new Date(movedStart.instant.getTime() + length) : movedEnd.instant;
+  return { start: movedStart.instant.toISOString(), end: proposedEnd.toISOString(), adjusted: movedStart.adjusted ?? movedEnd.adjusted };
+}
+export {
+  TOP_LANE_CROSS_MIDNIGHT_MINUTES,
+  itemDaySpan,
+  layoutDaySpans,
+  layoutMonthSpans,
+  layoutTimeGridDay,
+  placesInTopLane,
+  proposeMove,
+  schedulingGridDays
+};

package/dist/select-model.d.ts

@@ -0,0 +1,80 @@
+import { ReactNode } from 'react';
+
+/**
+ * Select model (HAR-1572) — pure, DOM-free logic behind the UIx `Select` listbox:
+ * flattening options and groups, keyboard movement (APG select-only combobox), typeahead,
+ * filtering and the multi-select value helpers. Unit-tested in select-model.test.mjs.
+ */
+
+interface SelectOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    /** A second, muted line under the label. */
+    description?: string;
+    /** Shown before the label, in the list and on the trigger. */
+    icon?: ReactNode;
+    /** Extra words that match a search or typeahead (never shown). */
+    keywords?: readonly string[];
+}
+interface SelectGroup {
+    label: string;
+    options: readonly SelectOption[];
+    /** Disables every option in the group. */
+    disabled?: boolean;
+}
+type SelectItem = SelectOption | SelectGroup;
+declare const isSelectGroup: (item: SelectItem) => item is SelectGroup;
+/** @internal One option in list order, with what navigation needs. */
+interface SelectEntry {
+    option: SelectOption;
+    /** Position among all entries (the `aria-activedescendant` target index). */
+    index: number;
+    /** Index into `sections`. */
+    section: number;
+    disabled: boolean;
+    /** In the form value only (an `<option hidden>` placeholder); never listed or focused. */
+    hidden: boolean;
+}
+/** @internal A run of entries: one group, or the ungrouped options between groups. */
+interface SelectSection {
+    label?: string;
+    disabled: boolean;
+    entries: SelectEntry[];
+}
+/** @internal */
+interface SelectModel {
+    sections: SelectSection[];
+    /** Every visible entry, in order (hidden placeholder options are left out). */
+    entries: SelectEntry[];
+    /** Every option including hidden ones, for the form proxy and value lookups. */
+    all: SelectEntry[];
+}
+/** @internal Flatten options and groups into sections and a navigable entry list. */
+declare function buildSelectModel(items: readonly SelectItem[]): SelectModel;
+declare const firstEnabled: (entries: readonly SelectEntry[]) => number;
+declare const lastEnabled: (entries: readonly SelectEntry[]) => number;
+/**
+ * Move the active option by `delta` (±1 for arrows, ±10 for PageUp/PageDown), skipping
+ * disabled options and stopping at the ends (the APG list does not wrap). With no active
+ * option, moving down lands on the first enabled option and moving up on the last.
+ */
+declare function moveActive(entries: readonly SelectEntry[], from: number, delta: number): number;
+/**
+ * Typeahead (APG): the typed buffer matches the start of a label. Repeating one character
+ * ("s", "s") cycles through the options that start with it; a longer string ("re") keeps the
+ * current option while it still matches. Disabled options are skipped. Returns -1 for no match.
+ */
+declare function typeahead(entries: readonly SelectEntry[], buffer: string, from: number): number;
+/** Does the option match a search query (label, value-free keywords and description)? */
+declare function selectOptionMatches(option: SelectOption, query: string): boolean;
+/** Keep only the options (and the groups holding them) that match `query`. */
+declare function filterSelectItems(items: readonly SelectItem[], query: string): SelectItem[];
+/** Count the options in a list of options and groups. */
+declare const countSelectOptions: (items: readonly SelectItem[]) => number;
+/** @internal A form value (string, number, array or nothing) as a list of strings. */
+declare function toValueList(value: unknown): string[];
+/** @internal Toggle `value` in a multi-select value, keeping list order stable. */
+declare function toggleValue(values: readonly string[], value: string): string[];
+
+export { type SelectEntry, type SelectGroup, type SelectItem, type SelectModel, type SelectOption, type SelectSection, buildSelectModel, countSelectOptions, filterSelectItems, firstEnabled, isSelectGroup, lastEnabled, moveActive, selectOptionMatches, toValueList, toggleValue, typeahead };

package/dist/select-model.js

@@ -0,0 +1,109 @@
+import { foldForSearch } from "./search-suggest-model.js";
+const isSelectGroup = (item) => Array.isArray(item.options);
+function buildSelectModel(items) {
+  const sections = [];
+  const entries = [];
+  const all = [];
+  let loose = null;
+  const add = (section, sectionIndex, option, groupDisabled) => {
+    const hidden = !!option.hidden;
+    const entry = {
+      option,
+      index: hidden ? -1 : entries.length,
+      section: sectionIndex,
+      disabled: groupDisabled || !!option.disabled,
+      hidden
+    };
+    all.push(entry);
+    if (hidden) return;
+    entries.push(entry);
+    section.entries.push(entry);
+  };
+  for (const item of items) {
+    if (isSelectGroup(item)) {
+      loose = null;
+      const section = { label: item.label, disabled: !!item.disabled, entries: [] };
+      sections.push(section);
+      for (const option of item.options) add(section, sections.length - 1, option, !!item.disabled);
+    } else {
+      if (!loose) {
+        loose = { disabled: false, entries: [] };
+        sections.push(loose);
+      }
+      add(loose, sections.length - 1, item, false);
+    }
+  }
+  return { sections: sections.filter((s) => s.entries.length > 0 || s.label != null), entries, all };
+}
+function scan(entries, from, step) {
+  for (let i = from; i >= 0 && i < entries.length; i += step) if (!entries[i].disabled) return i;
+  return -1;
+}
+const firstEnabled = (entries) => scan(entries, 0, 1);
+const lastEnabled = (entries) => scan(entries, entries.length - 1, -1);
+function moveActive(entries, from, delta) {
+  if (!entries.length) return -1;
+  if (from < 0) return delta > 0 ? firstEnabled(entries) : lastEnabled(entries);
+  const step = delta > 0 ? 1 : -1;
+  const target = Math.max(0, Math.min(entries.length - 1, from + delta));
+  const found = scan(entries, target, step);
+  if (found >= 0 && found !== from) return found;
+  const back = scan(entries, target, step === 1 ? -1 : 1);
+  return back >= 0 ? step === 1 ? Math.max(back, from) : Math.min(back, from) : from;
+}
+const fold = (text) => foldForSearch(text).text;
+function typeahead(entries, buffer, from) {
+  const query = fold(buffer);
+  if (!query || !entries.length) return -1;
+  const chars = [...query];
+  const repeated = chars.length > 1 && chars.every((c) => c === chars[0]);
+  const needle = repeated ? chars[0] : query;
+  const start = repeated || chars.length === 1 ? from + 1 : Math.max(0, from);
+  const n = entries.length;
+  for (let k = 0; k < n; k += 1) {
+    const i = ((start + k) % n + n) % n;
+    const entry = entries[i];
+    if (!entry.disabled && fold(entry.option.label).trimStart().startsWith(needle)) return i;
+  }
+  return -1;
+}
+function selectOptionMatches(option, query) {
+  const needle = fold(query).trim();
+  if (!needle) return true;
+  return [option.label, ...option.keywords ?? []].some((part) => fold(part).includes(needle));
+}
+function filterSelectItems(items, query) {
+  if (!fold(query).trim()) return [...items];
+  const out = [];
+  for (const item of items) {
+    if (isSelectGroup(item)) {
+      const options = item.options.filter((o) => selectOptionMatches(o, query));
+      if (options.length) out.push({ ...item, options });
+    } else if (selectOptionMatches(item, query)) {
+      out.push(item);
+    }
+  }
+  return out;
+}
+const countSelectOptions = (items) => items.reduce((n, item) => n + (isSelectGroup(item) ? item.options.length : 1), 0);
+function toValueList(value) {
+  if (value == null) return [];
+  if (Array.isArray(value)) return value.map((v) => String(v));
+  return [String(value)];
+}
+function toggleValue(values, value) {
+  return values.includes(value) ? values.filter((v) => v !== value) : [...values, value];
+}
+export {
+  buildSelectModel,
+  countSelectOptions,
+  filterSelectItems,
+  firstEnabled,
+  isSelectGroup,
+  lastEnabled,
+  moveActive,
+  selectOptionMatches,
+  toValueList,
+  toggleValue,
+  typeahead
+};

package/dist/table-engine.d.ts

@@ -71,8 +71,15 @@ interface VirtualWindow {
  * [start, end) plus `overscan` rows on each side; padTop/padBottom are spacer
  * heights (px) so the scrollbar stays correct. Below `threshold` rows, callers
  * should skip virtualization (render all) — see shouldVirtualize.
+ *
+ * `scrollTop` is clamped to what a list of `count` rows can scroll to. A scroll position left
+ * over from a longer list (5,000 rows filtered down to 150 while scrolled far down) then gives
+ * the last rows and a spacer no taller than the list, in the same pass — not an empty window
+ * under a spacer taller than everything, which the browser only corrects scroll by scroll
+ * (HAR-1616).
  */
 declare function virtualWindow(scrollTop: number, viewportH: number, rowH: number, count: number, overscan?: number): VirtualWindow;
+/** `count > threshold`: a list of exactly `threshold` rows is still rendered whole. */
 declare function shouldVirtualize(count: number, threshold?: number): boolean;
 /** Clamp a dragged column width to a sane minimum (and optional maximum). */
 declare function clampWidth(width: number, min?: number, max?: number): number;

package/dist/table-engine.js

@@ -190,7 +190,8 @@ function parseView(qs) {
 }
 function virtualWindow(scrollTop, viewportH, rowH, count, overscan = 6) {
   if (rowH <= 0 || count <= 0) return { start: 0, end: count, padTop: 0, padBottom: 0, total: 0 };
-  const first = Math.max(0, Math.floor(scrollTop / rowH) - overscan);
+  const top = Math.max(0, Math.min(scrollTop, count * rowH - viewportH));
+  const first = Math.max(0, Math.floor(top / rowH) - overscan);
   const visible = Math.ceil(viewportH / rowH) + overscan * 2;
   const end = Math.min(count, first + visible);
   return { start: first, end, padTop: first * rowH, padBottom: (count - end) * rowH, total: count * rowH };

package/dist/text-diff-model.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Two-way text diff for `TextDiff` (HAR-1368). Pure. Myers' O(ND) diff on lines or words,
+ * after trimming the common prefix and suffix. Past `maxEdits` the changed middle is shown as
+ * one replacement instead of searching further, so a rewrite never stalls the page.
+ */
+type TextDiffGranularity = 'line' | 'word';
+interface TextDiffOp {
+    type: 'equal' | 'insert' | 'delete';
+    /** Lines (granularity `line`) or word, space and punctuation tokens (`word`). */
+    tokens: string[];
+}
+interface TextDiffOptions {
+    granularity?: TextDiffGranularity;
+    /** More tokens than this on either side gives `status: 'too-large'`. Default 20 000. */
+    maxTokens?: number;
+    /** Edit budget for the search; beyond it the middle becomes one replacement. Default 2 000. */
+    maxEdits?: number;
+}
+interface TextDiffResult {
+    status: 'ok' | 'too-large';
+    granularity: TextDiffGranularity;
+    ops: TextDiffOp[];
+    /** Lines, or words (not spaces or punctuation), added and removed. */
+    added: number;
+    removed: number;
+}
+/** Splits text into lines (without their `\r\n` / `\n`) or into word, space and punctuation tokens. */
+declare function tokenizeText(text: string, granularity: TextDiffGranularity): string[];
+/** Myers diff of two token lists. Tokens compare by string equality. */
+declare function diffTokens(a: readonly string[], b: readonly string[], maxEdits?: number): TextDiffOp[];
+/** Diffs two texts by line or by word, with added/removed counts. */
+declare function diffText(before: string, after: string, { granularity, maxTokens, maxEdits }?: TextDiffOptions): TextDiffResult;
+/** A run of text inside one line; `changed` marks the words that differ from the other side. */
+interface TextDiffSegment {
+    text: string;
+    changed: boolean;
+}
+interface TextDiffLine {
+    /** 1-based line number on its side. */
+    number: number;
+    /** Word-level marks when the line was paired with a similar counterpart; otherwise one changed segment. */
+    segments: TextDiffSegment[];
+}
+type TextDiffRow = {
+    kind: 'equal';
+    before: TextDiffLine;
+    after: TextDiffLine;
+} | {
+    kind: 'change';
+    before: TextDiffLine;
+    after: TextDiffLine;
+} | {
+    kind: 'delete';
+    before: TextDiffLine;
+} | {
+    kind: 'insert';
+    after: TextDiffLine;
+} | {
+    kind: 'fold';
+    count: number;
+    rows: TextDiffRow[];
+};
+/**
+ * Rows for a line diff: unchanged lines, removed/added lines, and changed lines paired side by
+ * side with word marks. With `context`, unchanged runs longer than needed fold into one row.
+ */
+declare function textDiffRows(result: TextDiffResult, { context }?: {
+    context?: number;
+}): TextDiffRow[];
+
+export { type TextDiffGranularity, type TextDiffLine, type TextDiffOp, type TextDiffOptions, type TextDiffResult, type TextDiffRow, type TextDiffSegment, diffText, diffTokens, textDiffRows, tokenizeText };