urfu-ui-kit-react 2.1.3 → 2.1.4

package/dist/components/Table/TableRow.js

@@ -0,0 +1,136 @@
+import { jsx as p, jsxs as X } from "react/jsx-runtime";
+import { adaptTypographyStyle$u as S, pxAdd$u as w } from "./Table.helpers.js";
+import { handleDragOver$u as Y, handleDragStart$u as o } from "./Functions.js";
+const q = "auto", J = ({
+  item: r,
+  i: e,
+  level: k,
+  rowKey: b,
+  absoluteIndex: s,
+  filteredColumns: f,
+  id: $,
+  virtualizationOn: h,
+  start: j,
+  draggable: L,
+  rowRefs: D,
+  resize: a,
+  columnWidths: y,
+  parentDataField: i,
+  calcLeftValues: W,
+  handleDrop: x,
+  insertChildRows: B,
+  removeChildRows: E,
+  cellStyle: N,
+  tdStyle: A,
+  allTdStyleFunction: g,
+  cellContentStyle: M,
+  tdContentStyle: R,
+  allTdContentStyleFunction: v,
+  fillColumnIndex: O = -1
+}) => /* @__PURE__ */ p(
+  "tr",
+  {
+    "data-virtual-index": h && s !== void 0 ? s : void 0,
+    id: `row${k ? `${k}.` : ""}${e}`,
+    draggable: L,
+    onDragStart: (t) => o(t, String(e)),
+    onDragOver: (t) => Y(t),
+    onDrop: (t) => x(t, e),
+    ref: h && s !== void 0 ? (t) => {
+      D.current[s] = t;
+    } : void 0,
+    children: f == null ? void 0 : f.map((t, d) => /* @__PURE__ */ X(
+      "td",
+      {
+        id: `${$}td${e}${d}`,
+        className: `${t.sticky ? "sticky" : ""}`,
+        style: S(
+          Object.assign(
+            {
+              left: t.sticky ? W(d) : "",
+              // Вид по умолчанию 2.0 — как в Meetings: 15px сверху и снизу,
+              // боковой отступ держит блок содержимого (.u-table-td-content).
+              // Инлайном, потому что vanilla задаёт ячейке свои 20px и порядок
+              // подключения стилей у проектов разный. tdStyle по-прежнему главнее.
+              padding: "calc(15 * var(--u-unit, 1px)) 0",
+              display: i && d === 0 && r[i] ? "flex" : "table-cell",
+              gap: "calc(4 * var(--u-preset-unit, 1px))"
+            },
+            N,
+            A,
+            t.tdStyle,
+            t.cellStyle,
+            g && g(r),
+            t.tdStyleFunction && t.tdStyleFunction(r)
+          )
+        ),
+        children: [
+          /* @__PURE__ */ p(
+            "div",
+            {
+              className: "u-table-td-content",
+              style: S(
+                Object.assign(
+                  {
+                    // Растянутая колонка: width колонки — нижняя граница, иначе текст
+                    // переносится по ней посреди широкой пустой ячейки, а скелетон
+                    // меряет тот же узкий блок и висит по центру.
+                    width: d === O && !(a && !t.resizeOff) ? "100%" : a && !t.resizeOff && (t != null && t.width) ? y[t.field] >= t.width ? y[t.field] : w(t.width) : a && !t.resizeOff || t != null && t.width ? y[t.field] || (t == null ? void 0 : t.width) : q,
+                    minWidth: d === O && !(a && !t.resizeOff) && t.width ? w(t.width) : a && !t.resizeOff && t.width ? w(t.width) : "",
+                    position: t.sticky ? "sticky" : "",
+                    overflowX: "hidden",
+                    // break-word, а не anywhere: с anywhere минимальная ширина колонки без width — одна буква,
+                    // и на узком экране слова рвались посередине («Петр/ов»). Как во Vue-ките.
+                    overflowWrap: "break-word",
+                    overflowY: "hidden",
+                    display: "-webkit-box",
+                    WebkitLineClamp: 15,
+                    WebkitBoxOrient: "vertical"
+                  },
+                  M,
+                  R,
+                  t.tdContentStyle,
+                  t.cellContentStyle,
+                  v && v(r),
+                  t.tdContentStyleFunction && t.tdContentStyleFunction(r)
+                )
+              ),
+              children: t.render ? t.render(r, e) : r[t.field]
+            }
+          ),
+          !r.notExpandable && i && d === 0 && r[i] && r[i].length > 0 && /* @__PURE__ */ p(
+            "svg",
+            {
+              width: "12",
+              height: "12",
+              viewBox: "0 0 12 13",
+              fill: "none",
+              style: {
+                cursor: "pointer",
+                margin: "auto calc(8 * var(--u-preset-unit, 1px)) auto auto",
+                transform: r.parentDataOpened ? "rotate(180deg)" : "",
+                transition: "transform 0.2s ease"
+              },
+              onClick: () => {
+                r.parentDataOpened ? E(e) : B(e);
+              },
+              children: /* @__PURE__ */ p(
+                "path",
+                {
+                  d: "M1 4.5625L5.99999 9.5625L11 4.5625",
+                  stroke: "#1E4391",
+                  strokeWidth: "2",
+                  strokeLinecap: "round",
+                  strokeLinejoin: "round"
+                }
+              )
+            }
+          )
+        ]
+      },
+      t.key ? t.key : t.field ? t.field : d
+    ))
+  },
+  b ?? r.id ?? (h ? j + e : e)
+);
+export { J as TableRow$u };

