@ifc-lite/viewer 1.25.2 → 1.27.0

package/src/lib/lists/export/csv.ts

@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel } from './model';
+
+function esc(s: string, delim: string): string {
+  return /["\r\n]/.test(s) || s.includes(delim) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+
+/**
+ * CSV faithful to the configured columns. When grouped, a leading "Group"
+ * column preserves the grouping as data (so it stays re-importable), rows are
+ * ordered by group, and a TOTAL row carries the grand count + sums.
+ */
+export function toCsv(model: ExportModel, delimiter = ','): string {
+  const grouped = model.groups !== null;
+  const header = [...(grouped ? ['Group'] : []), ...model.columns.map((c) => c.label)];
+  const lines = [header.map((h) => esc(h, delimiter)).join(delimiter)];
+
+  const line = (groupLabel: string | null, values: CellValue[]) => {
+    const cells = grouped ? [esc(groupLabel ?? '', delimiter)] : [];
+    for (let i = 0; i < model.columns.length; i++) cells.push(esc(displayCell(values[i]), delimiter));
+    return cells.join(delimiter);
+  };
+
+  if (grouped && model.groups) {
+    for (const g of model.groups) for (const r of g.rows) lines.push(line(g.label, r));
+  } else {
+    for (const r of model.rows) lines.push(line(null, r));
+  }
+
+  if (model.sumColumnIds.length > 0) {
+    const totalLabel = `TOTAL (${model.totals.count})`;
+    const cells = grouped ? [esc(totalLabel, delimiter)] : [];
+    for (let i = 0; i < model.columns.length; i++) {
+      const c = model.columns[i];
+      if (c.summed) cells.push(esc(displayCell(model.totals.sums[c.id]), delimiter));
+      else if (!grouped && i === 0) cells.push(esc(totalLabel, delimiter));
+      else cells.push('');
+    }
+    lines.push(cells.join(delimiter));
+  }
+
+  return lines.join('\r\n');
+}

package/src/lib/lists/export/index.ts

@@ -0,0 +1,49 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * List results export — CSV / Excel / PDF, all driven by one normalised model
+ * (columns, grouping, sums, totals). Excel and PDF writers (and their heavy
+ * libs) are lazy-loaded so they never touch the initial bundle.
+ */
+
+import { toCsv } from './csv';
+import type { ExportModel } from './model';
+
+export type ExportFormat = 'csv' | 'xlsx' | 'pdf';
+
+export const EXPORT_LABELS: Record<ExportFormat, string> = {
+  csv: 'CSV (.csv)',
+  xlsx: 'Excel (.xlsx)',
+  pdf: 'PDF (.pdf)',
+};
+
+function slug(s: string): string {
+  return (s || 'list').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'list';
+}
+
+function download(blob: Blob, filename: string): void {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement('a');
+  a.href = url;
+  a.download = filename;
+  a.click();
+  setTimeout(() => URL.revokeObjectURL(url), 1500);
+}
+
+export async function exportList(format: ExportFormat, model: ExportModel): Promise<void> {
+  const name = slug(model.title);
+  if (format === 'csv') {
+    download(new Blob([toCsv(model)], { type: 'text/csv;charset=utf-8;' }), `${name}.csv`);
+  } else if (format === 'xlsx') {
+    const { toXlsx } = await import('./xlsx');
+    download(await toXlsx(model), `${name}.xlsx`);
+  } else {
+    const { toPdf } = await import('./pdf');
+    download(await toPdf(model), `${name}.pdf`);
+  }
+}
+
+export { buildExportModel } from './model';
+export type { ExportModel } from './model';

package/src/lib/lists/export/model.ts

@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+/**
+ * Normalised export model shared by the CSV / Excel / PDF writers. Built from
+ * the on-screen list view so every export honours the configured columns
+ * (order, labels, widths), the active grouping, and the summed columns —
+ * grouped sections with per-group count + subtotals, plus grand totals.
+ */
+
+import type { CellValue, ColumnDefinition, ListRow, ListGrouping } from '@ifc-lite/lists';
+
+export interface ExportColumn {
+  id: string;
+  label: string;
+  numeric: boolean;
+  summed: boolean;
+  /** Pixel width from the table (for proportional column sizing in exports). */
+  width: number;
+}
+
+export interface ExportGroup {
+  label: string;
+  count: number;
+  sums: Record<string, number>;
+  rows: CellValue[][];
+}
+
+export interface ExportModel {
+  title: string;
+  generatedAt: string;
+  columns: ExportColumn[];
+  /** Grouped sections (with member rows), or null when the list isn't grouped. */
+  groups: ExportGroup[] | null;
+  /** All rows in display order (flat) — used by writers that don't section. */
+  rows: CellValue[][];
+  groupColumnId: string | null;
+  sumColumnIds: string[];
+  totals: { count: number; sums: Record<string, number> };
+}
+
+export interface BuildModelInput {
+  title: string;
+  columns: ColumnDefinition[];
+  /** Rows already filtered + sorted exactly as shown on screen. */
+  rows: ListRow[];
+  grouping?: ListGrouping;
+  numericCols: boolean[];
+  columnWidths: number[];
+  generatedAt: string;
+}
+
+/** Format a cell for text-based exports (CSV/PDF). Excel keeps raw numbers. */
+export function displayCell(value: CellValue): string {
+  if (value === null || value === undefined) return '';
+  if (typeof value === 'boolean') return value ? 'Yes' : 'No';
+  if (typeof value === 'number') {
+    if (Number.isInteger(value)) return value.toLocaleString();
+    return value.toFixed(4).replace(/\.?0+$/, '');
+  }
+  return String(value);
+}
+
+export function buildExportModel(input: BuildModelInput): ExportModel {
+  const { columns, rows, grouping, numericCols, columnWidths, title, generatedAt } = input;
+  const sumColumnIds = grouping?.sumColumnIds ?? [];
+  const exportCols: ExportColumn[] = columns.map((c, i) => ({
+    id: c.id,
+    label: c.label ?? c.propertyName,
+    numeric: !!numericCols[i],
+    summed: sumColumnIds.includes(c.id),
+    width: columnWidths[i] ?? 120,
+  }));
+
+  const sumIdx = sumColumnIds
+    .map((id) => ({ id, idx: columns.findIndex((c) => c.id === id) }))
+    .filter((s) => s.idx >= 0);
+  const zeroSums = (): Record<string, number> => Object.fromEntries(sumIdx.map((s) => [s.id, 0]));
+  const addSums = (acc: Record<string, number>, values: CellValue[]) => {
+    for (const s of sumIdx) {
+      const v = values[s.idx];
+      if (typeof v === 'number' && Number.isFinite(v)) acc[s.id] += v;
+    }
+  };
+
+  const totals = { count: rows.length, sums: zeroSums() };
+  const flatRows: CellValue[][] = [];
+  for (const r of rows) { flatRows.push(r.values); addSums(totals.sums, r.values); }
+
+  const groupColumnId = grouping?.columnId && columns.some((c) => c.id === grouping.columnId)
+    ? grouping.columnId : null;
+
+  let groups: ExportGroup[] | null = null;
+  if (groupColumnId) {
+    const groupIdx = columns.findIndex((c) => c.id === groupColumnId);
+    const byKey = new Map<string, ExportGroup>();
+    for (const r of rows) {
+      const raw = r.values[groupIdx];
+      const label = raw === null || raw === undefined || raw === '' ? '(none)' : displayCell(raw);
+      let g = byKey.get(label);
+      if (!g) { g = { label, count: 0, sums: zeroSums(), rows: [] }; byKey.set(label, g); }
+      g.count++;
+      g.rows.push(r.values);
+      addSums(g.sums, r.values);
+    }
+    groups = Array.from(byKey.values()).sort((a, b) => b.count - a.count || a.label.localeCompare(b.label));
+  }
+
+  return { title, generatedAt, columns: exportCols, groups, rows: flatRows, groupColumnId, sumColumnIds, totals };
+}

package/src/lib/lists/export/pdf.ts

@@ -0,0 +1,67 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel } from './model';
+
+/** Quality tabular PDF report: title + meta, dark header, grouped sections
+ *  (bold group rows carrying per-group count + subtotals), right-aligned
+ *  numerics, a grand-total foot, and page numbers. */
+export async function toPdf(model: ExportModel): Promise<Blob> {
+  const { jsPDF } = await import('jspdf');
+  const autoTable = (await import('jspdf-autotable')).default;
+
+  const landscape = model.columns.length > 5;
+  const doc = new jsPDF({ orientation: landscape ? 'landscape' : 'portrait', unit: 'pt', format: 'a4' });
+
+  doc.setFont('helvetica', 'bold'); doc.setFontSize(14);
+  doc.text(model.title || 'List', 40, 42);
+  doc.setFont('helvetica', 'normal'); doc.setFontSize(9); doc.setTextColor(130);
+  doc.text(`${model.totals.count.toLocaleString()} elements · ${model.generatedAt}`, 40, 58);
+  doc.setTextColor(0);
+
+  const head = [model.columns.map((c) => c.label)];
+  const cell = (vals: CellValue[], i: number) => displayCell(vals[i]);
+  const body: Array<Array<string | { content: string; styles: Record<string, unknown> }>> = [];
+
+  if (model.groups) {
+    for (const g of model.groups) {
+      body.push(model.columns.map((c, i) => ({
+        content: i === 0 ? `${g.label}  (${g.count})` : (c.summed ? displayCell(g.sums[c.id]) : ''),
+        styles: { fontStyle: 'bold', fillColor: [226, 232, 240] as unknown as number[] },
+      })));
+      for (const r of g.rows) body.push(model.columns.map((_, i) => cell(r, i)));
+    }
+  } else {
+    for (const r of model.rows) body.push(model.columns.map((_, i) => cell(r, i)));
+  }
+
+  const foot = model.sumColumnIds.length > 0
+    ? [model.columns.map((c, i) => (c.summed ? displayCell(model.totals.sums[c.id]) : (i === 0 ? `Total (${model.totals.count})` : '')))]
+    : undefined;
+
+  const columnStyles: Record<number, { halign: 'right' }> = {};
+  model.columns.forEach((c, i) => { if (c.numeric) columnStyles[i] = { halign: 'right' }; });
+
+  autoTable(doc, {
+    head,
+    body,
+    foot,
+    startY: 72,
+    margin: { left: 40, right: 40, top: 70, bottom: 40 },
+    styles: { fontSize: 8, cellPadding: 3, overflow: 'ellipsize', lineColor: [226, 232, 240], lineWidth: 0.5 },
+    headStyles: { fillColor: [51, 65, 85], textColor: 255, fontStyle: 'bold' },
+    footStyles: { fillColor: [241, 245, 249], textColor: 20, fontStyle: 'bold' },
+    columnStyles,
+    didDrawPage: () => {
+      doc.setFontSize(8); doc.setTextColor(150);
+      const w = doc.internal.pageSize.getWidth();
+      const h = doc.internal.pageSize.getHeight();
+      doc.text(`Page ${doc.getNumberOfPages()}`, w - 60, h - 20);
+      doc.setTextColor(0);
+    },
+  });
+
+  return doc.output('blob');
+}

package/src/lib/lists/export/xlsx.ts

@@ -0,0 +1,83 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+
+import type { CellValue } from '@ifc-lite/lists';
+import { displayCell, type ExportModel, type ExportColumn } from './model';
+
+const XLSX_MIME = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+const NUM_FMT = '#,##0.####';
+
+/** px → Excel column-width units (≈ 7px per char). */
+const excelWidth = (px: number): number => Math.max(8, Math.min(80, Math.round(px / 7)));
+
+/** Excel keeps real numbers (so the recipient can re-aggregate); other types
+ *  fall back to the same display string the table shows. */
+function cellValue(v: CellValue, c: ExportColumn): string | number | null {
+  if (v === null || v === undefined) return null;
+  if (c.numeric && typeof v === 'number' && Number.isFinite(v)) return v;
+  return displayCell(v);
+}
+
+export async function toXlsx(model: ExportModel): Promise<Blob> {
+  const ExcelJS = (await import('exceljs')).default;
+  const wb = new ExcelJS.Workbook();
+  wb.creator = 'IFC-Lite';
+  const ws = wb.addWorksheet((model.title || 'List').slice(0, 31), {
+    views: [{ state: 'frozen', ySplit: 4 }],
+  });
+
+  const cols = model.columns;
+  const ncol = cols.length;
+
+  // Title + meta.
+  ws.addRow([model.title || 'List']);
+  ws.mergeCells(1, 1, 1, ncol);
+  ws.getCell(1, 1).font = { bold: true, size: 14 };
+  ws.addRow([`${model.totals.count.toLocaleString()} elements · ${model.generatedAt}`]);
+  ws.mergeCells(2, 1, 2, ncol);
+  ws.getCell(2, 1).font = { italic: true, size: 9, color: { argb: 'FF94A3B8' } };
+  ws.addRow([]);
+
+  // Header.
+  const header = ws.addRow(cols.map((c) => c.label));
+  header.font = { bold: true, color: { argb: 'FFFFFFFF' } };
+  header.eachCell((cell) => {
+    cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FF334155' } };
+    cell.alignment = { vertical: 'middle' };
+  });
+
+  // Column widths + numeric formatting/alignment.
+  cols.forEach((c, i) => {
+    const col = ws.getColumn(i + 1);
+    col.width = excelWidth(c.width);
+    if (c.numeric) { col.numFmt = NUM_FMT; col.alignment = { horizontal: 'right' }; }
+  });
+
+  const addDataRow = (values: CellValue[], outline?: number) => {
+    const r = ws.addRow(cols.map((c, i) => cellValue(values[i], c)));
+    if (outline) r.outlineLevel = outline;
+  };
+
+  if (model.groups) {
+    for (const g of model.groups) {
+      const gr = ws.addRow(cols.map((c, i) => (i === 0 ? `${g.label} (${g.count})` : (c.summed ? g.sums[c.id] : null))));
+      gr.font = { bold: true };
+      gr.eachCell((cell) => { cell.fill = { type: 'pattern', pattern: 'solid', fgColor: { argb: 'FFE2E8F0' } }; });
+      for (const row of g.rows) addDataRow(row, 1);
+    }
+    ws.properties.outlineLevelRow = 1;
+  } else {
+    for (const row of model.rows) addDataRow(row);
+  }
+
+  // Grand total.
+  if (model.sumColumnIds.length > 0) {
+    const tr = ws.addRow(cols.map((c, i) => (c.summed ? model.totals.sums[c.id] : (i === 0 ? `Total (${model.totals.count})` : null))));
+    tr.font = { bold: true };
+    tr.eachCell((cell) => { cell.border = { top: { style: 'double', color: { argb: 'FF334155' } } }; });
+  }
+
+  const buf = await wb.xlsx.writeBuffer();
+  return new Blob([buf], { type: XLSX_MIME });
+}

package/src/lib/lists/index.ts

@@ -14,10 +14,12 @@ export type {
   ConditionOperator,
   DiscoveredColumns,
   EntityAttribute,
+  ListGrouping,
 } from '@ifc-lite/lists';
 export {
   ENTITY_ATTRIBUTES,
   executeList,
+  summariseListRows,
   listResultToCSV,
   discoverColumns,
   LIST_PRESETS,

package/src/lib/search/filter-evaluate.test.ts

@@ -256,6 +256,87 @@ describe('matchQuantityRule', () => {
   });
 });
 
