@mlightcad/cad-simple-viewer 1.5.5 → 1.5.6

package/lib/view/AcTrView2d.js

@@ -71,6 +71,31 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { acdbHostApplicationServices, AcDbMText, AcDbRasterImage, AcDbRay, AcDbSysVarManager, AcDbViewport, AcDbXline, AcGeBox2d, AcGePoint2d, log } from '@mlightcad/data-model';
 import { AcDbSystemVariables } from '@mlightcad/data-model';
 import { AcTrEntity, AcTrGroup, AcTrRenderer, AcTrViewportView, getMaterialMetadata, hasByLayerBinding, setMaterialMetadata } from '@mlightcad/three-renderer';
@@ -78,18 +103,22 @@ import * as THREE from 'three';
 import Stats from 'three/examples/jsm/libs/stats.module';
 import { CSS2DRenderer } from 'three/examples/jsm/renderers/CSS2DRenderer.js';
 import { AcApDocManager, AcApSettingManager } from '../app';
-import { AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdMTextEditor, AcEdOpenMode, AcEdViewMode, eventBus, resolvePointerSelectionAction } from '../editor';
-import { isModelSpaceDatabase, MODEL_SPACE_BACKGROUND, readLayoutBackgroundColor } from '../editor/global/AcEdUiColor';
+import { AcEdBaseView, AcEdConditionWaiter, AcEdCorsorType, AcEdGripManager, AcEdMTextEditor, AcEdOpenMode, AcEdViewMode, eventBus, resolvePointerSelectionAction } from '../editor';
+import { ACGI_MODEL_SPACE_BACKGROUND, isModelSpaceDatabase, readLayoutBackgroundColor } from '../editor/global/AcEdUiColor';
 import { AcTrGeometryUtil } from '../util';
+import { AcTrEntityDisplayController } from './AcTrEntityDisplayController';
+import { assertAcTrGroupWcsBboxesConsistent } from './AcTrGroupWcsBboxAssert';
+import { AcTrLayer } from './AcTrLayer';
 import { AcTrLayoutView } from './AcTrLayoutView';
 import { AcTrLayoutViewManager } from './AcTrLayoutViewManager';
 import { sortPickResults } from './AcTrPickResultUtil';
+import { AcTrProgressiveOpenFitController } from './AcTrProgressiveOpenFitController';
 import { AcTrScene } from './AcTrScene';
 /**
  * Default view option values
  */
 export var DEFAULT_VIEW_2D_OPTIONS = {
-    background: MODEL_SPACE_BACKGROUND
+    background: ACGI_MODEL_SPACE_BACKGROUND
 };
 /**
  * A 2D CAD viewer component that renders CAD drawings using Three.js.
@@ -185,6 +214,21 @@ var AcTrView2d = /** @class */ (function (_super) {
          * race during document open.
          */
         _this._externallyFramedLayouts = new Set();
+        /**
+         * Layer names with an in-flight {@link convertMissingEntitiesOnLayer} pass.
+         *
+         * {@link updateLayer} triggers that conversion fire-and-forget when a layer
+         * becomes visible again. Rapid or repeated layer-on events for the same name
+         * would otherwise start parallel {@link batchConvert} runs over the same
+         * pending entities. `hasEntity` prevents duplicate scene entries, but not the
+         * wasted conversion work — this set skips re-entry until the current pass ends.
+         */
+        _this._convertingLayers = new Set();
+        /**
+         * When true, entity conversion during document open is deferred across
+         * event-loop turns so geometry appears incrementally.
+         */
+        _this._progressiveRendering = false;
         _this.animate = function () {
             var _a;
             _this._rafId = requestAnimationFrame(_this.animate);
@@ -193,15 +237,19 @@ var AcTrView2d = /** @class */ (function (_super) {
                 camera: _this.internalCamera
             });
             var stillLoading = _this._numOfEntitiesToProcess > 0;
+            var deferRenderWhileLoading = stillLoading && !_this._progressiveRendering;
             if (!_this._isDirty && !stillLoading)
                 return;
+            if (deferRenderWhileLoading)
+                return;
             var needsRedraw = _this._layoutViewManager.render(_this._scene);
             if (_this.internalCamera) {
                 _this._css2dRenderer.render(_this._scene.internalScene, _this.internalCamera);
             }
             (_a = _this._stats) === null || _a === void 0 ? void 0 : _a.update();
-            _this._isDirty = stillLoading || needsRedraw;
+            _this._isDirty = (_this._progressiveRendering && stillLoading) || needsRedraw;
         };
+        _this._gripManager = new AcEdGripManager(_this);
         if (options.calculateSizeCallback) {
             _this.setCalculateSizeCallback(options.calculateSizeCallback);
         }
@@ -219,7 +267,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         });
         _this._scene = _this.createScene();
         // Initialize background color through setter to keep renderer/cursor in sync.
-        _this.backgroundColor = (_b = mergedOptions.background) !== null && _b !== void 0 ? _b : MODEL_SPACE_BACKGROUND;
+        _this.backgroundColor = (_b = mergedOptions.background) !== null && _b !== void 0 ? _b : ACGI_MODEL_SPACE_BACKGROUND;
         _this._stats = _this.createStats(AcApSettingManager.instance.isShowStats);
         // Layout background sysvars drive the canvas clear colour and ACI-7
         // inversion (`MODELBKCOLOR` for model space, `PAPERBKCOLOR` for the
