@mlightcad/cad-simple-viewer 1.2.4 → 1.2.5

package/lib/editor/input/AcEdJig.d.ts

@@ -1,180 +0,0 @@
-import { AcEdBaseView } from '../view';
-/**
- * Base class for interactive drawing operations (jigs) in the CAD editor.
- *
- * A jig is an interactive operation that allows users to dynamically preview
- * and modify geometric elements during creation. Common examples include:
- * - Drawing lines with real-time preview as the mouse moves
- * - Selecting rectangular areas with visual feedback
- * - Dynamic entity placement with instant visual updates
- *
- * The jig system provides:
- * - Real-time visual feedback during user interaction
- * - Event-driven updates based on mouse movement
- * - Asynchronous completion handling
- * - Cancellation and error handling
- *
- * @template TResult - The type of result returned when the jig completes
- *
- * @example
- * ```typescript
- * class RectangleSelectionJig extends AcEdJig<Rectangle> {
- *   private startPoint?: Point;
- *   private currentPoint?: Point;
- *
- *   async sampler() {
- *     // Get start point
- *     this.startPoint = await this.view.editor.getPoint();
- *
- *     // Continue updating until complete
- *     this.view.events.mouseMove.addEventListener(this.onMouseMove);
- *   }
- *
- *   update() {
- *     if (this.startPoint && this.currentPoint) {
- *       // Update preview rectangle
- *       this.drawPreviewRectangle(this.startPoint, this.currentPoint);
- *     }
- *   }
- *
- *   private onMouseMove = (args) => {
- *     this.currentPoint = args;
- *     // Jig loop will call update() automatically
- *   }
- * }
- *
- * // Usage
- * const jig = new RectangleSelectionJig(view);
- * const rectangle = await jig.drag();
- * ```
- */
-export declare class AcEdJig<TResult> {
-    /** Internal jig loop that handles the interactive operation */
-    private _jigLoop;
-    /** The view associated with this jig */
-    private _view;
-    /**
-     * Creates a new jig instance for the specified view.
-     *
-     * Sets up the jig loop and connects update event handling.
-     *
-     * @param view - The view this jig will operate in
-     */
-    constructor(view: AcEdBaseView);
-    /**
-     * Gets the view associated with this jig.
-     *
-     * @returns The view instance
-     */
-    get view(): AcEdBaseView;
-    /**
-     * Resolves the jig operation with the specified result.
-     *
-     * This method should be called when the jig operation completes successfully.
-     * It cleans up event listeners and resolves the underlying promise.
-     *
-     * @param result - The result to return from the jig operation
-     *
-     * @example
-     * ```typescript
-     * // In a line drawing jig, when user completes the line
-     * if (this.hasValidEndPoint()) {
-     *   const line = new Line(this.startPoint, this.endPoint);
-     *   this.resolve(line);
-     * }
-     * ```
-     */
-    resolve(result: TResult): void;
-    /**
-     * Rejects the jig operation with an error.
-     *
-     * This method should be called when the jig operation fails or is cancelled.
-     * It cleans up event listeners and rejects the underlying promise.
-     *
-     * @param reason - The reason for the rejection
-     *
-     * @example
-     * ```typescript
-     * // If user cancels or invalid input is detected
-     * if (userPressedEscape) {
-     *   this.reject('Operation cancelled by user');
-     * }
-     * ```
-     */
-    reject(reason: string): void;
-    /**
-     * Starts the interactive jig operation.
-     *
-     * This method initiates both the jig loop and the sampling process.
-     * It returns a promise that resolves when the jig operation completes
-     * or rejects if an error occurs.
-     *
-     * @returns Promise that resolves when the jig operation completes
-     *
-     * @example
-     * ```typescript
-     * const jig = new MyCustomJig(view);
-     * try {
-     *   const result = await jig.drag();
-     *   console.log('Jig completed with result:', result);
-     * } catch (error) {
-     *   console.log('Jig was cancelled or failed:', error);
-     * }
-     * ```
-     */
-    drag(): Promise<void>;
-    /**
-     * Abstract method for handling jig input sampling.
-     *
-     * This method should be overridden by subclasses to implement
-     * the specific input handling logic for the jig. It typically:
-     * - Gets initial user input (like a start point)
-     * - Sets up event listeners for dynamic updates
-     * - Handles user interaction until completion
-     *
-     * The sampler runs concurrently with the jig loop and should
-     * call `resolve()` or `reject()` when the operation completes.
-     *
-     * @example
-     * ```typescript
-     * async sampler() {
-     *   // Get initial point
-     *   const startPoint = await this.view.editor.getPoint();
-     *
-     *   // Set up mouse tracking for dynamic preview
-     *   this.view.events.mouseMove.addEventListener(this.onMouseMove);
-     *   this.view.events.mouseClick.addEventListener(this.onMouseClick);
-     * }
-     * ```
-     */
-    sampler(): Promise<void>;
-    /**
-     * Called during each update cycle to refresh the jig display.
-     *
-     * This method should be overridden by subclasses to implement
-     * the visual update logic. It's called automatically by the jig loop
-     * whenever the display needs to be refreshed (typically on mouse movement).
-     *
-     * Common update operations include:
-     * - Redrawing preview geometry
-     * - Updating dimension displays
-     * - Refreshing visual feedback elements
-     *
-     * @example
-     * ```typescript
-     * update() {
-     *   if (this.startPoint && this.currentMousePoint) {
-     *     // Clear previous preview
-     *     this.clearPreview();
-     *
-     *     // Draw new preview line
-     *     this.drawPreviewLine(this.startPoint, this.currentMousePoint);
-     *   }
-     * }
-     * ```
-     */
-    update(): void;
-    /** Internal event handler for jig loop updates */
-    private onUpdate;
-}
-//# sourceMappingURL=AcEdJig.d.ts.map

