pivotgrid-js 0.1.0

package/dist/pivotgrid.min.js

@@ -0,0 +1,18 @@
+var PivotGridLib=(()=>{class r{static ROW_HEIGHT=24;static HEADER_HEIGHT=32;static COL_HEADER_W=200;static COL_W=150;static INDENT=16;static BUFFER=5;constructor({container:e,result:t,rows:s,columns:l,measure:o,fieldDefs:i={},labels:n={}}){this.container=e,this.rows=s,this.columns=l,this.measure=o,this.fieldDefs=i,this._labels=n,this._measureKey=o+"_sum",this._colHeaderW=r.COL_HEADER_W,this._hideSubtotals=!1,this.collapsed=new Set,this.collapsedCols=new Set,this.rowPool=[],this.rendered=new Map,this._applyResult(t),this._mount(),this._renderVisible(),this._bindScroll()}_applyResult(e){this.cells=e.cells,this.colTree=e.colTree,this.colKeys=e.colKeys,this.tree=e.tree,this.grandTotal=e.grandTotal,e.measureKey&&(this._measureKey=e.measureKey),this._buildFlatCols(),this._buildFlatRows()}_buildFlatCols(){if(!this.colTree||!this.colTree.length){this.flatCols=[];return}const e=[],t=this.columns&&this.columns.length>1,s=l=>{for(const o of l)o.children?this.collapsedCols.has(o.code)?e.push({code:o.code,label:o.value,isSubtotal:!0,collapsed:!0}):(s(o.children),t&&!this._hideSubtotals&&e.push({code:o.code,label:"\u2211",isSubtotal:!0,collapsed:!1})):e.push({code:o.code,label:o.value,isSubtotal:!1})};s(this.colTree),this.flatCols=e}_getGroupSpan(e){if(!e.children||this.collapsedCols.has(e.code))return 1;let s=this.columns&&this.columns.length>1&&!this._hideSubtotals?1:0;for(const l of e.children)s+=this._getGroupSpan(l);return s}_colTreeDepth(){if(!this.colTree||!this.colTree.length)return 1;const e=t=>{let s=0;for(const l of t)l.children&&!this.collapsedCols.has(l.code)&&(s=Math.max(s,1+e(l.children)));return s};return 1+e(this.colTree)}_buildFlatRows(){this.flatRows=[];const e=t=>{for(const s of t)this.flatRows.push(s),s.children&&!this.collapsed.has(s.code)&&e(s.children)};this.tree&&e(this.tree),this.flatRows.push({isGrandTotal:!0})}get _headerHeight(){return r.HEADER_HEIGHT*this._colTreeDepth()}_mount(){this.container.innerHTML="",this.container.classList.add("pg-root");const e=this.flatCols.length?this.flatCols:this.colKeys;this.totalWidth=this._colHeaderW+(e.length+1)*r.COL_W,this._mountColHeader(),this._mountScrollArea()}_mountColHeader(){const e=r.HEADER_HEIGHT,t=this._colHeaderW,s=r.COL_W,l=this._colTreeDepth(),o=e*l;this.headerEl=document.createElement("div"),this.headerEl.className="pg-col-header",this.headerEl.style.cssText=`
+      position: absolute; top: 0; left: 0;
+      width: ${this.totalWidth}px; height: ${o}px;
+      background: #fafafa; border-bottom: 1px solid #d0d0d0; z-index: 10;
+    `;const i=this._absCell({x:0,y:0,w:t,h:o,text:"",cls:"row-label"});this.rows.forEach((a,d)=>{const h=document.createElement("span"),u=(this.fieldDefs||{})[a]||{};if(h.textContent=u.title||u.label||a,h.style.cssText="cursor:pointer; padding: 0 2px;",h.title=`Expand to "${a}"`,d<this.rows.length-1?h.addEventListener("click",()=>this.expandToDepth(d+1)):h.style.cursor="default",d>0){const f=document.createElement("span");f.textContent=" \u203A ",f.style.color="#ccc",i.appendChild(f)}i.appendChild(h)});const n=document.createElement("div");if(n.className="pg-col-resize-handle",n.style.cssText=`
+      position: absolute; top: 0; left: ${t-4}px;
+      width: 8px; height: ${o}px;
+      cursor: col-resize; z-index: 20;
+    `,this.headerEl.appendChild(n),this._bindResizeHandle(n),this.colTree&&this.colTree.length){let a=0;for(const d of this.colTree)a=this._renderColNode(d,0,a,l)}const c=this.flatCols.length?this.flatCols:this.colKeys;this._absCell({x:t+c.length*s,y:0,w:s,h:o,text:this._labels.total||"Total",cls:"total-col"}),this.container.appendChild(this.headerEl)}_renderColNode(e,t,s,l){const o=r.HEADER_HEIGHT,i=this._colHeaderW,n=r.COL_W,c=this.collapsedCols.has(e.code),a=!e.children,d=this._getGroupSpan(e),h=a||c?(l-t)*o:o,u=c?"subtotal-col":a?"":"pg-col-header-group",f=this._absCell({x:i+s*n,y:t*o,w:d*n,h,text:e.value,cls:u});if(e.children){const p=document.createElement("span");p.className="pg-toggle"+(c?" collapsed":""),p.textContent="\u25BE",p.addEventListener("click",_=>{_.stopPropagation(),this._toggleColCollapse(e.code)}),f.insertBefore(p,f.firstChild)}if(!a&&!c){let p=s;for(const _ of e.children)p=this._renderColNode(_,t+1,p,l);if(this.columns&&this.columns.length>1&&!this._hideSubtotals){const _=(l-t-1)*o;_>0&&this._absCell({x:i+(s+d-1)*n,y:(t+1)*o,w:n,h:_,text:"\u2211",cls:"subtotal-col"})}}return s+d}_absCell({x:e,y:t,w:s,h:l,text:o,cls:i}){const n=document.createElement("div");return n.className="pg-col-header-cell"+(i?" "+i:""),n.style.cssText=`
+      position: absolute;
+      left: ${e}px; top: ${t}px;
+      width: ${s}px; height: ${l}px;
+      box-sizing: border-box;
+    `,n.textContent=o,this.headerEl.appendChild(n),n}_mountScrollArea(){const e=this._headerHeight;this.scrollArea=document.createElement("div"),this.scrollArea.className="pg-scroll",this.scrollArea.style.top=e+"px",this.container.appendChild(this.scrollArea),this.virtualSpace=document.createElement("div"),this.virtualSpace.style.cssText=`
+      position: relative;
+      width: ${this.totalWidth}px;
+      height: ${this.flatRows.length*r.ROW_HEIGHT}px;
+    `,this.scrollArea.appendChild(this.virtualSpace)}_renderVisible(){const e=this.scrollArea.clientHeight,t=this.scrollArea.scrollTop,s=r.ROW_HEIGHT,l=r.BUFFER,o=Math.max(0,Math.floor(t/s)-l),i=Math.min(this.flatRows.length-1,Math.ceil((t+e)/s)+l);for(const[n,c]of this.rendered)(n<o||n>i)&&(this.virtualSpace.removeChild(c),this._recycleRow(c),this.rendered.delete(n));for(let n=o;n<=i;n++){if(this.rendered.has(n))continue;const c=this._acquireRow();this._fillRow(c,this.flatRows[n],n),this.virtualSpace.appendChild(c),this.rendered.set(n,c)}}_acquireRow(){if(this.rowPool.length){const t=this.rowPool.pop();return t.className="pg-row",t.removeAttribute("style"),t.innerHTML="",t}const e=document.createElement("div");return e.className="pg-row",e}_recycleRow(e){this.rowPool.push(e)}_fillRow(e,t,s){const l=r.ROW_HEIGHT;if(e.style.top=s*l+"px",e.style.width=this.totalWidth+"px",e.style.height=l+"px",t.isGrandTotal){e.classList.add("grand-total"),this._fillGrandTotalRow(e);return}e.style.background=s%2===0?"#ffffff":"#fcfcfc",this._fillHeaderCell(e,t),this._fillValueCells(e,t)}_fillHeaderCell(e,t){const s=r.ROW_HEIGHT,l=this._colHeaderW,o=r.INDENT,i=document.createElement("div");if(i.className="pg-cell-header",i.style.cssText=`width:${l}px;height:${s}px;padding-left:${8+t.depth*o}px`,t.children){const c=document.createElement("span");c.className="pg-toggle"+(this.collapsed.has(t.code)?" collapsed":""),c.textContent="\u25BE",c.addEventListener("click",a=>{a.stopPropagation(),this._toggleCollapse(t.code)}),i.appendChild(c)}else{const c=document.createElement("span");c.className="pg-toggle-spacer",i.appendChild(c)}const n=document.createElement("span");n.className=`pg-label depth-${Math.min(t.depth,2)}`,n.textContent=t.value,i.appendChild(n),e.appendChild(i)}_fillValueCells(e,t){const s=r.ROW_HEIGHT,l=r.COL_W,o=this.flatCols.length?this.flatCols:this.colKeys;for(const a of o){const d=t.code+"||"+a.code,h=this.cells.get(d),u=document.createElement("div");u.className="pg-cell"+(h==null?" empty":"")+(a.isSubtotal?" subtotal":""),u.style.cssText=`width:${l}px;height:${s}px`,u.textContent=h!=null?this._fmt(h):"\u2014",h!=null&&u.addEventListener("click",()=>this._emitDrillthrough(t,a.code,h)),e.appendChild(u)}const i=t.code+"||__total__",n=this.cells.get(i)||0,c=document.createElement("div");c.className="pg-cell total",c.style.cssText=`width:${l}px;height:${s}px`,c.textContent=this._fmt(n),c.addEventListener("click",()=>this._emitDrillthrough(t,"__total__",n)),e.appendChild(c)}_fillGrandTotalRow(e){const t=r.ROW_HEIGHT,s=this._colHeaderW,l=r.COL_W,o=this.flatCols.length?this.flatCols:this.colKeys,i=document.createElement("div");i.className="pg-cell-header",i.style.cssText=`width:${s}px;height:${t}px;padding-left:8px`;const n=document.createElement("span");n.className="pg-toggle-spacer",i.appendChild(n);const c=document.createElement("span");c.className="pg-label depth-0",c.textContent=this._labels.total||"Total",i.appendChild(c),e.appendChild(i);for(const d of o){const h="__grand__||"+d.code,u=this.cells.get(h)||0,f=document.createElement("div");f.className="pg-cell total"+(d.isSubtotal?" subtotal":""),f.style.cssText=`width:${l}px;height:${t}px`,f.textContent=this._fmt(u),f.addEventListener("click",()=>this._emitDrillthrough({isGrandTotal:!0},d.code,u)),e.appendChild(f)}const a=document.createElement("div");a.className="pg-cell total grand-total-val",a.style.cssText=`width:${l}px;height:${t}px`,a.textContent=this._fmt(this.grandTotal||0),a.addEventListener("click",()=>this._emitDrillthrough({isGrandTotal:!0},"__total__",this.grandTotal)),e.appendChild(a)}_toggleColCollapse(e){if(this.collapsedCols.has(e)){this.collapsedCols.delete(e);const t=this._findColNode(e);if(t?.children)for(const s of t.children)s.children&&this.collapsedCols.add(s.code)}else this.collapsedCols.add(e);this._rebuildCols()}_findColNode(e,t=this.colTree){if(!t)return null;for(const s of t){if(s.code===e)return s;const l=this._findColNode(e,s.children);if(l)return l}return null}toggleSubtotals(e){this._hideSubtotals=!e,this._rebuildCols()}_rebuildCols(){this._buildFlatCols();const e=this.flatCols.length?this.flatCols:this.colKeys;this.totalWidth=this._colHeaderW+(e.length+1)*r.COL_W,this.virtualSpace.style.width=this.totalWidth+"px",this.scrollArea.style.top=this._headerHeight+"px",this.headerEl.remove(),this._mountColHeader(),this.headerEl.style.transform=`translateX(-${this.scrollArea.scrollLeft}px)`,this._redraw()}_redraw(){this.virtualSpace.style.height=this.flatRows.length*r.ROW_HEIGHT+"px";for(const[,e]of this.rendered)this.virtualSpace.removeChild(e),this._recycleRow(e);this.rendered.clear(),this._renderVisible()}_bindScroll(){let e=!1;this.scrollArea.addEventListener("scroll",()=>{this.headerEl.style.transform=`translateX(-${this.scrollArea.scrollLeft}px)`,e||(requestAnimationFrame(()=>{this._renderVisible(),e=!1}),e=!0)})}_emitDrillthrough(e,t,s){const l={};if(!e.isGrandTotal){const o=this._getNodeChain(e);for(let i=0;i<o.length;i++)l[this.rows[i]]=o[i].value}if(t!=="__total__"){const o=t.split("\u2192");for(let i=0;i<o.length;i++)this.columns[i]&&(l[this.columns[i]]=o[i])}this.container.dispatchEvent(new CustomEvent("drillthrough",{bubbles:!0,detail:{context:l,value:s}}))}_getNodeChain(e){const t=[e];if(e.depth===0)return t;const s=this.flatRows.indexOf(e);for(let l=s-1;l>=0;l--){const o=this.flatRows[l];if(!o.isGrandTotal&&o.depth===e.depth-1){if(t.unshift(o),o.depth===0)break;e=o}}return t}_fmt(e){return new Intl.NumberFormat("ru-RU",{maximumFractionDigits:0}).format(e)}_bindResizeHandle(e){e.addEventListener("mousedown",t=>{t.preventDefault();const s=t.clientX,l=this._colHeaderW,o=n=>{const c=Math.max(r.COL_HEADER_W,l+n.clientX-s);this._colHeaderW=c,this._rebuild()},i=()=>{document.removeEventListener("mousemove",o),document.removeEventListener("mouseup",i)};document.addEventListener("mousemove",o),document.addEventListener("mouseup",i)})}_rebuild(){this.headerEl?.remove(),this.headerEl=null,this._buildFlatCols(),this._mountColHeader();for(const[,e]of this.rendered)this._recycleRow(e);this.rendered.clear(),this._renderVisible()}setResult(e,{rows:t,columns:s,measure:l,fieldDefs:o}={}){if(t&&(this.rows=t),s&&(this.columns=s),l&&(this.measure=l),o&&(this.fieldDefs=o),this.collapsedCols.clear(),this._applyResult(e),this.colTree){for(const n of this.colTree)n.children&&this.collapsedCols.add(n.code);this._buildFlatCols()}const i=this.flatCols.length?this.flatCols:this.colKeys;this.totalWidth=this._colHeaderW+(i.length+1)*r.COL_W,this.virtualSpace.style.width=this.totalWidth+"px",this.scrollArea.style.top=this._headerHeight+"px",this.headerEl.remove(),this._mountColHeader(),this._redraw()}collapseAll(){const e=t=>{if(t)for(const s of t)s.children&&(this.collapsed.add(s.code),e(s.children))};e(this.tree),this._buildFlatRows(),this._redraw()}static _detectMaxHeight(){const e=document.createElement("div");e.style.cssText="position:fixed;visibility:hidden;",document.body.appendChild(e);let t=1e6;for(;t<1e8&&(e.style.height=t+"px",!(e.offsetHeight<t));)t*=2;return e.remove(),t/2}static MAX_FLAT_ROWS=Math.floor(r._detectMaxHeight()/r.ROW_HEIGHT);_confirmLargeExpand(e,t,s){const l=(e/1e6).toFixed(1),o=(this._labels.confirmLargeExpand||"Too many rows (~{millions}M). Click OK to expand anyway.").replace("{millions}",l);window.confirm(o)?t():s?.()}_toggleCollapse(e){const t=this.collapsed.has(e);if(t?this.collapsed.delete(e):this.collapsed.add(e),this._buildFlatRows(),t&&this.flatRows.length>r.MAX_FLAT_ROWS){this._confirmLargeExpand(this.flatRows.length,()=>this._redraw(),()=>{this.collapsed.add(e),this._buildFlatRows()});return}this._redraw()}expandToDepth(e){const t=[],s=o=>{for(const i of o)i.children&&(i.depth<e-1?(this.collapsed.delete(i.code),s(i.children)):i.depth===e-1&&t.push(i))};s(this.tree);const l=t.some(o=>!this.collapsed.has(o.code));for(const o of t)l?this.collapsed.add(o.code):this.collapsed.delete(o.code);this._buildFlatRows(),this._redraw()}expandAll(){if(this.collapsed.clear(),this._buildFlatRows(),this.flatRows.length>r.MAX_FLAT_ROWS){this._confirmLargeExpand(this.flatRows.length,()=>this._redraw());return}this._redraw()}expandAllCols(){this.collapsedCols.clear(),this._rebuildCols()}collapseAllCols(){const e=t=>{if(t)for(const s of t)s.children&&(this.collapsedCols.add(s.code),e(s.children))};e(this.colTree),this._rebuildCols()}}})();

