@mlightcad/cad-simple-viewer 1.5.10 → 1.6.0

package/lib/command/draw/AcApRevCloudCmd.js

@@ -0,0 +1,747 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+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 { AcDbPolyline, AcGePoint2d, AcGePoint3d, AcGeTol } from '@mlightcad/data-model';
+import { AcApDocManager } from '../../app';
+import { AcEdCommand, AcEdOpenMode, AcEdPreviewJig, AcEdPromptDistanceOptions, AcEdPromptEntityOptions, AcEdPromptKeywordOptions, AcEdPromptPointOptions, AcEdPromptStateMachine, AcEdPromptStatus } from '../../editor';
+import { AcApI18n } from '../../i18n';
+import { buildRevCloud, defaultRevCloudArcLength, distance2d, isRevCloudCloseToStart, rectanglePath, sampleEntityPath } from './AcApRevCloudGeom';
+var DEFAULT_SETTINGS = {
+    mode: 'rectangular',
+    style: 'normal',
+    variance: true
+};
+function addKeyword(prompt, key) {
+    prompt.keywords.add(AcApI18n.t("jig.revcloud.keywords.".concat(key, ".display")), AcApI18n.t("jig.revcloud.keywords.".concat(key, ".global")), AcApI18n.t("jig.revcloud.keywords.".concat(key, ".local")));
+}
+function toPoint2d(point) {
+    return new AcGePoint2d(point.x, point.y);
+}
+function applyCloud(cloud, path, closed, settings, reverse) {
+    var _a;
+    if (reverse === void 0) { reverse = false; }
+    return buildRevCloud(cloud, path, closed, {
+        arcLength: (_a = settings.arcLength) !== null && _a !== void 0 ? _a : 1,
+        style: settings.style,
+        variance: settings.variance,
+        reverse: reverse
+    });
+}
+/**
+ * Live preview for rectangular / polygonal / freehand revision clouds.
+ */
+var AcApRevCloudJig = /** @class */ (function (_super) {
+    __extends(AcApRevCloudJig, _super);
+    function AcApRevCloudJig(view, path, closed, settings) {
+        var _this = _super.call(this, view) || this;
+        _this._cloud = new AcDbPolyline();
+        _this._path = path.map(toPoint2d);
+        _this._closed = closed;
+        _this._settings = settings;
+        _this.rebuild();
+        return _this;
+    }
+    Object.defineProperty(AcApRevCloudJig.prototype, "entity", {
+        get: function () {
+            return this._cloud;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApRevCloudJig.prototype.updatePath = function (path, closed) {
+        this._path = path.map(toPoint2d);
+        this._closed = closed;
+        this.rebuild();
+    };
+    AcApRevCloudJig.prototype.update = function (point) {
+        if (this._path.length === 0)
+            return;
+        var preview = __spreadArray(__spreadArray([], __read(this._path), false), [toPoint2d(point)], false);
+        var closed = this._closed && preview.length >= 3;
+        applyCloud(this._cloud, preview, closed, this._settings);
+    };
+    AcApRevCloudJig.prototype.rebuild = function () {
+        if (this._path.length < 2) {
+            this._cloud.reset(false);
+            return;
+        }
+        applyCloud(this._cloud, this._path, this._closed, this._settings);
+    };
+    return AcApRevCloudJig;
+}(AcEdPreviewJig));
+export { AcApRevCloudJig };
+var AcApRevCloudRectJig = /** @class */ (function (_super) {
+    __extends(AcApRevCloudRectJig, _super);
+    function AcApRevCloudRectJig(view, start, settings) {
+        var _this = _super.call(this, view) || this;
+        _this._cloud = new AcDbPolyline();
+        _this._firstPoint = toPoint2d(start);
+        _this._settings = settings;
+        return _this;
+    }
+    Object.defineProperty(AcApRevCloudRectJig.prototype, "entity", {
+        get: function () {
+            return this._cloud;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApRevCloudRectJig.prototype.update = function (secondPoint) {
+        applyCloud(this._cloud, rectanglePath(this._firstPoint, secondPoint), true, this._settings);
+    };
+    return AcApRevCloudRectJig;
+}(AcEdPreviewJig));
+var AcApRevCloudFreehandJig = /** @class */ (function (_super) {
+    __extends(AcApRevCloudFreehandJig, _super);
+    function AcApRevCloudFreehandJig(view, start, settings) {
+        var _this = _super.call(this, view) || this;
+        _this._closed = false;
+        _this._cloud = new AcDbPolyline();
+        _this._points = [toPoint2d(start)];
+        _this._settings = settings;
+        return _this;
+    }
+    Object.defineProperty(AcApRevCloudFreehandJig.prototype, "entity", {
+        get: function () {
+            return this._cloud;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApRevCloudFreehandJig.prototype, "points", {
+        get: function () {
+            return this._points;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApRevCloudFreehandJig.prototype, "closed", {
+        get: function () {
+            return this._closed;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApRevCloudFreehandJig.prototype.addPoint = function (point) {
+        var next = toPoint2d(point);
+        var last = this._points[this._points.length - 1];
+        if (last && distance2d(last, next) < 1e-8)
+            return;
+        this._points.push(next);
+    };
+    AcApRevCloudFreehandJig.prototype.update = function (current) {
+        var _a;
+        var arcLength = (_a = this._settings.arcLength) !== null && _a !== void 0 ? _a : 1;
+        var last = this._points[this._points.length - 1];
+        if (last && distance2d(last, current) >= arcLength) {
+            this._points.push(toPoint2d(current));
+        }
+        this._closed =
+            this._points.length >= 3 &&
+                isRevCloudCloseToStart(this._points[0], current, arcLength);
+        var preview = this._closed
+            ? this._points
+            : __spreadArray(__spreadArray([], __read(this._points), false), [toPoint2d(current)], false);
+        applyCloud(this._cloud, preview, this._closed, this._settings);
+    };
+    return AcApRevCloudFreehandJig;
+}(AcEdPreviewJig));
+/**
+ * Static cloud preview used while prompting for Reverse direction.
+ *
+ * Keyword prompts do not drive jig updates, so this jig keeps the finished
+ * cloud visible and rebuilds it when the user toggles reverse.
+ */
+var AcApRevCloudStaticJig = /** @class */ (function (_super) {
+    __extends(AcApRevCloudStaticJig, _super);
+    function AcApRevCloudStaticJig(view, path, closed, settings) {
+        var _this = _super.call(this, view) || this;
+        _this._reverse = false;
+        _this._cloud = new AcDbPolyline();
+        _this._path = path;
+        _this._closed = closed;
+        _this._settings = settings;
+        _this._valid = applyCloud(_this._cloud, path, closed, settings);
+        return _this;
+    }
+    Object.defineProperty(AcApRevCloudStaticJig.prototype, "entity", {
+        get: function () {
+            return this._cloud;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApRevCloudStaticJig.prototype, "valid", {
+        get: function () {
+            return this._valid;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcApRevCloudStaticJig.prototype, "reverse", {
+        get: function () {
+            return this._reverse;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AcApRevCloudStaticJig.prototype.update = function (_value) {
+        // Keyword prompt: geometry is rebuilt only when reverse is toggled.
+    };
+    AcApRevCloudStaticJig.prototype.toggleReverse = function () {
+        this._reverse = !this._reverse;
+        this._valid = applyCloud(this._cloud, this._path, this._closed, this._settings, this._reverse);
+        this.render();
+    };
+    return AcApRevCloudStaticJig;
+}(AcEdPreviewJig));
+/**
+ * Command to create a revision cloud, aligned with AutoCAD REVCLOUD.
+ *
+ * Supports Rectangular (default), Polygonal, Freehand, Object conversion,
+ * Arc length, Style (Normal/Calligraphy), and Reverse direction.
+ */
+var AcApRevCloudCmd = /** @class */ (function (_super) {
+    __extends(AcApRevCloudCmd, _super);
+    function AcApRevCloudCmd() {
+        var _this = _super.call(this) || this;
+        _this.mode = AcEdOpenMode.Write;
+        return _this;
+    }
+    AcApRevCloudCmd.prototype.execute = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var settings, prompt_1, rectangular, polygonal, freehand, result, keyword, accepted, accepted;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        settings = AcApRevCloudCmd._settings;
+                        if (settings.arcLength == null) {
+                            settings.arcLength = defaultRevCloudArcLength(context.view);
+                        }
+                        _b.label = 1;
+                    case 1:
+                        if (!true) return [3 /*break*/, 22];
+                        prompt_1 = new AcEdPromptPointOptions(AcApI18n.t('jig.revcloud.firstCornerOrOptions'));
+                        addKeyword(prompt_1, 'arcLength');
+                        addKeyword(prompt_1, 'object');
+                        rectangular = prompt_1.keywords.add(AcApI18n.t('jig.revcloud.keywords.rectangular.display'), AcApI18n.t('jig.revcloud.keywords.rectangular.global'), AcApI18n.t('jig.revcloud.keywords.rectangular.local'));
+                        polygonal = prompt_1.keywords.add(AcApI18n.t('jig.revcloud.keywords.polygonal.display'), AcApI18n.t('jig.revcloud.keywords.polygonal.global'), AcApI18n.t('jig.revcloud.keywords.polygonal.local'));
+                        freehand = prompt_1.keywords.add(AcApI18n.t('jig.revcloud.keywords.freehand.display'), AcApI18n.t('jig.revcloud.keywords.freehand.global'), AcApI18n.t('jig.revcloud.keywords.freehand.local'));
+                        addKeyword(prompt_1, 'style');
+                        prompt_1.keywords.default =
+                            settings.mode === 'polygonal'
+                                ? polygonal
+                                : settings.mode === 'freehand'
+                                    ? freehand
+                                    : rectangular;
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt_1)];
+                    case 2:
+                        result = _b.sent();
+                        if (!(result.status === AcEdPromptStatus.Keyword)) return [3 /*break*/, 15];
+                        keyword = (_a = result.stringResult) !== null && _a !== void 0 ? _a : '';
+                        if (!(keyword === 'ArcLength')) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.promptArcLength(settings)];
+                    case 3:
+                        accepted = _b.sent();
+                        if (!accepted)
+                            return [2 /*return*/];
+                        return [3 /*break*/, 1];
+                    case 4:
+                        if (!(keyword === 'Object')) return [3 /*break*/, 6];
+                        return [4 /*yield*/, this.convertObject(context, settings)];
+                    case 5:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 6:
+                        if (!(keyword === 'Rectangular')) return [3 /*break*/, 8];
+                        settings.mode = 'rectangular';
+                        return [4 /*yield*/, this.drawRectangular(context, settings)];
+                    case 7:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 8:
+                        if (!(keyword === 'Polygonal')) return [3 /*break*/, 10];
+                        settings.mode = 'polygonal';
+                        return [4 /*yield*/, this.drawPolygonal(context, settings)];
+                    case 9:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 10:
+                        if (!(keyword === 'Freehand')) return [3 /*break*/, 12];
+                        settings.mode = 'freehand';
+                        return [4 /*yield*/, this.drawFreehand(context, settings)];
+                    case 11:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 12:
+                        if (!(keyword === 'Style')) return [3 /*break*/, 14];
+                        return [4 /*yield*/, this.promptStyle(settings)];
+                    case 13:
+                        accepted = _b.sent();
+                        if (!accepted)
+                            return [2 /*return*/];
+                        return [3 /*break*/, 1];
+                    case 14: return [3 /*break*/, 1];
+                    case 15:
+                        if (result.status !== AcEdPromptStatus.OK || !result.value)
+                            return [2 /*return*/];
+                        if (!(settings.mode === 'polygonal')) return [3 /*break*/, 17];
+                        return [4 /*yield*/, this.drawPolygonal(context, settings, result.value)];
+                    case 16:
+                        _b.sent();
+                        return [3 /*break*/, 21];
+                    case 17:
+                        if (!(settings.mode === 'freehand')) return [3 /*break*/, 19];
+                        return [4 /*yield*/, this.drawFreehand(context, settings, result.value)];
+                    case 18:
+                        _b.sent();
+                        return [3 /*break*/, 21];
+                    case 19: return [4 /*yield*/, this.drawRectangular(context, settings, result.value)];
+                    case 20:
+                        _b.sent();
+                        _b.label = 21;
+                    case 21: return [2 /*return*/];
+                    case 22: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.promptArcLength = function (settings) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result, value;
+            var _a, _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        prompt = new AcEdPromptDistanceOptions(AcApI18n.t('jig.revcloud.arcLength'));
+                        prompt.allowNegative = false;
+                        prompt.allowZero = false;
+                        prompt.useDefaultValue = settings.arcLength != null;
+                        prompt.defaultValue = (_a = settings.arcLength) !== null && _a !== void 0 ? _a : 1;
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getDistance(prompt)];
+                    case 1:
+                        result = _c.sent();
+                        if (result.status !== AcEdPromptStatus.OK &&
+                            result.status !== AcEdPromptStatus.None) {
+                            return [2 /*return*/, false];
+                        }
+                        value = (_b = result.value) !== null && _b !== void 0 ? _b : prompt.defaultValue;
+                        if (!AcGeTol.isPositive(value)) {
+                            this.showMessage(AcApI18n.t('jig.revcloud.invalidArcLength'), 'warning');
+                            return [2 /*return*/, true];
+                        }
+                        settings.arcLength = value;
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.promptStyle = function (settings) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, normal, calligraphy, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptKeywordOptions(AcApI18n.t('jig.revcloud.style'));
+                        prompt.allowNone = true;
+                        normal = prompt.keywords.add(AcApI18n.t('jig.revcloud.keywords.normal.display'), AcApI18n.t('jig.revcloud.keywords.normal.global'), AcApI18n.t('jig.revcloud.keywords.normal.local'));
+                        calligraphy = prompt.keywords.add(AcApI18n.t('jig.revcloud.keywords.calligraphy.display'), AcApI18n.t('jig.revcloud.keywords.calligraphy.global'), AcApI18n.t('jig.revcloud.keywords.calligraphy.local'));
+                        prompt.keywords.default =
+                            settings.style === 'calligraphy' ? calligraphy : normal;
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getKeywords(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        if (result.status === AcEdPromptStatus.Cancel)
+                            return [2 /*return*/, false];
+                        if (result.status === AcEdPromptStatus.OK ||
+                            result.status === AcEdPromptStatus.Keyword) {
+                            if (result.stringResult === 'Calligraphy') {
+                                settings.style = 'calligraphy';
+                            }
+                            else if (result.stringResult === 'Normal') {
+                                settings.style = 'normal';
+                            }
+                        }
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.drawRectangular = function (context, settings, firstPoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, _a, prompt, result, path;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(firstPoint !== null && firstPoint !== void 0)) return [3 /*break*/, 1];
+                        _a = firstPoint;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.promptPoint('firstCorner')];
+                    case 2:
+                        _a = (_b.sent());
+                        _b.label = 3;
+                    case 3:
+                        start = _a;
+                        if (!start)
+                            return [2 /*return*/];
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t('jig.revcloud.oppositeCorner'));
+                        prompt.useBasePoint = true;
+                        prompt.basePoint = new AcGePoint3d(start.x, start.y, 0);
+                        prompt.useDashedLine = false;
+                        prompt.jig = new AcApRevCloudRectJig(context.view, start, settings);
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 4:
+                        result = _b.sent();
+                        if (result.status !== AcEdPromptStatus.OK || !result.value)
+                            return [2 /*return*/];
+                        path = rectanglePath(start, result.value);
+                        if (AcGeTol.equalToZero(path[0].x - path[1].x) ||
+                            AcGeTol.equalToZero(path[0].y - path[3].y)) {
+                            return [2 /*return*/];
+                        }
+                        return [4 /*yield*/, this.commitCloud(context, path, true, settings)];
+                    case 5:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.drawPolygonal = function (context, settings, firstPoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, _a, points, NextPointState, machine;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!(firstPoint !== null && firstPoint !== void 0)) return [3 /*break*/, 1];
+                        _a = firstPoint;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.promptPoint('startPoint')];
+                    case 2:
+                        _a = (_b.sent());
+                        _b.label = 3;
+                    case 3:
+                        start = _a;
+                        if (!start)
+                            return [2 /*return*/];
+                        points = [toPoint2d(start)];
+                        NextPointState = /** @class */ (function () {
+                            function NextPointState() {
+                            }
+                            NextPointState.prototype.buildPrompt = function () {
+                                var prompt = new AcEdPromptPointOptions(AcApI18n.t(points.length >= 2
+                                    ? 'jig.revcloud.nextPointOrUndo'
+                                    : 'jig.revcloud.nextPoint'));
+                                if (points.length >= 2) {
+                                    addKeyword(prompt, 'undo');
+                                }
+                                prompt.useDashedLine = false;
+                                prompt.useBasePoint = true;
+                                var current = points[points.length - 1];
+                                prompt.basePoint = new AcGePoint3d(current.x, current.y, 0);
+                                prompt.allowNone = points.length >= 3;
+                                prompt.jig = new AcApRevCloudJig(context.view, points, true, settings);
+                                return prompt;
+                            };
+                            NextPointState.prototype.handleResult = function (result) {
+                                return __awaiter(this, void 0, void 0, function () {
+                                    return __generator(this, function (_a) {
+                                        if (result.status === AcEdPromptStatus.Keyword) {
+                                            if (result.stringResult === 'Undo' && points.length > 1) {
+                                                points.pop();
+                                            }
+                                            return [2 /*return*/, 'continue'];
+                                        }
+                                        if (result.status === AcEdPromptStatus.OK && result.value) {
+                                            points.push(toPoint2d(result.value));
+                                            return [2 /*return*/, 'continue'];
+                                        }
+                                        return [2 /*return*/, 'finish'];
+                                    });
+                                });
+                            };
+                            return NextPointState;
+                        }());
+                        machine = new AcEdPromptStateMachine();
+                        machine.setState(new NextPointState());
+                        return [4 /*yield*/, machine.run(function (prompt) { return AcApDocManager.instance.editor.getPoint(prompt); })];
+                    case 4:
+                        _b.sent();
+                        if (points.length < 3)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.commitCloud(context, points, true, settings)];
+                    case 5:
+                        _b.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.drawFreehand = function (context, settings, firstPoint) {
+        return __awaiter(this, void 0, void 0, function () {
+            var start, _a, jig, arcLength, prompt_2, result;
+            var _b;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(firstPoint !== null && firstPoint !== void 0)) return [3 /*break*/, 1];
+                        _a = firstPoint;
+                        return [3 /*break*/, 3];
+                    case 1: return [4 /*yield*/, this.promptPoint('firstPoint')];
+                    case 2:
+                        _a = (_c.sent());
+                        _c.label = 3;
+                    case 3:
+                        start = _a;
+                        if (!start)
+                            return [2 /*return*/];
+                        jig = new AcApRevCloudFreehandJig(context.view, start, settings);
+                        arcLength = (_b = settings.arcLength) !== null && _b !== void 0 ? _b : 1;
+                        _c.label = 4;
+                    case 4:
+                        if (!true) return [3 /*break*/, 10];
+                        prompt_2 = new AcEdPromptPointOptions(AcApI18n.t('jig.revcloud.guideCursor'));
+                        prompt_2.jig = jig;
+                        prompt_2.useDashedLine = false;
+                        prompt_2.useBasePoint = true;
+                        prompt_2.basePoint = new AcGePoint3d(start.x, start.y, 0);
+                        prompt_2.allowNone = true;
+                        prompt_2.disableOSnap = true;
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt_2)];
+                    case 5:
+                        result = _c.sent();
+                        if (result.status === AcEdPromptStatus.Cancel)
+                            return [2 /*return*/];
+                        if (!(result.status === AcEdPromptStatus.None)) return [3 /*break*/, 7];
+                        if (jig.points.length < 2)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.commitCloud(context, jig.points, jig.closed, settings)];
+                    case 6:
+                        _c.sent();
+                        return [2 /*return*/];
+                    case 7:
+                        if (result.status !== AcEdPromptStatus.OK || !result.value)
+                            return [2 /*return*/];
+                        if (!(jig.points.length >= 3 &&
+                            isRevCloudCloseToStart(jig.points[0], result.value, arcLength))) return [3 /*break*/, 9];
+                        return [4 /*yield*/, this.commitCloud(context, jig.points, true, settings)];
+                    case 8:
+                        _c.sent();
+                        return [2 /*return*/];
+                    case 9:
+                        jig.addPoint(result.value);
+                        return [3 /*break*/, 4];
+                    case 10: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.convertObject = function (context, settings) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt_3, result, entity, sampled, committed;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!true) return [3 /*break*/, 3];
+                        prompt_3 = new AcEdPromptEntityOptions(AcApI18n.t('jig.revcloud.selectObject'));
+                        prompt_3.setRejectMessage(AcApI18n.t('jig.revcloud.invalidObject'));
+                        prompt_3.addAllowedClass('Polyline');
+                        prompt_3.addAllowedClass('Circle');
+                        prompt_3.addAllowedClass('Ellipse');
+                        prompt_3.addAllowedClass('Spline');
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getEntity(prompt_3)];
+                    case 1:
+                        result = _b.sent();
+                        if (result.status !== AcEdPromptStatus.OK || !result.objectId)
+                            return [2 /*return*/];
+                        entity = context.doc.database.openEntityForRead(result.objectId);
+                        if (!entity)
+                            return [2 /*return*/];
+                        sampled = sampleEntityPath(entity, ((_a = settings.arcLength) !== null && _a !== void 0 ? _a : 1) * 0.5);
+                        if (!sampled) {
+                            this.showMessage(AcApI18n.t('jig.revcloud.invalidObject'), 'warning');
+                            return [3 /*break*/, 0];
+                        }
+                        return [4 /*yield*/, this.commitCloud(context, sampled.points, sampled.closed, settings)];
+                    case 2:
+                        committed = _b.sent();
+                        if (committed) {
+                            this.eraseEntity(context, entity);
+                        }
+                        return [2 /*return*/];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.commitCloud = function (context, path, closed, settings) {
+        return __awaiter(this, void 0, void 0, function () {
+            var preview, cloud;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        preview = new AcApRevCloudStaticJig(context.view, path, closed, settings);
+                        if (!preview.valid)
+                            return [2 /*return*/, false];
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 5, 6]);
+                        _a.label = 2;
+                    case 2:
+                        if (!true) return [3 /*break*/, 4];
+                        preview.render();
+                        return [4 /*yield*/, this.promptReverse(preview)];
+                    case 3:
+                        if (!(_a.sent()))
+                            return [3 /*break*/, 4];
+                        preview.toggleReverse();
+                        return [3 /*break*/, 2];
+                    case 4:
+                        cloud = new AcDbPolyline();
+                        if (!applyCloud(cloud, path, closed, settings, preview.reverse)) {
+                            return [2 /*return*/, false];
+                        }
+                        context.doc.database.tables.blockTable.modelSpace.appendEntity(cloud);
+                        return [2 /*return*/, true];
+                    case 5:
+                        preview.end();
+                        return [7 /*endfinally*/];
+                    case 6: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.promptReverse = function (preview) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, no, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptKeywordOptions(AcApI18n.t('jig.revcloud.reverseDirection'));
+                        prompt.jig = preview;
+                        prompt.allowNone = true;
+                        addKeyword(prompt, 'yes');
+                        no = prompt.keywords.add(AcApI18n.t('jig.revcloud.keywords.no.display'), AcApI18n.t('jig.revcloud.keywords.no.global'), AcApI18n.t('jig.revcloud.keywords.no.local'));
+                        prompt.keywords.default = no;
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getKeywords(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, ((result.status === AcEdPromptStatus.OK ||
+                                result.status === AcEdPromptStatus.Keyword) &&
+                                result.stringResult === 'Yes')];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.promptPoint = function (messageKey) {
+        return __awaiter(this, void 0, void 0, function () {
+            var prompt, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        prompt = new AcEdPromptPointOptions(AcApI18n.t("jig.revcloud.".concat(messageKey)));
+                        return [4 /*yield*/, AcApDocManager.instance.editor.getPoint(prompt)];
+                    case 1:
+                        result = _a.sent();
+                        if (result.status !== AcEdPromptStatus.OK || !result.value)
+                            return [2 /*return*/, undefined];
+                        return [2 /*return*/, result.value];
+                }
+            });
+        });
+    };
+    AcApRevCloudCmd.prototype.eraseEntity = function (context, entity) {
+        entity.erase();
+        context.view.removeEntity(entity);
+    };
+    AcApRevCloudCmd._settings = __assign({}, DEFAULT_SETTINGS);
+    return AcApRevCloudCmd;
+}(AcEdCommand));
+export { AcApRevCloudCmd };
+//# sourceMappingURL=AcApRevCloudCmd.js.map