package/lib/editor/input/AcEdJig.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcEdJig.d.ts","sourceRoot":"","sources":["../../../src/editor/input/AcEdJig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,qBAAa,OAAO,CAAC,OAAO;IAC1B,+DAA+D;IAC/D,OAAO,CAAC,QAAQ,CAAsB;IACtC,wCAAwC;IACxC,OAAO,CAAC,KAAK,CAAc;IAE3B;;;;;;OAMG;gBACS,IAAI,EAAE,YAAY;IAM9B;;;;OAIG;IACH,IAAI,IAAI,iBAEP;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,MAAM,EAAE,OAAO;IAKvB;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,EAAE,MAAM;IAKrB;;;;;;;;;;;;;;;;;;;OAmBG;IACG,IAAI;IAMV;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,OAAO;IAIb;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,MAAM;IAIN,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAEf;CACF"}

package/lib/editor/input/AcEdJig.js

@@ -1,256 +0,0 @@
-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 };
-    }
-};
-import { AcEdJigLoop } from './AcEdJigLoop';
-/**
- * Base class for interactive drawing operations (jigs) in the CAD editor.
- *
- * A jig is an interactive operation that allows users to dynamically preview
- * and modify geometric elements during creation. Common examples include:
- * - Drawing lines with real-time preview as the mouse moves
- * - Selecting rectangular areas with visual feedback
- * - Dynamic entity placement with instant visual updates
- *
- * The jig system provides:
- * - Real-time visual feedback during user interaction
- * - Event-driven updates based on mouse movement
- * - Asynchronous completion handling
- * - Cancellation and error handling
- *
- * @template TResult - The type of result returned when the jig completes
- *
- * @example
- * ```typescript
- * class RectangleSelectionJig extends AcEdJig<Rectangle> {
- *   private startPoint?: Point;
- *   private currentPoint?: Point;
- *
- *   async sampler() {
- *     // Get start point
- *     this.startPoint = await this.view.editor.getPoint();
- *
- *     // Continue updating until complete
- *     this.view.events.mouseMove.addEventListener(this.onMouseMove);
- *   }
- *
- *   update() {
- *     if (this.startPoint && this.currentPoint) {
- *       // Update preview rectangle
- *       this.drawPreviewRectangle(this.startPoint, this.currentPoint);
- *     }
- *   }
- *
- *   private onMouseMove = (args) => {
- *     this.currentPoint = args;
- *     // Jig loop will call update() automatically
- *   }
- * }
- *
- * // Usage
- * const jig = new RectangleSelectionJig(view);
- * const rectangle = await jig.drag();
- * ```
- */
-var AcEdJig = /** @class */ (function () {
-    /**
-     * Creates a new jig instance for the specified view.
-     *
-     * Sets up the jig loop and connects update event handling.
-     *
-     * @param view - The view this jig will operate in
-     */
-    function AcEdJig(view) {
-        var _this = this;
-        /** Internal event handler for jig loop updates */
-        this.onUpdate = function () {
-            _this.update();
-        };
-        this._view = view;
-        this._jigLoop = new AcEdJigLoop(view);
-        this._jigLoop.events.update.addEventListener(this.onUpdate);
-    }
-    Object.defineProperty(AcEdJig.prototype, "view", {
-        /**
-         * Gets the view associated with this jig.
-         *
-         * @returns The view instance
-         */
-        get: function () {
-            return this._view;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Resolves the jig operation with the specified result.
-     *
-     * This method should be called when the jig operation completes successfully.
-     * It cleans up event listeners and resolves the underlying promise.
-     *
-     * @param result - The result to return from the jig operation
-     *
-     * @example
-     * ```typescript
-     * // In a line drawing jig, when user completes the line
-     * if (this.hasValidEndPoint()) {
-     *   const line = new Line(this.startPoint, this.endPoint);
-     *   this.resolve(line);
-     * }
-     * ```
-     */
-    AcEdJig.prototype.resolve = function (result) {
-        this._jigLoop.events.update.removeEventListener(this.onUpdate);
-        this._jigLoop.resolve(result);
-    };
-    /**
-     * Rejects the jig operation with an error.
-     *
-     * This method should be called when the jig operation fails or is cancelled.
-     * It cleans up event listeners and rejects the underlying promise.
-     *
-     * @param reason - The reason for the rejection
-     *
-     * @example
-     * ```typescript
-     * // If user cancels or invalid input is detected
-     * if (userPressedEscape) {
-     *   this.reject('Operation cancelled by user');
-     * }
-     * ```
-     */
-    AcEdJig.prototype.reject = function (reason) {
-        this._jigLoop.events.update.removeEventListener(this.onUpdate);
-        this._jigLoop.reject(reason);
-    };
-    /**
-     * Starts the interactive jig operation.
-     *
-     * This method initiates both the jig loop and the sampling process.
-     * It returns a promise that resolves when the jig operation completes
-     * or rejects if an error occurs.
-     *
-     * @returns Promise that resolves when the jig operation completes
-     *
-     * @example
-     * ```typescript
-     * const jig = new MyCustomJig(view);
-     * try {
-     *   const result = await jig.drag();
-     *   console.log('Jig completed with result:', result);
-     * } catch (error) {
-     *   console.log('Jig was cancelled or failed:', error);
-     * }
-     * ```
-     */
-    AcEdJig.prototype.drag = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var promise1, promise2;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promise1 = this._jigLoop.start();
-                        promise2 = this.sampler();
-                        return [4 /*yield*/, Promise.allSettled([promise1, promise2])];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    /**
-     * Abstract method for handling jig input sampling.
-     *
-     * This method should be overridden by subclasses to implement
-     * the specific input handling logic for the jig. It typically:
-     * - Gets initial user input (like a start point)
-     * - Sets up event listeners for dynamic updates
-     * - Handles user interaction until completion
-     *
-     * The sampler runs concurrently with the jig loop and should
-     * call `resolve()` or `reject()` when the operation completes.
-     *
-     * @example
-     * ```typescript
-     * async sampler() {
-     *   // Get initial point
-     *   const startPoint = await this.view.editor.getPoint();
-     *
-     *   // Set up mouse tracking for dynamic preview
-     *   this.view.events.mouseMove.addEventListener(this.onMouseMove);
-     *   this.view.events.mouseClick.addEventListener(this.onMouseClick);
-     * }
-     * ```
-     */
-    AcEdJig.prototype.sampler = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/];
-            });
-        });
-    };
-    /**
-     * Called during each update cycle to refresh the jig display.
-     *
-     * This method should be overridden by subclasses to implement
-     * the visual update logic. It's called automatically by the jig loop
-     * whenever the display needs to be refreshed (typically on mouse movement).
-     *
-     * Common update operations include:
-     * - Redrawing preview geometry
-     * - Updating dimension displays
-     * - Refreshing visual feedback elements
-     *
-     * @example
-     * ```typescript
-     * update() {
-     *   if (this.startPoint && this.currentMousePoint) {
-     *     // Clear previous preview
-     *     this.clearPreview();
-     *
-     *     // Draw new preview line
-     *     this.drawPreviewLine(this.startPoint, this.currentMousePoint);
-     *   }
-     * }
-     * ```
-     */
-    AcEdJig.prototype.update = function () {
-        // Do nothing for now
-    };
-    return AcEdJig;
-}());
-export { AcEdJig };
-//# sourceMappingURL=AcEdJig.js.map

