@softwear/latestcollectioncore 1.0.206 → 1.0.207

package/dist/articleStatus.js

@@ -18,13 +18,13 @@ SELLOUT_PERCENTAGE, ROI, QTY_AVG_STOCK, VALUE_AVG_STOCK, QTY_TURNOVER_VELOCITY,
 const VECTOR_LENGTH = 50;
 const BEGIN_STOCK_VECTOR_START = QTY_STOCK;
 const BEGIN_STOCK_VECTOR_END = AMOUNT_SHELF_STOCK + 1;
+const TOTAL_KEY = '** TOTAL **';
 const msYear = 24 * 3600 * 365 * 1000;
-const globalJoinableTables = { customer: 'custnr', sku: 'ean', wh: 'wh', transaction: 'row' }; // defines the keys we can join on
+const globalJoinableTables = { customer: 'custnr', sku: 'ean', wh: 'wh' }; // defines the keys we can join on
 /**
  * Global variables
  */
 let globalRelations = {}; // holds the joined tables
-let globalNrAggegationExpressions = 0; // tracks the # aggregations rows so we can quit computing if it grows out of bounds
 /**
  * The propFunction for FiltreX needs some data that can't be passed as parameters. That's why the 'globalsRelations' variable is needed.
  * TODO: Functional: Experiment with curried functions
@@ -32,17 +32,28 @@ let globalNrAggegationExpressions = 0; // tracks the # aggregations rows so we c
 function resolvePath(obj, path) {
     return path.reduce((o, key) => o === null || o === void 0 ? void 0 : o[key], obj);
 }
+const MAX_PARSED_PROPERTIES = 1000;
+const parsedProperties = new Map();
+function parseProperty(propertyName) {
+    let parsed = parsedProperties.get(propertyName);
+    if (parsed)
+        return parsed;
+    const positionOfDot = propertyName.indexOf('.');
+    parsed = positionOfDot < 0 ? { table: undefined, path: [propertyName] } : { table: propertyName.substring(0, positionOfDot), path: propertyName.substring(positionOfDot + 1).split('.') };
+    if (parsedProperties.size >= MAX_PARSED_PROPERTIES)
+        parsedProperties.clear();
+    parsedProperties.set(propertyName, parsed);
+    return parsed;
+}
 function propFunction(propertyName, getPropertyName, obj) {
     var _a;
-    const positionOfDot = propertyName.indexOf('.');
-    if (positionOfDot < 0)
+    const { table, path } = parseProperty(propertyName);
+    if (table === undefined)
         return obj[propertyName];
-    const table = propertyName.substring(0, positionOfDot);
-    const path = propertyName.substring(positionOfDot + 1).split('.');
     if (table == 'transaction')
-        return resolvePath(obj, path);
+        return path.length == 1 ? obj[path[0]] : resolvePath(obj, path);
     const joinedRecord = (_a = globalRelations[table]) === null || _a === void 0 ? void 0 : _a[obj[globalJoinableTables[table]]];
-    return resolvePath(joinedRecord, path) || '~ ?';
+    return (path.length == 1 ? joinedRecord === null || joinedRecord === void 0 ? void 0 : joinedRecord[path[0]] : resolvePath(joinedRecord, path)) || '~ ?';
 }
 const lower = (s) => s.toLowerCase();
 const upper = (s) => s.toUpperCase();
@@ -50,23 +61,50 @@ const filtrexOptions = {
     extraFunctions: { lower, upper },
     customProp: propFunction,
 };
-// This is how the actual joining of 2 vectors happens
+const filtrexKeywords = ['and', 'or', 'not', 'in', 'of', 'if', 'then', 'else', 'mod'];
+/**
+ * The transaction fields an expression result depends on. Two transactions with the same values for
+ * these fields give the same result, so the expression is evaluated once per combination.
+ * - A joined table (sku., wh., customer.) depends on its join key.
+ * - transaction.<field> and a bare <field> depend on that field of the transaction itself.
+ * A field too many only costs cache hits; a field too few would give wrong results.
+ */
+function getExpressionGranularity(expression) {
+    const fields = [];
+    const addField = (field) => {
+        if (fields.indexOf(field) < 0)
+            fields.push(field);
+    };
+    Object.entries(globalJoinableTables).forEach(([table, joinKey]) => {
+        if (expression.includes(table + '.'))
+            addField(joinKey);
+    });
+    const withoutStrings = expression.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+    // 'quoted symbol' | symbol, optionally followed by "(" when it is a function call
+    const symbolPattern = /'((?:[^'\\]|\\.)*)'|([A-Za-z_$][A-Za-z0-9_$.]*)(\s*\()?/g;
+    let match;
+    while ((match = symbolPattern.exec(withoutStrings))) {
+        let symbol = match[2];
+        if (match[1] !== undefined)
+            symbol = match[1].replace(/\\(.)/g, '$1');
+        else if (match[3] || filtrexKeywords.indexOf(symbol) >= 0)
+            continue;
+        const positionOfDot = symbol.indexOf('.');
+        if (positionOfDot < 0)
+            addField(symbol);
+        else if (symbol.substring(0, positionOfDot) == 'transaction')
+            addField(symbol.substring(positionOfDot + 1).split('.')[0]);
+    }
+    return fields;
+}
+// Deprecated schema: transactions that still carry a stored vector are added slot by slot.
 function addVectors(targetVector, otherVector, begin, end) {
+    if (end > otherVector.length)
+        end = otherVector.length;
     for (let i = begin; i < end; i++)
         targetVector[i] += otherVector[i] || 0;
 }
