@ifc-lite/viewer 1.7.0 → 1.9.0

package/src/lib/scripts/templates/envelope-check.ts

@@ -0,0 +1,164 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Building Envelope & Thermal Check ───────────────────────────────────
+// Stakeholder: Architect / Energy Consultant
+//
+// Identifies all external-facing elements (walls, slabs, roofs, windows,
+// doors, curtain walls) by reading Pset_*Common.IsExternal and checks
+// whether they carry thermal transmittance values. Missing thermal data
+// on external elements is a common issue in energy models. The script
+// isolates the envelope, color-codes by thermal status, and exports
+// the findings — a workflow that requires cross-referencing two property
+// values across hundreds of elements.
+// ─────────────────────────────────────────────────────────────────────────
+
+bim.viewer.resetColors()
+bim.viewer.resetVisibility()
+
+// ── 1. Gather envelope candidates ───────────────────────────────────────
+const envelopeTypes = [
+  'IfcWall', 'IfcWallStandardCase', 'IfcCurtainWall',
+  'IfcSlab', 'IfcRoof',
+  'IfcDoor', 'IfcDoorStandardCase',
+  'IfcWindow',
+  'IfcPlate',
+]
+const candidates = bim.query.byType(...envelopeTypes)
+
+if (candidates.length === 0) {
+  console.error('No envelope element types found')
+  throw new Error('no elements')
+}
+
+// ── 2. Classify each element ────────────────────────────────────────────
+interface EnvelopeResult {
+  entity: BimEntity
+  isExternal: boolean | null
+  thermalTransmittance: number | null
+  thermalSource: string
+}
+
+const results: EnvelopeResult[] = []
+// Collect property paths for CSV export
+const envelopePropPaths = new Set<string>()
+
+for (const entity of candidates) {
+  const result: EnvelopeResult = { entity, isExternal: null, thermalTransmittance: null, thermalSource: '' }
+  const psets = bim.query.properties(entity)
+  for (const pset of psets) {
+    for (const p of pset.properties) {
+      const lower = p.name.toLowerCase()
+      if (lower === 'isexternal' && p.value !== null) {
+        result.isExternal = p.value === true || p.value === 'TRUE' || p.value === '.T.'
+        envelopePropPaths.add(pset.name + '.IsExternal')
+      }
+      if (lower === 'thermaltransmittance' && p.value !== null && p.value !== '') {
+        result.thermalTransmittance = typeof p.value === 'number' ? p.value : parseFloat(String(p.value))
+        result.thermalSource = pset.name
+        envelopePropPaths.add(pset.name + '.ThermalTransmittance')
+      }
+      // Also capture other thermal-related properties
+      if ((lower === 'firerating' || lower === 'loadbearing' || lower === 'acousticrating') && p.value !== null && p.value !== '') {
+        envelopePropPaths.add(pset.name + '.' + p.name)
+      }
+    }
+  }
+  results.push(result)
+}
+
+// ── 3. Separate external vs internal ────────────────────────────────────
+const external = results.filter(r => r.isExternal === true)
+const internal = results.filter(r => r.isExternal === false)
+const unknown = results.filter(r => r.isExternal === null)
+
+const extWithThermal = external.filter(r => r.thermalTransmittance !== null)
+const extNoThermal = external.filter(r => r.thermalTransmittance === null)
+
+// ── 4. Color-code ───────────────────────────────────────────────────────
+const batches: Array<{ entities: BimEntity[]; color: string }> = []
+if (extWithThermal.length > 0) batches.push({ entities: extWithThermal.map(r => r.entity), color: '#27ae60' })  // green: external + thermal
+if (extNoThermal.length > 0) batches.push({ entities: extNoThermal.map(r => r.entity), color: '#e74c3c' })    // red: external, missing thermal
+if (internal.length > 0) batches.push({ entities: internal.map(r => r.entity), color: '#95a5a6' })            // grey: internal
+if (unknown.length > 0) batches.push({ entities: unknown.map(r => r.entity), color: '#f39c12' })              // orange: unknown
+if (batches.length > 0) bim.viewer.colorizeAll(batches)
+
+// Isolate envelope if we found external elements
+if (external.length > 0) {
+  bim.viewer.isolate(external.map(r => r.entity))
+}
+
+// ── 5. Report ───────────────────────────────────────────────────────────
+console.log('═══════════════════════════════════════')
+console.log('  BUILDING ENVELOPE & THERMAL CHECK')
+console.log('═══════════════════════════════════════')
+console.log('')
+console.log('Scanned ' + candidates.length + ' envelope-type elements')
+console.log('')
+console.log('  External:   ' + external.length + '  (isolated in view)')
+console.log('  Internal:   ' + internal.length + '  ● grey')
+console.log('  Undefined:  ' + unknown.length + '  ● orange — IsExternal not set')
+console.log('')
+console.log('  External with thermal data:    ' + extWithThermal.length + '  ● green')
+console.log('  External without thermal data: ' + extNoThermal.length + '  ● red — NEEDS ATTENTION')
+
+// ── 6. Thermal value distribution ───────────────────────────────────────
+if (extWithThermal.length > 0) {
+  console.log('')
+  console.log('── Thermal Transmittance (U-value) Distribution ──')
+
+  // Group by type
+  const byType: Record<string, number[]> = {}
+  for (const r of extWithThermal) {
+    if (!byType[r.entity.Type]) byType[r.entity.Type] = []
+    if (r.thermalTransmittance !== null) byType[r.entity.Type].push(r.thermalTransmittance)
+  }
+
+  for (const [type, values] of Object.entries(byType).sort((a, b) => b[1].length - a[1].length)) {
+    const min = Math.min(...values)
+    const max = Math.max(...values)
+    const avg = values.reduce((s, v) => s + v, 0) / values.length
+    console.log('  ' + type + ' (' + values.length + ')')
+    console.log('    min=' + min.toFixed(3) + '  avg=' + avg.toFixed(3) + '  max=' + max.toFixed(3) + ' W/(m²·K)')
+  }
+}
+
+// ── 7. Elements missing IsExternal property ─────────────────────────────
+if (unknown.length > 0) {
+  console.log('')
+  console.warn('── Missing IsExternal Property ──')
+  const byType: Record<string, number> = {}
+  for (const r of unknown) {
+    byType[r.entity.Type] = (byType[r.entity.Type] || 0) + 1
+  }
+  for (const [type, count] of Object.entries(byType).sort((a, b) => b[1] - a[1])) {
+    console.warn('  ' + type + ': ' + count + ' elements')
+  }
+}
+
+// ── 8. External elements missing thermal data ───────────────────────────
+if (extNoThermal.length > 0) {
+  console.log('')
+  console.warn('── External Elements Without Thermal Data ──')
+  for (const r of extNoThermal.slice(0, 15)) {
+    console.warn('  ' + (r.entity.Name || '<unnamed>') + ' [' + r.entity.Type + ']')
+  }
+  if (extNoThermal.length > 15) console.warn('  ... and ' + (extNoThermal.length - 15) + ' more')
+
+  const envPropCols = Array.from(envelopePropPaths).sort()
+  bim.export.csv(extNoThermal.map(r => r.entity), {
+    columns: ['Name', 'Type', 'GlobalId', 'ObjectType', ...envPropCols],
+    filename: 'envelope-missing-thermal.csv'
+  })
+  console.log('')
+  console.log('Exported ' + extNoThermal.length + ' elements to envelope-missing-thermal.csv')
+}
+
+// Export full envelope dataset with all discovered properties
+if (external.length > 0) {
+  const envPropCols = Array.from(envelopePropPaths).sort()
+  bim.export.csv(external.map(r => r.entity), {
+    columns: ['Name', 'Type', 'GlobalId', 'ObjectType', ...envPropCols],
+    filename: 'envelope-analysis.csv'
+  })
+  console.log('Exported ' + external.length + ' external elements (' + (4 + envPropCols.length) + ' columns) to envelope-analysis.csv')
+}