package/lib/editor/input/AcEdJig.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcEdJig.js","sourceRoot":"","sources":["../../../src/editor/input/AcEdJig.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAME;;;;;;OAMG;IACH,iBAAY,IAAkB;QAA9B,iBAIC;QAyID,kDAAkD;QAC1C,aAAQ,GAAG;YACjB,KAAI,CAAC,MAAM,EAAE,CAAA;QACf,CAAC,CAAA;QA/IC,IAAI,CAAC,KAAK,GAAG,IAAI,CAAA;QACjB,IAAI,CAAC,QAAQ,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,CAAA;QACrC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;IAC7D,CAAC;IAOD,sBAAI,yBAAI;QALR;;;;WAIG;aACH;YACE,OAAO,IAAI,CAAC,KAAK,CAAA;QACnB,CAAC;;;OAAA;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,yBAAO,GAAP,UAAQ,MAAe;QACrB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC9D,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,CAAA;IAC/B,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBAAM,GAAN,UAAO,MAAc;QACnB,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC9D,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IAC9B,CAAC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACG,sBAAI,GAAV;;;;;;wBACQ,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,CAAA;wBAChC,QAAQ,GAAG,IAAI,CAAC,OAAO,EAAE,CAAA;wBAC/B,qBAAM,OAAO,CAAC,UAAU,CAAC,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,EAAA;;wBAA9C,SAA8C,CAAA;;;;;KAC/C;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,yBAAO,GAAb;;;;;;KAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,wBAAM,GAAN;QACE,qBAAqB;IACvB,CAAC;IAMH,cAAC;AAAD,CAAC,AA9JD,IA8JC"}