package/engine/aggregator.js

@@ -0,0 +1,193 @@
+/**
+ * Aggregator
+ *
+ * Builds the pivot structure from aggRows.
+ * Supports fieldDefs for correct sorting of dates and lookup fields.
+ *
+ * Usage:
+ *   const agg = new Aggregator();
+ *
+ *   const result = agg.build({
+ *     rows:      ['region', 'month'],
+ *     columns:   ['channel'],
+ *     measure:   'revenue',
+ *     func:      'sum',
+ *     aggRows,
+ *     fieldDefs: {
+ *       region: { label: 'region' },
+ *       month:  { label: 'month_name', sortKey: 'month_num' },
+ *     },
+ *   });
+ */
+
+class Aggregator {
+
+  build({ rows, columns, measure, func, aggRows, fieldDefs = {} }) {
+    const measureKey = `${measure}_${func}`;
+    const cells      = new Map();
+    let grandTotal   = 0;
+    const hasColumns = columns && columns.length > 0;
+
+    // Pre-compute label and sortKey once, outside the loop
+    const rowCols  = rows.map(f => (fieldDefs[f] || {}).label || f);
+    const rowSorts = rows.map(f => (fieldDefs[f] || {}).sortKey || null);
+    const colCols  = hasColumns ? columns.map(f => (fieldDefs[f] || {}).label || f) : [];
+    const colSorts = hasColumns ? columns.map(f => (fieldDefs[f] || {}).sortKey || null) : [];
+
+    const rowDepth   = rows.length;
+    const colDepth   = colCols.length;
+    const rowKeysBuf = new Array(rowDepth);
+    const colKeysBuf = new Array(colDepth);
+
+    // Build tree roots inline — no extra passes over aggRows needed
+    const rowRoot = new Map();
+    const colRoot = new Map();
+
+    for (const row of aggRows) {
+      const val = Number(row[measureKey]) || 0;
+      grandTotal += val;
+
+      // Row keys + row tree in a single pass
+      let rNode = rowRoot;
+      for (let d = 0; d < rowDepth; d++) {
+        const v       = String(row[rowCols[d]] ?? '');
+        const sortVal = rowSorts[d] ? row[rowSorts[d]] : v;
+        rowKeysBuf[d] = d === 0 ? v : rowKeysBuf[d - 1] + '→' + v;
+        if (!rNode.has(v)) rNode.set(v, { sortKey: sortVal, children: new Map() });
+        rNode = rNode.get(v).children;
+      }
+
+      // Column keys + column tree in a single pass
+      if (hasColumns) {
+        let cNode = colRoot;
+        for (let d = 0; d < colDepth; d++) {
+          const v       = String(row[colCols[d]] ?? '');
+          const sortVal = colSorts[d] ? row[colSorts[d]] : v;
+          colKeysBuf[d] = d === 0 ? v : colKeysBuf[d - 1] + '→' + v;
+          if (!cNode.has(v)) cNode.set(v, { sortKey: sortVal, children: new Map() });
+          cNode = cNode.get(v).children;
+        }
+      }
+
+      // Accumulate cell values
+      for (let d = 0; d < rowDepth; d++) {
+        const rk = rowKeysBuf[d];
+        if (hasColumns) {
+          for (let cd = 0; cd < colDepth; cd++) {
+            const key = rk + '||' + colKeysBuf[cd];
+            cells.set(key, (cells.get(key) || 0) + val);
+          }
+        }
+        const totalKey = rk + '||__total__';
+        cells.set(totalKey, (cells.get(totalKey) || 0) + val);
+      }
+
+      if (hasColumns) {
+        for (let cd = 0; cd < colDepth; cd++) {
+          const gtKey = '__grand__||' + colKeysBuf[cd];
+          cells.set(gtKey, (cells.get(gtKey) || 0) + val);
+        }
+      }
+    }
+
+    // Map trees → node arrays
+    const toNodes = (map, depth, parentKey, maxDepth) =>
+      [...map.entries()]
+        .sort(([, a], [, b]) => {
+          const av = a.sortKey, bv = b.sortKey;
+          if (av !== bv && !isNaN(Number(av)) && !isNaN(Number(bv))) return Number(av) - Number(bv);
+          return String(av).localeCompare(String(bv), 'ru');
+        })
+        .map(([val, data]) => {
+          const code     = parentKey ? parentKey + '→' + val : val;
+          const children = depth + 1 < maxDepth
+            ? toNodes(data.children, depth + 1, code, maxDepth)
+            : null;
+          return { value: val, code, depth, children };
+        });
+
+    const tree    = toNodes(rowRoot, 0, '', rowDepth);
+    const colTree = hasColumns ? toNodes(colRoot, 0, '', colDepth) : null;
+    const colKeys = hasColumns ? this._flattenColTree(colTree) : [];
+
+    return { cells, colKeys, colTree, tree, grandTotal };
+  }
+
+  // ── Get the label value for a field from a row ───────────────────────────
+
+  _labelVal(row, field, fieldDefs) {
+    const def = fieldDefs[field] || {};
+    return String(row[def.label || field] ?? '');
+  }
+
+  // ── Tree ─────────────────────────────────────────────────────────────────
+
+  /**
+   * Builds the tree in a single pass over aggRows.
+   * Groups by label, sorts by sortKey (if present).
+   */
+  _buildTree(aggRows, levels, fieldDefs = {}) {
+    if (!levels.length) return null;
+
+    // Map<labelValue, { sortKey: value, children: Map }>
+    const root = new Map();
+
+    for (const row of aggRows) {
+      let node = root;
+      for (let d = 0; d < levels.length; d++) {
+        const field    = levels[d];
+        const def      = fieldDefs[field] || {};
+        const labelCol = def.label   || field;
+        const sortCol  = def.sortKey || null;
+        const labelVal = String(row[labelCol] ?? '');
+        const sortVal  = sortCol ? row[sortCol] : labelVal;
+
+        if (!node.has(labelVal)) {
+          node.set(labelVal, { sortKey: sortVal, children: new Map() });
+        }
+        node = node.get(labelVal).children;
+      }
+    }
+
+    // Recursively convert Map → node tree
+    const toNodes = (map, depth, parentKey) => {
+      return [...map.entries()]
+        .sort(([, aData], [, bData]) => {
+          const a = aData.sortKey;
+          const b = bData.sortKey;
+          // Numeric sort if both values are numbers
+          if (a !== b && !isNaN(Number(a)) && !isNaN(Number(b))) {
+            return Number(a) - Number(b);
+          }
+          return String(a).localeCompare(String(b), 'ru');
+        })
+        .map(([val, data]) => {
+          const code     = parentKey ? parentKey + '→' + val : val;
+          const children = depth + 1 < levels.length
+            ? toNodes(data.children, depth + 1, code)
+            : null;
+          return { value: val, code, depth, children };
+        });
+    };
+
+    return toNodes(root, 0, '');
+  }
+
+  // Flat list of all column tree nodes
+  _flattenColTree(nodes) {
+    const result = [];
+    const walk = (nodes) => {
+      for (const node of nodes) {
+        result.push({
+          code:        node.code,
+          label:       node.value,
+          depth:       node.depth,
+          hasChildren: !!node.children,
+        });
+        if (node.children) walk(node.children);
+      }
+    };
+    walk(nodes);
+    return result;
+  }
+}

