@ifc-lite/viewer 1.1.7 → 1.6.0

package/src/webgpu-types.d.ts

@@ -6,6 +6,134 @@
  * WebGPU type definitions for TypeScript
  */
 
+// Extend Navigator interface with WebGPU support
+interface Navigator {
+  readonly gpu?: GPU;
+}
+
+// GPU interface for WebGPU API
+interface GPU {
+  requestAdapter(options?: GPURequestAdapterOptions): Promise<GPUAdapter | null>;
+  getPreferredCanvasFormat(): GPUTextureFormat;
+}
+
+interface GPURequestAdapterOptions {
+  powerPreference?: 'low-power' | 'high-performance';
+  forceFallbackAdapter?: boolean;
+}
+
+interface GPUAdapter {
+  readonly features: GPUSupportedFeatures;
+  readonly limits: GPUSupportedLimits;
+  readonly isFallbackAdapter: boolean;
+  requestDevice(descriptor?: GPUDeviceDescriptor): Promise<GPUDevice>;
+  requestAdapterInfo(): Promise<GPUAdapterInfo>;
+}
+
+interface GPUSupportedFeatures extends ReadonlySet<string> {}
+
+interface GPUSupportedLimits {
+  readonly maxTextureDimension1D: number;
+  readonly maxTextureDimension2D: number;
+  readonly maxTextureDimension3D: number;
+  readonly maxTextureArrayLayers: number;
+  readonly maxBindGroups: number;
+  readonly maxBindingsPerBindGroup: number;
+  readonly maxDynamicUniformBuffersPerPipelineLayout: number;
+  readonly maxDynamicStorageBuffersPerPipelineLayout: number;
+  readonly maxSampledTexturesPerShaderStage: number;
+  readonly maxSamplersPerShaderStage: number;
+  readonly maxStorageBuffersPerShaderStage: number;
+  readonly maxStorageTexturesPerShaderStage: number;
+  readonly maxUniformBuffersPerShaderStage: number;
+  readonly maxUniformBufferBindingSize: number;
+  readonly maxStorageBufferBindingSize: number;
+  readonly minUniformBufferOffsetAlignment: number;
+  readonly minStorageBufferOffsetAlignment: number;
+  readonly maxVertexBuffers: number;
+  readonly maxBufferSize: number;
+  readonly maxVertexAttributes: number;
+  readonly maxVertexBufferArrayStride: number;
+  readonly maxInterStageShaderComponents: number;
+  readonly maxColorAttachments: number;
+  readonly maxColorAttachmentBytesPerSample: number;
+  readonly maxComputeWorkgroupStorageSize: number;
+  readonly maxComputeInvocationsPerWorkgroup: number;
+  readonly maxComputeWorkgroupSizeX: number;
+  readonly maxComputeWorkgroupSizeY: number;
+  readonly maxComputeWorkgroupSizeZ: number;
+  readonly maxComputeWorkgroupsPerDimension: number;
+}
+
+interface GPUDeviceDescriptor {
+  requiredFeatures?: Iterable<string>;
+  requiredLimits?: Record<string, number>;
+  label?: string;
+}
+
+interface GPUDevice extends EventTarget {
+  readonly features: GPUSupportedFeatures;
+  readonly limits: GPUSupportedLimits;
+  readonly queue: GPUQueue;
+  readonly lost: Promise<GPUDeviceLostInfo>;
+  destroy(): void;
+  createBuffer(descriptor: GPUBufferDescriptor): GPUBuffer;
+  createTexture(descriptor: GPUTextureDescriptor): GPUTexture;
+  createSampler(descriptor?: GPUSamplerDescriptor): GPUSampler;
+  createBindGroupLayout(descriptor: GPUBindGroupLayoutDescriptor): GPUBindGroupLayout;
+  createPipelineLayout(descriptor: GPUPipelineLayoutDescriptor): GPUPipelineLayout;
+  createBindGroup(descriptor: GPUBindGroupDescriptor): GPUBindGroup;
+  createShaderModule(descriptor: GPUShaderModuleDescriptor): GPUShaderModule;
+  createComputePipeline(descriptor: GPUComputePipelineDescriptor): GPUComputePipeline;
+  createRenderPipeline(descriptor: GPURenderPipelineDescriptor): GPURenderPipeline;
+  createComputePipelineAsync(descriptor: GPUComputePipelineDescriptor): Promise<GPUComputePipeline>;
+  createRenderPipelineAsync(descriptor: GPURenderPipelineDescriptor): Promise<GPURenderPipeline>;
+  createCommandEncoder(descriptor?: GPUCommandEncoderDescriptor): GPUCommandEncoder;
+  createRenderBundleEncoder(descriptor: GPURenderBundleEncoderDescriptor): GPURenderBundleEncoder;
+  createQuerySet(descriptor: GPUQuerySetDescriptor): GPUQuerySet;
+}
+
+interface GPUAdapterInfo {
+  readonly vendor: string;
+  readonly architecture: string;
+  readonly device: string;
+  readonly description: string;
+}
+
+interface GPUDeviceLostInfo {
+  readonly reason: 'unknown' | 'destroyed';
+  readonly message: string;
+}
+
+type GPUTextureFormat = string;
+
+// Minimal interfaces for other GPU types (as placeholders)
+interface GPUQueue {}
+interface GPUBuffer {}
+interface GPUTexture {}
+interface GPUSampler {}
+interface GPUBindGroupLayout {}
+interface GPUPipelineLayout {}
+interface GPUBindGroup {}
+interface GPUShaderModule {}
+interface GPUComputePipeline {}
+interface GPURenderPipeline {}
+interface GPUCommandEncoder {}
+interface GPURenderBundleEncoder {}
+interface GPUQuerySet {}
+interface GPUBufferDescriptor {}
+interface GPUTextureDescriptor {}
+interface GPUSamplerDescriptor {}
+interface GPUBindGroupLayoutDescriptor {}
+interface GPUPipelineLayoutDescriptor {}
+interface GPUBindGroupDescriptor {}
+interface GPUShaderModuleDescriptor {}
+interface GPUComputePipelineDescriptor {}
+interface GPURenderPipelineDescriptor {}
+interface GPUCommandEncoderDescriptor {}
+interface GPURenderBundleEncoderDescriptor {}
+interface GPUQuerySetDescriptor {}
+
 declare const GPUBufferUsage: {
   readonly MAP_READ: number;
   readonly MAP_WRITE: number;

package/src-tauri/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "app"
+version = "0.1.0"
+description = "A Tauri App"
+authors = ["you"]
+license = ""
+repository = ""
+edition = "2021"
+rust-version = "1.77.2"
+
+# Exclude from parent workspace
+[workspace]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+name = "app_lib"
+crate-type = ["staticlib", "cdylib", "rlib"]
+
+[build-dependencies]
+tauri-build = { version = "2.5.3", features = [] }
+
+[dependencies]
+serde_json = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+log = "0.4"
+tauri = { version = "2.9.5", features = [] }
+tauri-plugin-log = "2"
+tauri-plugin-fs = "2"

package/src-tauri/build.rs

@@ -0,0 +1,7 @@
+// 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/.
+
+fn main() {
+  tauri_build::build()
+}

package/src-tauri/capabilities/default.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "default",
+  "description": "enables the default permissions",
+  "windows": [
+    "main"
+  ],
+  "permissions": [
+    "core:default",
+    "fs:allow-read-file",
+    "fs:allow-write-file",
+    "fs:allow-read-dir",
+    "fs:allow-create",
+    "fs:allow-exists",
+    "fs:allow-remove",
+    "fs:scope-appdata"
+  ]
+}