+describe('materialNamesOf', () => {
+  it('collects top-level, layer, constituent, profile, and list names', () => {
+    const names = __internal.materialNamesOf({
+      type: 'MaterialLayerSet',
+      name: 'Wall Buildup',
+      layers: [
+        { materialName: 'Concrete C30/37' },
+        { materialName: 'Rigid Insulation', name: 'Insulation Layer' },
+      ],
+      materials: [{ name: 'Steel S355' }],
+    });
+    assert.deepStrictEqual(names, [
+      'Wall Buildup',
+      'Concrete C30/37',
+      'Rigid Insulation',
+      'Insulation Layer',
+      'Steel S355',
+    ]);
+  });
+  it('returns [] for a null MaterialInfo (no association)', () => {
+    assert.deepStrictEqual(__internal.materialNamesOf(null), []);
+  });
+});
+
+describe('matchClassificationRule', () => {
+  const refs = [
+    { system: 'Uniclass 2015', identification: 'Pr_60_10_32', name: 'External wall' },
+    { system: 'OmniClass', identification: '23-13 11 11', name: 'Walls' },
+  ];
+  it('isSet / isNotSet check presence, optionally scoped by system', () => {
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'isSet', ''), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('OmniClass', 'isSet', ''), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('SfB', 'isSet', ''), refs), false);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('SfB', 'isNotSet', ''), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'isNotSet', ''), []), true);
+  });
+  it('value ops match code (identification) OR name', () => {
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'contains', 'Pr_60'), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'contains', 'external'), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'eq', 'Pr_60_10_32'), refs), true);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('', 'contains', 'Ss_'), refs), false);
+  });
+  it('system scope excludes refs from other systems', () => {
+    // Pr_60 only exists in the Uniclass ref — scoping to OmniClass misses it.
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('OmniClass', 'contains', 'Pr_60'), refs), false);
+    assert.strictEqual(__internal.matchClassificationRule(Rule.classification('OmniClass', 'contains', '23-13'), refs), true);
+  });
+});
+
+describe('elevationOf + elevation rule', () => {
+  function withHierarchy(store: IfcDataStore): IfcDataStore {
+    // elementToStorey: 10,20 → storey 100 (z=0); 30 → storey 200 (z=3.5).
+    // 40 is unplaced (no storey) → elevation null → never matches.
+    (store as unknown as { spatialHierarchy: unknown }).spatialHierarchy = {
+      elementToStorey: new Map<number, number>([[10, 100], [20, 100], [30, 200]]),
+      storeyElevations: new Map<number, number>([[100, 0], [200, 3.5]]),
+    };
+    return store;
+  }
+
+  it('resolves elevation from the element’s storey, null when unplaced', () => {
+    const store = withHierarchy(buildStore(rows));
+    assert.strictEqual(__internal.elevationOf(store, 10), 0);
+    assert.strictEqual(__internal.elevationOf(store, 30), 3.5);
+    assert.strictEqual(__internal.elevationOf(store, 40), null);
+  });
+
+  it('elevation > 3 matches only elements on the high storey', () => {
+    const store = withHierarchy(buildStore(rows));
+    const out = evaluateFilterRules('m1', store, [Rule.elevation('gt', 3)], 'AND');
+    assert.deepStrictEqual(out.map((r) => r.expressId), [30]);
+  });
+
+  it('elevation rule excludes unplaced elements even with lte', () => {
+    const store = withHierarchy(buildStore(rows));
+    const out = evaluateFilterRules('m1', store, [Rule.elevation('lte', 100)], 'AND');
+    // 10, 20 (z=0) and 30 (z=3.5) qualify; 40 (unplaced) is excluded.
+    assert.deepStrictEqual(out.map((r) => r.expressId).sort(), [10, 20, 30]);
+  });
+});
+
 describe('evaluateFilterRulesFederated — per-model candidate narrowing', () => {
   it('candidateExpressIdsByModel narrows each model independently', async () => {
     const a = buildStore(rows);