@ifc-lite/viewer 1.8.0 → 1.10.0

package/src/lib/scripts/persistence.ts

@@ -0,0 +1,132 @@
+/* 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/. */
+
+/**
+ * Persistence for user scripts via localStorage.
+ *
+ * Uses a versioned schema so future additions (tags, description, etc.)
+ * can be migrated without data loss.
+ */
+
+/** Current schema version */
+const SCHEMA_VERSION = 1;
+
+export interface SavedScript {
+  id: string;
+  name: string;
+  code: string;
+  createdAt: number;
+  updatedAt: number;
+  version: number;
+}
+
+/** Stored wrapper with schema version for migration */
+interface StoredScripts {
+  schemaVersion: number;
+  scripts: SavedScript[];
+}
+
+const STORAGE_KEY = 'ifc-lite-scripts';
+
+/** Maximum scripts allowed (prevents storage exhaustion) */
+const MAX_SCRIPTS = 500;
+
+/** Maximum code size per script in characters (~100KB) */
+const MAX_SCRIPT_SIZE = 100_000;
+
+export function loadSavedScripts(): SavedScript[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+
+    const parsed: unknown = JSON.parse(raw);
+
+    // Handle legacy format (bare array without schema version)
+    if (Array.isArray(parsed)) {
+      return migrateFromLegacy(parsed);
+    }
+
+    // Versioned format — validate structure
+    if (
+      typeof parsed === 'object' &&
+      parsed !== null &&
+      'schemaVersion' in parsed &&
+      'scripts' in parsed &&
+      Array.isArray((parsed as StoredScripts).scripts)
+    ) {
+      return (parsed as StoredScripts).scripts;
+    }
+
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+/** Migrate from the original unversioned format — discards corrupted entries */
+function migrateFromLegacy(scripts: unknown[]): SavedScript[] {
+  const migrated: SavedScript[] = [];
+  for (const s of scripts) {
+    if (s === null || typeof s !== 'object') continue;
+    const script = s as Record<string, unknown>;
+
+    // Validate essential fields — discard garbage values from String()/Number() coercion
+    const id = typeof script.id === 'string' && script.id.length > 0 ? script.id : crypto.randomUUID();
+    const name = typeof script.name === 'string' && script.name.length > 0 ? script.name : 'Untitled';
+    const code = typeof script.code === 'string' ? script.code : '';
+    const createdAt = typeof script.createdAt === 'number' && isFinite(script.createdAt) ? script.createdAt : Date.now();
+    const updatedAt = typeof script.updatedAt === 'number' && isFinite(script.updatedAt) ? script.updatedAt : Date.now();
+
+    migrated.push({ id, name, code, createdAt, updatedAt, version: SCHEMA_VERSION });
+  }
+  // Save in new format
+  saveScripts(migrated);
+  return migrated;
+}
+
+export type SaveResult =
+  | { ok: true }
+  | { ok: false; reason: 'quota_exceeded' | 'serialization_error' | 'unknown'; message: string };
+
+export function saveScripts(scripts: SavedScript[]): SaveResult {
+  const stored: StoredScripts = {
+    schemaVersion: SCHEMA_VERSION,
+    scripts,
+  };
+
+  try {
+    const json = JSON.stringify(stored);
+    localStorage.setItem(STORAGE_KEY, json);
+    return { ok: true };
+  } catch (err: unknown) {
+    if (err instanceof DOMException && err.name === 'QuotaExceededError') {
+      console.warn('[Scripts] localStorage quota exceeded. Consider deleting unused scripts.');
+      return { ok: false, reason: 'quota_exceeded', message: 'Storage quota exceeded. Delete unused scripts to free space.' };
+    }
+    if (err instanceof TypeError) {
+      console.warn('[Scripts] Failed to serialize scripts:', err.message);
+      return { ok: false, reason: 'serialization_error', message: err.message };
+    }
+    console.warn('[Scripts] Failed to save scripts to localStorage');
+    return { ok: false, reason: 'unknown', message: String(err) };
+  }
+}
+
+/** Validate a script name — returns sanitized name or null if invalid */
+export function validateScriptName(name: string): string | null {
+  const trimmed = name.trim();
+  if (trimmed.length === 0) return null;
+  if (trimmed.length > 100) return trimmed.slice(0, 100);
+  return trimmed;
+}
+
+/** Check if adding another script is within limits */
+export function canCreateScript(currentCount: number): boolean {
+  return currentCount < MAX_SCRIPTS;
+}
+
+/** Check if script code is within size limits */
+export function isScriptWithinSizeLimit(code: string): boolean {
+  return code.length <= MAX_SCRIPT_SIZE;
+}

package/src/lib/scripts/templates/bim-globals.d.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/. */
+
+/**
+ * AUTO-GENERATED — do not edit by hand.
+ * Run: npx tsx scripts/generate-bim-globals.ts
+ *
+ * Type declarations for the sandbox `bim` global.
+ * Generated from NAMESPACE_SCHEMAS in bridge-schema.ts.
+ */
+
+// ── Entity types ────────────────────────────────────────────────────────
+
+interface BimEntity {
+  ref: { modelId: string; expressId: number };
+  name: string; Name: string;
+  type: string; Type: string;
+  globalId: string; GlobalId: string;
+  description: string; Description: string;
+  objectType: string; ObjectType: string;
+}
+
+interface BimPropertySet {
+  name: string;
+  properties: Array<{ name: string; value: string | number | boolean | null }>;
+}
+
+interface BimQuantitySet {
+  name: string;
+  quantities: Array<{ name: string; value: number | null }>;
+}
+
+interface BimModelInfo {
+  id: string;
+  name: string;
+  schemaVersion: string;
+  entityCount: number;
+  fileSize: number;
+}
+
+// ── Namespace declarations ──────────────────────────────────────────────
+
+declare const bim: {
+  /** Model operations */
+  model: {
+    /** List loaded models */
+    list(): BimModelInfo[];
+    /** Get active model */
+    active(): BimModelInfo | null;
+    /** Get active model ID */
+    activeId(): string | null;
+  };
+  /** Query entities */
+  query: {
+    /** Get all entities */
+    all(): BimEntity[];
+    /** Filter by IFC type e.g. 'IfcWall' */
+    byType(...types: string[]): BimEntity[];
+    /** Get entity by model ID and express ID */
+    entity(modelId: string, expressId: number): BimEntity | null;
+    /** Get all IfcPropertySet data for an entity */
+    properties(entity: BimEntity): BimPropertySet[];
+    /** Get all IfcElementQuantity data for an entity */
+    quantities(entity: BimEntity): BimQuantitySet[];
+  };
+  /** Viewer control */
+  viewer: {
+    /** Colorize entities e.g. '#ff0000' */
+    colorize(entities: BimEntity[], color: string): void;
+    /** Batch colorize with [{entities, color}] */
+    colorizeAll(batches: Array<{ entities: BimEntity[]; color: string }>): void;
+    /** Hide entities */
+    hide(entities: BimEntity[]): void;
+    /** Show entities */
+    show(entities: BimEntity[]): void;
+    /** Isolate entities */
+    isolate(entities: BimEntity[]): void;
+    /** Select entities */
+    select(entities: BimEntity[]): void;
+    /** Fly camera to entities */
+    flyTo(entities: BimEntity[]): void;
+    /** Reset all colors */
+    resetColors(): void;
+    /** Reset all visibility */
+    resetVisibility(): void;
+  };
+  /** Property editing */
+  mutate: {
+    /** Set a property value */
+    setProperty(entity: unknown, psetName: string, propName: string, value: unknown): void;
+    /** Delete a property */
+    deleteProperty(entity: unknown, psetName: string, propName: string): void;
+    /** Undo last mutation */
+    undo(modelId: string): void;
+    /** Redo undone mutation */
+    redo(modelId: string): void;
+  };
+  /** Lens visualization */
+  lens: {
+    /** Get built-in lens presets */
+    presets(): unknown[];
+  };
+  /** Data export */
+  export: {
+    /** Export entities to CSV string */
+    csv(entities: BimEntity[], options: { columns: string[]; filename?: string; separator?: string }): string;
+    /** Export entities to JSON array */
+    json(entities: BimEntity[], columns: string[]): Record<string, unknown>[];
+  };
+};

package/src/lib/scripts/templates/data-quality-audit.ts

@@ -0,0 +1,149 @@
+export {} // module boundary (stripped by transpiler)
+
+// ── Data Quality Audit ──────────────────────────────────────────────────
+// Stakeholder: BIM Manager / QA
+//
+// Scans every entity in the model for data completeness issues that would
+// take hours to find by clicking through the UI. Produces a scorecard,
+// color-codes the 3D view by quality level, and exports an issues CSV.
+// ─────────────────────────────────────────────────────────────────────────
+
+bim.viewer.resetColors()
+const all = bim.query.all()
+if (all.length === 0) { console.error('No entities loaded'); throw new Error('empty model') }
+
+// ── 1. Check every entity for missing attributes ────────────────────────
+interface Issue { entity: BimEntity; field: string }
+const issues: Issue[] = []
+const scores: Record<string, { entity: BimEntity; score: number }> = {}
+
+// Track property coverage per type
+const typePsetCoverage: Record<string, { total: number; withPsets: number }> = {}
+
+for (const e of all) {
+  let score = 0
+  const maxScore = 5 // Name, Description, ObjectType, has properties, has quantities
+
+  if (e.Name && e.Name !== '') score++
+  else issues.push({ entity: e, field: 'Name' })
+
+  if (e.Description && e.Description !== '') score++
+  else issues.push({ entity: e, field: 'Description' })
+
+  if (e.ObjectType && e.ObjectType !== '') score++
+  else issues.push({ entity: e, field: 'ObjectType' })
+
+  const psets = bim.query.properties(e)
+  if (psets.length > 0) score++
+  else issues.push({ entity: e, field: 'PropertySets' })
+
+  const qsets = bim.query.quantities(e)
+  if (qsets.length > 0) score++
+  else issues.push({ entity: e, field: 'Quantities' })
+
+  scores[e.GlobalId] = { entity: e, score }
+
+  // Track pset coverage per type
+  if (!typePsetCoverage[e.Type]) typePsetCoverage[e.Type] = { total: 0, withPsets: 0 }
+  typePsetCoverage[e.Type].total++
+  if (psets.length > 0) typePsetCoverage[e.Type].withPsets++
+}
+
+// ── 2. Classify entities by quality tier ────────────────────────────────
+const tiers = { complete: [] as BimEntity[], good: [] as BimEntity[], partial: [] as BimEntity[], poor: [] as BimEntity[] }
+for (const { entity, score } of Object.values(scores)) {
+  if (score === 5) tiers.complete.push(entity)
+  else if (score >= 4) tiers.good.push(entity)
+  else if (score >= 2) tiers.partial.push(entity)
+  else tiers.poor.push(entity)
+}
+
+// ── 3. Color-code by quality ────────────────────────────────────────────
+const batches: Array<{ entities: BimEntity[]; color: string }> = []
+if (tiers.complete.length > 0) batches.push({ entities: tiers.complete, color: '#27ae60' }) // green
+if (tiers.good.length > 0) batches.push({ entities: tiers.good, color: '#f1c40f' })    // yellow
+if (tiers.partial.length > 0) batches.push({ entities: tiers.partial, color: '#e67e22' }) // orange
+if (tiers.poor.length > 0) batches.push({ entities: tiers.poor, color: '#e74c3c' })    // red
+if (batches.length > 0) bim.viewer.colorizeAll(batches)
+
+// ── 4. Report ───────────────────────────────────────────────────────────
+const overallScore = ((tiers.complete.length + tiers.good.length * 0.8 + tiers.partial.length * 0.4) / all.length * 100)
+console.log('═══════════════════════════════════════')
+console.log('  DATA QUALITY AUDIT')
+console.log('═══════════════════════════════════════')
+console.log('')
+console.log('Overall score: ' + overallScore.toFixed(1) + '% (' + all.length + ' entities)')
+console.log('')
+console.log('  Complete (5/5): ' + tiers.complete.length + '  ● green')
+console.log('  Good     (4/5): ' + tiers.good.length + '  ● yellow')
+console.log('  Partial  (2-3): ' + tiers.partial.length + '  ● orange')
+console.log('  Poor     (0-1): ' + tiers.poor.length + '  ● red')
+
+// ── 5. Issue breakdown by field ─────────────────────────────────────────
+const issuesByField: Record<string, number> = {}
+for (const issue of issues) {
+  issuesByField[issue.field] = (issuesByField[issue.field] || 0) + 1
+}
+console.log('')
+console.log('── Missing Data Breakdown ──')
+for (const [field, count] of Object.entries(issuesByField).sort((a, b) => b[1] - a[1])) {
+  const pct = (count / all.length * 100).toFixed(1)
+  console.log('  ' + field + ': ' + count + ' entities (' + pct + '% missing)')
+}
+
+// ── 6. Property coverage per type ───────────────────────────────────────
+console.log('')
+console.log('── Property Coverage by Type ──')
+const coverageSorted = Object.entries(typePsetCoverage)
+  .sort((a, b) => b[1].total - a[1].total)
+  .slice(0, 15)
+for (const [type, cov] of coverageSorted) {
+  const pct = (cov.withPsets / cov.total * 100).toFixed(0)
+  const bar = '█'.repeat(Math.round(cov.withPsets / cov.total * 20))
+  console.log('  ' + type + ': ' + bar + ' ' + pct + '% (' + cov.withPsets + '/' + cov.total + ')')
+}
+
+// ── 7. Worst offenders (first 10 entities with score 0-1) ──────────────
+if (tiers.poor.length > 0) {
+  console.log('')
+  console.log('── Worst Offenders (score 0-1) ──')
+  for (const e of tiers.poor.slice(0, 10)) {
+    console.log('  ' + (e.Name || '<no name>') + ' [' + e.Type + '] GlobalId=' + e.GlobalId)
+  }
+  if (tiers.poor.length > 10) {
+    console.log('  ... and ' + (tiers.poor.length - 10) + ' more')
+  }
+}
+
+// ── 8. Export all entities with discovered property/quantity data ────────
+// Discover common property columns from a sample
+const sampleForDiscovery = all.slice(0, 200)
+const discoveredPropPaths = new Set<string>()
+const discoveredQtyPaths = new Set<string>()
+for (const e of sampleForDiscovery) {
+  const psets = bim.query.properties(e)
+  for (const pset of psets) {
+    for (const p of pset.properties) {
+      if (p.value !== null && p.value !== '') {
+        discoveredPropPaths.add(pset.name + '.' + p.name)
+      }
+    }
+  }
+  const qsets = bim.query.quantities(e)
+  for (const qset of qsets) {
+    for (const q of qset.quantities) {
+      if (q.value !== null && q.value !== 0) {
+        discoveredQtyPaths.add(qset.name + '.' + q.name)
+      }
+    }
+  }
+}
+// Cap columns to keep CSV manageable
+const auditPropCols = Array.from(discoveredPropPaths).sort().slice(0, 20)
+const auditQtyCols = Array.from(discoveredQtyPaths).sort().slice(0, 10)
+bim.export.csv(all, {
+  columns: ['Name', 'Type', 'GlobalId', 'Description', 'ObjectType', ...auditPropCols, ...auditQtyCols],
+  filename: 'data-quality-audit.csv'
+})
+console.log('')
+console.log('Exported ' + all.length + ' entities (' + (5 + auditPropCols.length + auditQtyCols.length) + ' columns) to data-quality-audit.csv')

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')
+}