package/src-tauri/src/lib.rs

@@ -0,0 +1,21 @@
+// 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/.
+
+#[cfg_attr(mobile, tauri::mobile_entry_point)]
+pub fn run() {
+  tauri::Builder::default()
+    .plugin(tauri_plugin_fs::init())
+    .setup(|app| {
+      if cfg!(debug_assertions) {
+        app.handle().plugin(
+          tauri_plugin_log::Builder::default()
+            .level(log::LevelFilter::Info)
+            .build(),
+        )?;
+      }
+      Ok(())
+    })
+    .run(tauri::generate_context!())
+    .expect("error while running tauri application");
+}

package/src-tauri/src/main.rs

@@ -0,0 +1,10 @@
+// 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/.
+
+// Prevents additional console window on Windows in release, DO NOT REMOVE!!
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+fn main() {
+  app_lib::run();
+}

package/src-tauri/tauri.conf.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "../../../node_modules/@tauri-apps/cli/config.schema.json",
+  "productName": "IFC-Lite",
+  "version": "0.1.0",
+  "identifier": "com.tauri.dev",
+  "build": {
+    "frontendDist": "../dist",
+    "devUrl": "http://127.0.0.1:3000",
+    "beforeDevCommand": "pnpm dev",
+    "beforeBuildCommand": "pnpm build"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "IFC-Lite Viewer",
+        "width": 1400,
+        "height": 900,
+        "resizable": true,
+        "fullscreen": false,
+        "minWidth": 800,
+        "minHeight": 600
+      }
+    ],
+    "security": {
+      "csp": null
+    }
+  },
+  "bundle": {
+    "active": true,
+    "targets": "all",
+    "icon": [
+      "icons/32x32.png",
+      "icons/128x128.png",
+      "icons/128x128@2x.png",
+      "icons/icon.icns",
+      "icons/icon.ico"
+    ]
+  }
+}

