@mlightcad/cad-simple-viewer 1.2.2 → 1.2.4

package/lib/command/AcApZoomCmd.js

@@ -0,0 +1,57 @@
+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 { AcEdCommand } from '../command';
+/**
+ * Command to zoom the view to fit all visible entities.
+ *
+ * This command adjusts the view's zoom level and position to show all
+ * visible entities in the current drawing within the viewport. It's
+ * equivalent to the "Zoom Extents" or "Fit to Window" functionality
+ * found in most CAD applications.
+ *
+ * The command calculates the bounding box of all visible entities and
+ * adjusts the camera to show them all with appropriate padding.
+ *
+ * @example
+ * ```typescript
+ * const zoomCommand = new AcApZoomCmd();
+ * zoomCommand.globalName = 'ZOOM';
+ * zoomCommand.localName = 'Zoom to Fit';
+ *
+ * // Execute the command to fit all entities in view
+ * zoomCommand.trigger(docManager.context);
+ * ```
+ */
+var AcApZoomCmd = /** @class */ (function (_super) {
+    __extends(AcApZoomCmd, _super);
+    function AcApZoomCmd() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Executes the zoom to fit command.
+     *
+     * Calls the view's `zoomToFit()` method to adjust the camera position
+     * and zoom level to display all visible entities within the viewport.
+     *
+     * @param context - The current application context containing the view to zoom
+     */
+    AcApZoomCmd.prototype.execute = function (context) {
+        context.view.zoomToFit();
+    };
+    return AcApZoomCmd;
+}(AcEdCommand));
+export { AcApZoomCmd };
+//# sourceMappingURL=AcApZoomCmd.js.map

package/lib/command/AcApZoomCmd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcApZoomCmd.js","sourceRoot":"","sources":["../../src/command/AcApZoomCmd.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAAiC,+BAAW;IAA5C;;IAYA,CAAC;IAXC;;;;;;;OAOG;IACH,6BAAO,GAAP,UAAQ,OAAoB;QAC1B,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,CAAA;IAC1B,CAAC;IACH,kBAAC;AAAD,CAAC,AAZD,CAAiC,WAAW,GAY3C"}

package/lib/command/AcApZoomToBoxCmd.d.ts

@@ -0,0 +1,68 @@
+import { AcApContext } from '../app';
+import { AcEdCommand } from '../command';
+import { AcEdBaseView, AcEdJig } from '../editor';
+/**
+ * Jig for handling zoom-to-box selection interaction.
+ *
+ * This jig handles the user interaction for selecting a rectangular
+ * area to zoom to. It extends {@link AcEdJig} to provide interactive
+ * selection capabilities.
+ *
+ * The jig allows users to:
+ * - Select a rectangular area on the drawing
+ * - Zoom the view to fit the selected area
+ * - Provide visual feedback during selection
+ *
+ * @example
+ * ```typescript
+ * const jig = new AcApZoomToBoxJig(view);
+ * await jig.drag(); // User selects area to zoom to
+ * ```
+ */
+export declare class AcApZoomToBoxJig extends AcEdJig<boolean> {
+    /**
+     * Creates a new zoom-to-box jig.
+     *
+     * @param view - The view that will be zoomed
+     */
+    constructor(view: AcEdBaseView);
+    /**
+     * Handles the selection sampling and zooming operation.
+     *
+     * This method gets the user's selection box and applies
+     * the zoom operation to fit that area in the view.
+     *
+     * @returns Promise that resolves when the zoom operation completes
+     */
+    sampler(): Promise<void>;
+}
+/**
+ * Command for zooming to a user-selected rectangular area.
+ *
+ * This command initiates an interactive zoom-to-box operation where:
+ * - User selects a rectangular area by dragging
+ * - The view zooms to fit the selected area
+ * - The zoom level is adjusted to show the entire selected region
+ *
+ * This provides precise navigation control, allowing users to quickly
+ * focus on specific areas of large drawings.
+ *
+ * @example
+ * ```typescript
+ * const zoomToBoxCmd = new AcApZoomToBoxCmd();
+ * await zoomToBoxCmd.execute(context); // User selects area to zoom to
+ * ```
+ */
+export declare class AcApZoomToBoxCmd extends AcEdCommand {
+    /**
+     * Executes the zoom-to-box command.
+     *
+     * Creates a jig for interactive area selection and initiates
+     * the drag operation for the user to select the zoom area.
+     *
+     * @param context - The application context containing the view
+     * @returns Promise that resolves when the zoom operation completes
+     */
+    execute(context: AcApContext): Promise<void>;
+}
+//# sourceMappingURL=AcApZoomToBoxCmd.d.ts.map