package/lib/editor/input/AcEdJigLoop.d.ts

@@ -1,63 +0,0 @@
-import { AcCmEventManager, AcGePoint2d } from '@mlightcad/data-model';
-import { AcEdBaseView } from '../view/AcEdBaseView';
-import { AcEdBaseInput } from './AcEdBaseInput';
-/**
- * A specialized input class for jig operations that provides continuous mouse tracking.
- *
- * This class extends the base input functionality to provide real-time mouse position
- * tracking for interactive operations like drawing previews or dynamic objects that
- * follow the mouse cursor. It fires update events whenever the mouse moves, allowing
- * subscribers to respond to cursor movement.
- *
- * Jig loops are commonly used in CAD applications for operations like:
- * - Drawing preview lines that stretch from a fixed point to the cursor
- * - Moving objects dynamically with the mouse
- * - Providing visual feedback during interactive operations
- *
- * @template TResult - The type of result that this jig operation will return
- *
- * @example
- * ```typescript
- * const jigLoop = new AcEdJigLoop<string>(view);
- * jigLoop.events.update.subscribe(() => {
- *   // Update preview based on jigLoop.curPos
- *   console.log(`Mouse at: ${jigLoop.curPos.x}, ${jigLoop.curPos.y}`);
- * });
- * const result = await jigLoop.start();
- * ```
- */
-export declare class AcEdJigLoop<TResult> extends AcEdBaseInput<TResult> {
-    /** Event manager for handling mouse movement updates */
-    readonly events: {
-        /** Event fired when the mouse position updates */
-        update: AcCmEventManager<void>;
-    };
-    /** Current mouse position in screen coordinates */
-    curPos: AcGePoint2d;
-    /**
-     * Creates a new jig loop instance.
-     *
-     * @param view - The view that will handle this jig operation
-     */
-    constructor(view: AcEdBaseView);
-    /**
-     * Activates the jig loop operation.
-     * Sets up the mouse move event listener to track cursor position.
-     * Overrides the base class to add mouse move event handling.
-     */
-    activate(): void;
-    /**
-     * Deactivates the jig loop operation.
-     * Removes the mouse move event listener.
-     * Overrides the base class to clean up mouse move event handling.
-     */
-    deactivate(): void;
-    /**
-     * Handles mouse move events to update the current cursor position.
-     * Updates the current position and fires the update event to notify subscribers.
-     *
-     * @param event - The mouse move event containing the new cursor position
-     */
-    private onMouseMove;
-}
-//# sourceMappingURL=AcEdJigLoop.d.ts.map

package/lib/editor/input/AcEdJigLoop.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcEdJigLoop.d.ts","sourceRoot":"","sources":["../../../src/editor/input/AcEdJigLoop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAErE,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,WAAW,CAAC,OAAO,CAAE,SAAQ,aAAa,CAAC,OAAO,CAAC;IAC9D,wDAAwD;IACxD,SAAgB,MAAM;QACpB,kDAAkD;;MAEnD;IACD,mDAAmD;IAC5C,MAAM,EAAE,WAAW,CAAA;IAE1B;;;;OAIG;gBACS,IAAI,EAAE,YAAY;IAK9B;;;;OAIG;IACH,QAAQ;IAKR;;;;OAIG;IACH,UAAU;IAKV;;;;;OAKG;IACH,OAAO,CAAC,WAAW,CAGlB;CACF"}

package/lib/editor/input/AcEdJigLoop.js

