@cadview/core 0.1.0 → 0.2.0

package/README.md

@@ -76,14 +76,18 @@ new CadViewer(canvas: HTMLCanvasElement, options?: CadViewerOptions)
 | `maxZoom` | `number` | `100000` | Maximum zoom scale |
 | `zoomSpeed` | `number` | `1.1` | Zoom factor per wheel tick |
 | `initialTool` | `Tool` | `'pan'` | Active tool on init |
+| `formatConverters` | `FormatConverter[]` | `[]` | Format converters for non-DXF files (e.g. DWG) |
 
 #### Methods
 
 | Method | Description |
 |--------|-------------|
-| `loadFile(file: File)` | Load DXF from a File object |
-| `loadString(dxf: string)` | Load DXF from a string |
-| `loadArrayBuffer(buffer: ArrayBuffer)` | Load DXF from an ArrayBuffer |
+| `loadFile(file: File)` | Load from a File object (async, runs format converters) |
+| `loadBuffer(buffer: ArrayBuffer)` | Load from an ArrayBuffer (async, runs format converters) |
+| `loadString(dxf: string)` | Load DXF from a string (sync, no conversion) |
+| `loadArrayBuffer(buffer: ArrayBuffer)` | Load DXF from an ArrayBuffer (sync, no conversion) |
+| `loadDocument(doc: DxfDocument)` | Load a pre-parsed DxfDocument directly |
+| `clearDocument()` | Clear the current document without destroying the viewer |
 | `fitToView()` | Fit drawing to canvas bounds |
 | `setTheme(theme)` | Set color theme |
 | `setTool(tool)` | Set active tool (`pan`, `select`, `measure`) |
@@ -93,6 +97,35 @@ new CadViewer(canvas: HTMLCanvasElement, options?: CadViewerOptions)
 | `off(event, callback)` | Unsubscribe from events |
 | `destroy()` | Clean up all resources |
 
+### `FormatConverter`
+
+Interface for registering custom file format converters. Converters are checked in order during `loadFile()` and `loadBuffer()` — the first match wins.
+
+```ts
+interface FormatConverter {
+  /** Return true if the buffer is in this format (check magic bytes, not extensions). */
+  detect(buffer: ArrayBuffer): boolean;
+  /** Convert the buffer to a DXF string. */
+  convert(buffer: ArrayBuffer): Promise<string>;
+}
+```
+
+**Example — DWG support via `@cadview/dwg`:**
+
+```ts
+import { CadViewer } from '@cadview/core';
+import { dwgConverter } from '@cadview/dwg';
+
+const viewer = new CadViewer(canvas, {
+  formatConverters: [dwgConverter],
+});
+
+// loadFile and loadBuffer now handle both DXF and DWG
+await viewer.loadFile(file);
+```
+
+> **Note:** `@cadview/dwg` is licensed under GPL-3.0 (due to LibreDWG). `@cadview/core` remains MIT. See the [@cadview/dwg README](../dwg/README.md) for details.
+
 ### `parseDxf`
 
 Standalone DXF parser — use this if you only need parsing without the viewer.

package/dist/index.cjs

