@olddevs/ui 0.0.0-stage → 4.0.1

package/src/hooks/useOpenerFocus.ts

@@ -0,0 +1,118 @@
+"use client";
+
+import { useEffect, useRef, type RefObject } from "react";
+
+/**
+ * Возврат фокуса тому, кто открыл модальный слой.
+ *
+ * Radix возвращает фокус на свой `Dialog.Trigger`, а у кита его нет: окна
+ * открываются из состояния приложения, а не из обёрнутой кнопки. Модальный
+ * контент при этом безусловно зовёт `event.preventDefault()` и фокусирует
+ * `triggerRef`, которого не существует, — фокус уезжает на `<body>`, и
+ * пользователь клавиатуры начинает обход страницы заново.
+ *
+ * Связку завёл `Dialog`, потом повторил `Drawer`, а до `CommandPalette` она не
+ * доехала — при том что палитра существует ТОЛЬКО ради клавиатуры, и потеря
+ * фокуса там отказ основной функции, а не неудобство. Отсюда общий хук: третье
+ * повторение и есть повод вынести.
+ *
+ * Копии при этом РАЗОШЛИСЬ, и это второй довод. У `Drawer` было две проверки,
+ * которых не было у `Dialog` (см. `isOpenerCandidate`), — то есть один и тот же
+ * приём жил в двух версиях разного качества. Все три компонента зовут
+ * теперь одну.
+ */
+/**
+ * Может ли этот узел быть тем, кто открыл слой.
+ *
+ * Отсекаются ДВА случая, и оба разбирались на живых дефектах:
+ *
+ * - **`<body>`.** В StrictMode слой монтируется дважды, и на втором заходе
+ *   фокус уже уехал: `document.activeElement` равен `body`. Наивная запись
+ *   затирала настоящего открывшего, и возвращать становилось некуда. В сборке
+ *   этого нет, но разработчик смотрит на dev, и расхождение читается как
+ *   поломка.
+ * - **Содержимое СВОЕГО слоя.** Перемонтирование при уже открытом слое
+ *   запомнило бы его собственную кнопку закрытия — и фокус после закрытия
+ *   уезжал бы в никуда, потому что её к тому моменту уже нет.
+ *
+ * ИМЕННО СВОЕГО, а не «любого диалога». Первая версия этого хука отсекала всё,
+ * что лежит внутри `[role="dialog"]`, — и тем ломала ВЛОЖЕННЫЕ окна: кнопка,
+ * открывшая подтверждение, по определению лежит внутри родительского окна,
+ * то есть отвергалась, и фокус после закрытия уезжал на `<body>`. До волны 26
+ * `Dialog` такого условия не имел и работал верно; правило `Drawer`
+ * («не моё содержимое») строго сильнее и взято за основу.
+ */
+function isOpenerCandidate(
+  node: EventTarget | Element | null,
+  content: HTMLElement | null
+): node is HTMLElement {
+  return node instanceof HTMLElement && node !== document.body && !content?.contains(node);
+}
+
+export function useOpenerFocus(
+  open: boolean,
+  /** Содержимое собственного слоя: фокус внутри него открывшим не считается. */
+  contentRef: RefObject<HTMLElement | null>
+): {
+  /** В `onOpenAutoFocus`: запомнить того, кто открыл. */
+  remember: () => void;
+  /** В `onCloseAutoFocus`: вернуть ему фокус. */
+  restore: (event: Event) => void;
+} {
+  const opener = useRef<HTMLElement | null>(null);
+  const lastOutside = useRef<HTMLElement | null>(null);
+
+  /*
+    `activeElement` в `onOpenAutoFocus` — НЕ ВСЕГДА тот, кто открыл.
+
+    У `Dialog` он тот: Radix зовёт колбэк до того, как уведёт фокус внутрь. Но
+    содержимое слоя вправе забрать фокус раньше — `CommandPalette` так и делает,
+    её поле поиска автофокусируется при монтировании. Запоминался `input`
+    палитры, при закрытии он уже отцеплен, проверка `isConnected` отбрасывала
+    его — и фокус уезжал на `<body>`, то есть починка не срабатывала ровно в том
+    компоненте, ради которого писалась.
+
+    Поэтому ведём историю: последний сфокусированный узел ВНЕ модального слоя.
+
+    Слушатель висит, ПОКА СЛОЙ ЗАКРЫТ, — именно тогда и происходит то, что надо
+    запомнить. Оговорка про экономию, стоявшая здесь раньше, утверждала
+    обратное: платим мы как раз на каждом закрытом слое, а закрытых на странице
+    куда больше, чем открытых. Если это станет заметно (список, где у каждой
+    строки свой `Dialog`), историю надо сделать общей на модуль — как счётчик в
+    `useScrollLock` и стек в `overlay-layer.ts`; она и по смыслу глобальная.
+  */
+  useEffect(() => {
+    if (open) return;
+    const onFocusIn = (event: FocusEvent) => {
+      const el = event.target;
+      if (!isOpenerCandidate(el, contentRef.current)) return;
+      lastOutside.current = el;
+    };
+    document.addEventListener("focusin", onFocusIn, true);
+    return () => document.removeEventListener("focusin", onFocusIn, true);
+  }, [open]);
+
+  return {
+    remember: () => {
+      const active = document.activeElement;
+      opener.current = isOpenerCandidate(active, contentRef.current) ? active : lastOutside.current;
+    },
+    restore: (event) => {
+      /*
+        `remember` МОЖЕТ И НЕ СРАБОТАТЬ, и на это нельзя закладываться.
+
+        Radix зовёт `onOpenAutoFocus` не всегда: если содержимое слоя забрало
+        фокус само во время монтирования — а поле поиска палитры именно так и
+        делает, — колбэк не приходит вовсе (проверено). Поэтому история
+        `lastOutside` не подстраховка, а полноценный источник: `remember`
+        уточняет её там, где успевает.
+      */
+      const el = opener.current ?? lastOutside.current;
+      // `isConnected` обязателен: кнопка, открывшая слой, могла исчезнуть
+      // вместе с элементом списка, который слой и редактировал.
+      if (!el?.isConnected) return;
+      event.preventDefault();
+      el.focus();
+    },
+  };
+}

