@pooder/core 0.1.0 → 1.0.0

package/dist/index.js

@@ -20,25 +20,37 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Circle: () => import_fabric4.Circle,
-  Ellipse: () => import_fabric4.Ellipse,
-  Group: () => import_fabric4.Group,
-  Image: () => import_fabric4.FabricImage,
-  Line: () => import_fabric4.Line,
-  Path: () => import_fabric4.Path,
-  Pattern: () => import_fabric4.Pattern,
-  Point: () => import_fabric4.Point,
-  PooderCanvas: () => import_fabric.Canvas,
-  PooderEditor: () => PooderEditor,
-  PooderLayer: () => import_fabric2.Group,
-  PooderObject: () => import_fabric3.FabricObject,
-  Rect: () => import_fabric4.Rect,
-  Text: () => import_fabric4.Text,
-  filters: () => import_fabric4.filters,
-  util: () => import_fabric4.util
+  CommandService: () => CommandService,
+  ConfigurationService: () => ConfigurationService,
+  ContributionPointIds: () => ContributionPointIds,
+  ContributionRegistry: () => ContributionRegistry,
+  ExtensionManager: () => ExtensionManager,
+  ExtensionRegistry: () => ExtensionRegistry,
+  Pooder: () => Pooder,
+  ServiceRegistry: () => ServiceRegistry
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/service.ts
+var ServiceRegistry = class {
+  constructor() {
+    this.services = /* @__PURE__ */ new Map();
+  }
+  register(name, service) {
+    this.services.set(name, service);
+    return service;
+  }
+  get(serviceName) {
+    return this.services.get(serviceName);
+  }
+  has(serviceName) {
+    return this.services.has(serviceName);
+  }
+  delete(serviceName) {
+    this.services.delete(serviceName);
+  }
+};
+
 // src/event.ts
 var EventBus = class {
   constructor() {
@@ -75,440 +87,500 @@ var EventBus = class {
     return (_b = (_a = this.events.get(event)) == null ? void 0 : _a.length) != null ? _b : 0;
   }
 };
+var event_default = EventBus;
 
-// src/command.ts
-var DefaultCommandManager = class {
-  constructor(editor) {
-    this.editor = editor;
-  }
-  register(name, command) {
-    if (this.editor.commands.has(name)) {
-      console.warn(`Command "${name}" already exists. It will be overwritten.`);
-    }
-    this.editor.commands.set(name, command);
-  }
-  unregister(name) {
-    this.editor.commands.delete(name);
+// src/contribution/points.ts
+var ContributionPointIds = {
+  CONTRIBUTIONS: "contribution.point.contributions",
+  COMMANDS: "contribution.point.commands",
+  TOOLS: "contribution.point.tools",
+  VIEWS: "contribution.point.views",
+  CONFIGURATIONS: "contribution.point.configurations"
+};
+
+// src/contribution/registry.ts
+var ContributionRegistry = class {
+  constructor() {
+    this.points = /* @__PURE__ */ new Map();
+    this.contributions = {
+      byId: /* @__PURE__ */ new Map(),
+      byPointId: /* @__PURE__ */ new Map()
+    };
   }
-  execute(name, ...args) {
-    const command = this.editor.commands.get(name);
-    if (!command) {
-      console.warn(`Command "${name}" not found`);
-      return false;
+  /**
+   * Register a new contribution point
+   */
+  registerPoint(point) {
+    if (this.points.has(point.id)) {
+      console.warn(
+        `Contribution point ${point.id} already exists. Overwriting definitions may cause issues.`
+      );
     }
-    try {
-      return command.execute(...args);
-    } catch (e) {
-      console.error(`Error executing command "${name}":`, e);
-      return false;
+    this.points.set(point.id, point);
+    if (!this.contributions.byPointId.has(point.id)) {
+      this.contributions.byPointId.set(point.id, []);
     }
   }
-  get(name) {
-    return this.editor.commands.get(name);
-  }
-  has(name) {
-    return this.editor.commands.has(name);
-  }
-  count() {
-    return this.editor.commands.size;
+  /**
+   * Register a contribution to a specific point
+   * @returns Disposable to unregister the contribution
+   */
+  register(pointId, contribution) {
+    if (this.contributions.byId.has(contribution.id)) {
+      console.warn(
+        `Contribution with ID "${contribution.id}" is already registered. Overwriting.`
+      );
+      this.unregister(pointId, contribution.id);
+    }
+    if (!this.points.has(pointId)) {
+      console.warn(
+        `Contribution point ${pointId} does not exist. The contribution ${contribution.id} will be queued but may not be valid.`
+      );
+      if (!this.contributions.byPointId.has(pointId)) {
+        this.contributions.byPointId.set(pointId, []);
+      }
+    }
+    const point = this.points.get(pointId);
+    if (point == null ? void 0 : point.validate) {
+      try {
+        if (!point.validate(contribution.data)) {
+          console.error(
+            `Contribution ${contribution.id} failed validation for point ${pointId}.`
+          );
+          return { dispose: () => {
+          } };
+        }
+      } catch (e) {
+        console.error(
+          `Validation error for contribution ${contribution.id}:`,
+          e
+        );
+        return { dispose: () => {
+        } };
+      }
+    }
+    const arr = this.contributions.byPointId.get(pointId);
+    arr.push(contribution);
+    this.contributions.byId.set(contribution.id, contribution);
+    if (pointId === ContributionPointIds.CONTRIBUTIONS) {
+      this.registerPoint(contribution.data);
+    }
+    return {
+      dispose: () => {
+        this.unregister(pointId, contribution.id);
+      }
+    };
   }
-  list() {
-    return Array.from(this.editor.commands.keys());
+  /**
+   * Get all contributions for a given point
+   */
+  get(pointId) {
+    var _a;
+    return Array.from(
+      ((_a = this.contributions.byPointId.get(pointId)) == null ? void 0 : _a.values()) || []
+    );
   }
-  clear() {
-    this.editor.commands.clear();
+  /**
+   * Get a specific contribution by ID
+   */
+  getById(id) {
+    return this.contributions.byId.get(id);
+  }
+  /**
+   * Get the contribution point definition
+   */
+  getPoint(pointId) {
+    return this.points.get(pointId);
+  }
+  /**
+   * Unregister a contribution
+   */
+  unregister(pointId, contributionId) {
+    const arr = this.contributions.byPointId.get(pointId);
+    arr == null ? void 0 : arr.splice(
+      arr.findIndex((c) => c.id === contributionId),
+      1
+    );
+    this.contributions.byId.delete(contributionId);
   }
 };
 
 // src/extension.ts
-var DefaultExtensionManager = class {
-  constructor(editor) {
-    this.mounted = false;
-    this.editor = editor;
-  }
-  _registerCommands(extension) {
-    if (extension.commands) {
-      Object.entries(extension.commands).forEach(([name, command]) => {
-        const commandName = `${extension.name}.${name}`;
-        this.editor.registerCommand(commandName, command);
-      });
-    }
-  }
-  _unregisterCommands(extension) {
-    if (extension.commands) {
-      Object.keys(extension.commands).forEach((name) => {
-        const commandName = `${extension.name}.${name}`;
-        this.editor.unregisterCommand(commandName);
-      });
-    }
+var ExtensionRegistry = class extends Map {
+};
+var ExtensionManager = class {
+  constructor(context) {
+    this.extensionRegistry = new ExtensionRegistry();
+    this.extensionDisposables = /* @__PURE__ */ new Map();
+    this.context = context;
   }
   register(extension) {
-    var _a, _b;
-    if (this.editor.extensions.has(extension.name)) {
+    if (this.extensionRegistry.has(extension.id)) {
       console.warn(
-        `Plugin "${extension.name}" already registered. It will be overwritten.`
+        `Plugin "${extension.id}" already registered. It will be overwritten.`
       );
     }
-    try {
-      if (extension.enabled === void 0) {
-        extension.enabled = true;
+    this.extensionDisposables.set(extension.id, []);
+    const disposables = this.extensionDisposables.get(extension.id);
+    if (extension.contribute) {
+      for (const [pointId, items] of Object.entries(extension.contribute())) {
+        if (Array.isArray(items)) {
+          items.forEach((item, index) => {
+            const contributionId = item.id || (item.command ? item.command : `${extension.id}.${pointId}.${index}`);
+            const contribution = {
+              id: contributionId,
+              metadata: {
+                extensionId: extension.id,
+                ...item == null ? void 0 : item.metadata
+              },
+              data: item
+            };
+            const disposable = this.context.contributions.register(
+              pointId,
+              contribution
+            );
+            disposables.push(disposable);
+            const dispose = this.collectContribution(pointId, contribution);
+            if (dispose) {
+              disposables.push(dispose);
+            }
+          });
+        }
       }
-      this.editor.extensions.set(extension.name, extension);
-      (_a = extension.onCreate) == null ? void 0 : _a.call(extension, this.editor);
+    }
+    try {
+      this.extensionRegistry.set(extension.id, extension);
+      this.context.eventBus.emit("extension:register", extension);
     } catch (error) {
       console.error(
-        `Error in onCreate hook for plugin "${extension.name}":`,
+        `Error in onCreate hook for plugin "${extension.id}":`,
         error
       );
     }
-    if (extension.enabled) {
-      this._registerCommands(extension);
-      if (this.mounted) {
-        try {
-          (_b = extension.onMount) == null ? void 0 : _b.call(extension, this.editor);
-        } catch (error) {
-          console.error(
-            `Error in onMount hook for plugin "${extension.name}":`,
-            error
-          );
-        }
-      }
+    try {
+      extension.activate(this.context);
+    } catch (error) {
+      console.error(
+        `Error in onActivate hook for plugin "${extension.id}":`,
+        error
+      );
+    }
+    console.log(`Plugin "${extension.id}" registered successfully`);
+  }
+  collectContribution(pointId, item) {
+    if (pointId === ContributionPointIds.CONFIGURATIONS) {
+      const configService = this.context.services.get(
+        "ConfigurationService"
+      );
+      configService == null ? void 0 : configService.initializeDefaults([item.data]);
+    }
+    if (pointId === ContributionPointIds.COMMANDS && item.data.handler) {
+      const commandService = this.context.services.get("CommandService");
+      return commandService.registerCommand(item.id, item.data.handler);
     }
-    console.log(`Plugin "${extension.name}" registered successfully`);
   }
   unregister(name) {
-    var _a, _b;
-    const extension = this.editor.extensions.get(name);
+    const extension = this.extensionRegistry.get(name);
     if (!extension) {
       console.warn(`Plugin "${name}" not found.`);
       return;
     }
-    if (this.mounted && extension.enabled) {
-      try {
-        (_a = extension.onUnmount) == null ? void 0 : _a.call(extension, this.editor);
-      } catch (error) {
-        console.error(`Error in onUnmount hook for plugin "${name}":`, error);
-      }
-    }
     try {
-      (_b = extension.onDestroy) == null ? void 0 : _b.call(extension, this.editor);
+      extension.deactivate(this.context);
     } catch (error) {
-      console.error(`Error in onDestroy hook for plugin "${name}":`, error);
+      console.error(`Error in deactivate for plugin "${name}":`, error);
+    }
+    const disposables = this.extensionDisposables.get(name);
+    if (disposables) {
+      disposables.forEach((d) => d.dispose());
+      this.extensionDisposables.delete(name);
     }
-    this._unregisterCommands(extension);
-    this.editor.extensions.delete(name);
+    this.extensionRegistry.delete(name);
     console.log(`Plugin "${name}" unregistered`);
     return true;
   }
   enable(name) {
-    var _a;
-    const extension = this.get(name);
+    const extension = this.extensionRegistry.get(name);
     if (!extension) {
       console.warn(`Plugin "${name}" not found.`);
       return;
     }
-    if (extension.enabled) return;
-    extension.enabled = true;
-    this._registerCommands(extension);
-    if (this.mounted) {
-      try {
-        (_a = extension.onMount) == null ? void 0 : _a.call(extension, this.editor);
-      } catch (error) {
-        console.error(`Error in onMount hook for plugin "${name}":`, error);
-      }
-    }
   }
   disable(name) {
-    var _a;
-    const extension = this.get(name);
+    const extension = this.extensionRegistry.get(name);
     if (!extension) {
       console.warn(`Plugin "${name}" not found.`);
       return;
     }
-    if (!extension.enabled) return;
-    extension.enabled = false;
-    this._unregisterCommands(extension);
-    if (this.mounted) {
-      try {
-        (_a = extension.onUnmount) == null ? void 0 : _a.call(extension, this.editor);
-      } catch (error) {
-        console.error(`Error in onUnmount hook for plugin "${name}":`, error);
-      }
-    }
-  }
-  get(name) {
-    return this.editor.extensions.get(name);
-  }
-  has(name) {
-    return this.editor.extensions.has(name);
-  }
-  count() {
-    return this.editor.extensions.size;
-  }
-  list() {
-    return Array.from(this.editor.extensions.values());
-  }
-  mount() {
-    if (this.mounted) return;
-    this.editor.extensions.forEach((extension) => {
-      var _a;
-      if (extension.enabled) {
-        try {
-          console.log(`Mounting plugin "${extension.name}"`);
-          (_a = extension.onMount) == null ? void 0 : _a.call(extension, this.editor);
-        } catch (e) {
-          console.error(
-            `Error in onMount hook for plugin "${extension.name}":`,
-            e
-          );
-        }
-      }
-    });
-    console.log(`Plugins mounted`);
-    this.mounted = true;
-  }
-  unmount() {
-    if (!this.mounted) return;
-    this.editor.extensions.forEach((extension) => {
-      var _a;
-      if (extension.enabled) {
-        try {
-          (_a = extension.onUnmount) == null ? void 0 : _a.call(extension, this.editor);
-        } catch (e) {
-          console.error(
-            `Error in onUnmount hook for plugin "${extension.name}":`,
-            e
-          );
-        }
-      }
-    });
-    console.log(`Plugins unmounted`);
-    this.mounted = false;
   }
   update() {
-    const state = this.editor.getState();
-    this.editor.extensions.forEach((extension) => {
-      var _a;
-      if (extension.enabled) {
-        try {
-          (_a = extension.onUpdate) == null ? void 0 : _a.call(extension, this.editor, state);
-        } catch (e) {
-          console.error(
-            `Error in onUpdate hook for plugin "${extension.name}":`,
-            e
-          );
-        }
-      }
-    });
   }
   destroy() {
-    const extensionNames = Array.from(this.editor.extensions.keys());
+    const extensionNames = Array.from(this.extensionRegistry.keys());
     extensionNames.forEach((name) => this.unregister(name));
-    this.mounted = false;
   }
 };
 
-// src/canvas.ts
-var import_fabric = require("fabric");
-
-// src/editor.ts
-var PooderEditor = class {
-  constructor(el, options = {}) {
-    this.extensions = /* @__PURE__ */ new Map();
+// src/services/CommandService.ts
+var CommandService = class {
+  constructor() {
     this.commands = /* @__PURE__ */ new Map();
-    this.destroyed = false;
-    this.state = {
-      width: options.width || 800,
-      height: options.height || 600
-    };
-    this.canvas = new import_fabric.Canvas(el, {
-      width: this.state.width,
-      height: this.state.height,
-      preserveObjectStacking: true
-    });
-    this.eventBus = new EventBus();
-    this.commandManager = new DefaultCommandManager(this);
-    this.extensionManager = new DefaultExtensionManager(this);
-    if (options.extensions && options.extensions.length > 0) {
-      options.extensions.forEach(this.extensionManager.register);
-    }
-    this.extensionManager.mount();
-    console.log(
-      "Editor initialized with",
-      this.extensionManager.count(),
-      "plugins"
-    );
   }
-  use(extension) {
-    if (this.destroyed) {
-      throw new Error("Cannot register plugin: Editor is destroyed");
+  /**
+   * Register a command
+   * @param commandId Command Name (ID)
+   * @param handler Command handler function
+   * @param thisArg The `this` context for the handler
+   * @returns Disposable to unregister the command
+   */
+  registerCommand(commandId, handler, thisArg) {
+    if (this.commands.has(commandId)) {
+      console.warn(
+        `Command "${commandId}" is already registered. Overwriting.`
+      );
     }
-    this.extensionManager.register(extension);
-    this.emit("update", this.state);
-  }
-  unuse(name) {
-    return this.extensionManager.unregister(name);
-  }
-  getExtension(name) {
-    return this.extensionManager.get(name);
-  }
-  getExtensions() {
-    return this.extensionManager.list();
+    const command = {
+      id: commandId,
+      handler: thisArg ? handler.bind(thisArg) : handler
+    };
+    this.commands.set(commandId, command);
+    return {
+      dispose: () => {
+        if (this.commands.get(commandId) === command) {
+          this.commands.delete(commandId);
+        }
+      }
+    };
   }
-  enableExtension(name) {
-    this.extensionManager.enable(name);
-    this.emit("update", this.state);
+  /**
+   * Execute a command
+   * @param commandId Command Name (ID)
+   * @param args Arguments to pass to the handler
+   * @returns The result of the command handler
+   */
+  async executeCommand(commandId, ...args) {
+    const command = this.commands.get(commandId);
+    if (!command) {
+      throw new Error(`Command "${commandId}" not found.`);
+    }
+    try {
+      return await command.handler(...args);
+    } catch (error) {
+      console.error(`Error executing command "${commandId}":`, error);
+      throw error;
+    }
   }
-  disableExtension(name) {
-    this.extensionManager.disable(name);
-    this.emit("update", this.state);
+  /**
+   * Get all registered commands
+   */
+  getCommands() {
+    return this.commands;
   }
-  registerCommand(name, command) {
-    this.commandManager.register(name, command);
+  /**
+   * Get a specific command
+   */
+  getCommand(commandId) {
+    return this.commands.get(commandId);
   }
-  unregisterCommand(name) {
-    this.commandManager.unregister(name);
+  dispose() {
+    this.commands.clear();
   }
-  executeCommand(name, ...args) {
-    if (this.destroyed) {
-      console.warn("Cannot execute command: Editor is destroyed");
-      return false;
+};
+
+// src/services/ConfigurationService.ts
+var ConfigurationService = class {
+  constructor() {
+    this.configValues = /* @__PURE__ */ new Map();
+    this.eventBus = new event_default();
+  }
+  /**
+   * Get a configuration value.
+   */
+  get(key, defaultValue) {
+    if (this.configValues.has(key)) {
+      return this.configValues.get(key);
+    }
+    return defaultValue;
+  }
+  /**
+   * Update a configuration value.
+   * Emits 'change' event.
+   */
+  update(key, value) {
+    const oldValue = this.configValues.get(key);
+    if (oldValue !== value) {
+      this.configValues.set(key, value);
+      this.eventBus.emit(`change:${key}`, { key, value, oldValue });
+      this.eventBus.emit("change", { key, value, oldValue });
     }
-    this.emit("beforeCommand", name, ...args);
-    const result = this.commandManager.execute(name, ...args);
-    this.emit("afterCommand", name, args, result);
-    return result;
-  }
-  on(event, handler, priority) {
-    this.eventBus.on(event, handler, priority);
   }
-  off(event, handler) {
-    this.eventBus.off(event, handler);
+  /**
+   * Listen for changes to a specific configuration key.
+   */
+  onDidChange(key, callback) {
+    this.eventBus.on(`change:${key}`, callback);
+    return {
+      dispose: () => this.eventBus.off(`change:${key}`, callback)
+    };
   }
-  emit(event, ...args) {
-    this.eventBus.emit(event, ...args);
+  /**
+   * Listen for any configuration change.
+   */
+  onAnyChange(callback) {
+    this.eventBus.on("change", callback);
+    return {
+      dispose: () => this.eventBus.off("change", callback)
+    };
   }
-  getObjects() {
-    if (this.destroyed) {
-      throw new Error("Cannot get objects: Editor is destroyed");
+  /**
+   * Export current configuration state as a JSON-serializable object.
+   * Useful for saving configuration templates.
+   */
+  export() {
+    const exportData = {};
+    for (const [key, value] of this.configValues) {
+      exportData[key] = value;
     }
-    return this.canvas.getObjects();
-  }
-  getObject(id, layerId) {
-    var _a;
-    let objs;
-    if (layerId) {
-      objs = (_a = this.getLayer(layerId)) == null ? void 0 : _a.getObjects();
-    } else {
-      objs = this.getObjects();
+    return exportData;
+  }
+  /**
+   * Import configuration from a JSON object.
+   * This will merge the provided configuration with the current state,
+   * overwriting existing keys and triggering change events.
+   */
+  import(data) {
+    if (!data || typeof data !== "object") {
+      console.warn("ConfigurationService: Import data must be an object.");
+      return;
     }
-    return objs == null ? void 0 : objs.find((obj) => {
-      var _a2;
-      return ((_a2 = obj == null ? void 0 : obj.data) == null ? void 0 : _a2.id) === id;
+    Object.entries(data).forEach(([key, value]) => {
+      this.update(key, value);
     });
   }
-  getLayers() {
-    return this.getObjects().filter(
-      (obj) => obj.type === "group"
-    );
-  }
-  getLayer(id) {
-    return this.getLayers().find((obj) => {
-      var _a;
-      return ((_a = obj == null ? void 0 : obj.data) == null ? void 0 : _a.id) === id;
+  /**
+   * Initialize configuration with defaults from contributions.
+   * This should be called when a contribution is registered.
+   */
+  initializeDefaults(contributions) {
+    contributions.forEach((contrib) => {
+      if (!contrib.id) {
+        console.warn(
+          "Configuration contribution missing 'id'. Skipping default initialization.",
+          contrib
+        );
+        return;
+      }
+      if (!this.configValues.has(contrib.id) && contrib.default !== void 0) {
+        this.configValues.set(contrib.id, contrib.default);
+      }
     });
   }
-  updateState(updater) {
-    if (this.destroyed) {
-      console.warn("Cannot update state: Editor is destroyed");
-      return;
-    }
-    this.state = updater(this.state);
-    this.extensionManager.update();
-    this.emit("update", this.state);
-  }
-  toJSON() {
-    const extensions = {};
-    this.extensionManager.list().forEach((ext) => {
-      if (ext.toJSON) {
-        extensions[ext.name] = ext.toJSON();
-      } else if (ext.options) {
-        extensions[ext.name] = ext.options;
+  dispose() {
+    this.configValues.clear();
+  }
+};
+
+// src/index.ts
+var Pooder = class {
+  constructor() {
+    this.eventBus = new event_default();
+    this.services = new ServiceRegistry();
+    this.contributions = new ContributionRegistry();
+    this.initDefaultContributionPoints();
+    const commandService = new CommandService();
+    this.registerService(commandService);
+    const configurationService = new ConfigurationService();
+    this.registerService(configurationService);
+    const context = {
+      eventBus: this.eventBus,
+      services: {
+        get: (serviceName) => this.services.get(serviceName)
+      },
+      contributions: {
+        get: (pointId) => this.getContributions(pointId),
+        register: (pointId, contribution) => this.registerContribution(pointId, contribution)
       }
-    });
-    return {
-      width: this.state.width,
-      height: this.state.height,
-      metadata: this.state.metadata,
-      extensions
     };
+    this.extensionManager = new ExtensionManager(context);
   }
-  async loadFromJSON(json) {
-    if (!json) return;
-    this.extensionManager.unmount();
-    this.canvas.clear();
-    this.extensionManager.mount();
-    if (json.extensions) {
-      for (const [name, data] of Object.entries(json.extensions)) {
-        const ext = this.extensionManager.get(name);
-        if (ext) {
-          if (ext.loadFromJSON) {
-            await ext.loadFromJSON(data);
-          } else if (data) {
-            ext.options = data;
-          }
-        }
-      }
+  initDefaultContributionPoints() {
+    this.registerContributionPoint({
+      id: ContributionPointIds.CONTRIBUTIONS,
+      description: "Contribution point for contribution points"
+    });
+    this.registerContributionPoint({
+      id: ContributionPointIds.COMMANDS,
+      description: "Contribution point for commands"
+    });
+    this.registerContributionPoint({
+      id: ContributionPointIds.TOOLS,
+      description: "Contribution point for tools"
+    });
+    this.registerContributionPoint({
+      id: ContributionPointIds.VIEWS,
+      description: "Contribution point for UI views"
+    });
+    this.registerContributionPoint({
+      id: ContributionPointIds.CONFIGURATIONS,
+      description: "Contribution point for configurations"
+    });
+  }
+  // --- Service Management ---
+  registerService(service) {
+    var _a;
+    const serviceId = service.constructor.name;
+    try {
+      (_a = service == null ? void 0 : service.init) == null ? void 0 : _a.call(service);
+    } catch (e) {
+      console.error(`Error initializing service ${serviceId}:`, e);
+      return false;
+    }
+    this.services.register(serviceId, service);
+    this.eventBus.emit("service:register", service);
+    return true;
+  }
+  unregisterService(service) {
+    var _a;
+    const serviceId = service.constructor.name;
+    if (!this.services.has(serviceId)) {
+      console.warn(`Service ${serviceId} is not registered.`);
+      return true;
+    }
+    try {
+      (_a = service == null ? void 0 : service.dispose) == null ? void 0 : _a.call(service);
+    } catch (e) {
+      console.error(`Error disposing service ${serviceId}:`, e);
+      return false;
     }
-    this.updateState((state) => ({
-      ...state,
-      width: json.width,
-      height: json.height,
-      metadata: json.metadata
-    }));
+    this.services.delete(serviceId);
+    this.eventBus.emit("service:unregister", service);
+    return true;
   }
-  getState() {
-    return { ...this.state };
+  getService(id) {
+    return this.services.get(id);
   }
-  destroy() {
-    if (this.destroyed) return;
-    this.emit("beforeDestroy");
-    this.canvas.dispose();
-    this.extensionManager.destroy();
-    this.eventBus.clear();
-    this.commandManager.clear();
-    this.destroyed = true;
-    console.log("Editor destroyed");
-  }
-  isDestroyed() {
-    return this.destroyed;
+  // --- Contribution Management ---
+  registerContributionPoint(point) {
+    this.contributions.registerPoint(point);
+    this.eventBus.emit("contribution:point:register", point);
+  }
+  registerContribution(pointId, contribution) {
+    const disposable = this.contributions.register(pointId, contribution);
+    this.eventBus.emit("contribution:register", { ...contribution, pointId });
+    return disposable;
+  }
+  getContributions(pointId) {
+    return this.contributions.get(pointId);
   }
 };
-
-// src/layer.ts
-var import_fabric2 = require("fabric");
-
-// src/obj.ts
-var import_fabric3 = require("fabric");
-
-// src/index.ts
-var import_fabric4 = require("fabric");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Circle,
-  Ellipse,
-  Group,
-  Image,
-  Line,
-  Path,
-  Pattern,
-  Point,
-  PooderCanvas,
-  PooderEditor,
-  PooderLayer,
-  PooderObject,
-  Rect,
-  Text,
-  filters,
-  util
+  CommandService,
+  ConfigurationService,
+  ContributionPointIds,
+  ContributionRegistry,
+  ExtensionManager,
+  ExtensionRegistry,
+  Pooder,
+  ServiceRegistry
 });