@@ -1551,7 +1551,7 @@ function decodeInput(input) {
   const bytes = new Uint8Array(input);
   const sentinelBytes = new TextDecoder("ascii").decode(bytes.slice(0, BINARY_DXF_SENTINEL.length));
   if (sentinelBytes === BINARY_DXF_SENTINEL) {
-    throw new Error("Binary DXF format is not supported. Please export as ASCII DXF.");
+    throw new DxfParseError("Binary DXF format is not supported. Please export as ASCII DXF.");
   }
   let text = new TextDecoder("utf-8").decode(input);
   const versionMatch = text.match(/\$ACADVER[\s\S]*?\n\s*1\s*\n\s*(\S+)/);
@@ -1622,7 +1622,7 @@ function parseDxf(input) {
   try {
     text = decodeInput(input);
   } catch (err) {
-    if (err instanceof Error && err.message.includes("Binary DXF")) {
+    if (err instanceof DxfParseError) {
       throw err;
     }
     throw new DxfParseError("Failed to decode DXF input.", err);
@@ -2485,23 +2485,25 @@ function deBoor(degree, controlPoints, knots, t, weights) {
       const denom = knots[i + degree - r + 1] - knots[i];
       if (Math.abs(denom) < 1e-10) continue;
       const alpha = (t - knots[i]) / denom;
+      const dj = d[j];
+      const djPrev = d[j - 1];
       if (weights) {
         const w0 = w[j - 1] * (1 - alpha);
         const w1 = w[j] * alpha;
         const wSum = w0 + w1;
         if (Math.abs(wSum) < 1e-10) continue;
-        d[j].x = (d[j - 1].x * w0 + d[j].x * w1) / wSum;
-        d[j].y = (d[j - 1].y * w0 + d[j].y * w1) / wSum;
-        d[j].z = (d[j - 1].z * w0 + d[j].z * w1) / wSum;
+        dj.x = (djPrev.x * w0 + dj.x * w1) / wSum;
+        dj.y = (djPrev.y * w0 + dj.y * w1) / wSum;
+        dj.z = (djPrev.z * w0 + dj.z * w1) / wSum;
         w[j] = wSum;
       } else {
-        d[j].x = (1 - alpha) * d[j - 1].x + alpha * d[j].x;
-        d[j].y = (1 - alpha) * d[j - 1].y + alpha * d[j].y;
-        d[j].z = (1 - alpha) * d[j - 1].z + alpha * d[j].z;
+        dj.x = (1 - alpha) * djPrev.x + alpha * dj.x;
+        dj.y = (1 - alpha) * djPrev.y + alpha * dj.y;
+        dj.z = (1 - alpha) * djPrev.z + alpha * dj.z;
       }
     }
   }
-  return d[degree];
+  return d[degree] ?? { x: 0, y: 0, z: 0 };
 }
 function fitPointsToPolyline(fitPoints) {
   if (fitPoints.length < 2) return fitPoints.map((p) => ({ x: p.x, y: p.y }));
@@ -3717,9 +3719,11 @@ var CadViewer = class {
   currentTool;
   inputHandler;
   resizeObserver;
+  formatConverters;
   selectedEntityIndex = -1;
   renderPending = false;
   destroyed = false;
+  loadGeneration = 0;
   mouseScreenX = 0;
   mouseScreenY = 0;
   constructor(canvas, options) {
@@ -3733,6 +3737,7 @@ var CadViewer = class {
       zoomSpeed: options?.zoomSpeed ?? 1.1,
       initialTool: options?.initialTool ?? "pan"
     };
+    this.formatConverters = options?.formatConverters ?? [];
     this.renderer = new CanvasRenderer(canvas);
     this.camera = new Camera(this.options);
     this.layerManager = new LayerManager();
@@ -3747,15 +3752,91 @@ var CadViewer = class {
     this.requestRender();
   }
   // === Loading ===
+  /**
+   * Throws if the viewer has been destroyed.
+   * Call at the start of any public method that mutates state.
+   */
+  guardDestroyed() {
+    if (this.destroyed) {
+      throw new Error("CadViewer: cannot call methods on a destroyed instance.");
+    }
+  }
+  /**
+   * Run registered format converters on a buffer.
+   * Returns the converted DXF string if a converter matched, or null otherwise.
+   * Each converter's detect() is wrapped in try/catch — a throwing detect() is skipped.
+   */
+  async runConverters(buffer) {
+    for (const converter of this.formatConverters) {
+      let detected = false;
+      try {
+        detected = converter.detect(buffer);
+      } catch {
+        continue;
+      }
+      if (detected) {
+        return converter.convert(buffer);
+      }
+    }
+    return null;
+  }
+  /**
+   * Load a CAD file from a browser File object.
+   * Automatically detects the format using registered converters (e.g. DWG).
+   * Falls back to DXF parsing if no converter matches.
+   */
   async loadFile(file) {
+    this.guardDestroyed();
+    const generation = ++this.loadGeneration;
     const buffer = await file.arrayBuffer();
-    this.loadArrayBuffer(buffer);
+    if (this.destroyed || generation !== this.loadGeneration) return;
+    const dxfString = await this.runConverters(buffer);
+    if (this.destroyed || generation !== this.loadGeneration) return;
+    this.doc = dxfString != null ? parseDxf(dxfString) : parseDxf(buffer);
+    this.onDocumentLoaded();
   }
+  /**
+   * Load a CAD file from an ArrayBuffer with format converter support.
+   * Unlike `loadArrayBuffer()` (sync, DXF-only), this method is async and
+   * checks registered FormatConverters for non-DXF formats.
+   */
+  async loadBuffer(buffer) {
+    this.guardDestroyed();
+    const generation = ++this.loadGeneration;
+    const dxfString = await this.runConverters(buffer);
+    if (this.destroyed || generation !== this.loadGeneration) return;
+    this.doc = dxfString != null ? parseDxf(dxfString) : parseDxf(buffer);
+    this.onDocumentLoaded();
+  }
+  /**
+   * Load a pre-parsed DxfDocument directly, bypassing the parser.
+   * Useful for custom parsers or pre-processed documents.
+   */
+  loadDocument(doc) {
+    this.guardDestroyed();
+    ++this.loadGeneration;
+    if (!doc || !Array.isArray(doc.entities) || !(doc.layers instanceof Map)) {
+      throw new Error("CadViewer: invalid DxfDocument \u2014 expected entities array and layers Map.");
+    }
+    this.doc = doc;
+    this.onDocumentLoaded();
+  }
+  /**
+   * Load a DXF string directly (synchronous, no format conversion).
+   */
   loadString(dxf) {
+    this.guardDestroyed();
+    ++this.loadGeneration;
     this.doc = parseDxf(dxf);
     this.onDocumentLoaded();
   }
+  /**
+   * Load a DXF file from an ArrayBuffer (synchronous, no format conversion).
+   * For format conversion support (e.g. DWG), use `loadFile()` or `loadBuffer()` instead.
+   */
   loadArrayBuffer(buffer) {
+    this.guardDestroyed();
+    ++this.loadGeneration;
     this.doc = parseDxf(buffer);
     this.onDocumentLoaded();
   }
@@ -3763,6 +3844,8 @@ var CadViewer = class {
    * Clear the current document and reset all state without destroying the viewer.
    */
   clearDocument() {
+    this.guardDestroyed();
+    ++this.loadGeneration;
     this.doc = null;
     this.selectedEntityIndex = -1;
     this.spatialIndex.clear();
@@ -3783,6 +3866,7 @@ var CadViewer = class {
   }
   // === Camera Controls ===
   fitToView() {
+    this.guardDestroyed();
     if (!this.doc) return;
     const bounds = this.computeDocumentBounds();
     if (!bounds) return;
@@ -3794,6 +3878,7 @@ var CadViewer = class {
     this.emitter.emit("viewchange", this.camera.getTransform());
   }
   zoomTo(scale) {
+    this.guardDestroyed();
     const rect = this.canvas.getBoundingClientRect();
     const centerX = rect.width / 2;
     const centerY = rect.height / 2;
@@ -3803,6 +3888,7 @@ var CadViewer = class {
     this.emitter.emit("viewchange", this.camera.getTransform());
   }
   panTo(worldX, worldY) {
+    this.guardDestroyed();
     const rect = this.canvas.getBoundingClientRect();
     const vt = this.camera.getTransform();
     const currentSX = worldX * vt.scale + vt.offsetX;
@@ -3825,15 +3911,18 @@ var CadViewer = class {
     return this.layerManager.getAllLayers();
   }
   setLayerVisible(name, visible) {
+    this.guardDestroyed();
     this.layerManager.setVisible(name, visible);
     this.requestRender();
   }
   setLayerColor(name, color) {
+    this.guardDestroyed();
     this.layerManager.setColorOverride(name, color);
     this.requestRender();
   }
   // === Theme ===
   setTheme(theme) {
+    this.guardDestroyed();
     this.options.theme = theme;
     this.requestRender();
   }
@@ -3841,11 +3930,13 @@ var CadViewer = class {
     return this.options.theme;
   }
   setBackgroundColor(color) {
+    this.guardDestroyed();
     this.options.backgroundColor = color;
     this.requestRender();
   }
   // === Tools ===
   setTool(tool) {
+    this.guardDestroyed();
     if (this.currentTool === "measure" && tool !== "measure") {
       this.measureTool.deactivate();
     }