package/src/hooks/useOverlayLayer.ts

@@ -0,0 +1,42 @@
+"use client";
+
+import { useEffect, useRef, type RefObject } from "react";
+import { pushOverlayLayer } from "../lib/overlay-layer.js";
+
+/**
+ * Регистрация модального слоя в общем стеке (ADR-0041).
+ *
+ * Хук, а не прямой вызов в каждом компоненте, по двум причинам.
+ *
+ * ПЕРВАЯ — жизненный цикл. Регистрировать надо ИМЕННО В ЭФФЕКТЕ: стек —
+ * модульный, и запись в него из тела компонента была бы побочным действием
+ * рендера. В StrictMode React монтирует, размонтирует и монтирует снова, и
+ * слой, положенный в рендере и снятый уборщиком, обратно уже не попадал —
+ * подложка переставала считать себя верхней и молча переставала закрываться по
+ * Escape. Один правильный цикл лучше четырёх копий.
+ *
+ * ВТОРАЯ — охват. ADR обещает, что в стеке состоят ВСЕ модальные слои кита, и
+ * первая версия обещание не держала: регистрировался один `ModalOverlay`, то
+ * есть стек решал «подложка против подложки» и ничего больше.
+ */
+export function useOverlayLayer(
+  open: boolean,
+  /** Узел слоя: по его положению в документе и определяется верхний. */
+  nodeRef: RefObject<HTMLElement | null>
+): { isTopmost: () => boolean } {
+  const layerRef = useRef<ReturnType<typeof pushOverlayLayer> | null>(null);
+
+  useEffect(() => {
+    if (!open) return;
+    const layer = pushOverlayLayer();
+    layer.attach(nodeRef.current);
+    layerRef.current = layer;
+    return () => {
+      layer.release();
+      layerRef.current = null;
+    };
+  }, [open, nodeRef]);
+
+  // Незарегистрированный слой верхним себя не считает: он закрыт.
+  return { isTopmost: () => layerRef.current?.isTopmost() ?? false };
+}

package/src/hooks/useScrollLock.ts