@@ -251,7 +299,8 @@ var AcTrView2d = /** @class */ (function (_super) {
         var canHandleSelectionGesture = function () {
             return (_this.mode === AcEdViewMode.SELECTION &&
                 !_this.editor.isActive &&
-                !AcEdMTextEditor.getActiveInputBox());
+                !AcEdMTextEditor.getActiveInputBox() &&
+                !_this._gripManager.isDragging);
         };
         var clearSelectionPreview = function () {
             selectionPreviewEl === null || selectionPreviewEl === void 0 ? void 0 : selectionPreviewEl.remove();
@@ -422,6 +471,13 @@ var AcTrView2d = /** @class */ (function (_super) {
         container.appendChild(_this._css2dRenderer.domElement);
         _this._missedImages = new Map();
         _this._layoutViewManager = new AcTrLayoutViewManager();
+        _this._progressiveOpenFit = new AcTrProgressiveOpenFitController(function (box, margin) {
+            _this.activeLayoutView.zoomTo(box, margin !== null && margin !== void 0 ? margin : 1.1);
+            _this._isDirty = true;
+        });
+        _this._entityDisplay = new AcTrEntityDisplayController(function (layerName) {
+            return _this.resolveLayerInfo(layerName);
+        });
         _this.initialize();
         _this.onWindowResize();
         _this._isDirty = true;
@@ -479,6 +535,14 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "gripManager", {
+        /** Grip point manager for the view (Write mode only). */
+        get: function () {
+            return this._gripManager;
+        },
+        enumerable: false,
+        configurable: true
+    });
     Object.defineProperty(AcTrView2d.prototype, "isDirty", {
         /**
          * Gets whether the view needs to be re-rendered.
@@ -499,6 +563,46 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    Object.defineProperty(AcTrView2d.prototype, "isProcessingEntities", {
+        /**
+         * True while {@link addEntity} batch-conversion callbacks are still running.
+         *
+         * Parsing can report 100% before this reaches zero; callers opening files
+         * should wait on this (as {@link zoomToFitDrawing} does) before hiding
+         * progress UI or assuming the canvas is ready.
+         */
+        get: function () {
+            return this._numOfEntitiesToProcess > 0;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcTrView2d.prototype, "progressiveRendering", {
+        /**
+         * Whether entity conversion during document open is deferred for progressive display.
+         */
+        get: function () {
+            return this._progressiveRendering;
+        },
+        set: function (value) {
+            this._progressiveRendering = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Enables progressive camera framing while entities are batch-converted at
+     * document open. Pair with {@link zoomToFitDrawing} for the final accurate fit.
+     */
+    AcTrView2d.prototype.beginProgressiveOpenFit = function () {
+        this._progressiveOpenFit.begin(this._numOfEntitiesToProcess);
+    };
+    /**
+     * Disables progressive open framing after the final zoom-to-fit runs.
+     */
+    AcTrView2d.prototype.endProgressiveOpenFit = function () {
+        this._progressiveOpenFit.end();
+    };
     Object.defineProperty(AcTrView2d.prototype, "missedData", {
         /**
          * Gets information about missing data during rendering (fonts and images).
@@ -552,8 +656,9 @@ var AcTrView2d = /** @class */ (function (_super) {
      */
     AcTrView2d.prototype.applyCanvasBackground = function (value) {
         this._renderer.setClearColor(value);
+        // Updates style-manager background, repaints ACI-7 / bg-follow materials.
         this._renderer.currentBackgroundColor = value;
-        this._renderer.changeBackground(value);
+        this.refreshTextMaterialsInObjectTree(this._scene.internalScene);
         this.editor.syncCursorBackground(value);
         this._isDirty = true;
     };
@@ -641,6 +746,55 @@ var AcTrView2d = /** @class */ (function (_super) {
         enumerable: false,
         configurable: true
     });
+    /**
+     * Converts every drawable entity into the scene before offline export.
+     *
+     * Interactive viewing skips off/frozen layers for performance; HTML snapshots
+     * store layer visibility separately and need full geometry so the exported
+     * layer panel can toggle layers on later.
+     *
+     * Converted geometry remains in the live scene after this call completes.
+     */
+    AcTrView2d.prototype.ensureEntitiesConvertedForExport = function (options) {
+        return __awaiter(this, void 0, void 0, function () {
+            var includeInvisibleLayers, db, pending, _a, _b, _c, layoutBtrId, blockTableRecord;
+            var e_1, _d;
+            var _this = this;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        includeInvisibleLayers = (options === null || options === void 0 ? void 0 : options.includeInvisibleLayers) !== false;
+                        db = AcApDocManager.instance.curDocument.database;
+                        pending = [];
+                        try {
+                            for (_a = __values(this._scene.layouts), _b = _a.next(); !_b.done; _b = _a.next()) {
+                                _c = __read(_b.value, 1), layoutBtrId = _c[0];
+                                blockTableRecord = db.tables.blockTable.getIdAt(layoutBtrId);
+                                if (!blockTableRecord) {
+                                    continue;
+                                }
+                                pending.push.apply(pending, __spreadArray([], __read(this._entityDisplay.collectMissingEntitiesForExport(blockTableRecord, function (objectId) { return _this.hasEntity(objectId); }, includeInvisibleLayers)), false));
+                            }
+                        }
+                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        if (pending.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        this._numOfEntitiesToProcess += pending.length;
+                        return [4 /*yield*/, this.batchConvert(pending, { forExport: true })];
+                    case 1:
+                        _e.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     Object.defineProperty(AcTrView2d.prototype, "internalScene", {
         /**
          * The internal THREE scene used by this view.
@@ -736,15 +890,12 @@ var AcTrView2d = /** @class */ (function (_super) {
         var _this = this;
         if (timeout === void 0) { timeout = 0; }
         var waiter = new AcEdConditionWaiter(function () { return _this._numOfEntitiesToProcess <= 0; }, function () {
-            if (layoutBtrId &&
-                _this._externallyFramedLayouts.delete(layoutBtrId)) {
+            if (layoutBtrId && _this._externallyFramedLayouts.delete(layoutBtrId)) {
+                _this.endProgressiveOpenFit();
                 return;
             }
-            var box = _this.resolveLayoutFitBox();
-            if (box) {
-                _this.zoomTo(box);
-                _this._isDirty = true;
-            }
+            _this._progressiveOpenFit.applyFinalFit(function () { return _this.resolveLayoutFitBox(); });
+            _this.endProgressiveOpenFit();
         }, 300, // check every 300 ms
         timeout);
         waiter.start();
@@ -897,7 +1048,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * don't have to land pixel-perfect on the viewport line to grab it.
      */
     AcTrView2d.prototype.pick = function (point, hitRadius, pickOneOnly) {
-        var e_1, _a;
+        var e_2, _a;
         if (point == null)
             point = this.curPos;
         var results = [];
@@ -928,12 +1079,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                     }
                 }
             }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
             finally {
                 try {
                     if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
                 }
-                finally { if (e_1) throw e_1.error; }
+                finally { if (e_2) throw e_2.error; }
             }
         }
         // 1) Resolve hits in the active layout. Skip the `AcDbViewport`
@@ -974,7 +1125,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper-space pick.
      */
     AcTrView2d.prototype.pickThroughViewports = function (paperPoint, paperBox, viewports, results) {
-        var e_2, _a;
+        var e_3, _a;
         var modelLayout = this._scene.modelSpaceLayout;
         if (!modelLayout)
             return;
@@ -1007,12 +1158,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 _loop_1(vpView);
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        catch (e_3_1) { e_3 = { error: e_3_1 }; }
         finally {
             try {
                 if (viewports_1_1 && !viewports_1_1.done && (_a = viewports_1.return)) _a.call(viewports_1);
             }
-            finally { if (e_2) throw e_2.error; }
+            finally { if (e_3) throw e_3.error; }
         }
     };
     /**
@@ -1041,16 +1192,10 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.addLayer = function (layer) {
-        var updatedLayers = this._scene.addLayer({
-            name: layer.name,
-            isFrozen: layer.isFrozen,
-            isOff: layer.isOff,
-            color: layer.color
-        });
+        var updatedLayers = this._scene.addLayer(this.toLayerInfo(layer));
         var traits = {
             layer: layer.name,
             color: layer.color.clone(),
-            rgbColor: layer.color.RGB,
             lineType: layer.lineStyle,
             lineWeight: layer.lineWeight,
             transparency: layer.transparency
@@ -1068,16 +1213,10 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @inheritdoc
      */
     AcTrView2d.prototype.updateLayer = function (layer, changes) {
-        var updatedLayers = this._scene.updateLayer({
-            name: layer.name,
-            isFrozen: layer.isFrozen,
-            isOff: layer.isOff,
-            color: layer.color
-        });
+        var updatedLayers = this._scene.updateLayer(this.toLayerInfo(layer));
         var traits = {};
         if (changes.color) {
             traits.color = changes.color.clone();
-            traits.rgbColor = changes.color.RGB;
         }
         if (changes.lineStyle) {
             traits.lineType = layer.lineStyle;
@@ -1096,6 +1235,10 @@ var AcTrView2d = /** @class */ (function (_super) {
                 layer.updateMaterial(Number(id), material);
             }
         });
+        if (this._entityDisplay.layerVisibilityMayHaveChanged(changes) &&
+            AcTrLayer.isLayerVisible(this.toLayerInfo(layer))) {
+            void this.convertMissingEntitiesOnLayer(layer.name);
+        }
         this._isDirty = true;
     };
     /**
@@ -1129,7 +1272,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         var _this = this;
         var entities = Array.isArray(entity) ? entity : [entity];
         this._numOfEntitiesToProcess += entities.length;
-        setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+        var convert = function () { return __awaiter(_this, void 0, void 0, function () {
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.batchConvert(entities)];
@@ -1138,8 +1281,14 @@ var AcTrView2d = /** @class */ (function (_super) {
                         return [2 /*return*/];
                 }
             });
-        }); });
-        this._isDirty = true;
+        }); };
+        if (this._progressiveRendering) {
+            setTimeout(convert);
+            this._isDirty = true;
+        }
+        else {
+            void convert();
+        }
     };
     /**
      * @inheritdoc
@@ -1210,7 +1359,7 @@ var AcTrView2d = /** @class */ (function (_super) {
                 threeEntity.objectId = entity_2.objectId;
                 threeEntity.ownerId = entity_2.ownerId;
                 threeEntity.layerName = entity_2.layer;
-                threeEntity.visible = entity_2.visibility;
+                threeEntity.visible = entity_2.visibility !== false;
                 this._scene.updateEntity(threeEntity);
             }
         }
@@ -1408,6 +1557,7 @@ var AcTrView2d = /** @class */ (function (_super) {
         if (layoutView == null) {
             layoutView = new AcTrLayoutView(this._renderer, layoutBtrId, this.width, this.height);
             layoutView.events.viewChanged.addEventListener(function () {
+                _this._progressiveOpenFit.onLayoutViewChanged();
                 _this._isDirty = true;
                 _this.events.viewChanged.dispatch();
                 _this.clearHover();
@@ -1438,7 +1588,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param layoutBtrId Input the block table record id of the layout
      */
     AcTrView2d.prototype.loadLayoutEntitiesIfNeeded = function (layoutBtrId) {
-        var e_3, _a;
+        var e_4, _a;
         var _this = this;
         try {
             var db = AcApDocManager.instance.curDocument.database;
@@ -1509,12 +1659,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                     entities_1.push(entity);
                 }
             }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
             finally {
                 try {
                     if (iterator_1_1 && !iterator_1_1.done && (_a = iterator_1.return)) _a.call(iterator_1);
                 }
-                finally { if (e_3) throw e_3.error; }
+                finally { if (e_4) throw e_4.error; }
             }
             if (entities_1.length === 0) {
                 // Empty layout (e.g. a freshly-created paper space tab). Mark as
@@ -1525,10 +1675,10 @@ var AcTrView2d = /** @class */ (function (_super) {
                 }
                 return;
             }
-            // Load entities asynchronously
+            // Load entities asynchronously when progressive rendering is enabled.
             this._loadingLayouts.add(layoutBtrId);
             this._numOfEntitiesToProcess += entities_1.length;
-            setTimeout(function () { return __awaiter(_this, void 0, void 0, function () {
+            var convert = function () { return __awaiter(_this, void 0, void 0, function () {
                 var layout;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
@@ -1548,7 +1698,13 @@ var AcTrView2d = /** @class */ (function (_super) {
                         case 3: return [2 /*return*/];
                     }
                 });
-            }); });
+            }); };
+            if (this._progressiveRendering) {
+                setTimeout(convert);
+            }
+            else {
+                void convert();
+            }
         }
         catch (error) {
             log.error('[AcTrView2d] Error loading layout entities:', error);
@@ -1567,9 +1723,137 @@ var AcTrView2d = /** @class */ (function (_super) {
             stats.dom.style.display = 'none'; // Hide the stats
         }
     };
+    AcTrView2d.prototype.toLayerInfo = function (layer) {
+        return {
+            name: layer.name,
+            isFrozen: layer.isFrozen,
+            isOff: layer.isOff,
+            color: layer.color
+        };
+    };
+    AcTrView2d.prototype.resolveLayerInfo = function (layerName) {
+        var layer = AcApDocManager.instance.curDocument.database.tables.layerTable.getAt(layerName);
+        return layer ? this.toLayerInfo(layer) : undefined;
+    };
+    /**
+     * Converts entities on the given layer that were skipped while the layer was
+     * off/frozen and therefore are not yet present in the scene.
+     */
+    AcTrView2d.prototype.convertMissingEntitiesOnLayer = function (layerName) {
+        return __awaiter(this, void 0, void 0, function () {
+            var db, blockTableRecord, pending_1;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this._convertingLayers.has(layerName)) {
+                            return [2 /*return*/];
+                        }
+                        this._convertingLayers.add(layerName);
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 3, 4]);
+                        db = AcApDocManager.instance.curDocument.database;
+                        blockTableRecord = db.tables.blockTable.getIdAt(this.activeLayoutBtrId);
+                        if (!blockTableRecord) {
+                            return [2 /*return*/];
+                        }
+                        pending_1 = this._entityDisplay.collectMissingEntitiesOnLayer(layerName, blockTableRecord, function (objectId) { return _this.hasEntity(objectId); });
+                        if (pending_1.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        this._numOfEntitiesToProcess += pending_1.length;
+                        return [4 /*yield*/, this.batchConvert(pending_1)];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        this._convertingLayers.delete(layerName);
+                        return [7 /*endfinally*/];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
     AcTrView2d.prototype.drawEntity = function (entity, delay) {
         return entity.worldDraw(this._renderer, delay);
     };
+    /**
+     * Finishes geometry for a converted entity. Progressive mode defers MTEXT/SHAPE
+     * to async workers; non-progressive mode uses synchronous drawing from
+     * {@link drawEntity}(..., false).
+     */
+    AcTrView2d.prototype.finishEntityGeometry = function (threeEntity, progressive) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!progressive) return [3 /*break*/, 2];
+                        return [4 /*yield*/, threeEntity.draw()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                    case 2:
+                        if (this.entityUsedSyncDraw(threeEntity)) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, threeEntity.draw()];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Returns true when an entity already produced drawable geometry via syncDraw.
+     * MText/Shape expose syncDraw even when delay=true left the entity empty.
+     */
+    AcTrView2d.prototype.entityUsedSyncDraw = function (threeEntity) {
+        return (typeof threeEntity.syncDraw ===
+            'function' && threeEntity.children.length > 0);
+    };
+    /**
+     * Finishes deferred MText/Shape geometry inside a block group before it is
+     * split by layer. Block-reference attributes are created during INSERT
+     * worldDraw and can be left empty when progressive open passes delay=true.
+     */
+    AcTrView2d.prototype.ensureGroupDrawableGeometry = function (group) {
+        return __awaiter(this, void 0, void 0, function () {
+            var pending, finalizeDeferredEntity;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        pending = [];
+                        finalizeDeferredEntity = function (child) {
+                            if (_this.entityUsedSyncDraw(child)) {
+                                return;
+                            }
+                            var drawable = child;
+                            if (typeof drawable.syncDraw !== 'function') {
+                                return;
+                            }
+                            pending.push(Promise.resolve(drawable.syncDraw()));
+                        };
+                        group.getSourceEntities().forEach(finalizeDeferredEntity);
+                        group.traverse(function (child) {
+                            if (!(child instanceof AcTrEntity)) {
+                                return;
+                            }
+                            if (group.getSourceEntities().includes(child)) {
+                                return;
+                            }
+                            finalizeDeferredEntity(child);
+                        });
+                        return [4 /*yield*/, Promise.all(pending)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Walks the given block table record once and creates one
      * `AcTrViewportView` for every real `AcDbViewport` entity it finds
@@ -1589,7 +1873,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * paper layouts.
      */
     AcTrView2d.prototype.ensureViewportViews = function (blockTableRecord, layoutView) {
-        var e_4, _a;
+        var e_5, _a;
         var iterator = blockTableRecord.newIterator();
         try {
             for (var iterator_2 = __values(iterator), iterator_2_1 = iterator_2.next(); !iterator_2_1.done; iterator_2_1 = iterator_2.next()) {
@@ -1602,12 +1886,12 @@ var AcTrView2d = /** @class */ (function (_super) {
                 layoutView.addViewport(viewportView);
             }
         }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
         finally {
             try {
                 if (iterator_2_1 && !iterator_2_1.done && (_a = iterator_2.return)) _a.call(iterator_2);
             }
-            finally { if (e_4) throw e_4.error; }
+            finally { if (e_5) throw e_5.error; }
         }
     };
     /**
@@ -1615,20 +1899,23 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param entities - The database entities
      * @returns The converted three entities
      */
-    AcTrView2d.prototype.batchConvert = function (entities) {
-        return __awaiter(this, void 0, void 0, function () {
-            var i, entity, threeEntity, isExtendBbox, layoutView, viewportView, fileName, error_1;
+    AcTrView2d.prototype.batchConvert = function (entities_2) {
+        return __awaiter(this, arguments, void 0, function (entities, options) {
+            var progressive, i, entity, shouldConvert, threeEntity, isExtendBbox, layoutView, viewportView, fileName, error_1;
+            var _this = this;
+            if (options === void 0) { options = {}; }
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
+                        progressive = this._progressiveRendering && !options.forExport;
                         i = 0;
                         _a.label = 1;
                     case 1:
-                        if (!(i < entities.length)) return [3 /*break*/, 9];
+                        if (!(i < entities.length)) return [3 /*break*/, 13];
                         entity = entities[i];
                         _a.label = 2;
                     case 2:
-                        _a.trys.push([2, 6, 7, 8]);
+                        _a.trys.push([2, 10, 11, 12]);
                         // Skip the default paper-space viewport (`*Paper_Space`) entirely:
                         // it is an AutoCAD-internal viewport that exists in every paper
                         // layout and must not be drawn (would render a giant rectangle in
@@ -1642,18 +1929,24 @@ var AcTrView2d = /** @class */ (function (_super) {
                         // parsers).
                         if (entity instanceof AcDbViewport &&
                             AcTrViewportView.isDefaultPaperSpaceViewport(entity)) {
-                            return [3 /*break*/, 8];
+                            return [3 /*break*/, 12];
                         }
-                        if (!entity.visibility) {
-                            return [3 /*break*/, 8];
+                        shouldConvert = options.forExport
+                            ? this._entityDisplay.shouldConvertForExport(entity)
+                            : this._entityDisplay.shouldConvert(entity);
+                        if (!shouldConvert) {
+                            return [3 /*break*/, 12];
                         }
-                        threeEntity = this.drawEntity(entity, true);
-                        if (!threeEntity)
-                            return [3 /*break*/, 8];
+                        threeEntity = this.drawEntity(entity, progressive);
+                        // Viewports may produce no border geometry (e.g. on a no-plot layer) while
+                        // still needing an AcTrViewportView for model content below.
+                        if (!threeEntity && !(entity instanceof AcDbViewport))
+                            return [3 /*break*/, 12];
+                        if (!threeEntity) return [3 /*break*/, 9];
                         threeEntity.objectId = entity.objectId;
                         threeEntity.ownerId = entity.ownerId;
                         threeEntity.layerName = entity.layer;
-                        threeEntity.visible = entity.visibility;
+                        threeEntity.visible = entity.visibility !== false;
                         if (threeEntity instanceof AcTrGroup &&
                             threeEntity.isOnTheSameLayer) {
                             // Even when a block expands to a single layer bucket, children authored on
@@ -1661,21 +1954,36 @@ var AcTrView2d = /** @class */ (function (_super) {
                             this.remapInheritedLayerObjects(threeEntity.children, '0', threeEntity.layerName);
                         }
                         if (!(threeEntity instanceof AcTrGroup &&
-                            !threeEntity.isOnTheSameLayer)) return [3 /*break*/, 3];
-                        this.handleGroup(threeEntity);
-                        return [3 /*break*/, 5];
+                            !threeEntity.isOnTheSameLayer)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.handleGroup(threeEntity)];
                     case 3:
-                        isExtendBbox = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
-                        return [4 /*yield*/, threeEntity.draw()];
+                        _a.sent();
+                        return [3 /*break*/, 9];
                     case 4:
+                        isExtendBbox = !(entity instanceof AcDbRay || entity instanceof AcDbXline);
+                        if (!(threeEntity instanceof AcTrGroup)) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.ensureGroupDrawableGeometry(threeEntity)];
+                    case 5:
+                        _a.sent();
+                        _a.label = 6;
+                    case 6: return [4 /*yield*/, this.finishEntityGeometry(threeEntity, progressive)];
+                    case 7:
                         _a.sent();
+                        if (threeEntity instanceof AcTrGroup) {
+                            ;
+                            threeEntity.refreshWcsChildBoxesFromChildren();
+                        }
                         this._scene.addEntity(threeEntity, isExtendBbox);
                         this.applySessionHiddenObjectState(entity.objectId);
                         // Release memory occupied by this entity
                         threeEntity.dispose();
+                        if (!progressive) return [3 /*break*/, 9];
                         this._isDirty = true;
-                        _a.label = 5;
-                    case 5:
+                        return [4 /*yield*/, this._progressiveOpenFit.afterGeometryBatch(function () { return _this.resolveLayoutFitBox(); }, i)];
+                    case 8:
+                        _a.sent();
+                        _a.label = 9;
+                    case 9:
                         if (entity instanceof AcDbViewport) {
                             // Default paper-space viewport was already filtered out at the
                             // top of the loop, so anything that reaches here is a real
@@ -1695,149 +2003,143 @@ var AcTrView2d = /** @class */ (function (_super) {
                             if (fileName)
                                 this._missedImages.set(entity.objectId, fileName);
                         }
-                        return [3 /*break*/, 8];
-                    case 6:
+                        return [3 /*break*/, 12];
+                    case 10:
                         error_1 = _a.sent();
                         log.error("[AcTrView2d] Failed to convert entity ".concat(entity.objectId, " (").concat(entity.type, "):"), error_1);
-                        return [3 /*break*/, 8];
-                    case 7:
+                        return [3 /*break*/, 12];
+                    case 11:
                         this.decreaseNumOfEntitiesToProcess();
                         return [7 /*endfinally*/];
-                    case 8:
+                    case 12:
                         ++i;
                         return [3 /*break*/, 1];
-                    case 9: return [2 /*return*/];
+                    case 13: return [2 /*return*/];
                 }
             });
         });
     };
     AcTrView2d.prototype.handleGroup = function (group) {
-        var e_5, _a;
-        var _this = this;
-        var children = group.children;
-        var objectsGroupByLayer = new Map();
-        children.forEach(function (child) {
-            var _a;
-            if (!child.visible) {
-                return;
-            }
-            var layerName = child.userData.layerName;
-            if (!objectsGroupByLayer.has(layerName)) {
-                objectsGroupByLayer.set(layerName, []);
-            }
-            (_a = objectsGroupByLayer.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
-        });
-        // Important:
-        // Sometimes one group may contain huge amount of objects (> 100,000). So it is important
-        // to re-parent object with the fast approach. Calling add/remove method in THREE.Object3D
-        // is very slow because it do lots of things
-        // - Remove children from old group
-        // - Insert them into new group
-        // - Reset parent pointer
-        // - Do one updateMatrixWorld() at the end (optional)
-        // So we operate its children directly.
-        group.children = [];
-        try {
-            for (var children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
-                var child = children_1_1.value;
-                child.parent = null;
-            }
-        }
-        catch (e_5_1) { e_5 = { error: e_5_1 }; }
-        finally {
-            try {
-                if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
-            }
-            finally { if (e_5) throw e_5.error; }
-        }
-        var styleManager = group.styleManager;
-        var groupObjectId = group.objectId;
-        var groupLayerName = group.layerName;
-        var worldGroupBox = group.box.clone();
-        worldGroupBox.applyMatrix4(group.matrix);
-        var groupChildBoxes = group.boxes.map(function (box) {
-            var e_6, _a, e_7, _b;
-            var points = [
-                new THREE.Vector3(box.minX, box.minY, 0),
-                new THREE.Vector3(box.maxX, box.minY, 0),
-                new THREE.Vector3(box.maxX, box.maxY, 0),
-                new THREE.Vector3(box.minX, box.maxY, 0)
-            ];
-            try {
-                for (var points_1 = __values(points), points_1_1 = points_1.next(); !points_1_1.done; points_1_1 = points_1.next()) {
-                    var point = points_1_1.value;
-                    point.applyMatrix4(group.matrix);
-                }
-            }
-            catch (e_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (points_1_1 && !points_1_1.done && (_a = points_1.return)) _a.call(points_1);
-                }
-                finally { if (e_6) throw e_6.error; }
-            }
-            var minX = Infinity;
-            var minY = Infinity;
-            var maxX = -Infinity;
-            var maxY = -Infinity;
-            try {
-                for (var points_2 = __values(points), points_2_1 = points_2.next(); !points_2_1.done; points_2_1 = points_2.next()) {
-                    var point = points_2_1.value;
-                    minX = Math.min(minX, point.x);
-                    minY = Math.min(minY, point.y);
-                    maxX = Math.max(maxX, point.x);
-                    maxY = Math.max(maxY, point.y);
-                }
-            }
-            catch (e_7_1) { e_7 = { error: e_7_1 }; }
-            finally {
-                try {
-                    if (points_2_1 && !points_2_1.done && (_b = points_2.return)) _b.call(points_2);
+        return __awaiter(this, void 0, void 0, function () {
+            var children, objectsGroupByLayer, children_1, children_1_1, child, renderContext, groupObjectId, groupLayerName, groupChildBoxes;
+            var e_6, _a;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, this.ensureGroupDrawableGeometry(group)];
+                    case 1:
+                        _b.sent();
+                        group.refreshWcsChildBoxesFromChildren();
+                        children = group.children;
+                        objectsGroupByLayer = new Map();
+                        children.forEach(function (child) {
+                            var _a;
+                            if (child.visible === false) {
+                                return;
+                            }
+                            var layerName = child.userData.layerName;
+                            if (!objectsGroupByLayer.has(layerName)) {
+                                objectsGroupByLayer.set(layerName, []);
+                            }
+                            (_a = objectsGroupByLayer.get(layerName)) === null || _a === void 0 ? void 0 : _a.push(child);
+                        });
+                        // Important:
+                        // Sometimes one group may contain huge amount of objects (> 100,000). So it is important
+                        // to re-parent object with the fast approach. Calling add/remove method in THREE.Object3D
+                        // is very slow because it do lots of things
+                        // - Remove children from old group
+                        // - Insert them into new group
+                        // - Reset parent pointer
+                        // - Do one updateMatrixWorld() at the end (optional)
+                        // So we operate its children directly.
+                        group.children = [];
+                        try {
+                            for (children_1 = __values(children), children_1_1 = children_1.next(); !children_1_1.done; children_1_1 = children_1.next()) {
+                                child = children_1_1.value;
+                                child.parent = null;
+                            }
+                        }
+                        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+                        finally {
+                            try {
+                                if (children_1_1 && !children_1_1.done && (_a = children_1.return)) _a.call(children_1);
+                            }
+                            finally { if (e_6) throw e_6.error; }
+                        }
+                        renderContext = group.renderContext;
+                        groupObjectId = group.objectId;
+                        groupLayerName = group.layerName;
+                        // AcDbRenderingCache.draw (and similar paths such as AcDbTable) already call
+                        // applyMatrix on the group, which updates wcsBbbox and wcsChildBoxes to WCS.
+                        // Do not multiply group.matrix here — that would double-transform spatial bounds.
+                        if (process.env.NODE_ENV !== 'production') {
+                            assertAcTrGroupWcsBboxesConsistent(group);
+                        }
+                        groupChildBoxes = group.wcsChildBoxes.map(function (box) { return ({
+                            minX: box.minX,
+                            minY: box.minY,
+                            maxX: box.maxX,
+                            maxY: box.maxY,
+                            id: box.id
+                        }); });
+                        objectsGroupByLayer.forEach(function (objects, layerName) {
+                            // AutoCAD block rule: entities authored on layer "0" inherit the INSERT's layer.
+                            // Non-zero layers keep their original layer name.
+                            var effectiveLayerName = layerName === '0' ? groupLayerName : layerName;
+                            // Keep runtime layer metadata/material cache aligned with the inherited layer so
+                            // later layer style edits (color, linetype, lineweight, transparency) target this
+                            // object set correctly.
+                            _this.remapInheritedLayerObjects(objects, layerName, effectiveLayerName);
+                            // One INSERT can expand to children from multiple layers. Here we create one
+                            // render entity per layer bucket but preserve the INSERT object id for all
+                            // buckets, so selection/highlight still maps back to the same database object.
+                            // Within each layer bucket, the object id remains unique in scene indexing.
+                            var entity = new AcTrEntity(renderContext);
+                            entity.applyMatrix4(group.matrix);
+                            entity.objectId = groupObjectId;
+                            entity.ownerId = group.ownerId;
+                            // If block-definition entities are on layer "0", this bucket now uses the layer
+                            // of the block reference itself (effectiveLayerName).
+                            entity.layerName = effectiveLayerName;
+                            entity.wcsBbox = group.wcsBbox.clone();
+                            var entityUserData = entity.userData;
+                            entityUserData.spatialIndexChildBoxes = groupChildBoxes;
+                            // Important:
+                            // DO NOT USE spread operator when adding objects because it may be one very large array
+                            // and can result in maximum call stack size exceeded
+                            for (var i = 0; i < objects.length; i++) {
+                                entity.add(objects[i]);
+                            }
+                            _this.refreshTextMaterialsInObjectTree(entity);
+                            _this._scene.addEntity(entity, true);
+                            _this.applySessionHiddenObjectState(groupObjectId);
+                            entity.dispose();
+                        });
+                        group.dispose();
+                        if (this._progressiveRendering) {
+                            this._isDirty = true;
+                            void this._progressiveOpenFit.afterGeometryBatch(function () {
+                                return _this.resolveLayoutFitBox();
+                            });
+                        }
+                        return [2 /*return*/];
                 }
-                finally { if (e_7) throw e_7.error; }
-            }
-            return {
-                minX: minX,
-                minY: minY,
-                maxX: maxX,
-                maxY: maxY,
-                id: box.id
-            };
+            });
         });
-        objectsGroupByLayer.forEach(function (objects, layerName) {
-            // AutoCAD block rule: entities authored on layer "0" inherit the INSERT's layer.
-            // Non-zero layers keep their original layer name.
-            var effectiveLayerName = layerName === '0' ? groupLayerName : layerName;
-            // Keep runtime layer metadata/material cache aligned with the inherited layer so
-            // later layer style edits (color, linetype, lineweight, transparency) target this
-            // object set correctly.
-            _this.remapInheritedLayerObjects(objects, layerName, effectiveLayerName);
-            // One INSERT can expand to children from multiple layers. Here we create one
-            // render entity per layer bucket but preserve the INSERT object id for all
-            // buckets, so selection/highlight still maps back to the same database object.
-            // Within each layer bucket, the object id remains unique in scene indexing.
-            var entity = new AcTrEntity(styleManager);
-            entity.applyMatrix4(group.matrix);
-            entity.objectId = groupObjectId;
-            entity.ownerId = group.ownerId;
-            // If block-definition entities are on layer "0", this bucket now uses the layer
-            // of the block reference itself (effectiveLayerName).
-            entity.layerName = effectiveLayerName;
-            entity.box = worldGroupBox;
-            var entityUserData = entity.userData;
-            entityUserData.spatialIndexChildBoxes = groupChildBoxes;
-            // Important:
-            // DO NOT USE spread operator when adding objects because it may be one very large array
-            // and can result in maximum call stack size exceeded
-            for (var i = 0; i < objects.length; i++) {
-                entity.add(objects[i]);
+    };
+    /**
+     * Rebinds text materials after INSERT groups are split/reparented by layer.
+     *
+     * Layer remapping can replace mesh materials; text must keep entity-trait
+     * colours (especially ACI-7 foreground on paper layouts).
+     */
+    AcTrView2d.prototype.refreshTextMaterialsInObjectTree = function (root) {
+        root.traverse(function (child) {
+            var refresh = child.refreshTextMaterials;
+            if (typeof refresh === 'function') {
+                refresh.call(child);
             }
-            _this._scene.addEntity(entity, true);
-            _this.applySessionHiddenObjectState(groupObjectId);
-            entity.dispose();
         });
-        group.dispose();
-        this._isDirty = true;
     };
     /**
      * Remaps layer metadata/material bindings from a source layer to the effective render layer.
@@ -1853,7 +2155,7 @@ var AcTrView2d = /** @class */ (function (_super) {
      * @param effectiveLayerName - Final layer name used by rendering and style updates.
      */
     AcTrView2d.prototype.remapInheritedLayerObjects = function (objects, sourceLayerName, effectiveLayerName) {
-        var e_8, _a;
+        var e_7, _a;
         var _this = this;
         if (sourceLayerName === effectiveLayerName)
             return;
@@ -1863,33 +2165,67 @@ var AcTrView2d = /** @class */ (function (_super) {
             for (var objects_1 = __values(objects), objects_1_1 = objects_1.next(); !objects_1_1.done; objects_1_1 = objects_1.next()) {
                 var object = objects_1_1.value;
                 object.traverse(function (child) {
-                    if (child.userData.layerName === sourceLayerName) {
+                    var inheritsInsertLayer = child.userData.layerName === sourceLayerName;
+                    if (inheritsInsertLayer) {
                         child.userData.layerName = effectiveLayerName;
                     }
                     if (!('material' in child))
                         return;
+                    // Only layer-"0" (or the current source bucket) inherits INSERT traits.
+                    // Attributes/text on other layers must keep their own layer materials.
+                    if (!inheritsInsertLayer)
+                        return;
                     var material = child.material;
                     if (Array.isArray(material)) {
                         var materials = material;
                         child.material = materials.map(function (entry) {
-                            return renderer.getLayerBoundMaterial(_this.promoteLayerZeroByLayerColor(entry, sourceLayerName), effectiveLayerName, layerTraits);
+                            var _a;
+                            if (!_this.shouldRemapInheritedLayerMaterial(entry, sourceLayerName)) {
+                                return entry;
+                            }
+                            return ((_a = renderer.getLayerBoundMaterial(_this.promoteLayerZeroByLayerColor(entry, sourceLayerName), effectiveLayerName, layerTraits)) !== null && _a !== void 0 ? _a : entry);
                         });
                         return;
                     }
+                    if (!_this.shouldRemapInheritedLayerMaterial(material, sourceLayerName)) {
+                        return;
+                    }
                     var remappedMaterial = renderer.getLayerBoundMaterial(_this.promoteLayerZeroByLayerColor(material, sourceLayerName), effectiveLayerName, layerTraits);
+                    if (!remappedMaterial) {
+                        return;
+                    }
                     child.material = remappedMaterial;
                     child.userData.styleMaterialId = remappedMaterial.id;
                 });
             }
         }
-        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
         finally {
             try {
                 if (objects_1_1 && !objects_1_1.done && (_a = objects_1.return)) _a.call(objects_1);
             }
-            finally { if (e_8) throw e_8.error; }
+            finally { if (e_7) throw e_7.error; }
         }
     };
+    /**
+     * Layer-0 block contents with ByLayer color resolve to ACI-7 foreground materials before
+     * INSERT remapping. Those materials must still inherit the INSERT layer when their colour
+     * is layer-bound, while explicit ACI-7 entities on layer 0 stay untouched.
+     */
+    AcTrView2d.prototype.shouldRemapInheritedLayerMaterial = function (material, sourceLayerName) {
+        var metadata = getMaterialMetadata(material);
+        if (metadata.isForeground !== true) {
+            return true;
+        }
+        if (sourceLayerName !== '0') {
+            return false;
+        }
+        if (metadata.isByLayerColor === true) {
+            return true;
+        }
+        var promoted = this.promoteLayerZeroByLayerColor(material, sourceLayerName);
+        return getMaterialMetadata(promoted).isByLayerColor === true;
+    };
     /**
      * Some DXF conversion paths lose `isByLayerColor` on layer-0 block contents while still
      * retaining other ByLayer markers (lineType/lineWeight/transparency). For AutoCAD-compatible
@@ -1913,7 +2249,6 @@ var AcTrView2d = /** @class */ (function (_super) {
         return {
             layer: layer.name,
             color: layer.color.clone(),
-            rgbColor: layer.color.RGB,
             lineType: layer.lineStyle,
             lineWeight: layer.lineWeight,
             transparency: layer.transparency
@@ -1925,6 +2260,10 @@ var AcTrView2d = /** @class */ (function (_super) {
             this._numOfEntitiesToProcess = 0;
             log.warn('Something wrong! The number of entities to process should not be less than 0.');
         }
+        else if (this._numOfEntitiesToProcess === 0 &&
+            !this._progressiveRendering) {
+            this._isDirty = true;
+        }
     };
     return AcTrView2d;
 }(AcEdBaseView));