@mlightcad/cad-simple-viewer 1.8.0-preview.3 → 1.8.0-preview.4

package/lib/command/draw/dimStylePreview.js

@@ -0,0 +1,723 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { acdbDecodeDimStyleColor, AcDbDimStyleTableRecord } from '@mlightcad/data-model';
+/** Width of the preview drawing in SVG user units. */
+export var DIM_PREVIEW_WIDTH = 420;
+/** Height of the preview drawing in SVG user units. */
+export var DIM_PREVIEW_HEIGHT = 250;
+/**
+ * Pixel size used for one drawing unit of a DIMSTYLE value.
+ *
+ * DIMSCALE is deliberately not applied: like AutoCAD's fit-to-window preview,
+ * the whole illustration is normalized so that annotation sizes remain
+ * comparable between styles.
+ */
+var PX_PER_UNIT = 6;
+var GEOMETRY_STROKE = 1.4;
+var DIMENSION_STROKE = 1.15;
+var DEFAULT_STYLE = new AcDbDimStyleTableRecord();
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function asNumber(value, fallback) {
+    var parsed = Number(value);
+    return value == null || !Number.isFinite(parsed) ? fallback : parsed;
+}
+function asFlag(value) {
+    return asNumber(value, 0) !== 0;
+}
+/** UI token with Element Plus fallback so both the Vue dialog and plain DOM share it. */
+var UI = {
+    text: 'var(--ml-ui-text, var(--el-text-color-primary, #303133))',
+    textMuted: 'var(--ml-ui-text-muted, var(--el-text-color-secondary, #606266))',
+    accent: 'var(--ml-ui-accent, var(--el-color-primary, #409eff))'
+};
+function resolveColor(raw, fallback) {
+    var _a;
+    var color = acdbDecodeDimStyleColor(raw);
+    if (color.isForeground)
+        return UI.text;
+    if (color.isByBlock || color.isByLayer)
+        return fallback;
+    return (_a = color.cssColor) !== null && _a !== void 0 ? _a : fallback;
+}
+function classifyArrow(style) {
+    var _a;
+    if (asNumber(style.dimtsz, 0) > 0)
+        return 'tick';
+    var name = String((_a = style.dimblk) !== null && _a !== void 0 ? _a : '').toUpperCase();
+    if (!name || name === '.' || name === 'CLOSEDFILLED')
+        return 'filled';
+    if (name.includes('DOT'))
+        return 'dot';
+    if (name.includes('OPEN'))
+        return 'open';
+    if (name.includes('ARCHTICK') || name.includes('OBLIQUE'))
+        return 'tick';
+    if (name.includes('NONE'))
+        return 'none';
+    if (name.includes('ORIGIN'))
+        return 'origin';
+    if (name.includes('BOX'))
+        return 'box';
+    if (name.includes('CLOSEDBLANK'))
+        return 'open';
+    return 'filled';
+}
+function addLine(scene, p1, p2, stroke, strokeWidth) {
+    if (strokeWidth === void 0) { strokeWidth = DIMENSION_STROKE; }
+    scene.lines.push({
+        x1: p1.x,
+        y1: p1.y,
+        x2: p2.x,
+        y2: p2.y,
+        stroke: stroke,
+        strokeWidth: strokeWidth
+    });
+}
+function addArrow(scene, tip, direction, size, kind, color) {
+    if (kind === 'none' || size <= 0)
+        return;
+    var ux = direction.x;
+    var uy = direction.y;
+    var baseX = tip.x - ux * size;
+    var baseY = tip.y - uy * size;
+    var px = -uy;
+    var py = ux;
+    var half = size * 0.34;
+    switch (kind) {
+        case 'filled':
+            scene.paths.push({
+                d: "M ".concat(tip.x, " ").concat(tip.y, " L ").concat(baseX + px * half, " ").concat(baseY + py * half, " L ").concat(baseX - px * half, " ").concat(baseY - py * half, " Z"),
+                stroke: 'none',
+                strokeWidth: 0,
+                fill: color
+            });
+            break;
+        case 'open':
+            scene.paths.push({
+                d: "M ".concat(baseX + px * half, " ").concat(baseY + py * half, " L ").concat(tip.x, " ").concat(tip.y, " L ").concat(baseX - px * half, " ").concat(baseY - py * half),
+                stroke: color,
+                strokeWidth: DIMENSION_STROKE,
+                fill: 'none'
+            });
+            break;
+        case 'tick': {
+            var h = size * 0.55;
+            var dx = (ux + px) / Math.SQRT2;
+            var dy = (uy + py) / Math.SQRT2;
+            addLine(scene, { x: tip.x - dx * h, y: tip.y - dy * h }, { x: tip.x + dx * h, y: tip.y + dy * h }, color);
+            break;
+        }
+        case 'dot':
+            scene.circles.push({
+                cx: tip.x,
+                cy: tip.y,
+                r: Math.max(1.4, size * 0.2),
+                stroke: 'none',
+                strokeWidth: 0,
+                fill: color
+            });
+            break;
+        case 'box': {
+            var h = size * 0.5;
+            var p1 = { x: baseX + px * h, y: baseY + py * h };
+            var p2 = { x: tip.x + px * h, y: tip.y + py * h };
+            var p3 = { x: tip.x - px * h, y: tip.y - py * h };
+            var p4 = { x: baseX - px * h, y: baseY - py * h };
+            scene.paths.push({
+                d: "M ".concat(p1.x, " ").concat(p1.y, " L ").concat(p2.x, " ").concat(p2.y, " L ").concat(p3.x, " ").concat(p3.y, " L ").concat(p4.x, " ").concat(p4.y, " Z"),
+                stroke: color,
+                strokeWidth: 1,
+                fill: 'none'
+            });
+            break;
+        }
+        case 'origin': {
+            var h = size * 0.5;
+            addLine(scene, { x: tip.x - h, y: tip.y }, { x: tip.x + h, y: tip.y }, color);
+            addLine(scene, { x: tip.x, y: tip.y - h }, { x: tip.x, y: tip.y + h }, color);
+            break;
+        }
+    }
+}
+function estimateTextWidth(text, fontSize) {
+    var e_1, _a;
+    var factor = 0;
+    try {
+        for (var text_1 = __values(text), text_1_1 = text_1.next(); !text_1_1.done; text_1_1 = text_1.next()) {
+            var char = text_1_1.value;
+            factor += /[\u3000-\u9fff\uff00-\uffef]/.test(char) ? 1 : 0.58;
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (text_1_1 && !text_1_1.done && (_a = text_1.return)) _a.call(text_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return factor * fontSize;
+}
+/** Convert MTEXT-style codes produced by the data model into plain SVG text. */
+function sanitizeDimensionText(raw) {
+    var decode = function (value) {
+        return value.replace(/%%d/gi, '°').replace(/%%c/gi, '⌀').replace(/%%p/gi, '±');
+    };
+    var replaceTolerance = function (text) {
+        return text
+            .replace(/\{\\H[0-9.]+x;\\S\+([^^;]*)\^-([^;]*);\}/g, function (_match, plus, minus) {
+            return plus === minus ? "\u00B1".concat(plus) : " ".concat(plus, "/").concat(minus);
+        })
+            .replace(/\\S\+([^^;]*)\^-([^;]*);/g, function (_match, plus, minus) {
+            return plus === minus ? "\u00B1".concat(plus) : " ".concat(plus, "/").concat(minus);
+        });
+    };
+    return replaceTolerance(decode(raw)).replace(/[{}]/g, '').trim();
+}
+function gcd(a, b) {
+    var x = Math.abs(a);
+    var y = Math.abs(b);
+    while (y) {
+        var temp = y;
+        y = x % y;
+        x = temp;
+    }
+    return x || 1;
+}
+function formatDecimal(value, decimals, separator) {
+    var fixed = value.toFixed(Math.max(0, decimals));
+    return separator && separator !== '.' ? fixed.replace('.', separator) : fixed;
+}
+function formatFractional(value, precision) {
+    var whole = Math.trunc(value);
+    var fraction = Math.abs(value - whole);
+    var denominator = Math.max(1, Math.pow(2, Math.min(6, Math.max(0, precision))));
+    var numerator = Math.round(fraction * denominator);
+    if (numerator === 0)
+        return String(whole);
+    if (numerator === denominator) {
+        return String(whole + (value < 0 ? -1 : 1));
+    }
+    var divisor = gcd(numerator, denominator);
+    numerator /= divisor;
+    var reducedDenominator = denominator / divisor;
+    if (whole === 0) {
+        return "".concat(value < 0 ? '-' : '').concat(numerator, "/").concat(reducedDenominator);
+    }
+    return "".concat(whole, " ").concat(numerator, "/").concat(reducedDenominator);
+}
+function formatArchitectural(value, precision) {
+    var sign = value < 0 ? '-' : '';
+    var absolute = Math.abs(value);
+    var feet = Math.trunc(absolute / 12);
+    var inches = absolute - feet * 12;
+    var inchText = formatFractional(inches, precision);
+    if (feet > 0) {
+        return "".concat(sign).concat(feet, "'-").concat(inchText, "\"");
+    }
+    return "".concat(sign).concat(inchText, "\"");
+}
+function formatEngineering(value, decimals) {
+    var feet = Math.trunc(value / 12);
+    var inches = value - feet * 12;
+    return "".concat(feet, "'-").concat(inches.toFixed(Math.max(0, decimals)), "\"");
+}
+function applyZeroSuppression(body, zin) {
+    var text = body;
+    if ((zin & 4) !== 0 && text.startsWith('0.')) {
+        text = text.slice(1);
+    }
+    if ((zin & 8) !== 0 && text.includes('.')) {
+        text = text.replace(/\.?0+$/, '');
+    }
+    return text;
+}
+function applyAngularZeroSuppression(body, azin) {
+    var text = body;
+    if ((azin === 1 || azin === 3) && text.startsWith('0.')) {
+        text = text.slice(1);
+    }
+    if (azin === 2 || azin === 3) {
+        text = text
+            .replace(/(\.\d*?)0+(%%d|g|r|"|')?$/, '$1$2')
+            .replace(/\.(%%d|g|r)/, '$1');
+    }
+    return text;
+}
+function applyDimPost(body, dimpost) {
+    if (!dimpost)
+        return body;
+    if (dimpost.includes('<>')) {
+        return dimpost.split('<>').join(body);
+    }
+    return "".concat(body).concat(dimpost);
+}
+/**
+ * Format the alternate-unit value shown in brackets after the primary
+ * measurement, honoring DIMALTF / DIMALTRND / DIMALTD / DIMALTU / DIMALTZ /
+ * DIMAPOST the same way the primary measurement honors DIMLFAC / DIMRND /
+ * DIMDEC / DIMLUNIT / DIMZIN / DIMPOST.
+ */
+function formatAlternateMeasurement(raw, style) {
+    var _a;
+    var value = raw * asNumber(style.dimlfac, 1) * (asNumber(style.dimaltf, 0) || 25.4);
+    var rounding = asNumber(style.dimaltrnd, 0);
+    if (rounding > 0) {
+        value = Math.round(value / rounding) * rounding;
+    }
+    var decimals = Math.max(0, asNumber(style.dimaltd, 2));
+    var separator = String(style.dimdsep || '.');
+    var body;
+    switch (asNumber(style.dimaltu, 2)) {
+        case 1:
+            body = value.toExponential(decimals);
+            break;
+        case 3:
+            body = formatEngineering(value, decimals);
+            break;
+        case 4:
+        case 6:
+            body = formatArchitectural(value, decimals);
+            break;
+        case 5:
+        case 7:
+            body = formatFractional(value, decimals);
+            break;
+        default:
+            body = formatDecimal(value, decimals, separator);
+            break;
+    }
+    body = applyZeroSuppression(body, asNumber(style.dimaltz, 0));
+    return applyDimPost(body, String((_a = style.dimapost) !== null && _a !== void 0 ? _a : ''));
+}
+/** Format a linear measurement using the same rules as the dimension renderer. */
+function formatLinearMeasurement(raw, style) {
+    var _a;
+    var value = raw * asNumber(style.dimlfac, 1);
+    var rounding = asNumber(style.dimrnd, 0);
+    if (rounding > 0) {
+        value = Math.round(value / rounding) * rounding;
+    }
+    var decimals = Math.max(0, asNumber(style.dimdec, 2));
+    var separator = String(style.dimdsep || '.');
+    var body;
+    switch (asNumber(style.dimlunit, 2)) {
+        case 1:
+            body = value.toExponential(decimals);
+            break;
+        case 3:
+            body = formatEngineering(value, decimals);
+            break;
+        case 4:
+            body = formatArchitectural(value, decimals);
+            break;
+        case 5:
+            body = formatFractional(value, decimals);
+            break;
+        default:
+            body = formatDecimal(value, decimals, separator);
+            break;
+    }
+    body = applyZeroSuppression(body, asNumber(style.dimzin, 0));
+    return applyDimPost(body, String((_a = style.dimpost) !== null && _a !== void 0 ? _a : ''));
+}
+/** Format an angular measurement using the dimension style angle settings. */
+function formatAngularMeasurement(radians, style) {
+    var _a;
+    var absolute = Math.abs(radians);
+    var decimals = Math.max(0, asNumber(style.dimadec, 0));
+    var separator = String(style.dimdsep || '.');
+    var body;
+    switch (asNumber(style.dimaunit, 0)) {
+        case 1: {
+            var total = (absolute * 180) / Math.PI;
+            var degrees = Math.floor(total);
+            var minutesFloat = (total - degrees) * 60;
+            var minutes = Math.floor(minutesFloat);
+            var seconds = (minutesFloat - minutes) * 60;
+            var secondsText = decimals > 0 ? seconds.toFixed(decimals) : String(Math.round(seconds));
+            body = "".concat(degrees, "d").concat(String(minutes).padStart(2, '0'), "'").concat(secondsText, "\"");
+            break;
+        }
+        case 2:
+            body = "".concat(formatDecimal((absolute * 200) / Math.PI, decimals, separator), "g");
+            break;
+        case 3:
+            body = "".concat(formatDecimal(absolute, decimals, separator), "r");
+            break;
+        default:
+            body = "".concat(formatDecimal((absolute * 180) / Math.PI, decimals, separator), "%%d");
+            break;
+    }
+    body = applyAngularZeroSuppression(body, asNumber(style.dimazin, 0));
+    return applyDimPost(body, String((_a = style.dimpost) !== null && _a !== void 0 ? _a : ''));
+}
+function resolveAnnotation(raw, style, kind) {
+    var text = kind === 'angular'
+        ? formatAngularMeasurement(raw, style)
+        : formatLinearMeasurement(raw, style);
+    if (kind === 'radial' && !text.startsWith('R')) {
+        text = "R".concat(text);
+    }
+    if (kind !== 'angular' && asNumber(style.dimtol, 0) === 1) {
+        var precision = Math.max(0, asNumber(style.dimtdec, 0));
+        var plus = asNumber(style.dimtp, 0).toFixed(precision);
+        var minus = asNumber(style.dimtm, 0).toFixed(precision);
+        text = "".concat(text, "{\\H0.7x;\\S+").concat(plus, "^-").concat(minus, ";}");
+    }
+    if (kind !== 'angular' && asNumber(style.dimalt, 0) === 1) {
+        var alternate = formatAlternateMeasurement(raw, style);
+        text = "".concat(text, " [").concat(alternate, "]");
+    }
+    return text;
+}
+function measuredText(style, raw, kind) {
+    return sanitizeDimensionText(resolveAnnotation(raw, style, kind));
+}
+/**
+ * Push a dimension text entry and attach the background fill / frame
+ * rectangle (DIMTFILL, negative DIMGAP) and the viewing direction
+ * (DIMTXTDIRECTION). `gap` is the drawing-unit text gap already in pixels.
+ */
+function pushDimensionText(scene, style, colors, entry) {
+    var _a;
+    var text = {
+        x: entry.x,
+        y: entry.y,
+        text: entry.text,
+        fontSize: entry.fontSize,
+        fill: colors.text,
+        textAnchor: entry.textAnchor,
+        rotation: entry.rotation
+    };
+    var showBackground = asNumber(style.dimtfill, 0) !== 0;
+    var frame = asNumber(style.dimgap, 1) < 0;
+    if (showBackground || frame) {
+        var width = estimateTextWidth(entry.text, entry.fontSize);
+        var pad = clamp(entry.gap, 1.5, 8);
+        var startX = entry.textAnchor === 'middle'
+            ? entry.x - width / 2
+            : entry.textAnchor === 'end'
+                ? entry.x - width
+                : entry.x;
+        text.box = {
+            x: startX - pad,
+            y: entry.y - entry.fontSize * 0.8 - pad,
+            w: width + 2 * pad,
+            h: entry.fontSize + 2 * pad
+        };
+        if (showBackground) {
+            if (asNumber(style.dimtfill, 0) === 1) {
+                // Drawing background color — the canvas of the preview panel.
+                text.background = 'var(--el-bg-color)';
+            }
+            else {
+                var color = acdbDecodeDimStyleColor(style.dimtfillclr);
+                text.background =
+                    (_a = color.cssColor) !== null && _a !== void 0 ? _a : (color.isForeground
+                        ? 'var(--el-text-color-primary)'
+                        : 'var(--el-bg-color)');
+            }
+        }
+        if (frame) {
+            text.frame = colors.text;
+        }
+    }
+    if (asNumber(style.dimtxtdirection, 0) === 1) {
+        text.mirror = true;
+    }
+    scene.texts.push(text);
+}
+/**
+ * Draw one linear/aligned dimension.
+ *
+ * `p1` and `p2` are the measured points, and the dimension line is offset
+ * along the left-hand normal of `p1 -> p2` by `offset` pixels.
+ */
+function addLinearDimension(scene, style, metrics, colors, arrow, p1, p2, offset, raw) {
+    var dx = p2.x - p1.x;
+    var dy = p2.y - p1.y;
+    var length = Math.hypot(dx, dy);
+    if (length <= 0.001)
+        return;
+    var ux = dx / length;
+    var uy = dy / length;
+    var nx = uy;
+    var ny = -ux;
+    var at = function (t, n) { return ({
+        x: p1.x + ux * t + nx * n,
+        y: p1.y + uy * t + ny * n
+    }); };
+    if (!asFlag(style.dimse1)) {
+        addLine(scene, at(0, metrics.exo), at(0, offset + metrics.exe), colors.extension, 1);
+    }
+    if (!asFlag(style.dimse2)) {
+        addLine(scene, at(length, metrics.exo), at(length, offset + metrics.exe), colors.extension, 1);
+    }
+    var text = measuredText(style, raw, 'linear');
+    var fontSize = metrics.text;
+    var textWidth = estimateTextWidth(text, fontSize);
+    var gap = metrics.gap;
+    var startT = -metrics.dle;
+    var endT = length + metrics.dle;
+    var textT = length / 2;
+    var anchor = 'middle';
+    var justification = asNumber(style.dimjust, 0);
+    if (justification === 1) {
+        textT = gap;
+        anchor = 'start';
+    }
+    else if (justification === 2) {
+        textT = length - gap;
+        anchor = 'end';
+    }
+    else if (justification === 3) {
+        textT = 0;
+        anchor = 'start';
+    }
+    else if (justification === 4) {
+        textT = length;
+        anchor = 'end';
+    }
+    var gapStart = anchor === 'start'
+        ? textT
+        : anchor === 'end'
+            ? textT - textWidth
+            : textT - textWidth / 2;
+    var gapEnd = anchor === 'start'
+        ? textT + textWidth
+        : anchor === 'end'
+            ? textT
+            : textT + textWidth / 2;
+    var suppressFirst = asFlag(style.dimsd1);
+    var suppressSecond = asFlag(style.dimsd2);
+    var textVertical = asNumber(style.dimtad, 0);
+    if (textVertical === 0) {
+        if (!suppressFirst) {
+            var segmentEnd = Math.min(gapStart, endT);
+            if (segmentEnd > startT) {
+                addLine(scene, at(startT, offset), at(segmentEnd, offset), colors.dimension);
+            }
+        }
+        if (!suppressSecond) {
+            var segmentStart = Math.max(gapEnd, startT);
+            if (segmentStart < endT) {
+                addLine(scene, at(segmentStart, offset), at(endT, offset), colors.dimension);
+            }
+        }
+    }
+    else if (!suppressFirst && !suppressSecond) {
+        addLine(scene, at(startT, offset), at(endT, offset), colors.dimension);
+    }
+    else if (!suppressFirst) {
+        var segmentEnd = Math.min(textT, endT);
+        if (segmentEnd > startT) {
+            addLine(scene, at(startT, offset), at(segmentEnd, offset), colors.dimension);
+        }
+    }
+    else if (!suppressSecond) {
+        var segmentStart = Math.max(textT, startT);
+        if (segmentStart < endT) {
+            addLine(scene, at(segmentStart, offset), at(endT, offset), colors.dimension);
+        }
+    }
+    if (!suppressFirst) {
+        addArrow(scene, at(0, offset), { x: -ux, y: -uy }, metrics.arrow, arrow, colors.dimension);
+    }
+    if (!suppressSecond) {
+        addArrow(scene, at(length, offset), { x: ux, y: uy }, metrics.arrow, arrow, colors.dimension);
+    }
+    var baseline;
+    if (textVertical === 0) {
+        baseline = offset + fontSize * 0.35;
+    }
+    else if (textVertical === 4) {
+        baseline = offset - gap - fontSize * 0.8;
+    }
+    else {
+        baseline = offset + gap + fontSize * 0.8;
+    }
+    var rotation = 0;
+    // Preview dimensions sit outside the extension lines, so text alignment
+    // follows DIMTOH (see the "Text alignment" option of the Text tab).
+    if (!asFlag(style.dimtoh)) {
+        rotation = (Math.atan2(uy, ux) * 180) / Math.PI;
+        if (rotation > 90)
+            rotation -= 180;
+        else if (rotation < -90)
+            rotation += 180;
+    }
+    var position = at(textT, baseline);
+    pushDimensionText(scene, style, colors, {
+        x: position.x,
+        y: position.y,
+        text: text,
+        fontSize: fontSize,
+        textAnchor: anchor,
+        rotation: rotation,
+        gap: gap
+    });
+}
+/** Draw the fillet radius dimension at the lower-left corner. */
+function addRadialDimension(scene, style, metrics, colors, arrow, center, radius, raw) {
+    var angle = (3 * Math.PI) / 4;
+    var rx = Math.cos(angle);
+    var ry = Math.sin(angle);
+    var arcPoint = {
+        x: center.x + rx * radius,
+        y: center.y + ry * radius
+    };
+    var elbow = {
+        x: arcPoint.x + rx * 24,
+        y: arcPoint.y + ry * 24
+    };
+    var landing = { x: elbow.x - 36, y: elbow.y };
+    addLine(scene, arcPoint, elbow, colors.dimension, 1);
+    addLine(scene, elbow, landing, colors.dimension, 1);
+    addArrow(scene, arcPoint, { x: rx, y: ry }, metrics.arrow, arrow, colors.dimension);
+    var text = measuredText(style, raw, 'radial');
+    var rotation = 0;
+    if (!asFlag(style.dimtoh)) {
+        rotation = (angle * 180) / Math.PI;
+        if (rotation > 90)
+            rotation -= 180;
+        else if (rotation < -90)
+            rotation += 180;
+    }
+    pushDimensionText(scene, style, colors, {
+        x: elbow.x - 4,
+        y: elbow.y - metrics.gap,
+        text: text,
+        fontSize: metrics.text,
+        textAnchor: 'end',
+        rotation: rotation,
+        gap: metrics.gap
+    });
+}
+/** Draw the angular dimension at the lower-right vertex. */
+function addAngularDimension(scene, style, metrics, colors, arrow, vertex, startDegrees, endDegrees, rawRadians) {
+    var radius = 66;
+    var start = (startDegrees * Math.PI) / 180;
+    var end = (endDegrees * Math.PI) / 180;
+    var startPoint = {
+        x: vertex.x + Math.cos(start) * radius,
+        y: vertex.y + Math.sin(start) * radius
+    };
+    var endPoint = {
+        x: vertex.x + Math.cos(end) * radius,
+        y: vertex.y + Math.sin(end) * radius
+    };
+    scene.paths.push({
+        d: "M ".concat(startPoint.x, " ").concat(startPoint.y, " A ").concat(radius, " ").concat(radius, " 0 0 1 ").concat(endPoint.x, " ").concat(endPoint.y),
+        stroke: colors.dimension,
+        strokeWidth: DIMENSION_STROKE,
+        fill: 'none'
+    });
+    addArrow(scene, startPoint, { x: Math.sin(start), y: -Math.cos(start) }, metrics.arrow, arrow, colors.dimension);
+    addArrow(scene, endPoint, { x: -Math.sin(end), y: Math.cos(end) }, metrics.arrow, arrow, colors.dimension);
+    var middle = (start + end) / 2;
+    var textRadius = radius + metrics.gap + metrics.text / 2 + 2;
+    var text = measuredText(style, rawRadians, 'angular');
+    var rotation = 0;
+    if (!asFlag(style.dimtoh)) {
+        rotation = (middle * 180) / Math.PI;
+        if (rotation > 90)
+            rotation -= 180;
+        else if (rotation < -90)
+            rotation += 180;
+    }
+    pushDimensionText(scene, style, colors, {
+        x: vertex.x + Math.cos(middle) * textRadius,
+        y: vertex.y + Math.sin(middle) * textRadius + metrics.text * 0.35,
+        text: text,
+        fontSize: metrics.text,
+        textAnchor: 'middle',
+        rotation: rotation,
+        gap: metrics.gap
+    });
+}
+/**
+ * Build a scene that mirrors the illustration shown in AutoCAD's Dimension
+ * Style Manager: a beveled plate with a rounded corner, a center mark, an
+ * aligned dimension, linear dimensions, a radius and an angular dimension.
+ */
+export function buildDimStylePreview(style) {
+    var source = style !== null && style !== void 0 ? style : DEFAULT_STYLE;
+    var scene = {
+        lines: [],
+        paths: [],
+        circles: [],
+        texts: []
+    };
+    var colors = {
+        geometry: UI.text,
+        dimension: resolveColor(source.dimclrd, UI.accent),
+        extension: resolveColor(source.dimclre, UI.textMuted),
+        text: resolveColor(source.dimclrt, UI.text)
+    };
+    var tickSize = asNumber(source.dimtsz, 0);
+    var metrics = {
+        text: clamp(asNumber(source.dimtxt, 2.5) * PX_PER_UNIT, 7, 20),
+        arrow: tickSize > 0
+            ? clamp(tickSize * PX_PER_UNIT * 2, 3, 20)
+            : clamp(asNumber(source.dimasz, 2.5) * PX_PER_UNIT, 3, 20),
+        // DIMGAP magnitude drives spacing; a negative value only means "draw frame".
+        gap: clamp(Math.abs(asNumber(source.dimgap, 1)) * PX_PER_UNIT, 1.5, 12),
+        exo: clamp(asNumber(source.dimexo, 0.625) * PX_PER_UNIT, 0, 12),
+        exe: clamp(asNumber(source.dimexe, 0.18) * PX_PER_UNIT, 0, 12),
+        dle: clamp(asNumber(source.dimdle, 0) * PX_PER_UNIT, 0, 16)
+    };
+    var arrow = classifyArrow(source);
+    var corner = { x: 96, y: 72 };
+    var armEnd = { x: 210, y: 72 };
+    var bevelEnd = { x: 313, y: 104 };
+    var rightBottom = { x: 332, y: 212 };
+    var bottomStart = { x: 144, y: 212 };
+    var filletStart = { x: 96, y: 164 };
+    var filletRadius = 48;
+    var filletCenter = { x: 144, y: 164 };
+    var holeCenter = { x: 185, y: 146 };
+    var holeRadius = 42;
+    scene.paths.push({
+        d: "M ".concat(corner.x, " ").concat(corner.y, " L ").concat(armEnd.x, " ").concat(armEnd.y, " ") +
+            "L ".concat(bevelEnd.x, " ").concat(bevelEnd.y, " L ").concat(rightBottom.x, " ").concat(rightBottom.y, " ") +
+            "L ".concat(bottomStart.x, " ").concat(bottomStart.y, " ") +
+            "A ".concat(filletRadius, " ").concat(filletRadius, " 0 0 1 ").concat(filletStart.x, " ").concat(filletStart.y, " Z"),
+        stroke: colors.geometry,
+        strokeWidth: GEOMETRY_STROKE,
+        fill: 'none'
+    });
+    scene.circles.push({
+        cx: holeCenter.x,
+        cy: holeCenter.y,
+        r: holeRadius,
+        stroke: colors.geometry,
+        strokeWidth: GEOMETRY_STROKE,
+        fill: 'none'
+    });
+    var centerMark = asNumber(source.dimcen, 2.5);
+    if (Math.abs(centerMark) > 0.0001) {
+        var half = centerMark < 0
+            ? holeRadius + Math.abs(centerMark) * PX_PER_UNIT * 0.6
+            : Math.max(6, Math.min(holeRadius - 4, Math.abs(centerMark) * PX_PER_UNIT * 0.9));
+        addLine(scene, { x: holeCenter.x - half, y: holeCenter.y }, { x: holeCenter.x + half, y: holeCenter.y }, colors.extension, 1);
+        addLine(scene, { x: holeCenter.x, y: holeCenter.y - half }, { x: holeCenter.x, y: holeCenter.y + half }, colors.extension, 1);
+    }
+    addLinearDimension(scene, source, metrics, colors, arrow, corner, armEnd, 28, 1);
+    addLinearDimension(scene, source, metrics, colors, arrow, filletStart, corner, 28, 1.75);
+    addLinearDimension(scene, source, metrics, colors, arrow, bevelEnd, rightBottom, 28, 2);
+    addRadialDimension(scene, source, metrics, colors, arrow, filletCenter, filletRadius, 0.5);
+    addAngularDimension(scene, source, metrics, colors, arrow, rightBottom, 180, 260, (80 * Math.PI) / 180);
+    return scene;
+}
+//# sourceMappingURL=dimStylePreview.js.map