@mlightcad/cad-simple-viewer 1.4.7 → 1.4.9

package/lib/plugin/AcApPluginExample.js

@@ -0,0 +1,160 @@
+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 };
+    }
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { AcEdCommand } from '../editor/command/AcEdCommand';
+/**
+ * Example plugin demonstrating how to create and use plugins in cad-simple-viewer.
+ *
+ * This example shows:
+ * - How to implement the AcApPlugin interface
+ * - How to register custom commands in the onLoad hook
+ * - How to clean up resources in the onUnload hook
+ *
+ * @example
+ * ```typescript
+ * import { AcApDocManager } from '@mlightcad/cad-simple-viewer';
+ * import { ExamplePlugin } from './AcApPluginExample';
+ *
+ * // Load the plugin
+ * const plugin = new ExamplePlugin();
+ * await AcApDocManager.instance.pluginManager.loadPlugin(plugin);
+ *
+ * // The plugin's commands are now available
+ * // You can execute them via: docManager.sendStringToExecute('HELLO');
+ *
+ * // Unload the plugin when done
+ * await AcApDocManager.instance.pluginManager.unloadPlugin('ExamplePlugin');
+ * ```
+ */
+/**
+ * Example command that prints a greeting message.
+ */
+var AcApHelloCommand = /** @class */ (function (_super) {
+    __extends(AcApHelloCommand, _super);
+    function AcApHelloCommand() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    AcApHelloCommand.prototype.execute = function (context) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                console.log('Hello from ExamplePlugin!');
+                console.log('Current document:', context.doc);
+                console.log('Current view:', context.view);
+                return [2 /*return*/];
+            });
+        });
+    };
+    return AcApHelloCommand;
+}(AcEdCommand));
+/**
+ * Example plugin implementation.
+ */
+var AcApExamplePlugin = /** @class */ (function () {
+    function AcApExamplePlugin() {
+        this.name = 'ExamplePlugin';
+        this.version = '1.0.0';
+        this.description = 'An example plugin demonstrating the plugin system';
+        // Track registered commands for cleanup
+        this.registeredCommands = [];
+    }
+    /**
+     * Called when the plugin is loaded.
+     * Register custom commands here.
+     */
+    AcApExamplePlugin.prototype.onLoad = function (_context, commandManager) {
+        // Register a custom command
+        commandManager.addCommand('USER', // Command group
+        'HELLO', // Global command name
+        'Hello', // Local command name
+        new AcApHelloCommand());
+        // Track the command for cleanup
+        this.registeredCommands.push({ group: 'USER', name: 'HELLO' });
+        console.log("[".concat(this.name, "] Plugin loaded successfully"));
+        console.log("[".concat(this.name, "] Registered command: HELLO"));
+    };
+    /**
+     * Called when the plugin is unloaded.
+     * Clean up registered commands and other resources here.
+     */
+    AcApExamplePlugin.prototype.onUnload = function (_context, commandManager) {
+        var e_1, _a;
+        try {
+            // Remove all registered commands
+            for (var _b = __values(this.registeredCommands), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var cmd = _c.value;
+                commandManager.removeCmd(cmd.group, cmd.name);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        this.registeredCommands = [];
+        console.log("[".concat(this.name, "] Plugin unloaded"));
+    };
+    return AcApExamplePlugin;
+}());
+export { AcApExamplePlugin };
+//# sourceMappingURL=AcApPluginExample.js.map

package/lib/plugin/AcApPluginExample.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcApPluginExample.js","sourceRoot":"","sources":["../../src/plugin/AcApPluginExample.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAA;AAI3D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;GAEG;AACH;IAA+B,oCAAW;IAA1C;;IAMA,CAAC;IALO,kCAAO,GAAb,UAAc,OAAoB;;;gBAChC,OAAO,CAAC,GAAG,CAAC,2BAA2B,CAAC,CAAA;gBACxC,OAAO,CAAC,GAAG,CAAC,mBAAmB,EAAE,OAAO,CAAC,GAAG,CAAC,CAAA;gBAC7C,OAAO,CAAC,GAAG,CAAC,eAAe,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;;;;KAC3C;IACH,uBAAC;AAAD,CAAC,AAND,CAA+B,WAAW,GAMzC;AAED;;GAEG;AACH;IAAA;QACE,SAAI,GAAG,eAAe,CAAA;QACtB,YAAO,GAAG,OAAO,CAAA;QACjB,gBAAW,GAAG,mDAAmD,CAAA;QAEjE,wCAAwC;QAChC,uBAAkB,GAA2C,EAAE,CAAA;IAmCzE,CAAC;IAjCC;;;OAGG;IACH,kCAAM,GAAN,UAAO,QAAqB,EAAE,cAAgC;QAC5D,4BAA4B;QAC5B,cAAc,CAAC,UAAU,CACvB,MAAM,EAAE,gBAAgB;QACxB,OAAO,EAAE,sBAAsB;QAC/B,OAAO,EAAE,qBAAqB;QAC9B,IAAI,gBAAgB,EAAE,CACvB,CAAA;QAED,gCAAgC;QAChC,IAAI,CAAC,kBAAkB,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAA;QAE9D,OAAO,CAAC,GAAG,CAAC,WAAI,IAAI,CAAC,IAAI,iCAA8B,CAAC,CAAA;QACxD,OAAO,CAAC,GAAG,CAAC,WAAI,IAAI,CAAC,IAAI,gCAA6B,CAAC,CAAA;IACzD,CAAC;IAED;;;OAGG;IACH,oCAAQ,GAAR,UAAS,QAAqB,EAAE,cAAgC;;;YAC9D,iCAAiC;YACjC,KAAkB,IAAA,KAAA,SAAA,IAAI,CAAC,kBAAkB,CAAA,gBAAA,4BAAE,CAAC;gBAAvC,IAAM,GAAG,WAAA;gBACZ,cAAc,CAAC,SAAS,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,IAAI,CAAC,CAAA;YAC/C,CAAC;;;;;;;;;QACD,IAAI,CAAC,kBAAkB,GAAG,EAAE,CAAA;QAE5B,OAAO,CAAC,GAAG,CAAC,WAAI,IAAI,CAAC,IAAI,sBAAmB,CAAC,CAAA;IAC/C,CAAC;IACH,wBAAC;AAAD,CAAC,AAzCD,IAyCC"}

package/lib/plugin/AcApPluginManager.d.ts

@@ -0,0 +1,206 @@
+import { AcApContext } from '../app/AcApContext';
+import { AcEdCommandStack } from '../editor/command/AcEdCommandStack';
+import { AcApPlugin } from './AcApPlugin';
+/**
+ * Plugin manager for dynamically loading and unloading plugins.
+ *
+ * This class manages the lifecycle of plugins, including:
+ * - Loading plugins and calling their `onLoad` hooks
+ * - Unloading plugins and calling their `onUnload` hooks
+ * - Providing access to the application context and command manager
+ *
+ * Plugins are responsible for cleaning up their own registered commands
+ * in the `onUnload` hook using `commandManager.removeCmd()`.
+ *
+ * @example
+ * ```typescript
+ * const pluginManager = AcApDocManager.instance.pluginManager;
+ *
+ * // Load a plugin
+ * const myPlugin = new MyPlugin();
+ * await pluginManager.loadPlugin(myPlugin);
+ *
+ * // Unload a plugin
+ * await pluginManager.unloadPlugin('MyPlugin');
+ *
+ * // Check if a plugin is loaded
+ * if (pluginManager.isPluginLoaded('MyPlugin')) {
+ *   console.log('Plugin is loaded');
+ * }
+ *
+ * // Get all loaded plugins
+ * const loadedPlugins = pluginManager.getLoadedPlugins();
+ * ```
+ */
+export declare class AcApPluginManager {
+    /** Map of loaded plugins by name */
+    private _plugins;
+    /** The application context */
+    private _context;
+    /** The command manager */
+    private _commandManager;
+    /**
+     * Creates a new plugin manager.
+     *
+     * @param context - The application context
+     * @param commandManager - The command manager for plugin command registration
+     */
+    constructor(context: AcApContext, commandManager: AcEdCommandStack);
+    /**
+     * Loads a plugin and calls its `onLoad` hook.
+     *
+     * If the plugin is already loaded, this method will throw an error.
+     * The plugin's `onLoad` method will be called with the context and command manager.
+     *
+     * @param plugin - The plugin instance to load
+     * @throws {Error} If a plugin with the same name is already loaded
+     *
+     * @example
+     * ```typescript
+     * const plugin = new MyPlugin();
+     * await pluginManager.loadPlugin(plugin);
+     * ```
+     */
+    loadPlugin(plugin: AcApPlugin): Promise<void>;
+    /**
+     * Unloads a plugin and calls its `onUnload` hook.
+     *
+     * This method will:
+     * 1. Call the plugin's `onUnload` hook (plugins should clean up their commands here)
+     * 2. Remove the plugin from the loaded plugins map
+     *
+     * @param pluginName - The name of the plugin to unload
+     * @returns `true` if the plugin was successfully unloaded, `false` if it wasn't loaded
+     *
+     * @example
+     * ```typescript
+     * const success = await pluginManager.unloadPlugin('MyPlugin');
+     * if (success) {
+     *   console.log('Plugin unloaded successfully');
+     * }
+     * ```
+     */
+    unloadPlugin(pluginName: string): Promise<boolean>;
+    /**
+     * Checks if a plugin is currently loaded.
+     *
+     * @param pluginName - The name of the plugin to check
+     * @returns `true` if the plugin is loaded, `false` otherwise
+     */
+    isPluginLoaded(pluginName: string): boolean;
+    /**
+     * Gets information about a loaded plugin.
+     *
+     * @param pluginName - The name of the plugin
+     * @returns The plugin instance if loaded, `undefined` otherwise
+     */
+    getPlugin(pluginName: string): AcApPlugin | undefined;
+    /**
+     * Gets all currently loaded plugins.
+     *
+     * @returns Array of loaded plugin names
+     */
+    getLoadedPlugins(): string[];
+    /**
+     * Unloads all currently loaded plugins.
+     *
+     * This method calls `unloadPlugin` for each loaded plugin.
+     *
+     * @example
+     * ```typescript
+     * await pluginManager.unloadAllPlugins();
+     * ```
+     */
+    unloadAllPlugins(): Promise<void>;
+    /**
+     * Loads multiple plugins from a configuration array.
+     *
+     * This method accepts an array of plugin instances or plugin factory functions.
+     * Factory functions are useful when you want to create plugin instances lazily.
+     *
+     * @param plugins - Array of plugin instances or factory functions that return plugin instances
+     * @param options - Optional configuration for loading behavior
+     * @param options.continueOnError - If true, continue loading other plugins even if one fails (default: false)
+     * @returns Promise that resolves to an object containing successful and failed plugin loads
+     *
+     * @example
+     * ```typescript
+     * // Load plugins from instances
+     * await pluginManager.loadPluginsFromConfig([
+     *   new MyPlugin1(),
+     *   new MyPlugin2()
+     * ]);
+     *
+     * // Load plugins from factory functions
+     * await pluginManager.loadPluginsFromConfig([
+     *   () => new MyPlugin1(),
+     *   () => new MyPlugin2()
+     * ]);
+     *
+     * // Continue loading even if some fail
+     * const result = await pluginManager.loadPluginsFromConfig(
+     *   [new Plugin1(), new Plugin2()],
+     *   { continueOnError: true }
+     * );
+     * console.log('Loaded:', result.loaded);
+     * console.log('Failed:', result.failed);
+     * ```
+     */
+    loadPluginsFromConfig(plugins: Array<AcApPlugin | (() => AcApPlugin)>, options?: {
+        continueOnError?: boolean;
+    }): Promise<{
+        loaded: string[];
+        failed: Array<{
+            name: string;
+            error: Error;
+        }>;
+    }>;
+    /**
+     * Loads plugins from a folder using dynamic imports.
+     *
+     * This method scans a folder for plugin files and dynamically imports them.
+     * It expects each plugin file to export a default export that is either:
+     * - A plugin instance
+     * - A plugin class (constructor function)
+     * - A factory function that returns a plugin instance
+     *
+     * @param folderPath - Path to the folder containing plugin files (relative to the base URL)
+     * @param options - Optional configuration for loading behavior
+     * @param options.pattern - Glob pattern to match plugin files (default: '*.js' or '*.ts')
+     * @param options.continueOnError - If true, continue loading other plugins even if one fails (default: false)
+     * @param options.pluginList - Optional array of specific plugin file names to load (if not provided, attempts to auto-discover)
+     * @returns Promise that resolves to an object containing successful and failed plugin loads
+     *
+     * @example
+     * ```typescript
+     * // Load all plugins from a folder (requires plugin list or manifest)
+     * await pluginManager.loadPluginsFromFolder('./plugins', {
+     *   pluginList: ['MyPlugin1.js', 'MyPlugin2.js']
+     * });
+     *
+     * // Or with continue on error
+     * const result = await pluginManager.loadPluginsFromFolder('./plugins', {
+     *   pluginList: ['Plugin1.js', 'Plugin2.js'],
+     *   continueOnError: true
+     * });
+     * ```
+     *
+     * @remarks
+     * In browser environments, you typically need to provide a list of plugin files
+     * to load, as there's no direct way to list directory contents. You can:
+     * 1. Provide a `pluginList` array with specific file names
+     * 2. Create a manifest file that lists all plugins
+     * 3. Use a build-time tool to generate the plugin list
+     */
+    loadPluginsFromFolder(folderPath: string, options?: {
+        pluginList?: string[];
+        continueOnError?: boolean;
+    }): Promise<{
+        loaded: string[];
+        failed: Array<{
+            name: string;
+            error: Error;
+        }>;
+    }>;
+}
+//# sourceMappingURL=AcApPluginManager.d.ts.map

package/lib/plugin/AcApPluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcApPluginManager.d.ts","sourceRoot":"","sources":["../../src/plugin/AcApPluginManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,gBAAgB,EAAE,MAAM,oCAAoC,CAAA;AACrE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,iBAAiB;IAC5B,oCAAoC;IACpC,OAAO,CAAC,QAAQ,CAAyB;IACzC,8BAA8B;IAC9B,OAAO,CAAC,QAAQ,CAAa;IAC7B,0BAA0B;IAC1B,OAAO,CAAC,eAAe,CAAkB;IAEzC;;;;;OAKG;gBACS,OAAO,EAAE,WAAW,EAAE,cAAc,EAAE,gBAAgB;IAMlE;;;;;;;;;;;;;;OAcG;IACG,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;IA0BnD;;;;;;;;;;;;;;;;;OAiBG;IACG,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAuBxD;;;;;OAKG;IACH,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO;IAI3C;;;;;OAKG;IACH,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIrD;;;;OAIG;IACH,gBAAgB,IAAI,MAAM,EAAE;IAI5B;;;;;;;;;OASG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAOvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACG,qBAAqB,CACzB,OAAO,EAAE,KAAK,CAAC,UAAU,GAAG,CAAC,MAAM,UAAU,CAAC,CAAC,EAC/C,OAAO,CAAC,EAAE;QAAE,eAAe,CAAC,EAAE,OAAO,CAAA;KAAE,GACtC,OAAO,CAAC;QACT,MAAM,EAAE,MAAM,EAAE,CAAA;QAChB,MAAM,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,KAAK,CAAA;SAAE,CAAC,CAAA;KAC9C,CAAC;IAiCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoCG;IACG,qBAAqB,CACzB,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE;QACR,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;QACrB,eAAe,CAAC,EAAE,OAAO,CAAA;KAC1B,GACA,OAAO,CAAC;QACT,MAAM,EAAE,MAAM,EAAE,CAAA;QAChB,MAAM,EAAE,KAAK,CAAC;YAAE,IAAI,EAAE,MAAM,CAAC;YAAC,KAAK,EAAE,KAAK,CAAA;SAAE,CAAC,CAAA;KAC9C,CAAC;CA0FH"}