package/dist/components/Table/useColumnResize.d.ts

@@ -1,9 +1,10 @@
+import { type MouseEvent as ReactMouseEvent } from "react";
 import type { TableColumnsProperties } from "./Table.types";
 export declare const useColumnResize: (columns: TableColumnsProperties[], resize?: boolean) => {
     columnWidths: Record<string, number>;
     lookColumnWidths: Record<string, number>;
     setLookColumnWidths: import("react").Dispatch<import("react").SetStateAction<Record<string, number>>>;
-    handleMouseDown: (e: any, id: any) => void;
-    thRefs: import("react").MutableRefObject<{}>;
+    handleMouseDown: (e: ReactMouseEvent, id: string) => void;
+    thRefs: import("react").MutableRefObject<Record<string, HTMLElement>>;
 };
 //# sourceMappingURL=useColumnResize.d.ts.map

package/dist/components/Table/useColumnResize.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useColumnResize.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useColumnResize.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAK5D,eAAO,MAAM,eAAe,GAC1B,SAAS,sBAAsB,EAAE,EACjC,SAAS,OAAO;;;;;;CAiFjB,CAAC"}
+{"version":3,"file":"useColumnResize.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useColumnResize.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,UAAU,IAAI,eAAe,EAAE,MAAM,OAAO,CAAC;AAExF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAK5D,eAAO,MAAM,eAAe,GAC1B,SAAS,sBAAsB,EAAE,EACjC,SAAS,OAAO;;;;yBA2BY,eAAe,MAAM,MAAM;;CAsDxD,CAAC"}

package/dist/components/Table/useColumnResize.js

@@ -0,0 +1,44 @@
+import { useState as f, useRef as w, useEffect as E } from "react";
+import { columnWidthsFormatter$u as L } from "./Functions.js";
+const X = (u, h) => {
+  const i = u.reduce(
+    (t, e) => (e.field != null && e.width != null && (t[e.field] = e.width), t),
+    {}
+  ), [r, v] = f({}), [d, c] = f({}), m = w({}), a = (t, e) => {
+    const n = { ...r };
+    n[t] = i[t] ? e < i[t] ? i[t] : e : e > 30 ? e : 30, c(n);
+  }, C = (t, e) => {
+    t.preventDefault();
+    const n = t.clientX, o = (l) => {
+      const W = l.clientX - n, p = r[e] + W;
+      a(e, p);
+    }, s = () => {
+      document.removeEventListener("mousemove", o), document.removeEventListener("mouseup", s);
+    };
+    document.addEventListener("mousemove", o), document.addEventListener("mouseup", s);
+  };
+  return E(() => {
+    if (h) {
+      const t = u.reduce((e, n) => {
+        var s, l;
+        const o = (l = (s = m.current[n.field]) == null ? void 0 : s.getBoundingClientRect()) == null ? void 0 : l.width;
+        return n.field != null && o != null && (e[n.field] = o), e;
+      }, {});
+      v(
+        L(
+          t,
+          Object.keys(d).length === 0 ? t : d,
+          i,
+          u
+        )
+      );
+    }
+  }, [u, d]), {
+    columnWidths: r,
+    lookColumnWidths: d,
+    setLookColumnWidths: c,
+    handleMouseDown: C,
+    thRefs: m
+  };
+};
+export { X as useColumnResize$u };

