@softwear/latestcollectioncore 1.0.205 → 1.0.207

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/src/barcodeCanvas.ts

@@ -0,0 +1,59 @@
+import JsBarcodeImport from 'jsbarcode'
+
+export interface BarcodeCanvasResult {
+  dataUrl: string
+  width: number
+  height: number
+}
+
+/** Vite / CJS interop sometimes wraps the function as `{ default: fn }`. */
+function resolveJsBarcode(): ((element: unknown, value: string, options?: object) => void) | null {
+  const mod: any = JsBarcodeImport
+  if (typeof mod === 'function') return mod
+  if (mod && typeof mod.default === 'function') return mod.default
+  return null
+}
+
+function createCanvasElement(): HTMLCanvasElement | null {
+  if (typeof document !== 'undefined' && typeof document.createElement === 'function') {
+    return document.createElement('canvas')
+  }
+  return null
+}
+
+/**
+ * Render a barcode to a PNG data URL.
+ * Module width is fixed; the caller must scale the image uniformly into the layout box
+ * so bars are not distorted.
+ */
+export function renderBarcodeToDataUrl(value: string): BarcodeCanvasResult | null {
+  if (!value) return null
+  const canvas = createCanvasElement()
+  if (!canvas) return null
+
+  const JsBarcode = resolveJsBarcode()
+  if (!JsBarcode) return null
+
+  try {
+    JsBarcode(canvas, value, {
+      // Fixed module geometry — do not stretch independently in X/Y when placing on the page.
+      // CODE128 accepts arbitrary values.
+      format: 'CODE128',
+      width: 2,
+      height: 60,
+      displayValue: false,
+      margin: 0,
+    })
+  } catch (e) {
+    if (typeof console !== 'undefined') console.warn('Barcode render failed', value, e)
+    return null
+  }
+
+  if (!canvas.width || !canvas.height) return null
+
+  return {
+    dataUrl: canvas.toDataURL('image/png'),
+    width: canvas.width,
+    height: canvas.height,
+  }
+}

package/src/pdf.ts

@@ -7,7 +7,7 @@ export interface PaperSize {
 }
 
 export type TextAlign = 1 | 2 | 3 // 1: left, 2: center, 3: right
-export type ObjectType = 'text' | 'field' | 'rectangle' | 'image' | 'container'
+export type ObjectType = 'text' | 'field' | 'rectangle' | 'image' | 'container' | 'barcode'
 export type RepeatContainer = 'horizontal' | 'vertical' | undefined
 
 export interface BaseLayoutObject {
@@ -52,6 +52,15 @@ export interface ImageLayoutObject extends BaseLayoutObject {
   image?: HTMLImageElement
 }
 
+/**
+ * Renders a 1D barcode from printBuffer via `source` (default `barcode`).
+ * Drawn with uniform scale to fit width×height (never independently stretched).
+ */
+export interface BarcodeLayoutObject extends BaseLayoutObject {
+  type: 'barcode'
+  source?: string
+}
+
 export interface ContainerLayoutObject extends BaseLayoutObject {
   type: 'container'
   source: string
@@ -70,7 +79,7 @@ export interface ContainerLayoutObject extends BaseLayoutObject {
   printOnlyAtStart?: boolean
 }
 
-export type LayoutObject = TextLayoutObject | FieldLayoutObject | RectangleLayoutObject | ImageLayoutObject | ContainerLayoutObject
+export type LayoutObject = TextLayoutObject | FieldLayoutObject | RectangleLayoutObject | ImageLayoutObject | BarcodeLayoutObject | ContainerLayoutObject
 
 export interface Layout {
   name?: string

package/src/reports.ts

@@ -1,8 +1,9 @@
 import { jsPDF } from 'jspdf'
 import { format } from 'date-fns'
+import { renderBarcodeToDataUrl } from './barcodeCanvas'
 import deepCopy from './deepCopy'
 import { resolveLayoutFieldText } from './layoutFieldFormat'
-import { PaperSize, Layout, LayoutObject, ContainerLayoutObject } from './pdf'
+import { PaperSize, Layout, LayoutObject, ContainerLayoutObject, BarcodeLayoutObject } from './pdf'
 
 type RenderMode = 'measurement' | 'rendering'
 
@@ -453,6 +454,27 @@ function drawSimpleObject(x: number, y: number, doc: jsPDF, object: LayoutObject
     }
   }
 
+  // Draw barcode for barcode objects (uniform scale into the layout box — never stretch bars)
+  if (object.type == 'barcode') {
+    const barcodeObj = object as BarcodeLayoutObject
+    const source = barcodeObj.source || 'barcode'
+    const raw = getProperty(source, printBuffer)
+    const value = raw == null ? '' : String(raw)
+    if (!value) {
+      options.onAlert?.({ header: 'fieldnotfound', body: source, type: 'warning', timeout: 10000 })
+    } else {
+      const rendered = renderBarcodeToDataUrl(value)
+      if (rendered) {
+        const { x: drawX, y: drawY, width: drawWidth, height: drawHeight } = computeImageDrawRect(x, y, width, height, rendered.width, rendered.height)
+        try {
+          doc.addImage(rendered.dataUrl, 'PNG', drawX, drawY, drawWidth, drawHeight)
+        } catch (_e) {
+          // Skip if jsPDF cannot embed the canvas data URL
+        }
+      }
+    }
+  }
+
   // Draw text for text and field objets
   if ((object.type == 'text' || object.type == 'field') && text) {
     let textAlign: 'left' | 'center' | 'right' | undefined

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)