@@ -0,0 +1,92 @@
+"use client";
+
+import { useEffect, useRef } from "react";
+
+/**
+ * Счётчик замков — МОДУЛЬНЫЙ, и это принципиально.
+ *
+ * Модалки вкладываются: поверх окна редактирования открывается диалог
+ * подтверждения. Закрываясь, вложенный диалог не должен разблокировать
+ * прокрутку, пока внешнее окно ещё открыто. Считаем замки, снимаем блокировку
+ * на последнем.
+ *
+ * Отсюда же следует, что копий этого модуля в приложении должна быть РОВНО ОДНА.
+ * Два счётчика (например, свой во фронте и свой в пакете) не видят друг друга,
+ * и вложенный случай ломается молча: внутренний диалог снимает блокировку,
+ * которую ставил внешний. Поэтому хук живёт здесь, рядом с классом
+ * `body.scroll-locked` из `styles.css`, а не дублируется у потребителя.
+ */
+let lockCount = 0;
+
+/**
+ * Чей отступ стоял на `<body>` до первого замка.
+ *
+ * Замок ВОЗВРАЩАЕТ прежнее значение, а не стирает его. Раньше снятие
+ * присваивало `paddingRight = ""` безусловно, и приложение, держащее на
+ * `<body>` собственный inline-отступ (скажем, компенсацию под свою
+ * фиксированную панель), теряло его навсегда после первого же открытого
+ * диалога кита — до перезагрузки страницы.
+ *
+ * Модульная переменная рядом со счётчиком и по той же причине: замки
+ * вкладываются, и запомнить исходное состояние можно только на переходе 0→1.
+ */
+let paddingBeforeLock = "";
+/** Что положил сам замок — чтобы не затереть чужую правку. */
+let paddingSetByLock = "";
+
+function applyLock() {
+  // Полоса прокрутки исчезает вместе с прокруткой, и содержимое прыгает вбок
+  // на её ширину. Компенсируем отступом.
+  const scrollbarWidth = window.innerWidth - document.documentElement.clientWidth;
+  paddingBeforeLock = document.body.style.paddingRight;
+  document.body.classList.add("scroll-locked");
+  paddingSetByLock = scrollbarWidth > 0 ? `${scrollbarWidth}px` : "";
+  if (paddingSetByLock) document.body.style.paddingRight = paddingSetByLock;
+}
+
+function removeLock() {
+  document.body.classList.remove("scroll-locked");
+
+  /*
+    Возвращаем прежнее значение — но только если в стиле всё ещё ЛЕЖИТ НАШЕ.
+
+    Приложение вправе поменять отступ и при поднятом замке (своя панель
+    появилась, пока открыт диалог). Безусловное восстановление затёрло бы эту
+    правку — то есть тот же дефект, что чинился здесь, только с другой стороны.
+  */
+  if (document.body.style.paddingRight === paddingSetByLock) {
+    if (paddingBeforeLock) document.body.style.paddingRight = paddingBeforeLock;
+    else document.body.style.removeProperty("padding-right");
+  }
+  paddingBeforeLock = "";
+  paddingSetByLock = "";
+}
+
+/** Блокирует прокрутку страницы, пока `isLocked` истинно. */
+export function useScrollLock(isLocked: boolean): void {
+  const wasLocked = useRef(false);
+
+  useEffect(() => {
+    if (isLocked && !wasLocked.current) {
+      if (lockCount === 0) applyLock();
+      lockCount++;
+      wasLocked.current = true;
+    } else if (!isLocked && wasLocked.current) {
+      lockCount = Math.max(0, lockCount - 1);
+      if (lockCount === 0) removeLock();
+      wasLocked.current = false;
+    }
+  }, [isLocked]);
+
+  // Размонтирование при поднятом замке — обычное дело: компонент с модалкой
+  // может исчезнуть вместе с ней. Без этого счётчик залипает навсегда.
+  useEffect(() => {
+    return () => {
+      if (wasLocked.current) {
+        lockCount = Math.max(0, lockCount - 1);
+        if (lockCount === 0) removeLock();
+        wasLocked.current = false;
+      }
+    };
+  }, []);
+}

package/src/hooks/useStickyOffset.ts