package/dist/components/Table/useDelayedSkeleton.d.ts

@@ -1,5 +1,3 @@
-/** Сколько скелетон, появившийся после задержки, держится на экране: короче — он только мелькнёт. */
-export declare const SKELETON_MIN_VISIBLE = 300;
 /**
  * Скелетон повторной загрузки без мигания.
  *

package/dist/components/Table/useDelayedSkeleton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useDelayedSkeleton.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useDelayedSkeleton.ts"],"names":[],"mappings":"AAEA,qGAAqG;AACrG,eAAO,MAAM,oBAAoB,MAAM,CAAC;AAexC;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM;IAsDtG,2BAA2B;;IAE3B,wDAAwD;;IAExD,gFAAgF;;EAGnF"}
+{"version":3,"file":"useDelayedSkeleton.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useDelayedSkeleton.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,EAAE,OAAO,GAAG,SAAS,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM;IAsDtG,2BAA2B;;IAE3B,wDAAwD;;IAExD,gFAAgF;;EAGnF"}

package/dist/components/Table/useDelayedSkeleton.js

@@ -0,0 +1,32 @@
+import { useReducer as f, useRef as d, useEffect as c } from "react";
+const u = 300, p = (n) => !!n && n.length > 0;
+function g(n, o, i) {
+  const [, l] = f((t) => t + 1, 0), r = d({ phase: "idle", shown: void 0, skeletonAt: 0, delayed: !1 }), h = d(o);
+  h.current = o;
+  const e = r.current;
+  n ? e.phase === "idle" ? i > 0 && p(e.shown) ? e.phase = "waiting" : (e.phase = "skeleton", e.skeletonAt = Date.now(), e.delayed = !1) : e.phase === "holding" && (e.phase = "skeleton") : (e.phase === "waiting" ? e.phase = "idle" : e.phase === "skeleton" && (e.phase = e.delayed && Date.now() - e.skeletonAt < u ? "holding" : "idle"), e.phase === "idle" && (e.shown = o));
+  const { phase: s } = e;
+  return c(() => {
+    const t = r.current;
+    if (s === "waiting") {
+      const a = setTimeout(() => {
+        t.phase === "waiting" && (t.phase = "skeleton", t.skeletonAt = Date.now(), t.delayed = !0, l());
+      }, i);
+      return () => clearTimeout(a);
+    }
+    if (s === "holding") {
+      const a = setTimeout(() => {
+        t.phase === "holding" && (t.phase = "idle", t.shown = h.current, l());
+      }, Math.max(0, u - (Date.now() - t.skeletonAt)));
+      return () => clearTimeout(a);
+    }
+  }, [s, i]), {
+    /** Показывать скелетон. */
+    isLoading: s === "skeleton" || s === "holding",
+    /** Строки для таблицы: пока ждём задержку — прежние. */
+    data: s === "waiting" ? e.shown : o,
+    /** Идёт загрузка (для aria-busy), в том числе пока на экране прежние строки. */
+    isBusy: !!n || s !== "idle"
+  };
+}
+export { g as useDelayedSkeleton$u };

package/dist/components/Table/useMobileFilterColumns.d.ts

