@mlightcad/cad-simple-viewer 1.2.2 → 1.2.4

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

@@ -0,0 +1,180 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,256 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,91 @@
+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

@@ -0,0 +1 @@
+{"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"}