@@ -1,91 +0,0 @@
-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 __());
-    };
-})();
-import { AcCmEventManager, AcGePoint2d } from '@mlightcad/data-model';
-import { AcEdBaseInput } from './AcEdBaseInput';
-/**
- * A specialized input class for jig operations that provides continuous mouse tracking.
- *
- * This class extends the base input functionality to provide real-time mouse position
- * tracking for interactive operations like drawing previews or dynamic objects that
- * follow the mouse cursor. It fires update events whenever the mouse moves, allowing
- * subscribers to respond to cursor movement.
- *
- * Jig loops are commonly used in CAD applications for operations like:
- * - Drawing preview lines that stretch from a fixed point to the cursor
- * - Moving objects dynamically with the mouse
- * - Providing visual feedback during interactive operations
- *
- * @template TResult - The type of result that this jig operation will return
- *
- * @example
- * ```typescript
- * const jigLoop = new AcEdJigLoop<string>(view);
- * jigLoop.events.update.subscribe(() => {
- *   // Update preview based on jigLoop.curPos
- *   console.log(`Mouse at: ${jigLoop.curPos.x}, ${jigLoop.curPos.y}`);
- * });
- * const result = await jigLoop.start();
- * ```
- */
-var AcEdJigLoop = /** @class */ (function (_super) {
-    __extends(AcEdJigLoop, _super);
-    /**
-     * Creates a new jig loop instance.
-     *
-     * @param view - The view that will handle this jig operation
-     */
-    function AcEdJigLoop(view) {
-        var _this = _super.call(this, view) || this;
-        /** Event manager for handling mouse movement updates */
-        _this.events = {
-            /** Event fired when the mouse position updates */
-            update: new AcCmEventManager()
-        };
-        /**
-         * Handles mouse move events to update the current cursor position.
-         * Updates the current position and fires the update event to notify subscribers.
-         *
-         * @param event - The mouse move event containing the new cursor position
-         */
-        _this.onMouseMove = function (event) {
-            _this.curPos.set(event.clientX, event.clientY);
-            _this.events.update.dispatch();
-        };
-        _this.curPos = new AcGePoint2d();
-        return _this;
-    }
-    /**
-     * Activates the jig loop operation.
-     * Sets up the mouse move event listener to track cursor position.
-     * Overrides the base class to add mouse move event handling.
-     */
-    AcEdJigLoop.prototype.activate = function () {
-        _super.prototype.activate.call(this);
-        this.view.canvas.addEventListener('mousemove', this.onMouseMove);
-    };
-    /**
-     * Deactivates the jig loop operation.
-     * Removes the mouse move event listener.
-     * Overrides the base class to clean up mouse move event handling.
-     */
-    AcEdJigLoop.prototype.deactivate = function () {
-        _super.prototype.deactivate.call(this);
-        this.view.canvas.removeEventListener('mousemove', this.onMouseMove);
-    };
-    return AcEdJigLoop;
-}(AcEdBaseInput));
-export { AcEdJigLoop };
-//# sourceMappingURL=AcEdJigLoop.js.map

package/lib/editor/input/AcEdJigLoop.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AcEdJigLoop.js","sourceRoot":"","sources":["../../../src/editor/input/AcEdJigLoop.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AAAA,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAGrE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAA0C,+BAAsB;IAS9D;;;;OAIG;IACH,qBAAY,IAAkB;QAC5B,YAAA,MAAK,YAAC,IAAI,CAAC,SAAA;QAdb,wDAAwD;QACxC,YAAM,GAAG;YACvB,kDAAkD;YAClD,MAAM,EAAE,IAAI,gBAAgB,EAAQ;SACrC,CAAA;QAkCD;;;;;WAKG;QACK,iBAAW,GAAG,UAAC,KAAiB;YACtC,KAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,OAAO,EAAE,KAAK,CAAC,OAAO,CAAC,CAAA;YAC7C,KAAI,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAA;QAC/B,CAAC,CAAA;QAhCC,KAAI,CAAC,MAAM,GAAG,IAAI,WAAW,EAAE,CAAA;;IACjC,CAAC;IAED;;;;OAIG;IACH,8BAAQ,GAAR;QACE,gBAAK,CAAC,QAAQ,WAAE,CAAA;QAChB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;IAClE,CAAC;IAED;;;;OAIG;IACH,gCAAU,GAAV;QACE,gBAAK,CAAC,UAAU,WAAE,CAAA;QAClB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,mBAAmB,CAAC,WAAW,EAAE,IAAI,CAAC,WAAW,CAAC,CAAA;IACrE,CAAC;IAYH,kBAAC;AAAD,CAAC,AAjDD,CAA0C,aAAa,GAiDtD"}