package/engine/column-store.js

@@ -0,0 +1,99 @@
+/**
+ * Columnar row storage backed by TypedArrays.
+ * Dimensions → Uint16Array (via DictionaryEncoder),
+ * measures   → Float64Array.
+ * ~10× memory savings compared to an array of objects.
+ */
+class ColumnStore {
+  constructor({ dimensions, measures, funcs, capacity }) {
+    this.dimensions = dimensions;
+    this.capacity   = capacity;
+    this.length     = 0;
+
+    // Expand revenue → revenue_sum, revenue_avg...
+    const expandedMeasures = measures.flatMap(m =>
+      funcs.map(fn => `${m}_${fn}`)
+    );
+    this.measures = expandedMeasures;  // overwrite
+
+    // One encoder per dimension
+    this.encoders = {};
+    for (const dim of dimensions) {
+      this.encoders[dim] = new DictionaryEncoder();
+    }
+
+    // Columns: Uint16 for dimensions, Float64 for measures
+    this.dimCols  = {};
+    this.measCols = {};
+    for (const dim of dimensions)       this.dimCols[dim]  = new Uint16Array(capacity);
+    for (const m   of expandedMeasures) this.measCols[m]   = new Float64Array(capacity);
+  }
+
+  /** Returns true if no more rows can be added */
+  isFull() {
+    return this.length >= this.capacity;
+  }
+
+  /**
+   * Appends rows to the store.
+   * Rows beyond capacity are silently discarded.
+   * @param {Object[]} rows
+   * @returns {number} number of rows actually added
+   */
+  append(rows) {
+    const room  = this.capacity - this.length;
+    const batch = rows.length > room ? rows.slice(0, room) : rows;
+
+    for (let i = 0; i < batch.length; i++) {
+      const row = batch[i];
+      const idx = this.length + i;
+      for (const dim of this.dimensions) {
+        this.dimCols[dim][idx] = this.encoders[dim].encode(row[dim]);
+      }
+      for (const m of this.measures) {
+        this.measCols[m][idx] = Number(row[m]) || 0;
+      }
+    }
+
+    this.length += batch.length;
+    return batch.length;
+  }
+
+  /**
+   * Returns an iterable view of rows without materialising
+   * the full object array — Aggregator traverses data on-the-fly.
+   * Supports for…of, .forEach and .length.
+   */
+  rows() {
+    const { dimensions, measures, dimCols, measCols, encoders, length } = this;
+
+    const iterable = {
+      length,
+
+      forEach(fn) {
+        for (let i = 0; i < length; i++) {
+          const row = {};
+          for (const dim of dimensions) row[dim] = encoders[dim].decode(dimCols[dim][i]);
+          for (const m   of measures)   row[m]   = measCols[m][i];
+          fn(row, i);
+        }
+      },
+
+      [Symbol.iterator]() {
+        let i = 0;
+        return {
+          next() {
+            if (i >= length) return { done: true, value: undefined };
+            const row = {};
+            for (const dim of dimensions) row[dim] = encoders[dim].decode(dimCols[dim][i]);
+            for (const m   of measures)   row[m]   = measCols[m][i];
+            i++;
+            return { done: false, value: row };
+          }
+        };
+      }
+    };
+
+    return iterable;
+  }
+}