package/src/lib/scripts/templates/federation-compare.ts

@@ -0,0 +1,189 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Multi-Model Federation Comparison ───────────────────────────────────
+// Stakeholder: Project Manager / BIM Coordinator
+//
+// When multiple IFC models are loaded (architectural + structural + MEP),
+// this script compares them side by side: entity counts, type coverage,
+// naming consistency, and property completeness per model. The UI shows
+// one tree at a time — this script cross-references everything and
+// highlights discrepancies that indicate coordination issues.
+// ─────────────────────────────────────────────────────────────────────────
+
+const models = bim.model.list()
+
+if (models.length === 0) {
+  console.error('No models loaded')
+  throw new Error('no models')
+}
+
+console.log('═══════════════════════════════════════')
+console.log('  FEDERATION COMPARISON')
+console.log('═══════════════════════════════════════')
+console.log('')
+
+// ── 1. Model overview ───────────────────────────────────────────────────
+console.log('── Loaded Models (' + models.length + ') ──')
+let totalEntities = 0
+for (const m of models) {
+  const sizeMB = (m.fileSize / 1024 / 1024).toFixed(1)
+  console.log('  [' + m.id.slice(0, 8) + '] ' + m.name)
+  console.log('    Schema: ' + m.schemaVersion + '  |  Entities: ' + m.entityCount + '  |  Size: ' + sizeMB + ' MB')
+  totalEntities += m.entityCount
+}
+console.log('')
+console.log('Total: ' + totalEntities + ' entities across ' + models.length + ' models')
+
+// ── 2. Type distribution per model ──────────────────────────────────────
+const all = bim.query.all()
+
+// Build type→model distribution
+const typeByModel: Record<string, Record<string, number>> = {}
+const modelEntityMap: Record<string, BimEntity[]> = {}
+for (const e of all) {
+  const mid = e.ref.modelId
+  if (!modelEntityMap[mid]) modelEntityMap[mid] = []
+  modelEntityMap[mid].push(e)
+
+  if (!typeByModel[e.Type]) typeByModel[e.Type] = {}
+  typeByModel[e.Type][mid] = (typeByModel[e.Type][mid] || 0) + 1
+}
+
+// Find types that exist in multiple models (potential overlaps/conflicts)
+const sharedTypes: string[] = []
+const exclusiveTypes: Record<string, string[]> = {} // modelId → types only in that model
+
+for (const [type, distribution] of Object.entries(typeByModel)) {
+  const modelIds = Object.keys(distribution)
+  if (modelIds.length > 1) {
+    sharedTypes.push(type)
+  } else {
+    const mid = modelIds[0]
+    if (!exclusiveTypes[mid]) exclusiveTypes[mid] = []
+    exclusiveTypes[mid].push(type)
+  }
+}
+
+console.log('')
+console.log('── Type Distribution ──')
+console.log('')
+
+// Types present in multiple models
+if (sharedTypes.length > 0) {
+  console.log('Types shared across models (' + sharedTypes.length + '):')
+  const header = '  Type                         ' + models.map(m => ('| ' + m.name.slice(0, 10) + '          ').slice(0, 13)).join('')
+  console.log(header)
+  console.log('  ' + '-'.repeat(header.length - 2))
+
+  for (const type of sharedTypes.sort((a, b) => {
+    const totalA = Object.values(typeByModel[a]).reduce((s, v) => s + v, 0)
+    const totalB = Object.values(typeByModel[b]).reduce((s, v) => s + v, 0)
+    return totalB - totalA
+  }).slice(0, 20)) {
+    const typeStr = (type + '                              ').slice(0, 30)
+    const counts = models.map(m => {
+      const c = typeByModel[type][m.id] || 0
+      return ('| ' + (c > 0 ? String(c) : '-') + '           ').slice(0, 13)
+    }).join('')
+    console.log('  ' + typeStr + counts)
+  }
+}
+
+// Types exclusive to one model
+console.log('')
+console.log('Types exclusive to one model:')
+for (const m of models) {
+  const exclusive = exclusiveTypes[m.id] || []
+  if (exclusive.length > 0) {
+    console.log('  ' + m.name + ': ' + exclusive.slice(0, 8).join(', ') + (exclusive.length > 8 ? ' (+' + (exclusive.length - 8) + ' more)' : ''))
+  }
+}
+
+// ── 3. Naming consistency check ─────────────────────────────────────────
+console.log('')
+console.log('── Naming Consistency ──')
+for (const m of models) {
+  const entities = modelEntityMap[m.id] || []
+  const named = entities.filter(e => e.Name && e.Name !== '')
+  const described = entities.filter(e => e.Description && e.Description !== '')
+  const typed = entities.filter(e => e.ObjectType && e.ObjectType !== '')
+  const namePct = entities.length > 0 ? (named.length / entities.length * 100).toFixed(1) : '0'
+  const descPct = entities.length > 0 ? (described.length / entities.length * 100).toFixed(1) : '0'
+  const typePct = entities.length > 0 ? (typed.length / entities.length * 100).toFixed(1) : '0'
+  console.log('  ' + m.name + ':')
+  console.log('    Named: ' + namePct + '%  |  Described: ' + descPct + '%  |  ObjectType: ' + typePct + '%')
+}
+
+// ── 4. Property coverage comparison ─────────────────────────────────────
+console.log('')
+console.log('── Property Coverage (sample of 100 per model) ──')
+for (const m of models) {
+  const entities = modelEntityMap[m.id] || []
+  const sample = entities.slice(0, 100)
+  let withPsets = 0
+  let withQsets = 0
+  let totalPsets = 0
+  for (const e of sample) {
+    const psets = bim.query.properties(e)
+    const qsets = bim.query.quantities(e)
+    if (psets.length > 0) withPsets++
+    if (qsets.length > 0) withQsets++
+    totalPsets += psets.length
+  }
+  const psetPct = sample.length > 0 ? (withPsets / sample.length * 100).toFixed(0) : '0'
+  const qsetPct = sample.length > 0 ? (withQsets / sample.length * 100).toFixed(0) : '0'
+  const avgPsets = sample.length > 0 ? (totalPsets / sample.length).toFixed(1) : '0'
+  console.log('  ' + m.name + ':')
+  console.log('    With properties: ' + psetPct + '%  |  With quantities: ' + qsetPct + '%  |  Avg psets/entity: ' + avgPsets)
+}
+
+// ── 5. Potential coordination issues ────────────────────────────────────
+if (models.length > 1) {
+  console.log('')
+  console.log('── Coordination Notes ──')
+
+  // Check for spatial types in non-architectural models
+  const spatialTypes = ['IfcBuilding', 'IfcBuildingStorey', 'IfcSite', 'IfcSpace']
+  for (const m of models) {
+    const hasSpatial: string[] = []
+    for (const st of spatialTypes) {
+      if (typeByModel[st] && typeByModel[st][m.id]) {
+        hasSpatial.push(st + '(' + typeByModel[st][m.id] + ')')
+      }
+    }
+    if (hasSpatial.length > 0) {
+      console.log('  ' + m.name + ' defines: ' + hasSpatial.join(', '))
+    }
+  }
+
+  // Check entity count ratios (large disparities may indicate issues)
+  const counts = models.map(m => modelEntityMap[m.id]?.length || 0)
+  const maxCount = Math.max(...counts)
+  const minCount = Math.min(...counts)
+  if (maxCount > 0 && minCount > 0 && maxCount / minCount > 10) {
+    console.warn('')
+    console.warn('  Large entity count disparity (' + maxCount + ' vs ' + minCount + ')')
+    console.warn('  This may indicate models at different levels of detail')
+  }
+}
+
+// ── 6. Color-code by model origin ───────────────────────────────────────
+const modelColors = ['#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6', '#1abc9c']
+const colorBatches: Array<{ entities: BimEntity[]; color: string }> = []
+let idx = 0
+for (const m of models) {
+  const entities = modelEntityMap[m.id] || []
+  if (entities.length > 0) {
+    colorBatches.push({ entities, color: modelColors[idx % modelColors.length] })
+    idx++
+  }
+}
+if (colorBatches.length > 0) bim.viewer.colorizeAll(colorBatches)
+
+console.log('')
+console.log('── Model Colors ──')
+idx = 0
+for (const m of models) {
+  console.log('  ' + m.name + '  ● ' + modelColors[idx % modelColors.length])
+  idx++
+}