-// This function takes a transaction and adds it to the aggregations
-function addTransactionToAggregations(beginTimestamp, endTimestamp, aggregateKey, rawAggregations, transaction, maxRows) {
-    let aggregateVector = rawAggregations[aggregateKey];
-    if (globalNrAggegationExpressions >= maxRows)
-        return;
-    if (!aggregateVector) {
-        globalNrAggegationExpressions++;
-        aggregateVector = new Float64Array(VECTOR_LENGTH);
-        rawAggregations[aggregateKey] = aggregateVector;
-    }
-    if (!transaction.vector)
-        transaction.vector = transaction_1.default.buildVector(transaction);
+function addStoredVector(beginTimestamp, endTimestamp, aggregateVector, transaction) {
     if (Array.isArray(transaction.vector))
         transaction.vector = Float64Array.from(transaction.vector);
     const v = transaction.vector;
@@ -118,6 +156,8 @@ function getTrieLeaf(root, transaction, keys) {
     }
     return node;
 }
+// The most fields a single transaction adds to an aggregation row (a returned sale: 10)
+const MAX_CONTRIBUTIONS = 12;
 /*
  * A factory function that returns a function that can be used to aggregate transactions
  * The factory function is called once for each aggregationExpression
@@ -146,19 +186,228 @@ function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregatio
     const filterTrieRoot = {};
     if (filterExpression) {
         filter = (0, filtrex_1.compileExpression)(filterExpression, filtrexOptions);
-        filterGranularity = Object.entries(globalJoinableTables)
-            .filter((join) => filterExpression.includes(join[0] + '.'))
-            .map((join) => join[1]);
+        filterGranularity = getExpressionGranularity(filterExpression);
     }
     // Empty aggregation expression = no groupers → only the totals row
     const totalsOnly = !aggregationExpression;
     const aggregationEvaluator = totalsOnly ? undefined : buildAggregationEvaluator(aggregationExpression);
-    const aggregationGranularity = totalsOnly
-        ? []
-        : Object.entries(globalJoinableTables)
-            .filter((join) => aggregationExpression.includes(join[0] + '.'))
-            .map((join) => join[1]);
+    const aggregationGranularity = totalsOnly ? [] : getExpressionGranularity(aggregationExpression);
     const aggregationTrieRoot = {};
+    let nrNewRows = 0; // tracks the # rows added so we can quit computing if it grows out of bounds
+    let totalVector;
+    // What the current transaction adds to an aggregation row: computed once, added to its row, subtotal and total
+    const slots = new Int32Array(MAX_CONTRIBUTIONS);
+    const values = new Float64Array(MAX_CONTRIBUTIONS);
+    let nrContributions = 0;
+    // NaN (a missing qty or price) counts as 0
+    function contribute(slot, value) {
+        slots[nrContributions] = slot;
+        values[nrContributions++] = value || 0;
+    }
+    function contributeStockTime(qty, amount, timeLeft) {
+        slots[nrContributions] = STOCK_TIME_PRODUCT;
+        values[nrContributions++] = qty * timeLeft;
+        slots[nrContributions] = STOCKAMOUNT_TIME_PRODUCT;
+        values[nrContributions++] = amount * timeLeft;
+    }
+    // Same numbers as transaction.buildVector, without building a vector per transaction
+    function prepareContributions(transaction) {
+        nrContributions = 0;
+        const time = transaction.time;
+        const type = typeof transaction.type == 'string' ? transaction.type : String(transaction.type);
+        const qty = +transaction.qty;
+        if (time <= beginTimestamp) {
+            // Before the period: begin stock, plus outstanding picklists/consignments so endShelf remains stable
+            // when only the start date changes for a fixed end date.
+            switch (type) {
+                case types_1.transactionTypeE.RECEIVING:
+                case types_1.transactionTypeE.TRANSIT:
+                case types_1.transactionTypeE.CHANGE:
+                case types_1.transactionTypeE.START_STOCK:
+                case types_1.transactionTypeE.RETURN_CUSTOMER: {
+                    const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                    contribute(QTY_STOCK, qty);
+                    contribute(AMOUNT_STOCK, cost);
+                    contribute(QTY_SHELF_STOCK, qty);
+                    contribute(AMOUNT_SHELF_STOCK, cost);
+                    return;
+                }
+                case types_1.transactionTypeE.SALE:
+                case types_1.transactionTypeE.B2B_SOLD:
+                case types_1.transactionTypeE.B2B_RE_SOLD: {
+                    const cost = (0, index_1.round2)(-transaction.buyprice * transaction.qty);
+                    contribute(QTY_STOCK, -qty);
+                    contribute(AMOUNT_STOCK, cost);
+                    contribute(QTY_SHELF_STOCK, -qty);
+                    contribute(AMOUNT_SHELF_STOCK, cost);
+                    return;
+                }
+                case types_1.transactionTypeE.RE_VALUATION: {
+                    const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                    contribute(AMOUNT_STOCK, cost);
+                    contribute(AMOUNT_SHELF_STOCK, cost);
+                    return;
+                }
+                case types_1.transactionTypeE.START_SHELF_STOCK:
+                    // Type 10 subtracts outstanding picktickets of previous shards from the shelf stock
+                    contribute(QTY_SHELF_STOCK, qty);
+                    contribute(AMOUNT_SHELF_STOCK, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                    return;
+                case types_1.transactionTypeE.PICK_LIST:
+                    contribute(QTY_PICKLIST, qty);
+                    contribute(AMOUNT_PICKLIST, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                    contribute(COSTPRICE_PICKLIST, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                    return;
+                case types_1.transactionTypeE.CONSIGNMENT:
+                    contribute(QTY_CONSIGNMENT, qty);
+                    contribute(AMOUNT_CONSIGNMENT, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                    contribute(COSTPRICE_CONSIGNMENT, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                    return;
+            }
+            return;
+        }
+        if (time > endTimestamp)
+            return;
+        // Period transactions
+        const timeLeft = endTimestamp - time;
+        switch (type) {
+            case types_1.transactionTypeE.SALE: {
+                const sku = globalRelations['sku'][transaction.ean];
+                const amountSoldExcl = (0, index_1.round2)((transaction.sellprice / ((100 + (transaction.vat || 0)) / 100)) * transaction.qty);
+                const costprice = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                const amountSoldMax = (0, index_1.round2)((((sku === null || sku === void 0 ? void 0 : sku.price) || 0) / ((100 + (transaction.vat || (sku === null || sku === void 0 ? void 0 : sku.vat) || 21)) / 100)) * qty);
+                contribute(QTY_SOLD, qty);
+                contribute(AMOUNT_SOLD, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(AMOUNT_SOLD_EXCL, amountSoldExcl);
+                contribute(COSTPRICE_SOLD, costprice);
+                contribute(AMOUNT_SOLD_MAX, amountSoldMax);
+                contribute(AMOUNT_SOLD_DISCOUNT, (0, index_1.round2)(amountSoldMax - amountSoldExcl));
+                if (qty < 0)
+                    contribute(QTY_RETURN, qty);
+                if (amountSoldExcl < 0)
+                    contribute(AMOUNT_RETURN, amountSoldExcl);
+                contributeStockTime(-(qty || 0), -(costprice || 0), timeLeft);
+                return;
+            }
+            case types_1.transactionTypeE.RECEIVING: {
+                const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                contribute(QTY_RECIEVED, qty);
+                contribute(AMOUNT_RECIEVED, cost);
+                contributeStockTime(qty || 0, cost || 0, timeLeft);
+                return;
+            }
+            case types_1.transactionTypeE.TRANSIT: {
+                const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                contribute(QTY_TRANSIT, qty);
+                contribute(AMOUNT_TRANSIT, cost);
+                contributeStockTime(qty || 0, cost || 0, timeLeft);
+                return;
+            }
+            case types_1.transactionTypeE.CHANGE:
+            case types_1.transactionTypeE.START_STOCK: {
+                const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                contribute(QTY_CHANGE, qty);
+                contribute(AMOUNT_CHANGE, cost);
+                contributeStockTime(qty || 0, cost || 0, timeLeft);
+                return;
+            }
+            case types_1.transactionTypeE.B2B_SOLD: {
+                const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                contribute(QTY_B2B_SOLD, qty);
+                contribute(AMOUNT_B2B_SOLD, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(COSTPRICE_B2B_SOLD, cost);
+                contributeStockTime(-(qty || 0), -(cost || 0), timeLeft);
+                return;
+            }
+            case types_1.transactionTypeE.B2B_RE_SOLD: {
+                const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                contribute(QTY_B2B_RESOLD, qty);
+                contribute(AMOUNT_B2B_RESOLD, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(COSTPRICE_B2B_RESOLD, cost);
+                contributeStockTime(-(qty || 0), -(cost || 0), timeLeft);
+                return;
+            }
+            case types_1.transactionTypeE.RETURN_CUSTOMER: {
+                const cost = (0, index_1.round2)(transaction.buyprice * transaction.qty);
+                contribute(QTY_B2B_RETURN, qty);
+                contribute(AMOUNT_B2B_RETURN, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(COSTPRICE_B2B_RETURN, cost);
+                contributeStockTime(qty || 0, cost || 0, timeLeft);
+                return;
+            }
+            case types_1.transactionTypeE.CREDIT_INVOICE:
+                contribute(AMOUNT_B2B_RETURN, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.RE_VALUATION:
+                contribute(AMOUNT_REVALUATE, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.PURCHASE_ORDER:
+                contribute(QTY_PO, qty);
+                contribute(AMOUNT_PO, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.PURCHASE_ORDER_COMPLETE:
+                contribute(QTY_PO_COMPLETE, qty);
+                contribute(AMOUNT_PO_COMPLETE, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.MINIMUM_STOCK:
+                contribute(QTY_MINIMUM_STOCK, qty);
+                contribute(AMOUNT_MINIMUM_STOCK, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.ORDER:
+                contribute(QTY_ORDER, qty);
+                contribute(AMOUNT_ORDER, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(COSTPRICE_ORDER, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.RE_ORDER:
+                contribute(QTY_REORDER, qty);
+                contribute(AMOUNT_REORDER, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(COSTPRICE_REORDER, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.PICK_LIST:
+                // Picklists reduce shelfStock, which is handled by subtracting QTY_PICKLIST in postAgg
+                contribute(QTY_PICKLIST, qty);
+                contribute(AMOUNT_PICKLIST, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(COSTPRICE_PICKLIST, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+            case types_1.transactionTypeE.CONSIGNMENT:
+                // Consignments reduce shelfStock, which is handled by subtracting QTY_CONSIGNMENT in postAgg
+                contribute(QTY_CONSIGNMENT, qty);
+                contribute(AMOUNT_CONSIGNMENT, (0, index_1.round2)(transaction.sellprice * transaction.qty));
+                contribute(COSTPRICE_CONSIGNMENT, (0, index_1.round2)(transaction.buyprice * transaction.qty));
+                return;
+        }
+    }
+    // Deprecated schema: derived sale fields live in the stored vector
+    function prepareStoredVector(transaction) {
+        if (transaction.type != types_1.transactionTypeE.SALE)
+            return;
+        const sku = globalRelations['sku'][transaction.ean];
+        if (Array.isArray(transaction.vector)) {
+            const tmp = new Float64Array(AMOUNT_SOLD_DISCOUNT + 1);
+            tmp.set(transaction.vector);
+            transaction.vector = tmp;
+        }
+        const v = transaction.vector;
+        v[AMOUNT_SOLD_MAX] = (0, index_1.round2)((((sku === null || sku === void 0 ? void 0 : sku.price) || 0) / ((100 + (transaction.vat || (sku === null || sku === void 0 ? void 0 : sku.vat) || 21)) / 100)) * v[QTY_SOLD]);
+        v[AMOUNT_SOLD_DISCOUNT] = (0, index_1.round2)(v[AMOUNT_SOLD_MAX] - v[AMOUNT_SOLD_EXCL]);
+    }
+    function getAggregateVector(aggregateKey) {
+        let aggregateVector = rawAggregations[aggregateKey];
+        if (!aggregateVector) {
+            nrNewRows++;
+            aggregateVector = new Float64Array(VECTOR_LENGTH);
+            rawAggregations[aggregateKey] = aggregateVector;
+        }
+        return aggregateVector;
+    }
+    function addTransactionToVector(aggregateVector, transaction) {
+        if (transaction.vector)
+            return addStoredVector(beginTimestamp, endTimestamp, aggregateVector, transaction);
+        if (transaction.type == types_1.transactionTypeE.RECEIVING && transaction.time > aggregateVector[MAX_RECIEVE_TIMESTAMP])
+            aggregateVector[MAX_RECIEVE_TIMESTAMP] = transaction.time;
+        for (let i = 0; i < nrContributions; i++)
+            aggregateVector[slots[i]] += values[i];
+    }
     return function (transaction) {
         if (filter) {
             const filterLeaf = getTrieLeaf(filterTrieRoot, transaction, filterGranularity);
@@ -170,22 +419,15 @@ function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregatio
                     return;
             }
         }
-        // Prepare joined values for derived fields
-        if (transaction.type == types_1.transactionTypeE.SALE) {
-            const sku = globalRelations['sku'][transaction.ean];
-            if (!transaction.vector)
-                transaction.vector = transaction_1.default.buildVector(transaction);
-            if (Array.isArray(transaction.vector)) {
-                const tmp = new Float64Array(AMOUNT_SOLD_DISCOUNT + 1);
-                tmp.set(transaction.vector);
-                transaction.vector = tmp;
-            }
-            const v = transaction.vector;
-            v[AMOUNT_SOLD_MAX] = (0, index_1.round2)((((sku === null || sku === void 0 ? void 0 : sku.price) || 0) / ((100 + (transaction.vat || (sku === null || sku === void 0 ? void 0 : sku.vat) || 21)) / 100)) * v[QTY_SOLD]);
-            v[AMOUNT_SOLD_DISCOUNT] = (0, index_1.round2)(v[AMOUNT_SOLD_MAX] - v[AMOUNT_SOLD_EXCL]);
+        if (transaction.vector)
+            prepareStoredVector(transaction);
+        else
+            prepareContributions(transaction);
+        if ((totals || totalsOnly) && nrNewRows < maxRows) {
+            if (!totalVector)
+                totalVector = getAggregateVector(TOTAL_KEY);
+            addTransactionToVector(totalVector, transaction);
         }
-        if (totals || totalsOnly)
-            addTransactionToAggregations(beginTimestamp, endTimestamp, '** TOTAL **', rawAggregations, transaction, maxRows);
         // No detail/subtotal rows when there are no groupers
         if (totalsOnly)
             return;
@@ -198,20 +440,19 @@ function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregatio
         // Example: for 4 groupers we have rows like
         // g0 g1 g2 g3 <- normal row with no subtotal
         // g0          <- subtotal for g0
-        if (subtotalsForOuterGrouper == true) {
-            addTransactionToAggregations(beginTimestamp, endTimestamp, `${aggregateKey.substr(0, aggregateKey.indexOf('\t'))} Σ`, rawAggregations, transaction, maxRows);
-        }
-        if (parentGroupTotals) {
-            const KPIKey = prepareSubTotalAggKey(aggregateKey);
-            addTransactionToAggregations(beginTimestamp, endTimestamp, KPIKey, rawAggregations, transaction, maxRows);
-        }
-        else {
-            addTransactionToAggregations(beginTimestamp, endTimestamp, aggregateKey, rawAggregations, transaction, maxRows);
+        if (subtotalsForOuterGrouper == true && nrNewRows < maxRows) {
+            if (!aggregateKeyLeaf.subtotalVector)
+                aggregateKeyLeaf.subtotalVector = getAggregateVector(`${aggregateKey.substr(0, aggregateKey.indexOf('\t'))} Σ`);
+            addTransactionToVector(aggregateKeyLeaf.subtotalVector, transaction);
         }
+        if (nrNewRows >= maxRows)
+            return;
+        if (!aggregateKeyLeaf.vector)
+            aggregateKeyLeaf.vector = getAggregateVector(parentGroupTotals ? prepareSubTotalAggKey(aggregateKey) : aggregateKey);
+        addTransactionToVector(aggregateKeyLeaf.vector, transaction);
     };
 }
 function aggregate({ beginTimestamp, endTimestamp, filterExpression, aggregationExpression, transactions, beginStock, relations, rawAggregations, maxRows, totals, subtotalsForOuterGrouper, parentGroupTotals }) {
-    globalNrAggegationExpressions = 0;
     globalRelations = relations;
     const compiledAggregator = aggregator({
         beginTimestamp,

package/dist/barcodeCanvas.js

@@ -37,7 +37,7 @@ function renderBarcodeToDataUrl(value) {
     try {
         JsBarcode(canvas, value, {
             // Fixed module geometry — do not stretch independently in X/Y when placing on the page.
-            // CODE128 accepts arbitrary values (EAN auto-detect can throw on bad check digits).
+            // CODE128 accepts arbitrary values.
             format: 'CODE128',
             width: 2,
             height: 60,

package/dist/pdf.d.ts

@@ -50,7 +50,6 @@ export interface ImageLayoutObject extends BaseLayoutObject {
  */
 export interface BarcodeLayoutObject extends BaseLayoutObject {
     type: 'barcode';
-    /** Path into the current print buffer item; defaults to `barcode`. */
     source?: string;
 }
 export interface ContainerLayoutObject extends BaseLayoutObject {
@@ -60,10 +59,7 @@ export interface ContainerLayoutObject extends BaseLayoutObject {
     repeatContainer?: RepeatContainer;
     repeatOnOverflow?: boolean;
     pageBreak?: boolean;
-    /**
-     * Minimum remaining space before drawing the next item; if less, break to the next page first.
-     * Same units as layout x/y/width/height (tenths of mm), e.g. 220 ≈ 22mm.
-     */
+    /** Minimum mm of remaining space before drawing next item; if less, break to next page first */
     minHeightBeforeBreak?: number;
     /** When true, container and children are drawn only once at the end of the report, not on every page */
     printOnlyAtEnd?: boolean;

package/dist/reports.js

@@ -554,10 +554,9 @@ addObjectToPDF = function (originX, originY, doc, object, printBuffer, paperSize
             });
             const container = source[containerIndex];
             absoluteLowerRightHandSide = { x: originX / 10, y: originY / 10 };
-            // Layout units (tenths of mm), same as originY / paperSize after genPDF scales them ×10.
-            const minHeightBeforeBreak = object.minHeightBeforeBreak;
-            const useOrphanCheck = minHeightBeforeBreak != null && minHeightBeforeBreak > 0;
-            if (useOrphanCheck && (object.pageBreak || originY + minHeightBeforeBreak > paperSize.height - paperSize.footerHeight)) {
+            const minHeightMm = object.minHeightBeforeBreak;
+            const useOrphanCheck = minHeightMm != null && minHeightMm > 0;
+            if (useOrphanCheck && (object.pageBreak || originY + minHeightMm > paperSize.height - paperSize.footerHeight)) {
                 // We ran out of paper
                 originX = layoutXtenths;
                 // Continuation sheets must not reuse the page-1-only overlap bump: addPage hasn't run yet so getCurrentPageNumber is still 1.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@softwear/latestcollectioncore",
-  "version": "1.0.206",
+  "version": "1.0.207",
   "description": "Core functions for LatestCollections applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/articleStatus.ts

@@ -84,14 +84,15 @@ const VECTOR_LENGTH = 50
 const BEGIN_STOCK_VECTOR_START = QTY_STOCK
 const BEGIN_STOCK_VECTOR_END = AMOUNT_SHELF_STOCK + 1
 
+const TOTAL_KEY = '** TOTAL **'
+
 const msYear = 24 * 3600 * 365 * 1000
-const globalJoinableTables = { customer: 'custnr', sku: 'ean', wh: 'wh', transaction: 'row' } // defines the keys we can join on
+const globalJoinableTables = { customer: 'custnr', sku: 'ean', wh: 'wh' } // defines the keys we can join on
 
 /**
  * Global variables
  */
 let globalRelations = {} // holds the joined tables
-let globalNrAggegationExpressions = 0 // tracks the # aggregations rows so we can quit computing if it grows out of bounds
 
 /**
  * The propFunction for FiltreX needs some data that can't be passed as parameters. That's why the 'globalsRelations' variable is needed.
@@ -101,14 +102,27 @@ function resolvePath(obj: Record<string, any> | undefined, path: string[]): any
   return path.reduce((o, key) => o?.[key], obj)
 }
 
-function propFunction(propertyName: string, getPropertyName: Function, obj: Record<string, any>): any {
+// Property names are parsed once; FiltreX asks for the same few names over and over.
+type ParsedPropertyI = { table: string | undefined; path: string[] }
+const MAX_PARSED_PROPERTIES = 1000
+const parsedProperties = new Map<string, ParsedPropertyI>()
+
+function parseProperty(propertyName: string): ParsedPropertyI {
+  let parsed = parsedProperties.get(propertyName)
+  if (parsed) return parsed
   const positionOfDot = propertyName.indexOf('.')
-  if (positionOfDot < 0) return obj[propertyName]
-  const table = propertyName.substring(0, positionOfDot)
-  const path = propertyName.substring(positionOfDot + 1).split('.')
-  if (table == 'transaction') return resolvePath(obj, path)
+  parsed = positionOfDot < 0 ? { table: undefined, path: [propertyName] } : { table: propertyName.substring(0, positionOfDot), path: propertyName.substring(positionOfDot + 1).split('.') }
+  if (parsedProperties.size >= MAX_PARSED_PROPERTIES) parsedProperties.clear()
+  parsedProperties.set(propertyName, parsed)
+  return parsed
+}
+
+function propFunction(propertyName: string, getPropertyName: Function, obj: Record<string, any>): any {
+  const { table, path } = parseProperty(propertyName)
+  if (table === undefined) return obj[propertyName]
+  if (table == 'transaction') return path.length == 1 ? obj[path[0]] : resolvePath(obj, path)
   const joinedRecord = globalRelations[table]?.[obj[globalJoinableTables[table]]]
-  return resolvePath(joinedRecord, path) || '~ ?'
+  return (path.length == 1 ? joinedRecord?.[path[0]] : resolvePath(joinedRecord, path)) || '~ ?'
 }
 
 const lower = (s: string) => s.toLowerCase()
@@ -119,21 +133,45 @@ const filtrexOptions = {
   customProp: propFunction,
 }
 
-// This is how the actual joining of 2 vectors happens
+const filtrexKeywords = ['and', 'or', 'not', 'in', 'of', 'if', 'then', 'else', 'mod']
+
+/**
+ * The transaction fields an expression result depends on. Two transactions with the same values for
+ * these fields give the same result, so the expression is evaluated once per combination.
+ * - A joined table (sku., wh., customer.) depends on its join key.
+ * - transaction.<field> and a bare <field> depend on that field of the transaction itself.
+ * A field too many only costs cache hits; a field too few would give wrong results.
+ */
+function getExpressionGranularity(expression: string): string[] {
+  const fields: string[] = []
+  const addField = (field: string) => {
+    if (fields.indexOf(field) < 0) fields.push(field)
+  }
+  Object.entries(globalJoinableTables).forEach(([table, joinKey]) => {
+    if (expression.includes(table + '.')) addField(joinKey)
+  })
+  const withoutStrings = expression.replace(/"(?:[^"\\]|\\.)*"/g, '""')
+  // 'quoted symbol' | symbol, optionally followed by "(" when it is a function call
+  const symbolPattern = /'((?:[^'\\]|\\.)*)'|([A-Za-z_$][A-Za-z0-9_$.]*)(\s*\()?/g
+  let match: RegExpExecArray | null
+  while ((match = symbolPattern.exec(withoutStrings))) {
+    let symbol = match[2]
+    if (match[1] !== undefined) symbol = match[1].replace(/\\(.)/g, '$1')
+    else if (match[3] || filtrexKeywords.indexOf(symbol) >= 0) continue
+    const positionOfDot = symbol.indexOf('.')
+    if (positionOfDot < 0) addField(symbol)
+    else if (symbol.substring(0, positionOfDot) == 'transaction') addField(symbol.substring(positionOfDot + 1).split('.')[0])
+  }
+  return fields
+}
+
+// Deprecated schema: transactions that still carry a stored vector are added slot by slot.
 function addVectors(targetVector: Float64Array, otherVector: Float64Array, begin: number, end: number): void {
+  if (end > otherVector.length) end = otherVector.length
   for (let i = begin; i < end; i++) targetVector[i] += otherVector[i] || 0
 }
 
