@mlightcad/cad-simple-viewer 1.0.0 → 1.0.1

package/lib/editor/input/AcEdJig.js

@@ -35,9 +35,66 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 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();
         };
@@ -46,20 +103,78 @@ var AcEdJig = /** @class */ (function () {
         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;
@@ -76,6 +191,30 @@ var AcEdJig = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 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) {
@@ -83,6 +222,31 @@ var AcEdJig = /** @class */ (function () {
             });
         });
     };
+    /**
+     * 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
     };

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

@@ -1 +1 @@
-{"version":3,"file":"AcEdJig.js","sourceRoot":"","sources":["../../../src/editor/input/AcEdJig.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAE3C;IAIE,iBAAY,IAAkB;QAA9B,iBAIC;QA8BO,aAAQ,GAAG;YACjB,KAAI,CAAC,MAAM,EAAE,CAAA;QACf,CAAC,CAAA;QAnCC,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;IAED,sBAAI,yBAAI;aAAR;YACE,OAAO,IAAI,CAAC,KAAK,CAAA;QACnB,CAAC;;;OAAA;IAED,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,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;IAEK,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;IAEK,yBAAO,GAAb;;;;;;KAEC;IAED,wBAAM,GAAN;QACE,qBAAqB;IACvB,CAAC;IAKH,cAAC;AAAD,CAAC,AAzCD,IAyCC"}
+{"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,14 +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

@@ -1 +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,qBAAa,WAAW,CAAC,OAAO,CAAE,SAAQ,aAAa,CAAC,OAAO,CAAC;IAC9D,SAAgB,MAAM;;MAErB;IACM,MAAM,EAAE,WAAW,CAAA;gBAEd,IAAI,EAAE,YAAY;IAK9B,QAAQ;IAKR,UAAU;IAKV,OAAO,CAAC,WAAW,CAGlB;CACF"}
+{"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

@@ -15,13 +15,51 @@ var __extends = (this && this.__extends) || (function () {
 })();
 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();
@@ -29,10 +67,20 @@ var AcEdJigLoop = /** @class */ (function (_super) {
         _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);

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

@@ -1 +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;IAA0C,+BAAsB;IAM9D,qBAAY,IAAkB;QAC5B,YAAA,MAAK,YAAC,IAAI,CAAC,SAAA;QANG,YAAM,GAAG;YACvB,MAAM,EAAE,IAAI,gBAAgB,EAAQ;SACrC,CAAA;QAkBO,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;QAhBC,KAAI,CAAC,MAAM,GAAG,IAAI,WAAW,EAAE,CAAA;;IACjC,CAAC;IAED,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,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;IAMH,kBAAC;AAAD,CAAC,AAzBD,CAA0C,aAAa,GAyBtD"}
+{"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"}

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

@@ -1,26 +1,146 @@
 import { AcCmEventManager } from '@mlightcad/data-model';
 import { AcDbObjectId } from '@mlightcad/data-model';
 /**
- * Interface to define arguments of selection events.
+ * Event arguments for selection-related events.
+ *
+ * Contains the entity IDs that were involved in the selection change.
  */
 export interface AcEdSelectionEventArgs {
+    /** Array of entity IDs that were added or removed from selection */
     ids: AcDbObjectId[];
 }
 /**
- * The class represents the selection set in current view.
+ * Manages a collection of selected CAD entities in the current view.
+ *
+ * This class maintains a set of selected entity IDs and provides methods to:
+ * - Add entities to the selection
+ * - Remove entities from the selection
+ * - Clear all selections
+ * - Query selection state and count
+ * - Listen for selection change events
+ *
+ * The selection set fires events when entities are added or removed, allowing
+ * other components (like the view) to respond to selection changes by showing
+ * grip points, updating UI, etc.
+ *
+ * @example
+ * ```typescript
+ * const selectionSet = new AcEdSelectionSet();
+ *
+ * // Listen for selection changes
+ * selectionSet.events.selectionAdded.addEventListener(args => {
+ *   console.log('Added entities:', args.ids);
+ * });
+ *
+ * // Add entities to selection
+ * selectionSet.add(['entity1', 'entity2']);
+ *
+ * // Check selection
+ * if (selectionSet.count > 0) {
+ *   console.log(`${selectionSet.count} entities selected`);
+ * }
+ *
+ * // Clear selection
+ * selectionSet.clear();
+ * ```
  */
 export declare class AcEdSelectionSet {
+    /** Internal set storing the selected entity IDs */
     private _ids;
+    /** Events fired when selection changes */
     readonly events: {
+        /** Fired when entities are added to the selection */
         selectionAdded: AcCmEventManager<AcEdSelectionEventArgs>;
+        /** Fired when entities are removed from the selection */
         selectionRemoved: AcCmEventManager<AcEdSelectionEventArgs>;
     };
+    /**
+     * Creates a new selection set.
+     *
+     * @param ids - Optional initial array of entity IDs to include in the selection
+     *
+     * @example
+     * ```typescript
+     * // Create empty selection set
+     * const selectionSet = new AcEdSelectionSet();
+     *
+     * // Create selection set with initial entities
+     * const selectionSet = new AcEdSelectionSet(['entity1', 'entity2']);
+     * ```
+     */
     constructor(ids?: AcDbObjectId[]);
+    /**
+     * Gets an array of all selected entity IDs.
+     *
+     * @returns Array containing all selected entity IDs
+     */
     get ids(): string[];
+    /**
+     * Gets the number of selected entities.
+     *
+     * @returns The count of selected entities
+     */
     get count(): number;
+    /**
+     * Adds one or more entities to the selection.
+     *
+     * Fires a `selectionAdded` event with the added entity IDs.
+     * Duplicate IDs are automatically handled by the internal Set.
+     *
+     * @param value - Single entity ID or array of entity IDs to add
+     *
+     * @example
+     * ```typescript
+     * // Add single entity
+     * selectionSet.add('entity1');
+     *
+     * // Add multiple entities
+     * selectionSet.add(['entity2', 'entity3', 'entity4']);
+     * ```
+     */
     add(value: AcDbObjectId | AcDbObjectId[]): void;
+    /**
+     * Removes one or more entities from the selection.
+     *
+     * Fires a `selectionRemoved` event with the removed entity IDs.
+     * Non-existent IDs are silently ignored.
+     *
+     * @param value - Single entity ID or array of entity IDs to remove
+     *
+     * @example
+     * ```typescript
+     * // Remove single entity
+     * selectionSet.delete('entity1');
+     *
+     * // Remove multiple entities
+     * selectionSet.delete(['entity2', 'entity3']);
+     * ```
+     */
     delete(value: AcDbObjectId | AcDbObjectId[]): void;
+    /**
+     * Checks if an entity is currently selected.
+     *
+     * @param id - The entity ID to check
+     * @returns True if the entity is selected, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (selectionSet.has('entity1')) {
+     *   console.log('Entity1 is selected');
+     * }
+     * ```
+     */
     has(id: AcDbObjectId): boolean;
+    /**
+     * Removes all entities from the selection.
+     *
+     * Fires a `selectionRemoved` event with all previously selected entity IDs.
+     *
+     * @example
+     * ```typescript
+     * selectionSet.clear(); // Deselect everything
+     * ```
+     */
     clear(): void;
 }
 //# sourceMappingURL=AcEdSelectionSet.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AcEdSelectionSet.d.ts","sourceRoot":"","sources":["../../../src/editor/input/AcEdSelectionSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,GAAG,EAAE,YAAY,EAAE,CAAA;CACpB;AAED;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,IAAI,CAAmB;IAE/B,SAAgB,MAAM;;;MAGrB;gBAEW,GAAG,GAAE,YAAY,EAAO;IAIpC,IAAI,GAAG,aAEN;IAED,IAAI,KAAK,WAER;IAED,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,EAAE;IAUxC,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,EAAE;IAU3C,GAAG,CAAC,EAAE,EAAE,YAAY;IAIpB,KAAK;CAON"}
+{"version":3,"file":"AcEdSelectionSet.d.ts","sourceRoot":"","sources":["../../../src/editor/input/AcEdSelectionSet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAEpD;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,oEAAoE;IACpE,GAAG,EAAE,YAAY,EAAE,CAAA;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,qBAAa,gBAAgB;IAC3B,mDAAmD;IACnD,OAAO,CAAC,IAAI,CAAmB;IAE/B,0CAA0C;IAC1C,SAAgB,MAAM;QACpB,qDAAqD;;QAErD,yDAAyD;;MAE1D;IAED;;;;;;;;;;;;;OAaG;gBACS,GAAG,GAAE,YAAY,EAAO;IAIpC;;;;OAIG;IACH,IAAI,GAAG,aAEN;IAED;;;;OAIG;IACH,IAAI,KAAK,WAER;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,GAAG,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,EAAE;IAUxC;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY,EAAE;IAU3C;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,EAAE,EAAE,YAAY;IAIpB;;;;;;;;;OASG;IACH,KAAK;CAON"}

package/lib/editor/input/AcEdSelectionSet.js

@@ -1,17 +1,71 @@
 import { AcCmEventManager } from '@mlightcad/data-model';
 /**
- * The class represents the selection set in current view.
+ * Manages a collection of selected CAD entities in the current view.
+ *
+ * This class maintains a set of selected entity IDs and provides methods to:
+ * - Add entities to the selection
+ * - Remove entities from the selection
+ * - Clear all selections
+ * - Query selection state and count
+ * - Listen for selection change events
+ *
+ * The selection set fires events when entities are added or removed, allowing
+ * other components (like the view) to respond to selection changes by showing
+ * grip points, updating UI, etc.
+ *
+ * @example
+ * ```typescript
+ * const selectionSet = new AcEdSelectionSet();
+ *
+ * // Listen for selection changes
+ * selectionSet.events.selectionAdded.addEventListener(args => {
+ *   console.log('Added entities:', args.ids);
+ * });
+ *
+ * // Add entities to selection
+ * selectionSet.add(['entity1', 'entity2']);
+ *
+ * // Check selection
+ * if (selectionSet.count > 0) {
+ *   console.log(`${selectionSet.count} entities selected`);
+ * }
+ *
+ * // Clear selection
+ * selectionSet.clear();
+ * ```
  */
 var AcEdSelectionSet = /** @class */ (function () {
+    /**
+     * Creates a new selection set.
+     *
+     * @param ids - Optional initial array of entity IDs to include in the selection
+     *
+     * @example
+     * ```typescript
+     * // Create empty selection set
+     * const selectionSet = new AcEdSelectionSet();
+     *
+     * // Create selection set with initial entities
+     * const selectionSet = new AcEdSelectionSet(['entity1', 'entity2']);
+     * ```
+     */
     function AcEdSelectionSet(ids) {
         if (ids === void 0) { ids = []; }
+        /** Events fired when selection changes */
         this.events = {
+            /** Fired when entities are added to the selection */
             selectionAdded: new AcCmEventManager(),
+            /** Fired when entities are removed from the selection */
             selectionRemoved: new AcCmEventManager()
         };
         this._ids = new Set(ids);
     }
     Object.defineProperty(AcEdSelectionSet.prototype, "ids", {
+        /**
+         * Gets an array of all selected entity IDs.
+         *
+         * @returns Array containing all selected entity IDs
+         */
         get: function () {
             return Array.from(this._ids);
         },
@@ -19,12 +73,34 @@ var AcEdSelectionSet = /** @class */ (function () {
         configurable: true
     });
     Object.defineProperty(AcEdSelectionSet.prototype, "count", {
+        /**
+         * Gets the number of selected entities.
+         *
+         * @returns The count of selected entities
+         */
         get: function () {
             return this._ids.size;
         },
         enumerable: false,
         configurable: true
     });
+    /**
+     * Adds one or more entities to the selection.
+     *
+     * Fires a `selectionAdded` event with the added entity IDs.
+     * Duplicate IDs are automatically handled by the internal Set.
+     *
+     * @param value - Single entity ID or array of entity IDs to add
+     *
+     * @example
+     * ```typescript
+     * // Add single entity
+     * selectionSet.add('entity1');
+     *
+     * // Add multiple entities
+     * selectionSet.add(['entity2', 'entity3', 'entity4']);
+     * ```
+     */
     AcEdSelectionSet.prototype.add = function (value) {
         var _this = this;
         if (Array.isArray(value)) {
@@ -36,6 +112,23 @@ var AcEdSelectionSet = /** @class */ (function () {
             this.events.selectionAdded.dispatch({ ids: [value] });
         }
     };
+    /**
+     * Removes one or more entities from the selection.
+     *
+     * Fires a `selectionRemoved` event with the removed entity IDs.
+     * Non-existent IDs are silently ignored.
+     *
+     * @param value - Single entity ID or array of entity IDs to remove
+     *
+     * @example
+     * ```typescript
+     * // Remove single entity
+     * selectionSet.delete('entity1');
+     *
+     * // Remove multiple entities
+     * selectionSet.delete(['entity2', 'entity3']);
+     * ```
+     */
     AcEdSelectionSet.prototype.delete = function (value) {
         var _this = this;
         if (Array.isArray(value)) {
@@ -47,9 +140,32 @@ var AcEdSelectionSet = /** @class */ (function () {
             this.events.selectionRemoved.dispatch({ ids: [value] });
         }
     };
+    /**
+     * Checks if an entity is currently selected.
+     *
+     * @param id - The entity ID to check
+     * @returns True if the entity is selected, false otherwise
+     *
+     * @example
+     * ```typescript
+     * if (selectionSet.has('entity1')) {
+     *   console.log('Entity1 is selected');
+     * }
+     * ```
+     */
     AcEdSelectionSet.prototype.has = function (id) {
         return this._ids.has(id);
     };
+    /**
+     * Removes all entities from the selection.
+     *
+     * Fires a `selectionRemoved` event with all previously selected entity IDs.
+     *
+     * @example
+     * ```typescript
+     * selectionSet.clear(); // Deselect everything
+     * ```
+     */
     AcEdSelectionSet.prototype.clear = function () {
         if (this._ids.size > 0) {
             var ids = Array.from(this._ids);