package/vite.config.ts

@@ -1,9 +1,173 @@
 import { defineConfig } from 'vite';
 import react from '@vitejs/plugin-react';
+import wasm from 'vite-plugin-wasm';
+import topLevelAwait from 'vite-plugin-top-level-await';
 import path from 'path';
+import fs from 'fs';
+
+// --- Build-time changelog parser ---
+
+interface ReleaseHighlight {
+  type: 'feature' | 'fix' | 'perf';
+  text: string;
+}
+
+interface Release {
+  version: string;
+  highlights: ReleaseHighlight[];
+}
+
+const SKIP_BOLD_LOWER = new Set([
+  'bug fixes', 'new features', 'performance improvements', 'technical details',
+  'renderer fixes', 'parser fixes', 'viewer integration', 'fixes', 'features',
+  'breaking', 'minor changes', 'patch changes', 'dependencies',
+]);
+
+function isInternalName(text: string): boolean {
+  // Skip PascalCase single-word class names like "PolygonalFaceSetProcessor"
+  return /^[A-Z][a-zA-Z]+$/.test(text) && !text.includes(' ');
+}
+
+function categorizeHighlight(text: string): 'feature' | 'fix' | 'perf' {
+  const lower = text.toLowerCase();
+  if (lower.startsWith('fixed ') || lower.startsWith('fix ')) return 'fix';
+  if (
+    lower.includes('performance') || lower.includes('optimiz') ||
+    lower.includes('zero-copy') || lower.includes('faster') ||
+    lower.includes('batch siz')
+  ) return 'perf';
+  return 'feature';
+}
+
+function extractBulletDescription(line: string): string | null {
+  let text = line.replace(/^-\s+/, '');
+
+  // Pattern: "HASH: ### Header" -> skip inline section headers
+  if (/^[a-f0-9]{7,}:\s*###/.test(text)) return null;
+
+  // Pattern: "HASH: feat/fix/perf: DESCRIPTION"
+  const hashPrefixed = text.match(/^[a-f0-9]{7,}:\s*(?:feat|fix|perf|refactor|chore):\s*(.+)$/i);
+  if (hashPrefixed) return hashPrefixed[1].trim();
+
+  // Pattern: "HASH: DESCRIPTION" (without conventional commit prefix)
+  const hashOnly = text.match(/^[a-f0-9]{7,}:\s*(.+)$/);
+  if (hashOnly) return hashOnly[1].trim();
+
+  // Pattern: "[#PR](url) [`hash`](url) Thanks @user! - DESCRIPTION"
+  const prPattern = text.match(/Thanks\s+\[@[^\]]+\]\([^)]+\)!\s*-\s*(.+)$/);
+  if (prPattern) return prPattern[1].trim();
+
+  return null;
+}
+
+function compareSemver(a: string, b: string): number {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (pa[i] !== pb[i]) return pa[i] - pb[i];
+  }
+  return 0;
+}
+
+function parseChangelogs(): Release[] {
+  const packagesDir = path.resolve(__dirname, '../../packages');
+  let dirs: string[];
+  try {
+    dirs = fs.readdirSync(packagesDir);
+  } catch {
+    return [];
+  }
+
+  const versionMap = new Map<string, Map<string, ReleaseHighlight>>();
+  const seenVersionsPerFile = new Map<string, Set<string>>();
+
+  for (const dir of dirs) {
+    const changelogPath = path.join(packagesDir, dir, 'CHANGELOG.md');
+    if (!fs.existsSync(changelogPath)) continue;
+
+    const content = fs.readFileSync(changelogPath, 'utf-8');
+    const fileKey = dir;
+    seenVersionsPerFile.set(fileKey, new Set());
+
+    // Split into version blocks
+    const versionBlocks = content.split(/^## /m).slice(1);
+
+    for (const block of versionBlocks) {
+      const versionMatch = block.match(/^(\d+\.\d+\.\d+)/);
+      if (!versionMatch) continue;
+      const version = versionMatch[1];
+
+      // Skip duplicate version sections within same file
+      if (seenVersionsPerFile.get(fileKey)!.has(version)) continue;
+      seenVersionsPerFile.get(fileKey)!.add(version);
+
+      if (!versionMap.has(version)) {
+        versionMap.set(version, new Map());
+      }
+      const highlights = versionMap.get(version)!;
+
+      const lines = block.split('\n');
+
+      // 1) Extract top-level bullet descriptions (lines starting with "- " at root indent)
+      for (const line of lines) {
+        if (!line.startsWith('- ')) continue;
+        if (line.startsWith('- Updated dependencies')) continue;
+
+        const desc = extractBulletDescription(line);
+        if (desc && desc.length >= 10) {
+          const key = desc.toLowerCase().substring(0, 60);
+          if (!highlights.has(key)) {
+            highlights.set(key, { type: categorizeHighlight(desc), text: desc });
+          }
+        }
+      }
+
+      // 2) Extract bold items as highlights (nested feature names)
+      const boldRegex = /\*\*([^*]+)\*\*/g;
+      let match;
+      while ((match = boldRegex.exec(block)) !== null) {
+        let text = match[1].trim();
+        if (text.endsWith(':')) text = text.slice(0, -1);
+        if (text.includes('@ifc-lite/')) continue;
+        if (SKIP_BOLD_LOWER.has(text.toLowerCase())) continue;
+        if (text.length < 10) continue;
+        if (isInternalName(text)) continue;
+
+        const key = text.toLowerCase().substring(0, 60);
+        if (!highlights.has(key)) {
+          highlights.set(key, { type: categorizeHighlight(text), text });
+        }
+      }
+    }
+  }
+
+  const MAX_HIGHLIGHTS_PER_VERSION = 12;
+
+  return Array.from(versionMap.entries())
+    .sort((a, b) => compareSemver(b[0], a[0]))
+    .map(([version, highlights]) => ({
+      version,
+      highlights: Array.from(highlights.values()).slice(0, MAX_HIGHLIGHTS_PER_VERSION),
+    }))
+    .filter((r) => r.highlights.length > 0);
+}
+
+// Read version from root package.json
+const rootPkg = JSON.parse(
+  fs.readFileSync(path.resolve(__dirname, '../../package.json'), 'utf-8')
+);
 
 export default defineConfig({
-  plugins: [react()],
+  plugins: [
+    react(),
+    wasm(),
+    topLevelAwait(),
+  ],
+  define: {
+    __APP_VERSION__: JSON.stringify(rootPkg.version),
+    __BUILD_DATE__: JSON.stringify(new Date().toISOString()),
+    __RELEASE_HISTORY__: JSON.stringify(parseChangelogs()),
+  },
   resolve: {
     alias: {
       '@': path.resolve(__dirname, './src'),
@@ -11,49 +175,33 @@ export default defineConfig({
       '@ifc-lite/geometry': path.resolve(__dirname, '../../packages/geometry/src'),
       '@ifc-lite/renderer': path.resolve(__dirname, '../../packages/renderer/src'),
       '@ifc-lite/query': path.resolve(__dirname, '../../packages/query/src'),
+      '@ifc-lite/server-client': path.resolve(__dirname, '../../packages/server-client/src'),
       '@ifc-lite/spatial': path.resolve(__dirname, '../../packages/spatial/src'),
       '@ifc-lite/data': path.resolve(__dirname, '../../packages/data/src'),
       '@ifc-lite/export': path.resolve(__dirname, '../../packages/export/src'),
       '@ifc-lite/cache': path.resolve(__dirname, '../../packages/cache/src'),
+      '@ifc-lite/ifcx': path.resolve(__dirname, '../../packages/ifcx/src'),
       '@ifc-lite/wasm': path.resolve(__dirname, '../../packages/wasm/pkg/ifc-lite.js'),
     },
   },
   server: {
     port: 3000,
-    open: true,
-    hmr: {
-      overlay: true,
+    headers: {
+      'Cross-Origin-Opener-Policy': 'same-origin',
+      'Cross-Origin-Embedder-Policy': 'require-corp',
     },
-    watch: {
-      usePolling: false,
-      ignored: ['**/node_modules/**', '**/dist/**', '**/target/**', '**/pkg/**'],
+    fs: {
+      allow: ['../..'],
     },
   },
   build: {
     target: 'esnext',
   },
   optimizeDeps: {
-    exclude: ['@duckdb/duckdb-wasm'], // Optional dependency, exclude from pre-bundling
+    exclude: ['@duckdb/duckdb-wasm', '@ifc-lite/wasm', 'parquet-wasm'],
   },
-  assetsInclude: ['**/*.wasm'],
   worker: {
     format: 'es',
-    plugins: () => [
-      react(),
-      // Resolve aliases in worker context
-      {
-        name: 'worker-alias-resolver',
-        resolveId(id) {
-          if (id.startsWith('@ifc-lite/')) {
-            const packageName = id.split('/')[1];
-            // WASM package doesn't have src folder - use pkg
-            if (packageName === 'wasm') {
-              return path.resolve(__dirname, `../../packages/wasm/pkg/ifc-lite.js`);
-            }
-            return path.resolve(__dirname, `../../packages/${packageName}/src`);
-          }
-        },
-      },
-    ],
+    plugins: () => [wasm(), topLevelAwait()],
   },
 });