@progress/kendo-vue-grid 8.1.0-develop.5 → 8.1.0-develop.6

package/utils/virtualColumns.mjs

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