package/engine/dictionary-encoder.js

@@ -0,0 +1,30 @@
+/**
+ * Encodes string values of a single column into uint16 indices.
+ * Used inside ColumnStore — one instance per dimension.
+ */
+class DictionaryEncoder {
+  constructor() {
+    this._map     = new Map();  // string → index
+    this._reverse = [];         // index → string
+  }
+
+  /** Returns the numeric index for a value, creating it if needed */
+  encode(value) {
+    const str = String(value);
+    if (!this._map.has(str)) {
+      const idx = this._reverse.length;
+      this._map.set(str, idx);
+      this._reverse.push(str);
+    }
+    return this._map.get(str);
+  }
+
+  /** Restores the string value by index */
+  decode(index) {
+    return this._reverse[index];
+  }
+
+  get size() {
+    return this._reverse.length;
+  }
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "pivotgrid-js",
+  "version": "0.1.0",
+  "description": "Vanilla JS pivot table — no dependencies, no frameworks",
+  "author": "Aleksandr Korolev <korolevalexa@gmail.com>",
+  "license": "SEE LICENSE IN LICENSE",
+  "homepage": "https://github.com/AlexKorole/pivotgrid",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AlexKorole/pivotgrid.git"
+  },
+  "keywords": [
+    "pivot",
+    "grid",
+    "table",
+    "pivot-table",
+    "data",
+    "analytics",
+    "vanilla-js"
+  ],
+  "main": "dist/pivotgrid.cjs.js",
+  "module": "dist/pivotgrid.esm.js",
+  "exports": {
+    ".": {
+      "import": "./dist/pivotgrid.esm.js",
+      "require": "./dist/pivotgrid.cjs.js"
+    },
+    "./css": "./dist/pivotgrid.css"
+  },
+  "files": [
+    "dist",
+    "config",
+    "src",
+    "engine",
+    "providers",
+    "widget",
+    "server",
+    "demo_data",
+    "LICENSE",
+    "LICENSE.commercial",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node build.js",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "esbuild": "^0.20.2"
+  }
+}