-// This function takes a transaction and adds it to the aggregations
-function addTransactionToAggregations(beginTimestamp: number, endTimestamp: number, aggregateKey: string, rawAggregations: RaGI, transaction: TransactionI, maxRows: number): void {
-  let aggregateVector = rawAggregations[aggregateKey]
-  if (globalNrAggegationExpressions >= maxRows) return
-  if (!aggregateVector) {
-    globalNrAggegationExpressions++
-    aggregateVector = new Float64Array(VECTOR_LENGTH)
-    rawAggregations[aggregateKey] = aggregateVector
-  }
-  if (!transaction.vector) transaction.vector = transactionFunctions.buildVector(transaction)
+function addStoredVector(beginTimestamp: number, endTimestamp: number, aggregateVector: Float64Array, transaction: TransactionI): void {
   if (Array.isArray(transaction.vector)) transaction.vector = Float64Array.from(transaction.vector)
   const v = transaction.vector
   if (transaction.type == transactionTypeE.RECEIVING && transaction.time > aggregateVector[MAX_RECIEVE_TIMESTAMP]) aggregateVector[MAX_RECIEVE_TIMESTAMP] = transaction.time
@@ -171,7 +209,8 @@ function coerceJoinKeyValue(v: unknown): unknown {
   return typeof v === 'boolean' ? +v : v
 }
 
-type AggregateKeyTrieNode = { aggregateKey?: string; children?: Map<unknown, AggregateKeyTrieNode> }
+// A leaf remembers the aggregation rows of its key so a transaction is added without looking them up again
+type AggregateKeyTrieNode = { aggregateKey?: string; vector?: Float64Array; subtotalVector?: Float64Array; children?: Map<unknown, AggregateKeyTrieNode> }
 type FilterResultTrieNode = { filterResult?: 1 | -1; children?: Map<unknown, FilterResultTrieNode> }
 
 function getTrieLeaf<T extends { children?: Map<unknown, T> }>(root: T, transaction: TransactionI, keys: string[]): T {
@@ -191,6 +230,9 @@ function getTrieLeaf<T extends { children?: Map<unknown, T> }>(root: T, transact
   return node
 }
 
+// The most fields a single transaction adds to an aggregation row (a returned sale: 10)
+const MAX_CONTRIBUTIONS = 12
+
 /*
  * A factory function that returns a function that can be used to aggregate transactions
  * The factory function is called once for each aggregationExpression
@@ -219,20 +261,232 @@ function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregatio
   const filterTrieRoot: FilterResultTrieNode = {}
   if (filterExpression) {
     filter = compileExpression(filterExpression, filtrexOptions)
-    filterGranularity = Object.entries(globalJoinableTables)
-      .filter((join) => filterExpression.includes(join[0] + '.'))
-      .map((join) => join[1])
+    filterGranularity = getExpressionGranularity(filterExpression)
   }
   // Empty aggregation expression = no groupers → only the totals row
   const totalsOnly = !aggregationExpression
   const aggregationEvaluator = totalsOnly ? undefined : buildAggregationEvaluator(aggregationExpression)
-  const aggregationGranularity = totalsOnly
-    ? []
-    : Object.entries(globalJoinableTables)
-        .filter((join) => aggregationExpression.includes(join[0] + '.'))
-        .map((join) => join[1])
+  const aggregationGranularity = totalsOnly ? [] : getExpressionGranularity(aggregationExpression)
   const aggregationTrieRoot: AggregateKeyTrieNode = {}
 
+  let nrNewRows = 0 // tracks the # rows added so we can quit computing if it grows out of bounds
+  let totalVector: Float64Array | undefined
+
+  // What the current transaction adds to an aggregation row: computed once, added to its row, subtotal and total
+  const slots = new Int32Array(MAX_CONTRIBUTIONS)
+  const values = new Float64Array(MAX_CONTRIBUTIONS)
+  let nrContributions = 0
+
+  // NaN (a missing qty or price) counts as 0
+  function contribute(slot: number, value: number): void {
+    slots[nrContributions] = slot
+    values[nrContributions++] = value || 0
+  }
+
+  function contributeStockTime(qty: number, amount: number, timeLeft: number): void {
+    slots[nrContributions] = STOCK_TIME_PRODUCT
+    values[nrContributions++] = qty * timeLeft
+    slots[nrContributions] = STOCKAMOUNT_TIME_PRODUCT
+    values[nrContributions++] = amount * timeLeft
+  }
+
+  // Same numbers as transaction.buildVector, without building a vector per transaction
+  function prepareContributions(transaction: TransactionI): void {
+    nrContributions = 0
+    const time = transaction.time
+    const type = typeof transaction.type == 'string' ? transaction.type : String(transaction.type)
+    const qty = +transaction.qty
+
+    if (time <= beginTimestamp) {
+      // Before the period: begin stock, plus outstanding picklists/consignments so endShelf remains stable
+      // when only the start date changes for a fixed end date.
+      switch (type) {
+        case transactionTypeE.RECEIVING:
+        case transactionTypeE.TRANSIT:
+        case transactionTypeE.CHANGE:
+        case transactionTypeE.START_STOCK:
+        case transactionTypeE.RETURN_CUSTOMER: {
+          const cost = round2(transaction.buyprice * transaction.qty)
+          contribute(QTY_STOCK, qty)
+          contribute(AMOUNT_STOCK, cost)
+          contribute(QTY_SHELF_STOCK, qty)
+          contribute(AMOUNT_SHELF_STOCK, cost)
+          return
+        }
+        case transactionTypeE.SALE:
+        case transactionTypeE.B2B_SOLD:
+        case transactionTypeE.B2B_RE_SOLD: {
+          const cost = round2(-transaction.buyprice * transaction.qty)
+          contribute(QTY_STOCK, -qty)
+          contribute(AMOUNT_STOCK, cost)
+          contribute(QTY_SHELF_STOCK, -qty)
+          contribute(AMOUNT_SHELF_STOCK, cost)
+          return
+        }
+        case transactionTypeE.RE_VALUATION: {
+          const cost = round2(transaction.buyprice * transaction.qty)
+          contribute(AMOUNT_STOCK, cost)
+          contribute(AMOUNT_SHELF_STOCK, cost)
+          return
+        }
+        case transactionTypeE.START_SHELF_STOCK:
+          // Type 10 subtracts outstanding picktickets of previous shards from the shelf stock
+          contribute(QTY_SHELF_STOCK, qty)
+          contribute(AMOUNT_SHELF_STOCK, round2(transaction.buyprice * transaction.qty))
+          return
+        case transactionTypeE.PICK_LIST:
+          contribute(QTY_PICKLIST, qty)
+          contribute(AMOUNT_PICKLIST, round2(transaction.sellprice * transaction.qty))
+          contribute(COSTPRICE_PICKLIST, round2(transaction.buyprice * transaction.qty))
+          return
+        case transactionTypeE.CONSIGNMENT:
+          contribute(QTY_CONSIGNMENT, qty)
+          contribute(AMOUNT_CONSIGNMENT, round2(transaction.sellprice * transaction.qty))
+          contribute(COSTPRICE_CONSIGNMENT, round2(transaction.buyprice * transaction.qty))
+          return
+      }
+      return
+    }
+    if (time > endTimestamp) return
+
+    // Period transactions
+    const timeLeft = endTimestamp - time
+    switch (type) {
+      case transactionTypeE.SALE: {
+        const sku = globalRelations['sku'][transaction.ean]
+        const amountSoldExcl = round2((transaction.sellprice / ((100 + (transaction.vat || 0)) / 100)) * transaction.qty)
+        const costprice = round2(transaction.buyprice * transaction.qty)
+        const amountSoldMax = round2(((sku?.price || 0) / ((100 + (transaction.vat || sku?.vat || 21)) / 100)) * qty)
+        contribute(QTY_SOLD, qty)
+        contribute(AMOUNT_SOLD, round2(transaction.sellprice * transaction.qty))
+        contribute(AMOUNT_SOLD_EXCL, amountSoldExcl)
+        contribute(COSTPRICE_SOLD, costprice)
+        contribute(AMOUNT_SOLD_MAX, amountSoldMax)
+        contribute(AMOUNT_SOLD_DISCOUNT, round2(amountSoldMax - amountSoldExcl))
+        if (qty < 0) contribute(QTY_RETURN, qty)
+        if (amountSoldExcl < 0) contribute(AMOUNT_RETURN, amountSoldExcl)
+        contributeStockTime(-(qty || 0), -(costprice || 0), timeLeft)
+        return
+      }
+      case transactionTypeE.RECEIVING: {
+        const cost = round2(transaction.buyprice * transaction.qty)
+        contribute(QTY_RECIEVED, qty)
+        contribute(AMOUNT_RECIEVED, cost)
+        contributeStockTime(qty || 0, cost || 0, timeLeft)
+        return
+      }
+      case transactionTypeE.TRANSIT: {
+        const cost = round2(transaction.buyprice * transaction.qty)
+        contribute(QTY_TRANSIT, qty)
+        contribute(AMOUNT_TRANSIT, cost)
+        contributeStockTime(qty || 0, cost || 0, timeLeft)
+        return
+      }
+      case transactionTypeE.CHANGE:
+      case transactionTypeE.START_STOCK: {
+        const cost = round2(transaction.buyprice * transaction.qty)
+        contribute(QTY_CHANGE, qty)
+        contribute(AMOUNT_CHANGE, cost)
+        contributeStockTime(qty || 0, cost || 0, timeLeft)
+        return
+      }
+      case transactionTypeE.B2B_SOLD: {
+        const cost = round2(transaction.buyprice * transaction.qty)
+        contribute(QTY_B2B_SOLD, qty)
+        contribute(AMOUNT_B2B_SOLD, round2(transaction.sellprice * transaction.qty))
+        contribute(COSTPRICE_B2B_SOLD, cost)
+        contributeStockTime(-(qty || 0), -(cost || 0), timeLeft)
+        return
+      }
+      case transactionTypeE.B2B_RE_SOLD: {
+        const cost = round2(transaction.buyprice * transaction.qty)
+        contribute(QTY_B2B_RESOLD, qty)
+        contribute(AMOUNT_B2B_RESOLD, round2(transaction.sellprice * transaction.qty))
+        contribute(COSTPRICE_B2B_RESOLD, cost)
+        contributeStockTime(-(qty || 0), -(cost || 0), timeLeft)
+        return
+      }
+      case transactionTypeE.RETURN_CUSTOMER: {
+        const cost = round2(transaction.buyprice * transaction.qty)
+        contribute(QTY_B2B_RETURN, qty)
+        contribute(AMOUNT_B2B_RETURN, round2(transaction.sellprice * transaction.qty))
+        contribute(COSTPRICE_B2B_RETURN, cost)
+        contributeStockTime(qty || 0, cost || 0, timeLeft)
+        return
+      }
+      case transactionTypeE.CREDIT_INVOICE:
+        contribute(AMOUNT_B2B_RETURN, round2(transaction.sellprice * transaction.qty))
+        return
+      case transactionTypeE.RE_VALUATION:
+        contribute(AMOUNT_REVALUATE, round2(transaction.buyprice * transaction.qty))
+        return
+      case transactionTypeE.PURCHASE_ORDER:
+        contribute(QTY_PO, qty)
+        contribute(AMOUNT_PO, round2(transaction.buyprice * transaction.qty))
+        return
+      case transactionTypeE.PURCHASE_ORDER_COMPLETE:
+        contribute(QTY_PO_COMPLETE, qty)
+        contribute(AMOUNT_PO_COMPLETE, round2(transaction.buyprice * transaction.qty))
+        return
+      case transactionTypeE.MINIMUM_STOCK:
+        contribute(QTY_MINIMUM_STOCK, qty)
+        contribute(AMOUNT_MINIMUM_STOCK, round2(transaction.buyprice * transaction.qty))
+        return
+      case transactionTypeE.ORDER:
+        contribute(QTY_ORDER, qty)
+        contribute(AMOUNT_ORDER, round2(transaction.sellprice * transaction.qty))
+        contribute(COSTPRICE_ORDER, round2(transaction.buyprice * transaction.qty))
+        return
+      case transactionTypeE.RE_ORDER:
+        contribute(QTY_REORDER, qty)
+        contribute(AMOUNT_REORDER, round2(transaction.sellprice * transaction.qty))
+        contribute(COSTPRICE_REORDER, round2(transaction.buyprice * transaction.qty))
+        return
+      case transactionTypeE.PICK_LIST:
+        // Picklists reduce shelfStock, which is handled by subtracting QTY_PICKLIST in postAgg
+        contribute(QTY_PICKLIST, qty)
+        contribute(AMOUNT_PICKLIST, round2(transaction.sellprice * transaction.qty))
+        contribute(COSTPRICE_PICKLIST, round2(transaction.buyprice * transaction.qty))
+        return
+      case transactionTypeE.CONSIGNMENT:
+        // Consignments reduce shelfStock, which is handled by subtracting QTY_CONSIGNMENT in postAgg
+        contribute(QTY_CONSIGNMENT, qty)
+        contribute(AMOUNT_CONSIGNMENT, round2(transaction.sellprice * transaction.qty))
+        contribute(COSTPRICE_CONSIGNMENT, round2(transaction.buyprice * transaction.qty))
+        return
+    }
+  }
+
+  // Deprecated schema: derived sale fields live in the stored vector
+  function prepareStoredVector(transaction: TransactionI): void {
+    if (transaction.type != transactionTypeE.SALE) return
+    const sku = globalRelations['sku'][transaction.ean]
+    if (Array.isArray(transaction.vector)) {
+      const tmp = new Float64Array(AMOUNT_SOLD_DISCOUNT + 1)
+      tmp.set(transaction.vector)
+      transaction.vector = tmp
+    }
+    const v = transaction.vector
+    v[AMOUNT_SOLD_MAX] = round2(((sku?.price || 0) / ((100 + (transaction.vat || sku?.vat || 21)) / 100)) * v[QTY_SOLD])
+    v[AMOUNT_SOLD_DISCOUNT] = round2(v[AMOUNT_SOLD_MAX] - v[AMOUNT_SOLD_EXCL])
+  }
+
+  function getAggregateVector(aggregateKey: string): Float64Array {
+    let aggregateVector = rawAggregations[aggregateKey]
+    if (!aggregateVector) {
+      nrNewRows++
+      aggregateVector = new Float64Array(VECTOR_LENGTH)
+      rawAggregations[aggregateKey] = aggregateVector
+    }
+    return aggregateVector
+  }
+
+  function addTransactionToVector(aggregateVector: Float64Array, transaction: TransactionI): void {
+    if (transaction.vector) return addStoredVector(beginTimestamp, endTimestamp, aggregateVector, transaction)
+    if (transaction.type == transactionTypeE.RECEIVING && transaction.time > aggregateVector[MAX_RECIEVE_TIMESTAMP]) aggregateVector[MAX_RECIEVE_TIMESTAMP] = transaction.time
+    for (let i = 0; i < nrContributions; i++) aggregateVector[slots[i]] += values[i]
+  }
+
   return function (transaction: TransactionI): void {
     if (filter) {
       const filterLeaf = getTrieLeaf<FilterResultTrieNode>(filterTrieRoot, transaction, filterGranularity)
@@ -242,21 +496,13 @@ function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregatio
         if (filterLeaf.filterResult === -1) return
       }
     }
-    // Prepare joined values for derived fields
-    if (transaction.type == transactionTypeE.SALE) {
-      const sku = globalRelations['sku'][transaction.ean]
-      if (!transaction.vector) transaction.vector = transactionFunctions.buildVector(transaction)
-      if (Array.isArray(transaction.vector)) {
-        const tmp = new Float64Array(AMOUNT_SOLD_DISCOUNT + 1)
-        tmp.set(transaction.vector)
-        transaction.vector = tmp
-      }
-      const v = transaction.vector
-      v[AMOUNT_SOLD_MAX] = round2(((sku?.price || 0) / ((100 + (transaction.vat || sku?.vat || 21)) / 100)) * v[QTY_SOLD])
-      v[AMOUNT_SOLD_DISCOUNT] = round2(v[AMOUNT_SOLD_MAX] - v[AMOUNT_SOLD_EXCL])
-    }
+    if (transaction.vector) prepareStoredVector(transaction)
+    else prepareContributions(transaction)
 
-    if (totals || totalsOnly) addTransactionToAggregations(beginTimestamp, endTimestamp, '** TOTAL **', rawAggregations, transaction, maxRows)
+    if ((totals || totalsOnly) && nrNewRows < maxRows) {
+      if (!totalVector) totalVector = getAggregateVector(TOTAL_KEY)
+      addTransactionToVector(totalVector, transaction)
+    }
 
     // No detail/subtotal rows when there are no groupers
     if (totalsOnly) return
@@ -271,21 +517,18 @@ function aggregator({ beginTimestamp, endTimestamp, filterExpression, aggregatio
     // Example: for 4 groupers we have rows like
     // g0 g1 g2 g3 <- normal row with no subtotal
     // g0          <- subtotal for g0
-    if (subtotalsForOuterGrouper == true) {
-      addTransactionToAggregations(beginTimestamp, endTimestamp, `${aggregateKey.substr(0, aggregateKey.indexOf('\t'))} Σ`, rawAggregations, transaction, maxRows)
+    if (subtotalsForOuterGrouper == true && nrNewRows < maxRows) {
+      if (!aggregateKeyLeaf.subtotalVector) aggregateKeyLeaf.subtotalVector = getAggregateVector(`${aggregateKey.substr(0, aggregateKey.indexOf('\t'))} Σ`)
+      addTransactionToVector(aggregateKeyLeaf.subtotalVector, transaction)
     }
 
-    if (parentGroupTotals) {
-      const KPIKey = prepareSubTotalAggKey(aggregateKey)
-      addTransactionToAggregations(beginTimestamp, endTimestamp, KPIKey, rawAggregations, transaction, maxRows)
-    } else {
-      addTransactionToAggregations(beginTimestamp, endTimestamp, aggregateKey, rawAggregations, transaction, maxRows)
-    }
+    if (nrNewRows >= maxRows) return
+    if (!aggregateKeyLeaf.vector) aggregateKeyLeaf.vector = getAggregateVector(parentGroupTotals ? prepareSubTotalAggKey(aggregateKey) : aggregateKey)
+    addTransactionToVector(aggregateKeyLeaf.vector, transaction)
   }
 }
 
 function aggregate({ beginTimestamp, endTimestamp, filterExpression, aggregationExpression, transactions, beginStock, relations, rawAggregations, maxRows, totals, subtotalsForOuterGrouper, parentGroupTotals }: AggregateFnI) {
-  globalNrAggegationExpressions = 0
   globalRelations = relations
 
   const compiledAggregator = aggregator({

package/test/articleStatus.spec.js

@@ -532,6 +532,87 @@ describe('articleStatus', () => {
       expect(lateStart[articleStatus.QTY_END_SHELF_STOCK]).toBe(9)
     })
 
+    describe('transaction fields in expressions', () => {
+      const timeframe = { beginTimeStamp: 1000, endTimeStamp: 9000 }
+      // Document snapshots carry no row number
+      const purchaseOrders = () => [
+        { time: 2000, type: '14', ean: 'A', wh: '50', qty: 1, buyprice: 10, docnr: 'PO-A' },
+        { time: 2000, type: '14', ean: 'A', wh: '50', qty: 2, buyprice: 10, docnr: 'PO-B' },
+        { time: 2000, type: '14', ean: 'B', wh: '50', qty: 4, buyprice: 10, docnr: 'PO-B' },
+      ]
+      const query = (groups, filter) => articleStatus.runQuery(timeframe, {}, false, purchaseOrders(), groups, { A: {}, B: {} }, {}, {}, false, filter, false)
+
+      it('should group transactions without a row number by a transaction field', () => {
+        const rawAggregations = query(['transaction.docnr'], '')
+        expect(Object.keys(rawAggregations)).toEqual(['** TOTAL **', 'PO-A', 'PO-B'])
+        expect(rawAggregations['PO-A'][articleStatus.QTY_PO]).toBe(1)
+        expect(rawAggregations['PO-B'][articleStatus.QTY_PO]).toBe(6)
+      })
+
+      it('should filter transactions without a row number by a transaction field', () => {
+        const rawAggregations = query([], 'transaction.docnr == "PO-B"')
+        expect(rawAggregations['** TOTAL **'][articleStatus.QTY_PO]).toBe(6)
+      })
+
+      it('should filter by a field that is not prefixed with transaction.', () => {
+        const rawAggregations = query([], 'qty > 1 and lower(docnr) == "po-b"')
+        expect(rawAggregations['** TOTAL **'][articleStatus.QTY_PO]).toBe(6)
+      })
+    })
+
+    describe('transaction schemas', () => {
+      const begin = 10000
+      const end = 20000
+      const timeframe = { beginTimeStamp: begin, endTimeStamp: end }
+      const types = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '10', '14', '15', '18', '92', '93', '94', '95', '96', '97', '98']
+      const skus = { A: { brand: 'a', price: 49.95, vat: 21 }, B: { brand: 'b' } }
+      const buildTransactions = () => {
+        const transactions = []
+        types.forEach((type, t) => {
+          // before the period, on its begin, in the period, on its end and after the period
+          ;[begin - 500, begin, begin + 2500, end, end + 500].forEach((time, i) => {
+            ;[3, -2].forEach((qty) => {
+              transactions.push({ time, type, ean: i % 2 ? 'A' : 'B', wh: '50', qty, buyprice: 12.345 + t, sellprice: 29.95 + i, vat: i % 3 ? 21 : undefined, row: transactions.length })
+            })
+          })
+        })
+        return transactions
+      }
+      const query = (transactions) => articleStatus.runQuery(timeframe, {}, true, transactions, ['sku.brand', 'transaction.type'], skus, {}, {}, true, '', false)
+
+      it('should not add a vector to the transactions', () => {
+        const transactions = buildTransactions()
+        query(transactions)
+        expect(transactions.some((transaction) => 'vector' in transaction)).toBe(false)
+      })
+
+      it('should give the same result for the deprecated stored vector as for qty and prices', () => {
+        const expected = query(buildTransactions())
+        const storedVector = (transaction) => Array.from(core.transaction.buildVector(transaction))
+        const withVector = buildTransactions().map((transaction) => ({ ...transaction, vector: storedVector(transaction) }))
+        const vectorOnly = buildTransactions().map(({ qty, buyprice, sellprice, ...transaction }) => ({ ...transaction, vector: storedVector({ ...transaction, qty, buyprice, sellprice }) }))
+        const mixed = buildTransactions().map((transaction, i) => (i % 2 ? transaction : { ...transaction, vector: storedVector(transaction) }))
+
+        expect(Object.keys(expected).length).toBe(1 + 2 + 2 * types.length)
+        expect(expected['a\t2'][articleStatus.QTY_SOLD]).not.toBe(0)
+        expect(query(withVector)).toEqual(expected)
+        expect(query(vectorOnly)).toEqual(expected)
+        expect(query(mixed)).toEqual(expected)
+      })
+
+      it('should count a missing qty or price as 0', () => {
+        const transactions = [
+          { time: begin + 1, type: '1', ean: 'A', wh: '50', qty: 2, buyprice: 10 },
+          { time: begin + 1, type: '1', ean: 'A', wh: '50', buyprice: 10 },
+          { time: begin + 1, type: '1', ean: 'A', wh: '50', qty: 3 },
+        ]
+        const total = articleStatus.runQuery(timeframe, {}, true, transactions, [], skus, {}, {}, false, '', false)['** TOTAL **']
+        expect(total[articleStatus.QTY_RECIEVED]).toBe(5)
+        expect(total[articleStatus.AMOUNT_RECIEVED]).toBe(20)
+        expect(total[articleStatus.STOCK_TIME_PRODUCT]).toBe(5 * (end - begin - 1))
+      })
+    })
+
     it('#getDateRangeFromPicker', () => {
       const dateRange = articleStatus.getDateRangeFromPicker(['2024-01-01', '2024-12-31'])
       expect(dateRange.beginTimeStamp).toBe(1704063600000)