@progress/kendo-vue-grid 9.1.0-develop.1 → 9.1.0

package/utils/virtualColumns.mjs

@@ -6,47 +6,47 @@
  *-------------------------------------------------------------------------------------------
  */
 function B(f, n, e) {
-  let s = 0, u = !1;
+  let a = 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));
+        (S.rowSpan || 1) > e - t && (a += S.headerColSpan || 1, p === 0 && (u = !0));
       }
     }
-  return { emptyColSpan: s, skipOffset: u };
+  return { emptyColSpan: a, skipOffset: u };
 }
 function M(f, n) {
   const e = f[n];
   return !e || e.parentIndex < 0 ? [] : [e.parentIndex, ...M(f, e.parentIndex)];
 }
 function P(f, n, e) {
-  n.forEach((s) => {
-    M(f, s).forEach((t) => e.add(t));
+  n.forEach((a) => {
+    M(f, a).forEach((t) => e.add(t));
   });
 }
 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) => {
+  const a = f[n];
+  ((u = a == null ? void 0 : a.children) == null ? void 0 : u.length) > 0 && a.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 j(f) {
-  const { cellsToRender: n, columns: e, rowIndex: s, enableVirtualization: u, columnsMap: t } = f;
+  const { cellsToRender: n, columns: e, rowIndex: a, enableVirtualization: u, columnsMap: t } = f;
   if (!u || !n || n.length === 0)
     return { columnsToRender: [], colSpans: [] };
   const c = [], p = [];
   let h = -1, S = -1;
-  function I(o, r) {
-    let a = -1, i = -1;
+  function g(o, r) {
+    let s = -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 };
+      o[r[d]].locked || (s === -1 && (s = d), i = d);
+    return { first: s, last: i };
   }
-  const R = n.reduce((o, r) => o + r.colSpan, 0);
+  const O = n.reduce((o, r) => o + r.colSpan, 0);
   let w = 0;
   for (const o of n) {
     const r = e[o.columnIndex];
@@ -55,13 +55,13 @@ function j(f) {
     else
       break;
   }
-  const l = R - w;
-  let T = [], g = [];
+  const l = O - w;
+  let T = [], m = [];
   const L = e.filter((o) => o.children.length === 0), V = /* @__PURE__ */ new Map();
   e.forEach((o, r) => {
     if (o.children.length === 0) {
-      const a = L.findIndex((i) => i === o);
-      a >= 0 && V.set(a, r);
+      const s = L.findIndex((i) => i === o);
+      s >= 0 && V.set(s, r);
     }
   });
   const C = /* @__PURE__ */ new Set();
@@ -69,8 +69,8 @@ function j(f) {
     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) => {
+      const s = M(e, r);
+      s.forEach((i) => C.add(i)), P(e, s, C), U(e, r, C), s.forEach((i) => {
         U(e, i, C);
       });
     }
@@ -79,51 +79,51 @@ function j(f) {
       T[o] = t[o].filter(
         (r) => C.has(r)
       );
-    g = T[s] || [];
+    m = T[a] || [];
   }
-  const v = I(e, g);
-  h = v.first, S = v.last;
-  let y = 0;
+  const y = g(e, m);
+  h = y.first, S = y.last;
+  let A = 0;
   for (let o = 0; o < h; o++) {
-    const r = e[g[o]];
-    r != null && r.locked && (y += r.headerColSpan || 1);
+    const r = e[m[o]];
+    r != null && r.locked && (A += r.headerColSpan || 1);
   }
-  let A = 0, b = 0, F = !1;
-  return g.forEach((o, r) => {
+  let v = 0, b = 0, F = !1;
+  return m.forEach((o, r) => {
     c.push(o);
-    const a = e[o], i = (a == null ? void 0 : a.headerColSpan) || 1;
+    const s = e[o], i = (s == null ? void 0 : s.headerColSpan) || 1;
     let d;
     if (h === S)
       d = l;
     else if (r === h) {
-      const E = a.virtualColumnOffset ? a.virtualColumnOffset : 0, { emptyColSpan: k, skipOffset: m } = B(e, T, s);
+      const E = (s == null ? void 0 : s.virtualColumnOffset) || 0, { emptyColSpan: k, skipOffset: x } = B(e, T, a);
       b += k;
-      const x = Math.max(0, E - y);
-      m && (b += x, F = !0), x > 0 && !m ? d = i + x : d = i;
+      const I = Math.max(0, E - A);
+      x && (b += I, F = !0), I > 0 && !x ? d = i + I : 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];
+      let E = r === m.length - 1;
+      if (t != null && t[a]) {
+        const k = t[a], x = o;
+        let I = -1;
+        for (let R = k.length - 1; R >= 0; R--)
+          if (!e[k[R]].locked) {
+            I = k[R];
             break;
           }
-        E = m === x;
+        E = x === I;
       }
       if (E)
         d = i;
       else {
-        const k = l - A - b;
+        const k = l - v - b;
         if (d = Math.max(k, i), i > k && p.length > 0) {
-          const m = i - k;
-          p[0] -= m;
+          const x = i - k;
+          p[0] -= x;
         }
       }
     } else
       d = i;
-    p.push(d), A += d;
+    p.push(d), v += d;
   }), {
     columnsToRender: c,
     colSpans: p,
@@ -131,7 +131,7 @@ function j(f) {
   };
 }
 function z(f) {
-  const { cellModels: n, columns: e = [], tableViewPortWidth: s, scrollLeft: u } = f;
+  const { cellModels: n, columns: e = [], tableViewPortWidth: a, 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)) {
@@ -140,20 +140,20 @@ function z(f) {
     }
   for (let l = t; l < n.length; l++)
     if (!e[n[l].columnIndex].locked)
-      if (p < s + u)
+      if (p < a + u)
         p += n[l].width || 10, c = l;
       else
         break;
   t > 0 && t--, c < n.length - 1 && c++;
-  let S = 0, I = 0;
+  let S = 0, g = 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);
+    e[n[l].columnIndex].locked || (g += n[l].colSpan);
+  n[t].colSpan += S, n[c].colSpan += g;
+  const O = n.slice(0, t).filter((l) => e[l.columnIndex].locked), w = n.slice(c + 1).filter((l) => e[l.columnIndex].locked);
   return [
-    ...R,
+    ...O,
     ...n.slice(t, c + 1),
     ...w
   ];