@progress/kendo-vue-grid 8.0.3-develop.4 → 8.1.0-develop.1

package/utils/virtualColumns.mjs

@@ -5,54 +5,147 @@
  * Licensed under commercial license. See LICENSE.md in the package root for more information
  *-------------------------------------------------------------------------------------------
  */
-function m(u) {
-  const { cellsToRender: n, columns: c, rowIndex: f, enableVirtualization: s } = u;
-  if (!s || f !== 0 || !n || n.length === 0)
+function A(f, e, n) {
+  let i = 0, p = !1;
+  if (n > 0 && e)
+    for (let l = 0; l < n; l++) {
+      const r = e[l] || [];
+      for (let u = 0; u < r.length; u++) {
+        const h = r[u], S = f[h];
+        (S.rowSpan || 1) > n - l && (i += S.headerColSpan || 1, u === 0 && (p = !0));
+      }
+    }
+  return { emptyColSpan: i, skipOffset: p };
+}
+function T(f, e) {
+  const n = f[e];
+  return !n || n.parentIndex < 0 ? [] : [n.parentIndex, ...T(f, n.parentIndex)];
+}
+function L(f, e, n) {
+  e.forEach((i) => {
+    T(f, i).forEach((l) => n.add(l));
+  });
+}
+function O(f, e, n) {
+  var p;
+  const i = f[e];
+  ((p = i == null ? void 0 : i.children) == null ? void 0 : p.length) > 0 && i.children.forEach((l) => {
+    let r = typeof l == "number" ? l : f.indexOf(l);
+    r >= 0 && !n.has(r) && (n.add(r), O(f, r, n));
+  });
+}
+function F(f) {
+  const { cellsToRender: e, columns: n, rowIndex: i, enableVirtualization: p, columnsMap: l } = f;
+  if (!p || !e || e.length === 0)
     return { columnsToRender: [], colSpans: [] };
-  const t = [], o = [];
-  let i = -1, d = -1;
-  for (let l = 0; l < n.length; l++)
-    c[n[l].columnIndex].locked || (i === -1 && (i = l), d = l);
-  return n.forEach((l, r) => {
-    if (t.push(l.columnIndex), r === i)
-      o.push(l.colSpan);
-    else if (r === d)
-      o.push(l.colSpan);
-    else {
-      const a = c[l.columnIndex];
-      o.push(a.headerColSpan || 1);
+  const r = [], u = [];
+  let h = -1, S = -1;
+  function g(o, c) {
+    let a = -1, s = -1;
+    for (let d = 0; d < c.length; d++)
+      o[c[d]].locked || (a === -1 && (a = d), s = d);
+    return { first: a, last: s };
+  }
+  const w = e.reduce((o, c) => o + c.colSpan, 0);
+  let x = [], t = [];
+  const V = n.filter((o) => o.children.length === 0), b = /* @__PURE__ */ new Map();
+  n.forEach((o, c) => {
+    if (o.children.length === 0) {
+      const a = V.findIndex((s) => s === o);
+      a >= 0 && b.set(a, c);
+    }
+  });
+  const k = /* @__PURE__ */ new Set();
+  if (e.forEach((o) => {
+    const c = b.get(o.columnIndex);
+    if (c !== void 0) {
+      k.add(c);
+      const a = T(n, c);
+      a.forEach((s) => k.add(s)), L(n, a, k), O(n, c, k), a.forEach((s) => {
+        O(n, s, k);
+      });
     }
-  }), { columnsToRender: t, colSpans: o };
+  }), l && Array.isArray(l)) {
+    for (let o = 0; o < l.length; o++)
+      x[o] = l[o].filter(
+        (c) => k.has(c)
+      );
+    t = x[i] || [];
+  }
+  const U = g(n, t);
+  h = U.first, S = U.last;
+  let v = 0, R = 0, y = !1;
+  return t.forEach((o, c) => {
+    r.push(o);
+    const a = n[o], s = a.headerColSpan || 1;
+    let d;
+    if (h === S)
+      d = w;
+    else if (c === h) {
+      const m = a.virtualColumnOffset ? a.virtualColumnOffset : 0, { emptyColSpan: C, skipOffset: I } = A(n, x, i);
+      R += C, I && (R += m, y = !0), m > 0 && !I ? d = s + m : d = s;
+    } else if (c === S) {
+      let m = c === t.length - 1;
+      if (l != null && l[i]) {
+        const C = l[i], I = o;
+        let M = -1;
+        for (let E = C.length - 1; E >= 0; E--)
+          if (!n[C[E]].locked) {
+            M = C[E];
+            break;
+          }
+        m = I === M;
+      }
+      if (m)
+        d = s;
+      else {
+        const C = w - v - R;
+        if (d = Math.max(C, s), s > C && u.length > 0) {
+          const I = s - C;
+          u[0] -= I;
+        }
+      }
+    } else
+      d = s;
+    u.push(d), v += d;
+  }), {
+    columnsToRender: r,
+    colSpans: u,
+    skipOffset: y
+  };
 }
-function p(u) {
-  const { cellModels: n, columns: c = [], tableViewPortWidth: f, scrollLeft: s } = u;
-  let t = 0, o = n.length - 1, i = 0, d = 0;
-  for (let e = 0; e < n.length; e++)
-    if (!c[n[e].columnIndex].locked && (i = d, d += n[e].width || 10, d >= s)) {
-      t = e;
+function B(f) {
+  const { cellModels: e, columns: n = [], tableViewPortWidth: i, scrollLeft: p } = f;
+  let l = 0, r = e.length - 1, u = 0, h = 0;
+  for (let t = 0; t < e.length; t++)
+    if (!n[e[t].columnIndex].locked && (u = h, h += e[t].width || 10, h >= p)) {
+      l = t;
       break;
     }
-  for (let e = t; e < n.length; e++)
-    if (!c[n[e].columnIndex].locked)
-      if (i < f + s)
-        i += n[e].width || 10, o = e;
+  for (let t = l; t < e.length; t++)
+    if (!n[e[t].columnIndex].locked)
+      if (u < i + p)
+        u += e[t].width || 10, r = t;
       else
         break;
-  t > 0 && t--, o < n.length - 1 && o++;
-  let l = 0, r = 0;
-  for (let e = 0; e < t; e++)
-    c[n[e].columnIndex].locked || (l += n[e].colSpan);
-  for (let e = o + 1; e < n.length; e++)
-    c[n[e].columnIndex].locked || (r += n[e].colSpan);
-  n[t].colSpan += l, n[o].colSpan += r;
-  const a = n.slice(0, t).filter((e) => c[e.columnIndex].locked), h = n.slice(o + 1).filter((e) => c[e.columnIndex].locked);
+  l > 0 && l--, r < e.length - 1 && r++;
+  let S = 0, g = 0;
+  for (let t = 0; t < l; t++)
+    n[e[t].columnIndex].locked || (S += e[t].colSpan);
+  for (let t = r + 1; t < e.length; t++)
+    n[e[t].columnIndex].locked || (g += e[t].colSpan);
+  e[l].colSpan += S, e[r].colSpan += g;
+  const w = e.slice(0, l).filter((t) => n[t.columnIndex].locked), x = e.slice(r + 1).filter((t) => n[t.columnIndex].locked);
   return [
-    ...a,
-    ...n.slice(t, o + 1),
-    ...h
+    ...w,
+    ...e.slice(l, r + 1),
+    ...x
   ];
 }
 export {
-  p as getVirtualCellsToRender,
-  m as getVirtualHeaderCellsToRender
+  L as addAllAncestors,
+  O as addDescendants,
+  T as getParentIndices,
+  B as getVirtualCellsToRender,
+  F as getVirtualHeaderCellsToRender
 };