@file-viewer/renderer-cad 2.1.17 → 2.1.18

package/dist/cad.js

@@ -1,7 +1,10 @@
-import { CadViewer, } from '@flyfish-dev/cad-viewer';
+import { CadViewer, inferEntityKind, } from '@flyfish-dev/cad-viewer';
 import { resolveFileViewerCadAssetUrls } from '@file-viewer/core/assets';
 import { createFileViewerViewStateChange, createFileViewerViewStateChangeEmitter, createFileViewerTranslator, createFileViewerZoomChangeEmitter, registerFileViewerViewStateProvider, registerFileViewerZoomProvider, resolveFileViewerLocale, unregisterFileViewerViewStateProvider, unregisterFileViewerZoomProvider, } from '@file-viewer/core';
 const CAD_WORKER_TIMEOUT = 120000;
+const CAD_DEFAULT_FIT_PADDING = 0.92;
+const CAD_BOUNDS_EPSILON = 1e-9;
+const CAD_BEST_FIT_OUTLIER_RATIO = 8;
 const cadStyle = `
 .cad-shell{display:flex;height:100%;min-height:100%;flex-direction:column;background:#f5f7fb;color:#142335}
 .cad-shell *{box-sizing:border-box}
@@ -11,17 +14,19 @@ const cadStyle = `
 .cad-tools button:hover{background:rgba(31,150,110,.14);color:#0f8f62}
 .cad-zoom,.cad-meta span{color:#64748b;font-size:12px;font-weight:800;letter-spacing:0}
 .cad-meta span{border-radius:999px;padding:5px 9px;background:rgba(15,23,42,.06)}
-.cad-body{display:grid;min-height:0;flex:1;grid-template-columns:minmax(168px,220px) minmax(0,1fr) minmax(150px,190px);background:#eef2f7}
-.cad-body.without-layers{grid-template-columns:minmax(0,1fr) minmax(150px,190px)}
+.cad-body{display:grid;min-height:0;flex:1;grid-template-columns:minmax(176px,236px) minmax(0,1fr) minmax(142px,176px);background:#eef2f7}
+.cad-body.without-layers{grid-template-columns:minmax(0,1fr) minmax(142px,176px)}
 .cad-layers,.cad-inspector{min-height:0;overflow:auto;border-right:1px solid rgba(15,23,42,.08);background:#fff}
 .cad-layers[hidden]{display:none}
 .cad-inspector{border-right:0;border-left:1px solid rgba(15,23,42,.08);padding:14px}
-.cad-layers-head{position:sticky;top:0;display:flex;align-items:center;justify-content:space-between;padding:12px 12px 8px;background:#fff;color:#1f2a3d;font-size:13px;z-index:1}
-.cad-layers-head span{color:#7b8ca5;font-size:12px;font-weight:700}
-.cad-layers-list{display:flex;flex-direction:column;padding:0 0 8px}
-.cad-layers button{display:flex;width:calc(100% - 16px);min-height:34px;align-items:center;gap:8px;margin:0 8px 6px;border:1px solid rgba(148,163,184,.22);border-radius:8px;background:#f8fafc;color:#25344c;cursor:pointer;font-size:12px;font-weight:700;text-align:left}
-.cad-layers button.muted{opacity:.48}
-.cad-layer-color{width:10px;height:10px;flex:0 0 auto;border-radius:50%;background:#1f966e;box-shadow:inset 0 0 0 1px rgba(15,23,42,.14)}
+.cad-layers-head{position:sticky;top:0;display:flex;align-items:center;justify-content:space-between;gap:10px;padding:12px 12px 9px;border-bottom:1px solid rgba(148,163,184,.16);background:rgba(255,255,255,.96);color:#1f2a3d;font-size:12px;z-index:1}
+.cad-layers-head span{color:#7b8ca5;font-size:11px;font-weight:800;white-space:nowrap}
+.cad-layers-list{display:flex;flex-direction:column;gap:2px;padding:7px 8px 10px}
+.cad-layers button{display:grid;width:100%;min-height:30px;grid-template-columns:14px minmax(0,1fr);align-items:center;gap:7px;border:0;border-radius:6px;background:transparent;color:#25344c;cursor:pointer;font-size:12px;font-weight:700;text-align:left}
+.cad-layers button:hover{background:#f1f5f9}
+.cad-layers button.muted{color:#94a3b8}
+.cad-layers button span:last-child{min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.cad-layer-color{width:8px;height:8px;justify-self:center;border-radius:50%;background:#1f966e;box-shadow:0 0 0 1px rgba(15,23,42,.12),0 0 0 3px rgba(31,150,110,.1)}
 .cad-canvas-wrap{position:relative;min-width:0;min-height:0;overflow:hidden;background:linear-gradient(90deg,rgba(15,23,42,.04) 1px,transparent 1px),linear-gradient(180deg,rgba(15,23,42,.04) 1px,transparent 1px),#f8fafc;background-size:28px 28px}
 .cad-stage{position:relative;width:100%;height:100%;min-height:420px;overflow:hidden}
 .cad-stage canvas{position:absolute;inset:0;display:block;width:100%!important;height:100%!important}
@@ -99,13 +104,79 @@ const createElement = (tagName, className, text) => {
 const normalizeType = (type) => {
     return (type || 'dxf').toLowerCase();
 };
+const normalizeLayerKey = (name) => name.trim().toLocaleLowerCase();
+const getLayerNameScore = (name) => {
+    const letters = name.replace(/[^a-z]/gi, '');
+    if (!letters) {
+        return 0;
+    }
+    const isUpper = letters === letters.toLocaleUpperCase();
+    const isLower = letters === letters.toLocaleLowerCase();
+    if (!isUpper && !isLower) {
+        return 3;
+    }
+    return isUpper ? 2 : 1;
+};
+const shouldPreferLayerName = (candidate, current) => {
+    const nextScore = getLayerNameScore(candidate);
+    const currentScore = getLayerNameScore(current);
+    if (nextScore !== currentScore) {
+        return nextScore > currentScore;
+    }
+    if (candidate.length !== current.length) {
+        return candidate.length > current.length;
+    }
+    return candidate.localeCompare(current, undefined, { sensitivity: 'base' }) < 0;
+};
+const addLayerSourceName = (layer, name) => {
+    if (typeof name !== 'string' && typeof name !== 'number') {
+        return;
+    }
+    const nextName = String(name);
+    if (!nextName || layer.sourceNames.includes(nextName)) {
+        return;
+    }
+    layer.sourceNames.push(nextName);
+};
 const collectLayers = (result) => {
     if (!result) {
         return [];
     }
-    return Object.entries(result.document.layers)
-        .map(([name, layer]) => ({ ...layer, name }))
-        .sort((left, right) => left.name.localeCompare(right.name));
+    const groups = new Map();
+    Object.entries(result.document.layers).forEach(([key, layer]) => {
+        var _a, _b, _c, _d, _e;
+        const sourceName = typeof layer.name === 'string' && layer.name ? layer.name : key;
+        const groupKey = normalizeLayerKey(sourceName || key);
+        const current = groups.get(groupKey);
+        if (!current) {
+            groups.set(groupKey, {
+                ...layer,
+                name: sourceName || key,
+                sourceNames: Array.from(new Set([key, sourceName].filter((name) => typeof name === 'string' && name.length > 0))),
+                duplicateCount: 1,
+            });
+            return;
+        }
+        current.duplicateCount += 1;
+        addLayerSourceName(current, key);
+        addLayerSourceName(current, sourceName);
+        current.isVisible = current.isVisible !== false || layer.isVisible !== false;
+        current.isFrozen = !!current.isFrozen && !!layer.isFrozen;
+        current.isLocked = !!current.isLocked || !!layer.isLocked;
+        current.color = (_a = current.color) !== null && _a !== void 0 ? _a : layer.color;
+        current.colorIndex = (_b = current.colorIndex) !== null && _b !== void 0 ? _b : layer.colorIndex;
+        current.trueColor = (_c = current.trueColor) !== null && _c !== void 0 ? _c : layer.trueColor;
+        current.lineType = (_d = current.lineType) !== null && _d !== void 0 ? _d : layer.lineType;
+        current.lineweight = (_e = current.lineweight) !== null && _e !== void 0 ? _e : layer.lineweight;
+        if (shouldPreferLayerName(sourceName, current.name)) {
+            current.name = sourceName;
+        }
+    });
+    return Array.from(groups.values())
+        .sort((left, right) => left.name.localeCompare(right.name, undefined, {
+        numeric: true,
+        sensitivity: 'base',
+    }));
 };
 const formatNumber = (value, locale = 'zh-CN') => {
     if (!Number.isFinite(value)) {
@@ -115,7 +186,350 @@ const formatNumber = (value, locale = 'zh-CN') => {
 };
 const getCadDocumentBaseUrl = (target) => {
     var _a;
-    return ((_a = target.ownerDocument) === null || _a === void 0 ? void 0 : _a.baseURI) || 'http://localhost/';
+    return ((_a = target.ownerDocument) === null || _a === void 0 ? void 0 : _a.baseURI) || 'file:///';
+};
+const createEmptyCadBounds = () => ({
+    minX: Number.POSITIVE_INFINITY,
+    minY: Number.POSITIVE_INFINITY,
+    maxX: Number.NEGATIVE_INFINITY,
+    maxY: Number.NEGATIVE_INFINITY,
+});
+const isCadBoundsValid = (bounds) => {
+    return !!bounds &&
+        Number.isFinite(bounds.minX) &&
+        Number.isFinite(bounds.minY) &&
+        Number.isFinite(bounds.maxX) &&
+        Number.isFinite(bounds.maxY) &&
+        bounds.maxX >= bounds.minX &&
+        bounds.maxY >= bounds.minY;
+};
+const getCadBoundsWidth = (bounds) => bounds.maxX - bounds.minX;
+const getCadBoundsHeight = (bounds) => bounds.maxY - bounds.minY;
+const isCadBoundsMeaningful = (bounds) => {
+    return getCadBoundsWidth(bounds) > CAD_BOUNDS_EPSILON ||
+        getCadBoundsHeight(bounds) > CAD_BOUNDS_EPSILON;
+};
+const isCadPoint = (value) => {
+    return !!value &&
+        typeof value === 'object' &&
+        Number.isFinite(value.x) &&
+        Number.isFinite(value.y);
+};
+const addCadPointToBounds = (bounds, point) => {
+    if (!isCadPoint(point)) {
+        return;
+    }
+    bounds.minX = Math.min(bounds.minX, point.x);
+    bounds.minY = Math.min(bounds.minY, point.y);
+    bounds.maxX = Math.max(bounds.maxX, point.x);
+    bounds.maxY = Math.max(bounds.maxY, point.y);
+};
+const addCadBounds = (target, source) => {
+    if (!isCadBoundsValid(source)) {
+        return;
+    }
+    addCadPointToBounds(target, { x: source.minX, y: source.minY });
+    addCadPointToBounds(target, { x: source.maxX, y: source.maxY });
+};
+const unionCadBounds = (boundsList) => {
+    const union = createEmptyCadBounds();
+    boundsList.forEach(bounds => addCadBounds(union, bounds));
+    return isCadBoundsValid(union) ? union : null;
+};
+const getCadBoundsArea = (bounds) => {
+    return Math.max(getCadBoundsWidth(bounds), CAD_BOUNDS_EPSILON) *
+        Math.max(getCadBoundsHeight(bounds), CAD_BOUNDS_EPSILON);
+};
+const addCadCircleBounds = (bounds, center, radius) => {
+    const value = Number(radius);
+    if (!isCadPoint(center) || !Number.isFinite(value)) {
+        return;
+    }
+    const nextRadius = Math.abs(value);
+    addCadPointToBounds(bounds, { x: center.x - nextRadius, y: center.y - nextRadius });
+    addCadPointToBounds(bounds, { x: center.x + nextRadius, y: center.y + nextRadius });
+};
+const addCadPointListToBounds = (bounds, points) => {
+    if (!Array.isArray(points)) {
+        return;
+    }
+    points.forEach(point => addCadPointToBounds(bounds, point));
+};
+const addCadPathCommandsToBounds = (bounds, commands) => {
+    if (!Array.isArray(commands)) {
+        return;
+    }
+    commands.forEach(command => {
+        const points = command.points;
+        addCadPointListToBounds(bounds, points);
+    });
+};
+const addCadTextBounds = (bounds, entity) => {
+    var _a, _b, _c, _d;
+    const anchor = entity.insertionPoint || entity.startPoint || entity.center;
+    if (!isCadPoint(anchor)) {
+        return;
+    }
+    const text = String((_b = (_a = entity.text) !== null && _a !== void 0 ? _a : entity.value) !== null && _b !== void 0 ? _b : '');
+    const height = Math.abs(Number((_d = (_c = entity.textHeight) !== null && _c !== void 0 ? _c : entity.height) !== null && _d !== void 0 ? _d : 1));
+    const lines = text.split(/\r?\n/g);
+    const width = Math.max(1, ...lines.map(line => line.length)) * Math.max(height, 1) * 0.62;
+    const blockHeight = Math.max(1, lines.length) * Math.max(height, 1) * 1.22;
+    addCadPointToBounds(bounds, anchor);
+    addCadPointToBounds(bounds, { x: anchor.x + width, y: anchor.y - blockHeight });
+};
+const getCadEntityAnchor = (entity) => {
+    var _a;
+    for (const key of ['startPoint', 'insertionPoint', 'center', 'point', 'location']) {
+        const point = entity[key];
+        if (isCadPoint(point)) {
+            return point;
+        }
+    }
+    const vertices = entity.vertices || entity.points;
+    if (Array.isArray(vertices) && isCadPoint(vertices[0])) {
+        return vertices[0];
+    }
+    const command = (_a = entity.commands) === null || _a === void 0 ? void 0 : _a.find(item => item.points.length > 0);
+    return command === null || command === void 0 ? void 0 : command.points[0];
+};
+const getCadEntityLocalBounds = (entity) => {
+    var _a, _b, _c, _d, _e;
+    const bounds = createEmptyCadBounds();
+    const type = String((_a = entity.type) !== null && _a !== void 0 ? _a : '').toUpperCase();
+    const kind = entity.kind || inferEntityKind(type);
+    if (kind === 'viewport') {
+        return null;
+    }
+    if (kind === 'line') {
+        addCadPointToBounds(bounds, entity.startPoint);
+        addCadPointToBounds(bounds, entity.endPoint);
+    }
+    else if (kind === 'circle' || kind === 'arc') {
+        addCadCircleBounds(bounds, entity.center, entity.radius);
+    }
+    else if (kind === 'polyline' || kind === 'solid' || kind === 'spline') {
+        addCadPointListToBounds(bounds, entity.vertices);
+        addCadPointListToBounds(bounds, entity.points);
+        addCadPointListToBounds(bounds, entity.controlPoints);
+        addCadPointListToBounds(bounds, entity.fitPoints);
+    }
+    else if (kind === 'ellipse') {
+        const center = entity.center;
+        const major = entity.majorAxisEndPoint;
+        if (isCadPoint(center) && isCadPoint(major)) {
+            const majorRadius = Math.hypot(major.x, major.y);
+            const minorRadius = majorRadius * Math.abs(Number((_b = entity.axisRatio) !== null && _b !== void 0 ? _b : 1));
+            addCadCircleBounds(bounds, center, Math.max(majorRadius, minorRadius));
+        }
+    }
+    else if (kind === 'text') {
+        addCadTextBounds(bounds, entity);
+    }
+    else if (kind === 'path') {
+        addCadPathCommandsToBounds(bounds, entity.commands);
+    }
+    else if (kind === 'hatch') {
+        (_c = entity.loops) === null || _c === void 0 ? void 0 : _c.forEach(loop => {
+            addCadPointListToBounds(bounds, loop.vertices);
+            addCadPathCommandsToBounds(bounds, loop.commands);
+        });
+    }
+    else if (kind === 'image') {
+        const point = entity.insertionPoint;
+        const width = Number((_d = entity.width) !== null && _d !== void 0 ? _d : 32);
+        const height = Number((_e = entity.height) !== null && _e !== void 0 ? _e : 32);
+        if (isCadPoint(point) && Number.isFinite(width) && Number.isFinite(height)) {
+            addCadPointToBounds(bounds, point);
+            addCadPointToBounds(bounds, { x: point.x + width, y: point.y - height });
+        }
+    }
+    else {
+        addCadPointToBounds(bounds, getCadEntityAnchor(entity));
+    }
+    return isCadBoundsValid(bounds) ? bounds : null;
+};
+const identityCadMatrix = () => ({ a: 1, b: 0, c: 0, d: 1, e: 0, f: 0 });
+const translateCadMatrix = (x, y) => ({ a: 1, b: 0, c: 0, d: 1, e: x, f: y });
+const scaleCadMatrix = (x, y) => ({ a: x, b: 0, c: 0, d: y, e: 0, f: 0 });
+const rotateCadMatrix = (rotation) => {
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return { a: cos, b: sin, c: -sin, d: cos, e: 0, f: 0 };
+};
+const multiplyCadMatrix = (left, right) => ({
+    a: left.a * right.a + left.c * right.b,
+    b: left.b * right.a + left.d * right.b,
+    c: left.a * right.c + left.c * right.d,
+    d: left.b * right.c + left.d * right.d,
+    e: left.a * right.e + left.c * right.f + left.e,
+    f: left.b * right.e + left.d * right.f + left.f,
+});
+const transformCadPoint = (point, matrix) => ({
+    x: point.x * matrix.a + point.y * matrix.c + matrix.e,
+    y: point.x * matrix.b + point.y * matrix.d + matrix.f,
+});
+const transformCadBounds = (bounds, matrix) => {
+    const next = createEmptyCadBounds();
+    [
+        { x: bounds.minX, y: bounds.minY },
+        { x: bounds.minX, y: bounds.maxY },
+        { x: bounds.maxX, y: bounds.minY },
+        { x: bounds.maxX, y: bounds.maxY },
+    ].forEach(point => addCadPointToBounds(next, transformCadPoint(point, matrix)));
+    return isCadBoundsValid(next) ? next : null;
+};
+const createCadInsertMatrix = (entity, blockBasePoint = { x: 0, y: 0 }) => {
+    var _a, _b, _c, _d, _e;
+    const insertion = entity.insertionPoint || { x: 0, y: 0 };
+    const scale = entity.scale;
+    const scaleX = Number(typeof scale === 'object' && scale ? (_a = scale.x) !== null && _a !== void 0 ? _a : 1 : (_b = entity.scaleX) !== null && _b !== void 0 ? _b : 1);
+    const scaleY = Number(typeof scale === 'object' && scale ? (_c = scale.y) !== null && _c !== void 0 ? _c : scaleX : (_d = entity.scaleY) !== null && _d !== void 0 ? _d : scaleX);
+    const rotation = Number((_e = entity.rotation) !== null && _e !== void 0 ? _e : 0);
+    let matrix = translateCadMatrix(isCadPoint(insertion) ? insertion.x : 0, isCadPoint(insertion) ? insertion.y : 0);
+    matrix = multiplyCadMatrix(matrix, rotateCadMatrix(Number.isFinite(rotation) ? rotation : 0));
+    matrix = multiplyCadMatrix(matrix, scaleCadMatrix(Number.isFinite(scaleX) ? scaleX : 1, Number.isFinite(scaleY) ? scaleY : 1));
+    matrix = multiplyCadMatrix(matrix, translateCadMatrix(-blockBasePoint.x, -blockBasePoint.y));
+    return matrix;
+};
+const findCadLayer = (document, name) => {
+    if (typeof name !== 'string' && typeof name !== 'number') {
+        return undefined;
+    }
+    const key = String(name);
+    return document.layers[key] ||
+        document.layers[key.toLocaleLowerCase()] ||
+        Object.values(document.layers).find(layer => normalizeLayerKey(layer.name) === normalizeLayerKey(key));
+};
+const findCadBlock = (document, name) => {
+    if (typeof name !== 'string' && typeof name !== 'number') {
+        return undefined;
+    }
+    const key = String(name);
+    return document.blocks[key] ||
+        document.blocks[key.toLocaleLowerCase()] ||
+        Object.values(document.blocks).find(block => normalizeLayerKey(block.name) === normalizeLayerKey(key));
+};
+const isCadEntityVisible = (document, entity) => {
+    if (entity.isVisible === false) {
+        return false;
+    }
+    const layer = findCadLayer(document, entity.layer);
+    return layer ? layer.isVisible !== false && !layer.isFrozen : true;
+};
+const collectCadVisibleEntityBounds = (document, maxInsertDepth) => {
+    const boundsList = [];
+    const visit = (entity, depth, matrix) => {
+        var _a, _b;
+        if (!isCadEntityVisible(document, entity)) {
+            return;
+        }
+        const type = String((_a = entity.type) !== null && _a !== void 0 ? _a : '').toUpperCase();
+        const kind = entity.kind || inferEntityKind(type);
+        if (kind === 'insert') {
+            const block = findCadBlock(document, (_b = entity.blockName) !== null && _b !== void 0 ? _b : entity.name);
+            if (block && depth < maxInsertDepth) {
+                const nextMatrix = multiplyCadMatrix(matrix, createCadInsertMatrix(entity, block.basePoint || { x: 0, y: 0 }));
+                block.entities.forEach(child => visit(child, depth + 1, nextMatrix));
+                return;
+            }
+        }
+        const localBounds = getCadEntityLocalBounds(entity);
+        if (!localBounds) {
+            return;
+        }
+        const nextBounds = transformCadBounds(localBounds, matrix);
+        if (nextBounds) {
+            boundsList.push(nextBounds);
+        }
+    };
+    document.entities.forEach(entity => visit(entity, 0, identityCadMatrix()));
+    return boundsList;
+};
+const inflateCadDegenerateBounds = (bounds) => {
+    const width = getCadBoundsWidth(bounds);
+    const height = getCadBoundsHeight(bounds);
+    if (width > CAD_BOUNDS_EPSILON && height > CAD_BOUNDS_EPSILON) {
+        return bounds;
+    }
+    const centerX = (bounds.minX + bounds.maxX) / 2;
+    const centerY = (bounds.minY + bounds.maxY) / 2;
+    const pad = Math.max(width, height, 1) * 0.5;
+    return {
+        minX: centerX - (width > CAD_BOUNDS_EPSILON ? width / 2 : pad),
+        maxX: centerX + (width > CAD_BOUNDS_EPSILON ? width / 2 : pad),
+        minY: centerY - (height > CAD_BOUNDS_EPSILON ? height / 2 : pad),
+        maxY: centerY + (height > CAD_BOUNDS_EPSILON ? height / 2 : pad),
+    };
+};
+const selectCadBestFitBounds = (boundsList) => {
+    let candidates = boundsList.filter(isCadBoundsValid);
+    const meaningful = candidates.filter(isCadBoundsMeaningful);
+    if (meaningful.length > 0) {
+        candidates = meaningful;
+    }
+    const globalBounds = unionCadBounds(candidates);
+    if (!globalBounds || candidates.length < 8) {
+        return globalBounds ? inflateCadDegenerateBounds(globalBounds) : null;
+    }
+    const centers = candidates.map(bounds => ({
+        bounds,
+        x: (bounds.minX + bounds.maxX) / 2,
+        y: (bounds.minY + bounds.maxY) / 2,
+    }));
+    const trim = Math.max(1, Math.floor(centers.length * 0.05));
+    const sortedX = [...centers].sort((left, right) => left.x - right.x);
+    const sortedY = [...centers].sort((left, right) => left.y - right.y);
+    const minX = sortedX[Math.min(trim, sortedX.length - 1)].x;
+    const maxX = sortedX[Math.max(sortedX.length - 1 - trim, 0)].x;
+    const minY = sortedY[Math.min(trim, sortedY.length - 1)].y;
+    const maxY = sortedY[Math.max(sortedY.length - 1 - trim, 0)].y;
+    const trimmed = centers
+        .filter(item => item.x >= minX && item.x <= maxX && item.y >= minY && item.y <= maxY)
+        .map(item => item.bounds);
+    const minKeep = Math.max(4, Math.floor(candidates.length * 0.55));
+    const trimmedBounds = trimmed.length >= minKeep ? unionCadBounds(trimmed) : null;
+    if (!trimmedBounds) {
+        return inflateCadDegenerateBounds(globalBounds);
+    }
+    const globalSpan = Math.max(getCadBoundsWidth(globalBounds), getCadBoundsHeight(globalBounds), CAD_BOUNDS_EPSILON);
+    const trimmedSpan = Math.max(getCadBoundsWidth(trimmedBounds), getCadBoundsHeight(trimmedBounds), CAD_BOUNDS_EPSILON);
+    const areaRatio = getCadBoundsArea(globalBounds) / getCadBoundsArea(trimmedBounds);
+    if (globalSpan / trimmedSpan >= CAD_BEST_FIT_OUTLIER_RATIO || areaRatio >= CAD_BEST_FIT_OUTLIER_RATIO ** 2) {
+        return inflateCadDegenerateBounds(trimmedBounds);
+    }
+    return inflateCadDegenerateBounds(globalBounds);
+};
+const resolveCadFitPadding = (options) => {
+    const padding = Number(options.fitPadding);
+    if (!Number.isFinite(padding) || padding <= 0) {
+        return CAD_DEFAULT_FIT_PADDING;
+    }
+    return Math.min(1, Math.max(0.2, padding));
+};
+const resolveCadFitBounds = (document, rendererBounds, options) => {
+    var _a;
+    if (!document || options.fitMode === 'native') {
+        return rendererBounds && isCadBoundsValid(rendererBounds)
+            ? inflateCadDegenerateBounds(rendererBounds)
+            : null;
+    }
+    const configuredDepth = Number((_a = options.maxInsertDepth) !== null && _a !== void 0 ? _a : 16);
+    const maxInsertDepth = Number.isFinite(configuredDepth) ? Math.max(0, configuredDepth) : 16;
+    const entityBounds = collectCadVisibleEntityBounds(document, maxInsertDepth);
+    return selectCadBestFitBounds(entityBounds) ||
+        (rendererBounds && isCadBoundsValid(rendererBounds) ? inflateCadDegenerateBounds(rendererBounds) : null);
+};
+const resolveLayerSourceNames = (document, layer) => {
+    const normalized = normalizeLayerKey(layer.name);
+    const names = new Set(layer.sourceNames);
+    Object.entries(document.layers).forEach(([key, source]) => {
+        if (normalizeLayerKey(key) === normalized || normalizeLayerKey(source.name) === normalized) {
+            names.add(key);
+            names.add(source.name);
+        }
+    });
+    return Array.from(names);
 };
 export default async function renderCad(buffer, target, type = 'dxf', context) {
     var _a;
@@ -133,6 +547,7 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
     let viewer = null;
     let resizeObserver = null;
     let abortController = null;
+    let fitViewActive = true;
     let disposed = false;
     const style = createStyle();
     const shell = createElement('div', 'cad-shell');
@@ -247,7 +662,12 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
         layersList.replaceChildren(...layers.map(layer => {
             const button = createElement('button');
             button.type = 'button';
-            button.classList.toggle('muted', layer.isVisible === false || !!layer.isFrozen);
+            const layerVisible = layer.isVisible !== false && !layer.isFrozen;
+            button.classList.toggle('muted', !layerVisible);
+            button.title = layer.duplicateCount > 1
+                ? `${layer.name} (${layer.duplicateCount} merged)`
+                : layer.name;
+            button.setAttribute('aria-pressed', String(layerVisible));
             const color = createElement('span', 'cad-layer-color');
             if (typeof layer.color === 'string') {
                 color.style.background = layer.color;
@@ -255,16 +675,22 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
             button.append(color, createElement('span', undefined, layer.name));
             button.addEventListener('click', () => {
                 const document = viewer === null || viewer === void 0 ? void 0 : viewer.getDocument();
-                if (!(document === null || document === void 0 ? void 0 : document.layers[layer.name])) {
+                if (!document) {
                     return;
                 }
-                const current = document.layers[layer.name];
-                current.isVisible = current.isVisible === false;
+                const nextVisible = !layerVisible;
+                resolveLayerSourceNames(document, layer).forEach(sourceName => {
+                    const current = document.layers[sourceName] || findCadLayer(document, sourceName);
+                    if (current) {
+                        current.isVisible = nextVisible;
+                    }
+                });
                 loadResult = (viewer === null || viewer === void 0 ? void 0 : viewer.setDocument(document, buildFileName())) || null;
                 layers = collectLayers(loadResult);
                 syncUi();
                 queueMicrotask(() => {
-                    viewer === null || viewer === void 0 ? void 0 : viewer.fit();
+                    fitViewActive = true;
+                    applyCadFit();
                     cadZoomEmitter.emit();
                     emitCadViewStateChange('layer-toggle', 'user');
                 });
@@ -295,19 +721,83 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
         progressMessage = `${prefix}${progress.message}${percent}`;
         syncState();
     };
-    const fitToView = () => {
-        viewer === null || viewer === void 0 ? void 0 : viewer.fit();
+    const applyCadFit = () => {
+        var _a, _b, _c, _d;
+        if (!viewer) {
+            return false;
+        }
+        if ((_a = viewer.isNativeRendererActive) === null || _a === void 0 ? void 0 : _a.call(viewer)) {
+            viewer.fit();
+            return true;
+        }
+        const renderer = viewer.renderer;
+        const rendererBounds = (_b = renderer.getBounds) === null || _b === void 0 ? void 0 : _b.call(renderer);
+        const fitBounds = resolveCadFitBounds(viewer.getDocument(), rendererBounds, options);
+        if (!fitBounds || !renderer.setViewState) {
+            viewer.fit();
+            return true;
+        }
+        const width = Math.max(1, stage.clientWidth || viewer.canvas.clientWidth || target.clientWidth);
+        const height = Math.max(1, stage.clientHeight || viewer.canvas.clientHeight || target.clientHeight);
+        const boundsWidth = Math.max(getCadBoundsWidth(fitBounds), CAD_BOUNDS_EPSILON);
+        const boundsHeight = Math.max(getCadBoundsHeight(fitBounds), CAD_BOUNDS_EPSILON);
+        const canvasOptions = options.canvasOptions || {};
+        const minScale = Number((_c = canvasOptions.minScale) !== null && _c !== void 0 ? _c : CAD_BOUNDS_EPSILON);
+        const maxScale = Number((_d = canvasOptions.maxScale) !== null && _d !== void 0 ? _d : 1e9);
+        const unclampedScale = Math.min(width / boundsWidth, height / boundsHeight) * resolveCadFitPadding(options);
+        const nextScale = Math.min(Number.isFinite(maxScale) ? maxScale : 1e9, Math.max(Number.isFinite(minScale) ? minScale : CAD_BOUNDS_EPSILON, unclampedScale));
+        const nextView = {
+            centerX: (fitBounds.minX + fitBounds.maxX) / 2,
+            centerY: (fitBounds.minY + fitBounds.maxY) / 2,
+            scale: nextScale,
+        };
+        // Keep cad-viewer's zoom label at 100% for File Viewer's best-fit bounds.
+        renderer.fitScale = nextScale;
+        renderer.setViewState(nextView);
+        return true;
+    };
+    const fitToView = (source = 'user', action = 'zoom-reset') => {
+        fitViewActive = true;
+        applyCadFit();
+        cadZoomEmitter.emit();
+        syncState();
+        emitCadViewStateChange(action, source);
+    };
+    const applyCadFitRequest = (request) => {
+        fitViewActive = true;
+        const applied = applyCadFit();
+        if (!applied) {
+            return {
+                applied: false,
+                mode: request.mode,
+                resize: request.resize,
+                source: request.source,
+                reason: 'not-ready',
+                provider: 'view-state',
+            };
+        }
         cadZoomEmitter.emit();
         syncState();
-        emitCadViewStateChange('zoom-reset', 'user');
+        const state = emitCadViewStateChange('fit', request.source);
+        return {
+            applied: true,
+            mode: request.mode,
+            resize: request.resize,
+            scale: state.scale,
+            source: request.source,
+            provider: 'view-state',
+            state,
+        };
     };
     const zoomIn = () => {
+        fitViewActive = false;
         viewer === null || viewer === void 0 ? void 0 : viewer.zoomIn();
         cadZoomEmitter.emit();
         syncState();
         emitCadViewStateChange('zoom-in', 'user');
     };
     const zoomOut = () => {
+        fitViewActive = false;
         viewer === null || viewer === void 0 ? void 0 : viewer.zoomOut();
         cadZoomEmitter.emit();
         syncState();
@@ -326,6 +816,7 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
             fitToView();
             return getCadZoomState();
         },
+        fit: applyCadFitRequest,
         getState: getCadZoomState,
         subscribe: cadZoomEmitter.subscribe,
     });
@@ -340,9 +831,10 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
             }
             return getCadViewState();
         },
+        fit: applyCadFitRequest,
         subscribe: cadViewStateEmitter.subscribe,
     });
-    fitButton.addEventListener('click', fitToView);
+    fitButton.addEventListener('click', () => fitToView());
     zoomInButton.addEventListener('click', zoomIn);
     zoomOutButton.addEventListener('click', zoomOut);
     const createViewer = () => {
@@ -424,6 +916,7 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
         renderStats = null;
         viewState = null;
         layers = [];
+        fitViewActive = true;
         syncUi();
         abortController === null || abortController === void 0 ? void 0 : abortController.abort();
         const controller = new AbortController();
@@ -448,7 +941,7 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
             status = 'ready';
             syncUi();
             queueMicrotask(() => {
-                viewer === null || viewer === void 0 ? void 0 : viewer.fit();
+                applyCadFit();
                 cadZoomEmitter.emit();
                 emitCadViewStateChange('init', 'viewer');
                 syncState();
@@ -467,6 +960,15 @@ export default async function renderCad(buffer, target, type = 'dxf', context) {
     if (typeof ResizeObserver !== 'undefined') {
         resizeObserver = new ResizeObserver(() => {
             viewer === null || viewer === void 0 ? void 0 : viewer.resize();
+            if (fitViewActive) {
+                requestAnimationFrame(() => {
+                    if (!disposed && fitViewActive) {
+                        applyCadFit();
+                        cadZoomEmitter.emit();
+                        syncState();
+                    }
+                });
+            }
         });
         resizeObserver.observe(stage);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@file-viewer/renderer-cad",
-  "version": "2.1.17",
+  "version": "2.1.18",
   "private": false,
   "type": "module",
   "description": "Standalone CAD renderer plugin for Flyfish File Viewer powered by @flyfish-dev/cad-viewer.",
@@ -56,7 +56,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@file-viewer/core": "^2.1.17",
+    "@file-viewer/core": "^2.1.18",
     "@flyfish-dev/cad-viewer": "^0.6.4"
   },
   "devDependencies": {