@@ -0,0 +1,228 @@
+"use client";
+
+import { useCallback, useEffect, useRef, useState } from "react";
+
+export interface StickyOffsetOptions {
+  /**
+   * Имя CSS-переменной, в которой приложение публикует высоту своей верхней
+   * панели. Проп, а не константа: пакет не знает, что у потребителя есть
+   * шапка, как она называется и есть ли она вообще ([ADR-0016]).
+   */
+  offsetVar?: string;
+  /** Смещение, когда переменной нет. Это законное состояние, а не ошибка. */
+  fallback?: string;
+}
+
+export interface StickyOffset {
+  /**
+   * Вешается на пустой блок нулевой высоты **прямо перед** липким элементом.
+   * Пересечение именно этого блока и означает, что полоса встала на место.
+   *
+   * Callback-ref, а не объект: полоса бывает условной и появляется позже самой
+   * страницы, а эффект на монтировании такой маркер попросту не застаёт.
+   */
+  sentinelRef: (node: HTMLElement | null) => void;
+  /** Полоса прижалась к верхней границе. */
+  isStuck: boolean;
+}
+
+/**
+ * Отступ со сменённым знаком.
+ *
+ * Приписывать минус строкой НЕЛЬЗЯ: опубликованное значение само бывает
+ * отрицательным, и `-` + `-10px` давало `--10px` — `SyntaxError` в конструкторе
+ * наблюдателя, то есть падение поддерева. Ровно тот отказ, ради которого писан
+ * `toPixels`, только через другой вход.
+ */
+function negate(value: string): string {
+  return value.startsWith("-") ? value.slice(1) : `-${value}`;
+}
+
+/**
+ * Приводит опубликованную длину к пикселям.
+ *
+ * `IntersectionObserver` принимает ТОЛЬКО пиксели и проценты и бросает
+ * `SyntaxError` на всём остальном. Значение уходило в `rootMargin` как есть, а
+ * кит нигде не требует от приложения публиковать высоту именно в пикселях:
+ * `--topbar-h: 4rem` роняло полосу и всё поддерево во время коммита.
+ *
+ * Единицы, которые браузер понимает сам, пропускаются без работы; остальные
+ * меряются одноразовым элементом. Мерить приходится в документе — вне его
+ * раскладки нет. Вызывающий обязан отсечь повтор ДО вызова (см. `rawRef`):
+ * замер стоит двух принудительных пересчётов раскладки.
+ *
+ * Пределы, принятые осознанно: `em` меряется относительно шрифта `body`, а не
+ * шапки; отрицательное значение в неизвестных единицах браузер отбрасывает, и
+ * получается `0px` (в пикселях знак сохраняется).
+ */
+export function toPixels(value: string, fallback: string): string {
+  const raw = value || fallback;
+  // Пустая строка сюда доходит, когда потребитель передал пустой `fallback`:
+  // тип пропа этого не запрещает. Без нормализации получался `rootMargin`
+  // вида `"- 0px 0px 0px"` — то есть ровно то падение, ради которого функция и
+  // написана, только через другой вход.
+  if (raw === "") return "0px";
+  // Число, а не `[\d.]+`: тот класс принимает `1.2.3` и `..`, то есть пропускал
+  // бы мимо замера значение, которое браузер отвергнет, — и падение возвращалось
+  // бы тем же путём, каким пришло с `4rem`.
+  if (/^-?(\d+(\.\d+)?|\.\d+)(px|%)$/.test(raw)) return raw;
+
+  const probe = document.createElement("div");
+  // `setProperty`, а не `cssText`: значение приходит из CSS приложения, и
+  // собственные объявления внутри него затёрли бы защитные свойства зонда.
+  probe.style.position = "absolute";
+  probe.style.visibility = "hidden";
+  probe.style.pointerEvents = "none";
+  probe.style.setProperty("height", raw);
+  document.body.appendChild(probe);
+  const px = probe.getBoundingClientRect().height;
+  probe.remove();
+  return Number.isFinite(px) ? `${px}px` : fallback || "0px";
+}
+
+/**
+ * Липкая полоса: знает, прижалась ли она уже к верхней панели приложения.
+ *
+ * Отсчёт идёт от НАСТОЯЩЕЙ высоты панели, а не от зашитого числа: на узких
+ * экранах шапка ниже, чем на широких, и константа оставляет просвет, сквозь
+ * который видно уезжающий контент. Высоту публикует приложение — в CSS-переменной,
+ * имя которой здесь проп. Решение и отвергнутые варианты — [ADR-0016].
+ *
+ * Потребитель обычно использует `isStuck`, чтобы убрать верхние скругления:
+ * у прижавшейся полосы они приоткрывают фон страницы уголками на стыке.
+ */
+export function useStickyOffset({
+  offsetVar = "--topbar-h",
+  fallback = "0px",
+}: StickyOffsetOptions = {}): StickyOffset {
+  const [isStuck, setIsStuck] = useState(false);
+  const nodeRef = useRef<HTMLElement | null>(null);
+  const observerRef = useRef<IntersectionObserver | null>(null);
+  /** Последний применённый отступ: пересоздавать наблюдателя ради того же числа незачем. */
+  const appliedRef = useRef<string | null>(null);
+  /** Сырое значение переменной, из которого этот отступ получен. */
+  const rawRef = useRef<string | null>(null);
+
+  const connect = useCallback(() => {
+    const node = nodeRef.current;
+    if (!node) return;
+    // Отсутствие API — законное состояние, а не ошибка: на сервере его нет
+    // вовсе, а в тестах потребителя jsdom его не подкладывает. Полоса просто
+    // никогда не считается прижатой.
+    if (typeof IntersectionObserver === "undefined") return;
+
+    /*
+      Сначала сравниваем СЫРУЮ строку — до всякой работы.
+
+      Отсечка стояла после `toPixels`, и это расходилось с её же комментарием
+      («только при смене значения»): `getComputedStyle` корня и цикл зонда
+      платились на каждый вызов. А вызовов много: наблюдатель за `style` корня
+      будят и `usePreventScroll` из react-aria (он пишет туда `overflow` и
+      `padding-right` при открытии ЛЮБОГО оверлея — то есть половина кита), и
+      переключатель темы приложения, и `--vh`-полифилл. С `4rem` это давало два
+      принудительных пересчёта раскладки на каждое такое пробуждение.
+    */
+    const raw = getComputedStyle(document.documentElement).getPropertyValue(offsetVar).trim();
+    if (raw === rawRef.current && observerRef.current) return;
+    rawRef.current = raw;
+
+    const offset = toPixels(raw, fallback);
+    if (offset === appliedRef.current && observerRef.current) return;
+
+    observerRef.current?.disconnect();
+    appliedRef.current = offset;
+    observerRef.current = new IntersectionObserver(
+      ([entry]) => {
+        if (entry) setIsStuck(!entry.isIntersecting);
+      },
+      { rootMargin: `${negate(offset)} 0px 0px 0px` }
+    );
+    observerRef.current.observe(node);
+  }, [offsetVar, fallback]);
+
+  const sentinelRef = useCallback(
+    (node: HTMLElement | null) => {
+      nodeRef.current = node;
+      if (node) {
+        connect();
+        return;
+      }
+      observerRef.current?.disconnect();
+      observerRef.current = null;
+      appliedRef.current = null;
+      rawRef.current = null;
+      setIsStuck(false);
+    },
+    [connect]
+  );
+
+  useEffect(() => {
+    /*
+      Пересборка сводится к одной на кадр.
+
+      Обработчиком `resize` стоял сам `connect`, а он делает синхронный
+      `getComputedStyle` корня (принудительный пересчёт стилей) и полный цикл
+      жизни наблюдателя. Протягивание рамки окна мышью даёт десятки событий в
+      секунду, и каждый новый наблюдатель выдавал стартовый колбэк — скругления
+      липкой полосы подрагивали. Вдобавок значение переменной при этом почти
+      всегда одно и то же: высота меняется на брейкпоинте, а не на каждом
+      пикселе.
+    */
+    let frame = 0;
+    const schedule = () => {
+      if (frame) return;
+      frame = requestAnimationFrame(() => {
+        frame = 0;
+        connect();
+      });
+    };
+
+    window.addEventListener("resize", schedule);
+
+    /*
+      Ширины окна НЕДОСТАТОЧНО. Парная сторона контракта (`TopBar`) публикует
+      высоту через `ResizeObserver` и в комментарии прямо называет причины, не
+      связанные с шириной: перенос содержимого слотов и вторая строка в поиске.
+      Шапка становится двухстрочной, `--topbar-h` уезжает с 56 на 96, а
+      `rootMargin` оставался прежним — полоса считала себя прижатой на 40px
+      раньше, чем прижималась.
+
+      Наблюдаем не за шапкой (хук про неё ничего не знает — ADR-0016), а за
+      атрибутом `style` корня: переменную публикуют именно туда.
+    */
+    const mutations =
+      typeof MutationObserver === "undefined" ? null : new MutationObserver(schedule);
+    mutations?.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["style"],
+    });
+
+    /*
+      Наблюдатель ставится ЗДЕСЬ, а не только из callback-ref.
+
+      Смена `offsetVar` меняет идентичность `connect`, а с ней и `sentinelRef`.
+      React отцепляет старый ref (обнуляя рефы), цепляет новый — тот создаёт
+      живой наблюдатель, — и ТОЛЬКО ПОТОМ гоняет уборщик старого пассивного
+      эффекта, который этот свежий наблюдатель и отключал. Пока отсечек в
+      `connect` не было, следующий `resize` пересоздавал его безусловно, и сбой
+      сам собой лечился. Отсечки по значению (выше) эту страховку убрали:
+      мёртвый, но не обнулённый `observerRef` выглядит для них живым, и полоса
+      замирала НАВСЕГДА.
+    */
+    connect();
+
+    return () => {
+      if (frame) cancelAnimationFrame(frame);
+      window.removeEventListener("resize", schedule);
+      mutations?.disconnect();
+      observerRef.current?.disconnect();
+      // Сброс тот же, что в ветке отключения узла: иначе отсечки принимают
+      // отключённый наблюдатель за действующий.
+      observerRef.current = null;
+      appliedRef.current = null;
+      rawRef.current = null;
+    };
+  }, [connect]);
+
+  return { sentinelRef, isStuck };
+}