@@ -7,7 +7,7 @@ interface Options<Row> {
     enabled: boolean;
     columns?: readonly TableColumnsProperties<Row>[];
     rows: readonly Row[];
-    sort: TableSortState;
+    sort: TableSortState | undefined;
     sortField?: string;
     sortDir?: 'asc' | 'desc';
     onSortToggle: (field: string) => void;

package/dist/components/Table/useMobileFilterColumns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMobileFilterColumns.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useMobileFilterColumns.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D,UAAU,OAAO,CAAC,GAAG;IACnB,iDAAiD;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,SAAS,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC;IACjD,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IACrB,IAAI,EAAE,cAAc,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACzB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,OAAO,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACvC,UAAU,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC;CAC9C;AAID;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,GAAG,CAAC;;wBAqCpH,MAAM;EAclC"}
+{"version":3,"file":"useMobileFilterColumns.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useMobileFilterColumns.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC5D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAG1D,UAAU,OAAO,CAAC,GAAG;IACnB,iDAAiD;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,SAAS,sBAAsB,CAAC,GAAG,CAAC,EAAE,CAAC;IACjD,IAAI,EAAE,SAAS,GAAG,EAAE,CAAC;IACrB,IAAI,EAAE,cAAc,GAAG,SAAS,CAAC;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,KAAK,GAAG,MAAM,CAAC;IACzB,YAAY,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,OAAO,EAAE,kBAAkB,CAAC,SAAS,CAAC,CAAC;IACvC,UAAU,EAAE,kBAAkB,CAAC,YAAY,CAAC,CAAC;CAC9C;AAID;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,OAAO,CAAC,GAAG,CAAC;;wBAqCpH,MAAM;EAclC"}

package/dist/components/Table/useMobileFilterColumns.js

@@ -0,0 +1,52 @@
+import { jsx as E } from "react/jsx-runtime";
+import { useState as P, useRef as v, useCallback as R } from "react";
+import { FilterPanel$u as V } from "./Filter/FilterPanel.js";
+import { getServerFilterSelectionKey$u as C, getFilterSelectedCount$u as _, hasColumnValues$u as S, isServerFilterActive$u as q } from "./Table.helpers.js";
+function I({ enabled: p, columns: i, rows: c, sort: F, sortField: b, sortDir: g, onSortToggle: h, filters: x, setFilters: K }) {
+  const [A, M] = P({}), f = v(i);
+  f.current = i;
+  const o = v(/* @__PURE__ */ new Map()), j = R((e) => {
+    let t = o.current.get(e);
+    return t || (t = (r) => {
+      var d;
+      const l = (d = f.current) == null ? void 0 : d.find((n) => n.field === e), s = C(l == null ? void 0 : l.filterServer);
+      s && M((n) => {
+        var a, u;
+        return ((a = n[e]) == null ? void 0 : a.selectionKey) === s && ((u = n[e]) == null ? void 0 : u.count) === r ? n : { ...n, [e]: { selectionKey: s, count: r } };
+      });
+    }, o.current.set(e, t)), t;
+  }, []);
+  return !p || !i ? { options: void 0, renderFilter: void 0 } : (o.current.forEach((e, t) => {
+    i.some((r) => r.field === t) || o.current.delete(t);
+  }), { options: i.map((e) => {
+    const t = A[e.field];
+    return {
+      key: e.field,
+      label: e.title,
+      active: e.filterActive ?? q(e.filterServer),
+      disabled: !S(c, e),
+      selectedCount: _({ filter: e.filterServer, explicitCount: e.filterSelectedCount }) ?? ((t == null ? void 0 : t.selectionKey) === C(e.filterServer) ? t == null ? void 0 : t.count : void 0),
+      sort: b === e.field ? g : void 0
+    };
+  }), renderFilter: (e) => {
+    const t = i.find((l) => l.field === e);
+    if (!(t != null && t.filterServer)) return null;
+    const r = { ...t, sticky: !1 };
+    return /* @__PURE__ */ E(
+      V,
+      {
+        column: r,
+        common: {
+          column: r,
+          embedded: !0,
+          sort: F,
+          handleSort: S(c, t) ? () => h(e) : void 0,
+          onSelectedCountChange: j(e)
+        },
+        context: { filters: x, setFilters: K, close: () => {
+        } }
+      }
+    );
+  } });
+}
+export { I as useMobileFilterColumns$u };

package/dist/components/Table/useStableColumnWidths.js

@@ -0,0 +1,22 @@
+import { useState as a, useLayoutEffect as b } from "react";
+const d = (n, i) => n.field ?? n.title ?? String(i);
+function O(n, i, c, g) {
+  const [o, f] = a({}), S = JSON.stringify(i.map((t, s) => [d(t, s), t.width]));
+  return b(() => {
+    var s;
+    if (!c) {
+      f((e) => Object.keys(e).length ? {} : e);
+      return;
+    }
+    if (!g) return;
+    const t = (s = n.current) == null ? void 0 : s.querySelectorAll("thead > tr > th");
+    !(t != null && t.length) || t.length !== i.length || f((e) => {
+      const r = {};
+      return i.forEach((h, l) => {
+        const y = d(h, l), u = h.width || e[y] || t[l].getBoundingClientRect().width;
+        u > 0 && (r[y] = u);
+      }), Object.keys(e).length === Object.keys(r).length && Object.keys(r).every((h) => e[h] === r[h]) ? e : r;
+    });
+  }, [n, S, c, g]), o;
+}
+export { d as getStableColumnKey$u, O as useStableColumnWidths$u };

package/dist/components/Table/useTableColumnPinning.d.ts

@@ -1,60 +1,5 @@
 import type { RefObject } from 'react';
 import type { TableColumnsProperties } from './Table.types';
-/** Явные стороны — opt-in группировка; legacy boolean сохраняет переданный порядок. */
-export declare function orderPinnedColumns<Row>(columns: TableColumnsProperties<Row>[]): Partial<{
-    sticky: boolean | "left" | "right";
-    stickyOverflowOnly: boolean;
-    width: number;
-    tdStyle: import("react").CSSProperties;
-    thStyle: import("react").CSSProperties;
-    cellStyle: import("react").CSSProperties;
-    tdContentStyle: import("react").CSSProperties;
-    thContentStyle: import("react").CSSProperties;
-    cellContentStyle: import("react").CSSProperties;
-    title: string;
-    field: string;
-    filterHasValues: boolean;
-    sortOn?: boolean;
-    headerIcon?: import("react").ReactNode;
-    headerTooltip?: import("react").ReactNode;
-    render: (row: Row) => import("react").ReactNode;
-    renderMobile: (row: Row, index: number) => import("react").ReactNode;
-    renderHeader: () => import("react").ReactNode;
-    tdStyleFunction: (...args: unknown[]) => unknown;
-    tdContentStyleFunction: (...args: unknown[]) => unknown;
-    filterOn: boolean;
-    filterServer: import("./Table.filterTypes").TableServerFilter;
-    renderFilter: (context: import("./Table.filterTypes").TableFilterContext) => import("react").ReactNode;
-    filterShowConditions: boolean;
-    filterWidth: number;
-    filterAdaptiveHeight: boolean;
-    filterActive: boolean;
-    filterSelectedCount: number;
-    filterType: string;
-    filterOptions: Array<string | number>;
-    filterValue: (row: Row) => string | number;
-    hidden: boolean;
-    key: string;
-    roundUpTo: number;
-    resizeOff: boolean;
-    bitDepth: boolean;
-    sortValue: (row: Row) => string | number;
-    sortComparator: (a: Row, b: Row) => number;
-    mobilePrimary: boolean;
-    mobileHidden: boolean;
-    mobileActions: boolean;
-    mobileLabel: string;
-    mobileCollapsible: boolean;
-    mobileExpandLines: number;
-    mobileGridSpan: 2 | "narrow" | "full";
-    mobileGridRowSpan: 2;
-    mobileSecondary: boolean;
-    mobileInline: boolean;
-    mobileSubtitle: boolean;
-    mobileHideLabel: boolean;
-    mobileValueColor: string;
-    mobileLabelColor: string;
-}>[];
 /** Одни измеренные смещения для обычной шапки, Filter и всех строк. */
 export declare function useTableColumnPinning<Row>(rootRef: RefObject<HTMLDivElement>, columns: TableColumnsProperties<Row>[], enabled: boolean, layoutRevision: unknown): (Partial<{
     sticky: boolean | "left" | "right";
@@ -85,7 +30,7 @@ export declare function useTableColumnPinning<Row>(rootRef: RefObject<HTMLDivEle
     filterAdaptiveHeight: boolean;
     filterActive: boolean;
     filterSelectedCount: number;
-    filterType: string;
+    filterType: import("./Table.types").TableFilterType;
     filterOptions: Array<string | number>;
     filterValue: (row: Row) => string | number;
     hidden: boolean;
@@ -1000,7 +945,7 @@ export declare function useTableColumnPinning<Row>(rootRef: RefObject<HTMLDivEle
     filterAdaptiveHeight?: boolean;
     filterActive?: boolean;
     filterSelectedCount?: number;
-    filterType?: string;
+    filterType?: import("./Table.types").TableFilterType;
     filterOptions?: Array<string | number>;
     filterValue?: (row: Row) => string | number;
     hidden?: boolean;

package/dist/components/Table/useTableColumnPinning.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useTableColumnPinning.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useTableColumnPinning.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAM5D,uFAAuF;AACvF,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,sBAAsB,CAAC,GAAG,CAAC,EAAE;;;;;;;;;;;;;;;;;;;sBAuB/C,GAAG;6BAC5B,GAAC;;yBACuD,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KArBlF;AAED,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,CAAC,cAAc,CAAC,EAC3E,OAAO,EAAE,sBAAsB,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO;;;;;;;;;;;;;;;;;;;sBAepD,GAAG;6BAC5B,GAAC;;yBACuD,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAFpD,GAAG;8BAC5B,GAAC;;0BACuD,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA4ClF"}
+{"version":3,"file":"useTableColumnPinning.d.ts","sourceRoot":"","sources":["../../../src/components/Table/useTableColumnPinning.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAC;AACvC,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAa5D,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,CAAC,cAAc,CAAC,EAC3E,OAAO,EAAE,sBAAsB,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,OAAO;;;;;;;;;;;;;;;;;;;sBAiBa,GAAG;6BAGzE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAHmE,GAAG;8BAGzE,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyC5B"}

package/dist/components/Table/useTableColumnPinning.js

@@ -0,0 +1,52 @@
+import { useMemo as b, useState as L, useLayoutEffect as z } from "react";
+const u = (i) => i.sticky === !0 || i.sticky === "left" ? "left" : i.sticky === "right" ? "right" : void 0;
+function q(i) {
+  return i.some((n) => typeof n.sticky == "string") ? [
+    ...i.filter((n) => u(n) === "left"),
+    ...i.filter((n) => !u(n)),
+    ...i.filter((n) => u(n) === "right")
+  ] : i;
+}
+function C(i, n, h, m) {
+  const o = b(() => h ? q(n) : n, [n, h]), p = o.some((t) => !!u(t)), [y, E] = L({ overflow: !1, widths: [] });
+  z(() => {
+    var v;
+    const t = i.current, e = t == null ? void 0 : t.querySelector("table");
+    if (!h || !p || !t || !e) return;
+    let s = !1;
+    const f = Array.from(e.querySelectorAll("thead > tr:first-child > th"));
+    f.length || f.push(...e.querySelectorAll("tbody > tr:not(.u-empty-table-row) > td"));
+    const c = () => {
+      if (s) return;
+      const l = f.slice(0, o.length).map((d) => d.getBoundingClientRect().width), k = t.clientWidth > 0 && t.scrollWidth > t.clientWidth + 1;
+      E((d) => d.overflow === k && d.widths.length === l.length && d.widths.every((S, O) => S === l[O]) ? d : { overflow: k, widths: l });
+    };
+    c();
+    const r = typeof ResizeObserver > "u" ? null : new ResizeObserver(c);
+    return r == null || r.observe(t), r == null || r.observe(e), f.slice(0, o.length).forEach((l) => r == null ? void 0 : r.observe(l)), window.addEventListener("resize", c), (v = document.fonts) == null || v.addEventListener("loadingdone", c), () => {
+      var l;
+      s = !0, r == null || r.disconnect(), window.removeEventListener("resize", c), (l = document.fonts) == null || l.removeEventListener("loadingdone", c);
+    };
+  }, [i, o, h, p, m]);
+  const a = o.map((t) => h && (!t.stickyOverflowOnly || y.overflow) ? u(t) : void 0), g = { left: 0, right: 0 }, w = [];
+  o.forEach((t, e) => {
+    a[e] === "left" && (w[e] = g.left, g.left += y.widths[e] || t.width || 0);
+  });
+  for (let t = o.length - 1; t >= 0; t--)
+    a[t] === "right" && (w[t] = g.right, g.right += y.widths[t] || o[t].width || 0);
+  return o.map((t, e) => {
+    const s = a[e];
+    if (!s) return t.sticky ? { ...t, sticky: !1 } : t;
+    const f = s === "left" ? a.lastIndexOf("left") === e : a.indexOf("right") === e;
+    return { ...t, sticky: !0, cellStyle: {
+      ...t.cellStyle,
+      left: s === "left" ? w[e] : "auto",
+      right: s === "right" ? w[e] : "auto",
+      "--u-table-pin-shadow-left": s === "right" ? "calc(-4 * var(--u-unit, 1px))" : "auto",
+      "--u-table-pin-shadow-right": s === "left" ? "calc(-4 * var(--u-unit, 1px))" : "auto",
+      "--u-table-pin-shadow-transform": s === "right" ? "none" : "matrix(-1, 0, 0, 1, 0, 0)",
+      "--u-table-pin-shadow-display": f ? "block" : "none"
+    } };
+  });
+}
+export { C as useTableColumnPinning$u };

package/dist/components/Table/useTableFilters.js

@@ -0,0 +1,39 @@
+import { useState as j, useRef as V, useCallback as d, useEffect as m } from "react";
+const a = () => ({ uncheckedValues: {}, dates: [] }), h = (t, c) => t instanceof Date && c instanceof Date ? t.getTime() === c.getTime() : Object.is(t, c), D = (t, c) => {
+  const r = Object.keys(t.uncheckedValues);
+  return r.length === Object.keys(c.uncheckedValues).length && r.every((e) => {
+    var i;
+    return t.uncheckedValues[e].length === ((i = c.uncheckedValues[e]) == null ? void 0 : i.length) && t.uncheckedValues[e].every((u, l) => h(u, c.uncheckedValues[e][l]));
+  }) && t.dates.length === c.dates.length && t.dates.every((e, i) => {
+    const u = c.dates[i];
+    return e.id === u.id && e.type === u.type && h(e.begin, u.begin) && h(e.end, u.end);
+  });
+}, v = ({ filters: t, defaultFilters: c, onFiltersChange: r, filterResetParam: e }) => {
+  const [i, u] = j(() => c ?? a()), l = t ?? i, f = V(l);
+  f.current = l;
+  const k = V(e), o = d((s) => {
+    const n = typeof s == "function" ? s(f.current) : s;
+    D(f.current, n) || (f.current = n, t === void 0 && u(n), r == null || r(n));
+  }, [t, r]), y = d((s) => {
+    o((n) => ({
+      ...n,
+      uncheckedValues: typeof s == "function" ? s(n.uncheckedValues) : s
+    }));
+  }, [o]), g = d((s) => {
+    o((n) => ({
+      ...n,
+      dates: typeof s == "function" ? s(n.dates) : s
+    }));
+  }, [o]);
+  return m(() => {
+    Object.is(k.current, e) || (k.current = e, o(a()));
+  }, [e, o]), {
+    filters: l,
+    setFilters: o,
+    uncheckedValues: l.uncheckedValues,
+    setUncheckedValues: y,
+    filterDates: l.dates,
+    setFilterDates: g
+  };
+};
+export { v as useTableFilters$u };

package/dist/components/Table/useTableSortState.js

@@ -0,0 +1,38 @@
+import { useState as a, useMemo as F } from "react";
+import { nextSort$u as T } from "../../shared/sortRows.js";
+const M = ({
+  defaultSort: d,
+  controlledSort: v,
+  controlledSortDir: n,
+  onSortChange: r,
+  managedSort: f
+}) => {
+  const [c, m] = a(
+    d != null && d.field ? { column: d.field, asc: d.dir !== "desc" } : void 0
+  ), [u, p] = a(null), i = typeof r == "function" && !f, o = i ? v : (c == null ? void 0 : c.asc) !== void 0 ? c == null ? void 0 : c.column : void 0, e = i ? n ?? (v ? "asc" : void 0) : (c == null ? void 0 : c.asc) === !0 ? "asc" : (c == null ? void 0 : c.asc) === !1 ? "desc" : void 0, l = (s, t) => {
+    i || m({
+      column: s,
+      asc: t === "asc" ? !0 : t === "desc" ? !1 : void 0
+    }), r == null || r(s, t);
+  }, S = (s) => {
+    const t = T({ field: o, dir: e }, s);
+    l(t.field, t.dir);
+  }, y = (s) => l(s, o === s ? e ?? "asc" : "asc"), D = () => {
+    o && l(o, e === "asc" ? "desc" : "asc");
+  };
+  return {
+    sort: F(() => i ? { column: o, asc: e === void 0 ? void 0 : e === "asc" } : c, [i, o, e, c]),
+    // Прежний попап тоже проходит через controlled-обработчик, а не меняет локальные строки.
+    setSort: (s) => l(s.column, s.asc === void 0 ? void 0 : s.asc ? "asc" : "desc"),
+    hoveredSortCol: u,
+    setHoveredSortCol: p,
+    isSortControlled: i,
+    effectiveSortField: o,
+    effectiveSortDir: e,
+    applySort: l,
+    handleSortToggle: S,
+    setSortField: y,
+    toggleSortDir: D
+  };
+};
+export { M as useTableSortState$u };