package/lib/command/AcApZoomToBoxCmd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcApZoomToBoxCmd.d.ts","sourceRoot":"","sources":["../../src/command/AcApZoomToBoxCmd.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAA;AAEpC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,gBAAiB,SAAQ,OAAO,CAAC,OAAO,CAAC;IACpD;;;;OAIG;gBACS,IAAI,EAAE,YAAY;IAI9B;;;;;;;OAOG;IACG,OAAO;CAKd;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C;;;;;;;;OAQG;IACG,OAAO,CAAC,OAAO,EAAE,WAAW;CAInC"}

package/lib/command/AcApZoomToBoxCmd.js

@@ -0,0 +1,158 @@
+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 __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 { AcApDocManager } from '../app';
+import { AcEdCommand } from '../command';
+import { AcEdJig } from '../editor';
+/**
+ * Jig for handling zoom-to-box selection interaction.
+ *
+ * This jig handles the user interaction for selecting a rectangular
+ * area to zoom to. It extends {@link AcEdJig} to provide interactive
+ * selection capabilities.
+ *
+ * The jig allows users to:
+ * - Select a rectangular area on the drawing
+ * - Zoom the view to fit the selected area
+ * - Provide visual feedback during selection
+ *
+ * @example
+ * ```typescript
+ * const jig = new AcApZoomToBoxJig(view);
+ * await jig.drag(); // User selects area to zoom to
+ * ```
+ */
+var AcApZoomToBoxJig = /** @class */ (function (_super) {
+    __extends(AcApZoomToBoxJig, _super);
+    /**
+     * Creates a new zoom-to-box jig.
+     *
+     * @param view - The view that will be zoomed
+     */
+    function AcApZoomToBoxJig(view) {
+        return _super.call(this, view) || this;
+    }
+    /**
+     * Handles the selection sampling and zooming operation.
+     *
+     * This method gets the user's selection box and applies
+     * the zoom operation to fit that area in the view.
+     *
+     * @returns Promise that resolves when the zoom operation completes
+     */
+    AcApZoomToBoxJig.prototype.sampler = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, AcApDocManager.instance.editor.getSelection().then(function (box) {
+                            return _this.view.zoomTo(box, 1);
+                        })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return AcApZoomToBoxJig;
+}(AcEdJig));
+export { AcApZoomToBoxJig };
+/**
+ * Command for zooming to a user-selected rectangular area.
+ *
+ * This command initiates an interactive zoom-to-box operation where:
+ * - User selects a rectangular area by dragging
+ * - The view zooms to fit the selected area
+ * - The zoom level is adjusted to show the entire selected region
+ *
+ * This provides precise navigation control, allowing users to quickly
+ * focus on specific areas of large drawings.
+ *
+ * @example
+ * ```typescript
+ * const zoomToBoxCmd = new AcApZoomToBoxCmd();
+ * await zoomToBoxCmd.execute(context); // User selects area to zoom to
+ * ```
+ */
+var AcApZoomToBoxCmd = /** @class */ (function (_super) {
+    __extends(AcApZoomToBoxCmd, _super);
+    function AcApZoomToBoxCmd() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    /**
+     * Executes the zoom-to-box command.
+     *
+     * Creates a jig for interactive area selection and initiates
+     * the drag operation for the user to select the zoom area.
+     *
+     * @param context - The application context containing the view
+     * @returns Promise that resolves when the zoom operation completes
+     */
+    AcApZoomToBoxCmd.prototype.execute = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var jig;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        jig = new AcApZoomToBoxJig(context.view);
+                        return [4 /*yield*/, jig.drag()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return AcApZoomToBoxCmd;
+}(AcEdCommand));
+export { AcApZoomToBoxCmd };
+//# sourceMappingURL=AcApZoomToBoxCmd.js.map

package/lib/command/AcApZoomToBoxCmd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcApZoomToBoxCmd.js","sourceRoot":"","sources":["../../src/command/AcApZoomToBoxCmd.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,cAAc,EAAE,MAAM,QAAQ,CAAA;AACvC,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AACxC,OAAO,EAAgB,OAAO,EAAE,MAAM,WAAW,CAAA;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AACH;IAAsC,oCAAgB;IACpD;;;;OAIG;IACH,0BAAY,IAAkB;QAC5B,OAAA,MAAK,YAAC,IAAI,CAAC,SAAA;IACb,CAAC;IAED;;;;;;;OAOG;IACG,kCAAO,GAAb;;;;;4BACE,qBAAM,cAAc,CAAC,QAAQ,CAAC,MAAM,CAAC,YAAY,EAAE,CAAC,IAAI,CAAC,UAAA,GAAG;4BAC1D,OAAO,KAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA;wBACjC,CAAC,CAAC,EAAA;;wBAFF,SAEE,CAAA;;;;;KACH;IACH,uBAAC;AAAD,CAAC,AAvBD,CAAsC,OAAO,GAuB5C;;AAED;;;;;;;;;;;;;;;;GAgBG;AACH;IAAsC,oCAAW;IAAjD;;IAcA,CAAC;IAbC;;;;;;;;OAQG;IACG,kCAAO,GAAb,UAAc,OAAoB;;;;;;wBAC1B,GAAG,GAAG,IAAI,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;wBAC9C,qBAAM,GAAG,CAAC,IAAI,EAAE,EAAA;;wBAAhB,SAAgB,CAAA;;;;;KACjB;IACH,uBAAC;AAAD,CAAC,AAdD,CAAsC,WAAW,GAchD"}

package/lib/command/index.d.ts

@@ -0,0 +1,11 @@
+export * from '../editor/command/AcEdCommand';
+export * from '../editor/command/AcEdCommandStack';
+export * from './AcApConvertToSvgCmd';
+export * from './AcApOpenCmd';
+export * from './AcApQNewCmd';
+export * from './AcApRegenCmd';
+export * from './AcApSelectCmd';
+export * from './AcApZoomCmd';
+export * from './AcApZoomToBoxCmd';
+export * from './AcApPanCmd';
+//# sourceMappingURL=index.d.ts.map

package/lib/command/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/command/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,oCAAoC,CAAA;AAClD,cAAc,uBAAuB,CAAA;AACrC,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA"}

package/lib/command/index.js

@@ -0,0 +1,11 @@
+export * from '../editor/command/AcEdCommand';
+export * from '../editor/command/AcEdCommandStack';
+export * from './AcApConvertToSvgCmd';
+export * from './AcApOpenCmd';
+export * from './AcApQNewCmd';
+export * from './AcApRegenCmd';
+export * from './AcApSelectCmd';
+export * from './AcApZoomCmd';
+export * from './AcApZoomToBoxCmd';
+export * from './AcApPanCmd';
+//# sourceMappingURL=index.js.map

package/lib/command/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/command/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAA;AAC7C,cAAc,oCAAoC,CAAA;AAClD,cAAc,uBAAuB,CAAA;AACrC,cAAc,eAAe,CAAA;AAC7B,cAAc,eAAe,CAAA;AAC7B,cAAc,gBAAgB,CAAA;AAC9B,cAAc,iBAAiB,CAAA;AAC/B,cAAc,eAAe,CAAA;AAC7B,cAAc,oBAAoB,CAAA;AAClC,cAAc,cAAc,CAAA"}

package/lib/editor/command/AcEdCommand.d.ts

@@ -0,0 +1,151 @@
+import { AcCmEventManager } from '@mlightcad/data-model';
+import { AcApContext } from '../../app';
+/**
+ * Event arguments for command lifecycle events.
+ *
+ * Contains the command instance that triggered the event.
+ */
+export interface AcEdCommandEventArgs {
+    /** The command instance involved in the event */
+    command: AcEdCommand;
+}
+/**
+ * Abstract base class for all CAD commands.
+ *
+ * This class provides the foundation for implementing CAD commands with:
+ * - Command name management (global and localized names)
+ * - Lifecycle event handling (command start/end)
+ * - Execution framework with context access
+ * - Event notification system
+ *
+ * Commands are the primary way users interact with the CAD system. Each command
+ * represents a specific operation like drawing lines, selecting objects, zooming, etc.
+ *
+ * ## Command Lifecycle
+ * 1. Command is triggered via `trigger()` method
+ * 2. `commandWillStart` event is fired
+ * 3. `execute()` method is called with current context
+ * 4. `commandEnded` event is fired
+ *
+ * @example
+ * ```typescript
+ * class MyDrawCommand extends AcEdCommand {
+ *   constructor() {
+ *     super();
+ *     this.globalName = 'DRAW';
+ *     this.localName = 'Draw Line';
+ *   }
+ *
+ *   execute(context: AcApContext) {
+ *     // Implement command logic here
+ *     const view = context.view;
+ *     const document = context.doc;
+ *     // ... drawing logic
+ *   }
+ * }
+ *
+ * // Usage
+ * const command = new MyDrawCommand();
+ * command.events.commandWillStart.addEventListener(args => {
+ *   console.log('Command starting:', args.command.globalName);
+ * });
+ * command.trigger(context);
+ * ```
+ */
+export declare abstract class AcEdCommand {
+    /** The global (untranslated) name of the command */
+    private _globalName;
+    /** The local (translated) name of the command */
+    private _localName;
+    /**
+     * Creates a new command instance.
+     *
+     * Initializes the command with empty names. Subclasses should set
+     * appropriate global and local names in their constructors.
+     */
+    constructor();
+    /** Events fired during command execution lifecycle */
+    readonly events: {
+        /** Fired just before the command starts executing */
+        commandWillStart: AcCmEventManager<AcEdCommandEventArgs>;
+        /** Fired after the command finishes executing */
+        commandEnded: AcCmEventManager<AcEdCommandEventArgs>;
+    };
+    /**
+     * Gets the global (untranslated) name of the command.
+     *
+     * The global name is typically used for programmatic access and
+     * should remain consistent across different language localizations.
+     *
+     * @returns The global command name
+     */
+    get globalName(): string;
+    /**
+     * Sets the global (untranslated) name of the command.
+     *
+     * @param value - The global command name (e.g., 'LINE', 'CIRCLE', 'ZOOM')
+     */
+    set globalName(value: string);
+    /**
+     * Gets the local (translated) name of the command.
+     *
+     * The local name is displayed to users and should be localized
+     * to the current language/region.
+     *
+     * @returns The localized command name
+     */
+    get localName(): string;
+    /**
+     * Sets the local (translated) name of the command.
+     *
+     * @param value - The localized command name (e.g., 'Draw Line', 'Zoom In')
+     */
+    set localName(value: string);
+    /**
+     * Triggers the command execution with proper event handling.
+     *
+     * This method should not be overridden by subclasses as it handles
+     * the event notification workflow. Subclasses should implement the
+     * `execute()` method instead.
+     *
+     * The execution flow:
+     * 1. Fires `commandWillStart` event
+     * 2. Calls the `execute()` method
+     * 3. Fires `commandEnded` event
+     *
+     * @param context - The current application context containing view and document
+     *
+     * @example
+     * ```typescript
+     * const command = new MyCommand();
+     * command.trigger(docManager.context);
+     * ```
+     */
+    tirgger(context: AcApContext): void;
+    /**
+     * Executes the command logic.
+     *
+     * This abstract method must be implemented by subclasses to define
+     * the specific behavior of the command. The method receives the current
+     * application context providing access to the view and document.
+     *
+     * @param _context - The current application context
+     *
+     * @example
+     * ```typescript
+     * execute(context: AcApContext) {
+     *   const view = context.view;
+     *   const doc = context.doc;
+     *
+     *   // Get user input
+     *   const point = await view.editor.getPoint();
+     *
+     *   // Create entity in document
+     *   const entity = new SomeEntity(point);
+     *   doc.database.addEntity(entity);
+     * }
+     * ```
+     */
+    execute(_context: AcApContext): void;
+}
+//# sourceMappingURL=AcEdCommand.d.ts.map

package/lib/editor/command/AcEdCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcEdCommand.d.ts","sourceRoot":"","sources":["../../../src/editor/command/AcEdCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAExD,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEvC;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,iDAAiD;IACjD,OAAO,EAAE,WAAW,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,8BAAsB,WAAW;IAC/B,oDAAoD;IACpD,OAAO,CAAC,WAAW,CAAQ;IAC3B,iDAAiD;IACjD,OAAO,CAAC,UAAU,CAAQ;IAE1B;;;;;OAKG;;IAMH,sDAAsD;IACtD,SAAgB,MAAM;QACpB,qDAAqD;;QAErD,iDAAiD;;MAElD;IAED;;;;;;;OAOG;IACH,IAAI,UAAU,IASQ,MAAM,CAP3B;IAED;;;;OAIG;IACH,IAAI,UAAU,CAAC,KAAK,EAAE,MAAM,EAE3B;IAED;;;;;;;OAOG;IACH,IAAI,SAAS,IASQ,MAAM,CAP1B;IAED;;;;OAIG;IACH,IAAI,SAAS,CAAC,KAAK,EAAE,MAAM,EAE1B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,OAAO,CAAC,OAAO,EAAE,WAAW;IAM5B;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,OAAO,CAAC,QAAQ,EAAE,WAAW;CAG9B"}

package/lib/editor/command/AcEdCommand.js

@@ -0,0 +1,164 @@
+import { AcCmEventManager } from '@mlightcad/data-model';
+/**
+ * Abstract base class for all CAD commands.
+ *
+ * This class provides the foundation for implementing CAD commands with:
+ * - Command name management (global and localized names)
+ * - Lifecycle event handling (command start/end)
+ * - Execution framework with context access
+ * - Event notification system
+ *
+ * Commands are the primary way users interact with the CAD system. Each command
+ * represents a specific operation like drawing lines, selecting objects, zooming, etc.
+ *
+ * ## Command Lifecycle
+ * 1. Command is triggered via `trigger()` method
+ * 2. `commandWillStart` event is fired
+ * 3. `execute()` method is called with current context
+ * 4. `commandEnded` event is fired
+ *
+ * @example
+ * ```typescript
+ * class MyDrawCommand extends AcEdCommand {
+ *   constructor() {
+ *     super();
+ *     this.globalName = 'DRAW';
+ *     this.localName = 'Draw Line';
+ *   }
+ *
+ *   execute(context: AcApContext) {
+ *     // Implement command logic here
+ *     const view = context.view;
+ *     const document = context.doc;
+ *     // ... drawing logic
+ *   }
+ * }
+ *
+ * // Usage
+ * const command = new MyDrawCommand();
+ * command.events.commandWillStart.addEventListener(args => {
+ *   console.log('Command starting:', args.command.globalName);
+ * });
+ * command.trigger(context);
+ * ```
+ */
+var AcEdCommand = /** @class */ (function () {
+    /**
+     * Creates a new command instance.
+     *
+     * Initializes the command with empty names. Subclasses should set
+     * appropriate global and local names in their constructors.
+     */
+    function AcEdCommand() {
+        /** Events fired during command execution lifecycle */
+        this.events = {
+            /** Fired just before the command starts executing */
+            commandWillStart: new AcCmEventManager(),
+            /** Fired after the command finishes executing */
+            commandEnded: new AcCmEventManager()
+        };
+        this._globalName = '';
+        this._localName = '';
+    }
+    Object.defineProperty(AcEdCommand.prototype, "globalName", {
+        /**
+         * Gets the global (untranslated) name of the command.
+         *
+         * The global name is typically used for programmatic access and
+         * should remain consistent across different language localizations.
+         *
+         * @returns The global command name
+         */
+        get: function () {
+            return this._globalName;
+        },
+        /**
+         * Sets the global (untranslated) name of the command.
+         *
+         * @param value - The global command name (e.g., 'LINE', 'CIRCLE', 'ZOOM')
+         */
+        set: function (value) {
+            this._globalName = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(AcEdCommand.prototype, "localName", {
+        /**
+         * Gets the local (translated) name of the command.
+         *
+         * The local name is displayed to users and should be localized
+         * to the current language/region.
+         *
+         * @returns The localized command name
+         */
+        get: function () {
+            return this._localName;
+        },
+        /**
+         * Sets the local (translated) name of the command.
+         *
+         * @param value - The localized command name (e.g., 'Draw Line', 'Zoom In')
+         */
+        set: function (value) {
+            this._localName = value;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Triggers the command execution with proper event handling.
+     *
+     * This method should not be overridden by subclasses as it handles
+     * the event notification workflow. Subclasses should implement the
+     * `execute()` method instead.
+     *
+     * The execution flow:
+     * 1. Fires `commandWillStart` event
+     * 2. Calls the `execute()` method
+     * 3. Fires `commandEnded` event
+     *
+     * @param context - The current application context containing view and document
+     *
+     * @example
+     * ```typescript
+     * const command = new MyCommand();
+     * command.trigger(docManager.context);
+     * ```
+     */
+    AcEdCommand.prototype.tirgger = function (context) {
+        this.events.commandWillStart.dispatch({ command: this });
+        this.execute(context);
+        this.events.commandEnded.dispatch({ command: this });
+    };
+    /**
+     * Executes the command logic.
+     *
+     * This abstract method must be implemented by subclasses to define
+     * the specific behavior of the command. The method receives the current
+     * application context providing access to the view and document.
+     *
+     * @param _context - The current application context
+     *
+     * @example
+     * ```typescript
+     * execute(context: AcApContext) {
+     *   const view = context.view;
+     *   const doc = context.doc;
+     *
+     *   // Get user input
+     *   const point = await view.editor.getPoint();
+     *
+     *   // Create entity in document
+     *   const entity = new SomeEntity(point);
+     *   doc.database.addEntity(entity);
+     * }
+     * ```
+     */
+    AcEdCommand.prototype.execute = function (_context) {
+        // Do nothing - subclasses should override this method
+    };
+    return AcEdCommand;
+}());
+export { AcEdCommand };
+//# sourceMappingURL=AcEdCommand.js.map

package/lib/editor/command/AcEdCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcEdCommand.js","sourceRoot":"","sources":["../../../src/editor/command/AcEdCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AAcxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH;IAME;;;;;OAKG;IACH;QAKA,sDAAsD;QACtC,WAAM,GAAG;YACvB,qDAAqD;YACrD,gBAAgB,EAAE,IAAI,gBAAgB,EAAwB;YAC9D,iDAAiD;YACjD,YAAY,EAAE,IAAI,gBAAgB,EAAwB;SAC3D,CAAA;QAVC,IAAI,CAAC,WAAW,GAAG,EAAE,CAAA;QACrB,IAAI,CAAC,UAAU,GAAG,EAAE,CAAA;IACtB,CAAC;IAkBD,sBAAI,mCAAU;QARd;;;;;;;WAOG;aACH;YACE,OAAO,IAAI,CAAC,WAAW,CAAA;QACzB,CAAC;QAED;;;;WAIG;aACH,UAAe,KAAa;YAC1B,IAAI,CAAC,WAAW,GAAG,KAAK,CAAA;QAC1B,CAAC;;;OATA;IAmBD,sBAAI,kCAAS;QARb;;;;;;;WAOG;aACH;YACE,OAAO,IAAI,CAAC,UAAU,CAAA;QACxB,CAAC;QAED;;;;WAIG;aACH,UAAc,KAAa;YACzB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAA;QACzB,CAAC;;;OATA;IAWD;;;;;;;;;;;;;;;;;;;OAmBG;IACH,6BAAO,GAAP,UAAQ,OAAoB;QAC1B,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;QACxD,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;QACrB,IAAI,CAAC,MAAM,CAAC,YAAY,CAAC,QAAQ,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAA;IACtD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,6BAAO,GAAP,UAAQ,QAAqB;QAC3B,sDAAsD;IACxD,CAAC;IACH,kBAAC;AAAD,CAAC,AAxHD,IAwHC"}