package/src/lib/scripts/templates/fire-safety-check.ts

@@ -0,0 +1,161 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Fire Safety Compliance Check ────────────────────────────────────────
+// Stakeholder: Architect / Fire Safety Engineer
+//
+// Cross-references fire rating properties across walls and doors — a task
+// that requires clicking through hundreds of entities in the properties
+// panel. The script checks Pset_WallCommon.FireRating and
+// Pset_DoorCommon.FireRating, flags missing or non-compliant values,
+// color-codes the model by compliance status, and generates a report.
+// ─────────────────────────────────────────────────────────────────────────
+
+bim.viewer.resetColors()
+
+// ── 1. Gather fire-rated element types ──────────────────────────────────
+const walls = bim.query.byType('IfcWall', 'IfcWallStandardCase')
+const doors = bim.query.byType('IfcDoor', 'IfcDoorStandardCase')
+const slabs = bim.query.byType('IfcSlab')
+const total = walls.length + doors.length + slabs.length
+
+if (total === 0) {
+  console.error('No walls, doors, or slabs found in model')
+  throw new Error('no elements')
+}
+
+// ── 2. Extract fire rating from properties ──────────────────────────────
+interface FireResult {
+  entity: BimEntity
+  rating: string | null
+  isLoadBearing: boolean | null
+  isExternal: boolean | null
+}
+
+// Collect fire-related property paths for CSV export
+const firePropPaths = new Set<string>()
+
+function extractFireData(entity: BimEntity): FireResult {
+  const result: FireResult = { entity, rating: null, isLoadBearing: null, isExternal: null }
+  const psets = bim.query.properties(entity)
+  for (const pset of psets) {
+    for (const p of pset.properties) {
+      const lower = p.name.toLowerCase()
+      if (lower === 'firerating' && p.value !== null && p.value !== '') {
+        result.rating = String(p.value)
+        firePropPaths.add(pset.name + '.FireRating')
+      }
+      if (lower === 'loadbearing' && p.value !== null) {
+        result.isLoadBearing = p.value === true || p.value === 'TRUE' || p.value === '.T.'
+        firePropPaths.add(pset.name + '.LoadBearing')
+      }
+      if (lower === 'isexternal' && p.value !== null) {
+        result.isExternal = p.value === true || p.value === 'TRUE' || p.value === '.T.'
+        firePropPaths.add(pset.name + '.IsExternal')
+      }
+    }
+  }
+  return result
+}
+
+// ── 3. Analyze each element category ────────────────────────────────────
+const wallResults = walls.map(extractFireData)
+const doorResults = doors.map(extractFireData)
+const slabResults = slabs.map(extractFireData)
+
+// Classify
+const rated: BimEntity[] = []
+const unrated: BimEntity[] = []
+const loadBearingUnrated: BimEntity[] = []
+const externalUnrated: BimEntity[] = []
+
+for (const r of [...wallResults, ...doorResults, ...slabResults]) {
+  if (r.rating) {
+    rated.push(r.entity)
+  } else {
+    unrated.push(r.entity)
+    if (r.isLoadBearing) loadBearingUnrated.push(r.entity)
+    if (r.isExternal) externalUnrated.push(r.entity)
+  }
+}
+
+// ── 4. Group by fire rating value ───────────────────────────────────────
+const ratingGroups: Record<string, BimEntity[]> = {}
+for (const r of [...wallResults, ...doorResults, ...slabResults]) {
+  if (r.rating) {
+    if (!ratingGroups[r.rating]) ratingGroups[r.rating] = []
+    ratingGroups[r.rating].push(r.entity)
+  }
+}
+
+// ── 5. Color-code by compliance ─────────────────────────────────────────
+const batches: Array<{ entities: BimEntity[]; color: string }> = []
+if (rated.length > 0) batches.push({ entities: rated, color: '#27ae60' })           // green = rated
+if (loadBearingUnrated.length > 0) batches.push({ entities: loadBearingUnrated, color: '#e74c3c' }) // red = critical
+if (externalUnrated.length > 0) batches.push({ entities: externalUnrated, color: '#e67e22' })       // orange = warning
+// Remaining unrated that are not load-bearing or external
+const otherUnrated = unrated.filter(e => {
+  const isLB = loadBearingUnrated.some(lb => lb.GlobalId === e.GlobalId)
+  const isExt = externalUnrated.some(ext => ext.GlobalId === e.GlobalId)
+  return !isLB && !isExt
+})
+if (otherUnrated.length > 0) batches.push({ entities: otherUnrated, color: '#f1c40f' }) // yellow = missing
+if (batches.length > 0) bim.viewer.colorizeAll(batches)
+
+// ── 6. Report ───────────────────────────────────────────────────────────
+const compliancePct = (rated.length / total * 100).toFixed(1)
+console.log('═══════════════════════════════════════')
+console.log('  FIRE SAFETY COMPLIANCE CHECK')
+console.log('═══════════════════════════════════════')
+console.log('')
+console.log('Scanned: ' + walls.length + ' walls, ' + doors.length + ' doors, ' + slabs.length + ' slabs')
+console.log('Compliance: ' + compliancePct + '% (' + rated.length + '/' + total + ' rated)')
+console.log('')
+console.log('  ● Rated:                    ' + rated.length + '  green')
+console.log('  ● Missing (load-bearing):   ' + loadBearingUnrated.length + '  red — CRITICAL')
+console.log('  ● Missing (external):       ' + externalUnrated.length + '  orange — WARNING')
+console.log('  ● Missing (other):          ' + otherUnrated.length + '  yellow')
+
+// ── 7. Rating distribution ──────────────────────────────────────────────
+if (Object.keys(ratingGroups).length > 0) {
+  console.log('')
+  console.log('── Fire Rating Distribution ──')
+  const ratingsSorted = Object.entries(ratingGroups).sort((a, b) => b[1].length - a[1].length)
+  for (const [rating, entities] of ratingsSorted) {
+    console.log('  ' + rating + ': ' + entities.length + ' elements')
+  }
+}
+
+// ── 8. Per-type breakdown ───────────────────────────────────────────────
+console.log('')
+console.log('── Breakdown by Element Type ──')
+const typeGroups: Record<string, { rated: number; total: number }> = {}
+for (const r of [...wallResults, ...doorResults, ...slabResults]) {
+  const t = r.entity.Type
+  if (!typeGroups[t]) typeGroups[t] = { rated: 0, total: 0 }
+  typeGroups[t].total++
+  if (r.rating) typeGroups[t].rated++
+}
+for (const [type, g] of Object.entries(typeGroups).sort((a, b) => b[1].total - a[1].total)) {
+  const pct = (g.rated / g.total * 100).toFixed(0)
+  console.log('  ' + type + ': ' + g.rated + '/' + g.total + ' rated (' + pct + '%)')
+}
+
+// ── 9. Critical issues list ─────────────────────────────────────────────
+if (loadBearingUnrated.length > 0) {
+  console.log('')
+  console.warn('── CRITICAL: Load-Bearing Without Fire Rating ──')
+  for (const e of loadBearingUnrated.slice(0, 15)) {
+    console.warn('  ' + (e.Name || '<unnamed>') + ' [' + e.Type + '] GlobalId=' + e.GlobalId)
+  }
+  if (loadBearingUnrated.length > 15) console.warn('  ... and ' + (loadBearingUnrated.length - 15) + ' more')
+}
+
+// ── 10. Export all scanned elements with fire properties ────────────────
+const allFireElements = [...walls, ...doors, ...slabs]
+const fireCols = Array.from(firePropPaths).sort()
+bim.export.csv(allFireElements, {
+  columns: ['Name', 'Type', 'GlobalId', 'ObjectType', ...fireCols],
+  filename: 'fire-safety-report.csv'
+})
+console.log('')
+console.log('Exported ' + allFireElements.length + ' elements (' + (4 + fireCols.length) + ' columns) to fire-safety-report.csv')