package/providers/array-provider.js

@@ -0,0 +1,255 @@
+/**
+ * ArrayProvider
+ *
+ * Provider for local array data.
+ * Implements the same interface as RestProvider —
+ * used for demo mode without a server.
+ */
+class ArrayProvider {
+
+  constructor({ data, dimensions, measures, funcs, fields = {},
+                cachedDimensions = [], maxCachedRows = 500_000,
+                drillthroughQuery = null }) {
+    this.data              = data;
+    this.dimensions        = dimensions;
+    this.measures          = measures;
+    this.funcs             = funcs;
+    this.fields            = fields;
+    this.maxCachedRows     = maxCachedRows;
+    this.drillthroughQuery = drillthroughQuery;
+
+    this._cachedDims = [...cachedDimensions];
+    this._store      = null;
+    this._cacheRows  = 0;
+  }
+
+  // ── Cache API ──────────────────────────────────────────────────────────────
+
+  async prefetch() {
+    this._store     = null;
+    this._cacheRows = 0;
+    if (!this._cachedDims.length) return;
+
+    const aggRows   = this._groupBy(this._cachedDims);
+    this._store     = this._makeStore(this._cachedDims, aggRows);
+    this._cacheRows = aggRows.length;
+  }
+
+  async countRows(logicalFields) {
+    if (!logicalFields.length) return 0;
+    const keys = new Set();
+    for (const row of this.data) {
+      keys.add(logicalFields.map(f => this._val(row, f)).join('|'));
+    }
+    return keys.size;
+  }
+
+  async refreshCache(newDims) {
+    this._cachedDims = [...newDims];
+    await this.prefetch();
+  }
+
+  get cachedDimensions() { return [...this._cachedDims]; }
+  get cacheRows()        { return this._cacheRows; }
+
+  // ── Grid data ─────────────────────────────────────────────────────────────
+
+  getBestRows(requiredDims = [], activeFilters = {}) {
+    if (!this._store) return null;
+
+    const hasAllRequired = requiredDims.every(dim => {
+      const col = (this.fields[dim] || {}).label || dim;
+      return this._store.dimensions.includes(col);
+    });
+    if (!hasAllRequired) return null;
+
+    const filterDims = Object.keys(activeFilters);
+    const hasAllFilterDims = filterDims.every(dim => {
+      const col = (this.fields[dim] || {}).label || dim;
+      return this._store.dimensions.includes(col);
+    });
+    if (!hasAllFilterDims) return null;
+
+    const rows = this._store.rows();
+    return filterDims.length > 0
+      ? this._filterRows(rows, activeFilters)
+      : rows;
+  }
+
+  async getRowsForDims(requiredDims, activeFilters = {}) {
+    const cached = this.getBestRows(requiredDims, activeFilters);
+    if (cached) return { rows: cached, fromCache: true };
+
+    const rows = this._groupBy(requiredDims, activeFilters);
+    return { rows, fromCache: false };
+  }
+
+  // ── Drillthrough ───────────────────────────────────────────────────────────
+
+  async countDistinct(logicalField) {
+    const col  = (this.fields[logicalField] || {}).label || logicalField;
+    const vals = new Set(this.data.map(r => String(r[col] ?? '')));
+    return vals.size;
+  }
+
+  async getDistinctValues(logicalField) {
+    const def     = this.fields[logicalField] || {};
+    const col     = def.label   || logicalField;
+    const sortCol = def.sortKey || col;
+    const vals    = [...new Set(this.data.map(r => String(r[col] ?? '')))];
+    return vals.sort((a, b) => {
+      const av = this.data.find(r => String(r[col]) === a)?.[sortCol];
+      const bv = this.data.find(r => String(r[col]) === b)?.[sortCol];
+      if (av !== undefined && bv !== undefined && !isNaN(Number(av)) && !isNaN(Number(bv))) {
+        return Number(av) - Number(bv);
+      }
+      return String(av ?? a).localeCompare(String(bv ?? b), 'ru');
+    });
+  }
+
+  async drillthrough({ filters = {}, limit = 200 }) {
+    let rows = this.data;
+
+    // Apply filters
+    for (const [dim, val] of Object.entries(filters)) {
+      const col = (this.fields[dim] || {}).label || dim;
+      rows = rows.filter(r => String(r[col] ?? '') === String(val));
+    }
+
+    return rows.slice(0, limit);
+  }
+
+  // ── Aggregation ───────────────────────────────────────────────────────────
+
+  _groupBy(logicalFields, activeFilters = {}) {
+    // Filter source data
+    let data = this.data;
+    if (Object.keys(activeFilters).length) {
+      data = this._filterRawRows(data, activeFilters);
+    }
+
+    const cols   = logicalFields.map(f => (this.fields[f] || {}).label || f);
+    const groups = new Map();
+
+    for (const row of data) {
+      const key = cols.map(c => String(row[c] ?? '')).join('|§|');
+      if (!groups.has(key)) {
+        const entry = {};
+        for (const col of cols) entry[col] = row[col];
+        // Add sortKey columns if present
+        for (const f of logicalFields) {
+          const def = this.fields[f] || {};
+          if (def.sortKey) entry[def.sortKey] = row[def.sortKey];
+        }
+        // Initialize aggregates
+        for (const m of this.measures) {
+          for (const fn of this.funcs) {
+            entry[`${m}_${fn}`]    = fn === 'min' ? Infinity : fn === 'max' ? -Infinity : 0;
+          }
+          entry[`__count_${m}`] = 0;
+          entry[`__sum2_${m}`]  = 0;
+        }
+        groups.set(key, entry);
+      }
+      const entry = groups.get(key);
+      for (const m of this.measures) {
+        const v = Number(row[m]) || 0;
+        entry[`__count_${m}`]++;
+        entry[`${m}_sum`]  = (entry[`${m}_sum`]  || 0) + v;
+        entry[`${m}_count`]= entry[`__count_${m}`];
+        entry[`${m}_min`]  = Math.min(entry[`${m}_min`] ?? Infinity, v);
+        entry[`${m}_max`]  = Math.max(entry[`${m}_max`] ?? -Infinity, v);
+        entry[`__sum2_${m}`] += v * v;
+      }
+    }
+
+    // Compute avg, stddev, variance
+    for (const entry of groups.values()) {
+      for (const m of this.measures) {
+        const n   = entry[`__count_${m}`] || 1;
+        const sum = entry[`${m}_sum`] || 0;
+        const sum2= entry[`__sum2_${m}`] || 0;
+        entry[`${m}_avg`]      = sum / n;
+        const variance          = sum2 / n - (sum / n) ** 2;
+        entry[`${m}_variance`] = variance;
+        entry[`${m}_stddev`]   = Math.sqrt(Math.max(0, variance));
+        delete entry[`__count_${m}`];
+        delete entry[`__sum2_${m}`];
+      }
+    }
+
+    return [...groups.values()];
+  }
+
+  _filterRawRows(data, activeFilters) {
+    const predicates = [];
+    for (const [dim, filter] of Object.entries(activeFilters)) {
+      const col = (this.fields[dim] || {}).label || dim;
+      if (filter.values && filter.values.length > 0) {
+        const valSet = new Set(filter.values);
+        predicates.push(row => valSet.has(String(row[col] ?? '')));
+      }
+      if (filter.searchText) {
+        const text = filter.searchText.toLowerCase();
+        predicates.push(filter.searchType === 'starts_with'
+          ? row => String(row[col] ?? '').toLowerCase().startsWith(text)
+          : row => String(row[col] ?? '').toLowerCase().includes(text)
+        );
+      }
+    }
+    if (!predicates.length) return data;
+    return data.filter(row => predicates.every(p => p(row)));
+  }
+
+  _filterRows(rows, activeFilters) {
+    const predicates = [];
+    for (const [dim, filter] of Object.entries(activeFilters)) {
+      const col = (this.fields[dim] || {}).label || dim;
+      if (filter.values && filter.values.length > 0) {
+        const valSet = new Set(filter.values);
+        predicates.push(row => valSet.has(String(row[col] ?? '')));
+      }
+      if (filter.searchText) {
+        const text = filter.searchText.toLowerCase();
+        predicates.push(filter.searchType === 'starts_with'
+          ? row => String(row[col] ?? '').toLowerCase().startsWith(text)
+          : row => String(row[col] ?? '').toLowerCase().includes(text)
+        );
+      }
+    }
+    if (!predicates.length) return rows;
+    const filtered = [];
+    for (const row of rows) {
+      if (predicates.every(p => p(row))) filtered.push(row);
+    }
+    return filtered;
+  }
+
+  // ── Helpers ────────────────────────────────────────────────────────────────
+
+  _val(row, logicalField) {
+    const col = (this.fields[logicalField] || {}).label || logicalField;
+    return String(row[col] ?? '');
+  }
+
+  _makeStore(logicalFields, rows) {
+    const dims  = logicalFields.map(f => (this.fields[f] || {}).label || f);
+    // Add sortKey columns
+    for (const f of logicalFields) {
+      const def = this.fields[f] || {};
+      if (def.sortKey && !dims.includes(def.sortKey)) dims.push(def.sortKey);
+    }
+    const store = new ColumnStore({
+      dimensions: dims,
+      measures:   this.measures,
+      funcs:      this.funcs,
+      capacity:   this.maxCachedRows,
+    });
+    store.append(rows);
+    return store;
+  }
+
+  async load() {
+    throw new Error('Use prefetch() / getRowsForDims() / drillthrough()');
+  }
+}