package/src/hooks/useTableState.ts

@@ -0,0 +1,76 @@
+"use client";
+
+import { useCallback, useMemo, useState } from "react";
+import { useUiConfig } from "../i18n/useMessages.js";
+import { DEFAULT_TABLE_STATE, type TableState } from "../lib/table-state.js";
+
+export interface TableStateApi {
+  state: TableState;
+  /**
+   * Изменить часть состояния. Один обновлятель, а не десять именованных
+   * обработчиков: инварианты ниже обязаны срабатывать независимо от того, что
+   * именно поменяли, и разложенные по десяти функциям они разъехались бы.
+   */
+  set: (patch: Partial<TableState>) => void;
+  /** Вернуть начальное состояние целиком. */
+  reset: () => void;
+}
+
+/**
+ * Состояние таблицы: форма и связи между её частями.
+ *
+ * Хук **ничего не хранит вне React** и ни на что не подписывается — ни на
+ * маршрутизатор, ни на хранилище. Кит описывает форму, владеет ею потребитель
+ * (ADR-0023). Перенос в адрес — `tableStateToParams` / `tableStateFromParams`,
+ * применять их к адресу тоже дело приложения.
+ *
+ * ИНВАРИАНТЫ, ради которых хук вообще существует:
+ *
+ * - смена фильтров, сортировки или РАЗМЕРА СТРАНИЦЫ **сбрасывает страницу на
+ *   первую**. Иначе
+ *   пользователь оказывается на четвёртой странице выборки из десяти строк и
+ *   видит пустоту, приняв её за «ничего не найдено»;
+ * - выделение при этом **не сбрасывается**. Обратное выглядит аккуратнее и
+ *   срывает массовое действие ровно тогда, когда оно нужнее всего: отметил
+ *   строки, перелистнул — потерял всё.
+ *
+ * Начальная плотность берётся у `UiProvider`, если её не задали явно: админка
+ * с пятью таблицами объявляет её один раз.
+ */
+export function useTableState(initial: Partial<TableState> = {}): TableStateApi {
+  const { density: providerDensity } = useUiConfig();
+
+  const start = useMemo<TableState>(
+    () => ({ ...DEFAULT_TABLE_STATE, density: providerDensity, ...initial }),
+    // Начальное значение и есть начальное: пересобирать его на каждое
+    // изменение пропов значило бы сбрасывать состояние пользователя под ним.
+    []
+  );
+
+  const [state, setState] = useState<TableState>(start);
+
+  const set = useCallback((patch: Partial<TableState>) => {
+    setState((prev) => {
+      const next = { ...prev, ...patch };
+
+      // Страницу сбрасывает смена выборки, а не любое изменение: смена
+      // плотности или видимости колонок оставляет пользователя там, где он был.
+      const narrowed =
+        ("filters" in patch && patch.filters !== prev.filters) ||
+        ("sort" in patch && patch.sort !== prev.sort) ||
+        // `pageSize` меняет ЧИСЛО СТРАНИЦ напрямую, и без него инвариант
+        // держался наполовину: 200 строк, размер 25 → 100 со страницы 8 дают
+        // `slice(700, 800)` — пусто, и таблица рисует «ничего не найдено».
+        // Само это не чинится: `Pagination` зажимает страницу только у себя и
+        // подсвечивает «2», пока таблица пуста.
+        ("pageSize" in patch && patch.pageSize !== prev.pageSize);
+
+      if (narrowed && !("page" in patch)) next.page = 1;
+      return next;
+    });
+  }, []);
+
+  const reset = useCallback(() => setState(start), [start]);
+
+  return { state, set, reset };
+}