@pooder/core 0.0.2

package/dist/index.js

@@ -0,0 +1,437 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// 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
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/event.ts
+var EventBus = class {
+  constructor() {
+    this.events = /* @__PURE__ */ new Map();
+  }
+  on(event, handler, priority = 0) {
+    if (this.events.has(event)) {
+      const listeners = this.events.get(event);
+      listeners.push({ handler, priority });
+      listeners.sort((a, b) => b.priority - a.priority);
+    } else {
+      this.events.set(event, [{ handler, priority }]);
+    }
+  }
+  off(event, handler) {
+    const listeners = this.events.get(event);
+    if (!listeners) return;
+    const index = listeners.findIndex((l) => l.handler === handler);
+    listeners.splice(index, 1);
+  }
+  emit(event, ...args) {
+    const listeners = this.events.get(event);
+    if (!listeners) return;
+    for (const { handler } of listeners) {
+      const result = handler(...args);
+      if (result === false) break;
+    }
+  }
+  clear() {
+    this.events.clear();
+  }
+  count(event) {
+    var _a, _b;
+    return (_b = (_a = this.events.get(event)) == null ? void 0 : _a.length) != null ? _b : 0;
+  }
+};
+
+// 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);
+  }
+  execute(name, ...args) {
+    const command = this.editor.commands.get(name);
+    if (!command) {
+      console.warn(`Command "${name}" not found`);
+      return false;
+    }
+    try {
+      return command.execute(...args);
+    } catch (e) {
+      console.error(`Error executing command "${name}":`, e);
+      return false;
+    }
+  }
+  get(name) {
+    return this.editor.commands.get(name);
+  }
+  has(name) {
+    return this.editor.commands.has(name);
+  }
+  count() {
+    return this.editor.commands.size;
+  }
+  list() {
+    return Array.from(this.editor.commands.keys());
+  }
+  clear() {
+    this.editor.commands.clear();
+  }
+};
+
+// 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);
+      });
+    }
+  }
+  register(extension) {
+    var _a, _b;
+    if (this.editor.extensions.has(extension.name)) {
+      console.warn(`Plugin "${extension.name}" already registered. It will be overwritten.`);
+    }
+    try {
+      if (extension.enabled === void 0) {
+        extension.enabled = true;
+      }
+      this.editor.extensions.set(extension.name, extension);
+      (_a = extension.onCreate) == null ? void 0 : _a.call(extension, this.editor);
+    } catch (error) {
+      console.error(`Error in onCreate hook for plugin "${extension.name}":`, 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);
+        }
+      }
+    }
+    console.log(`Plugin "${extension.name}" registered successfully`);
+  }
+  unregister(name) {
+    var _a, _b;
+    const extension = this.editor.extensions.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);
+    } catch (error) {
+      console.error(`Error in onDestroy hook for plugin "${name}":`, error);
+    }
+    this._unregisterCommands(extension);
+    this.editor.extensions.delete(name);
+    console.log(`Plugin "${name}" unregistered`);
+    return true;
+  }
+  enable(name) {
+    var _a;
+    const extension = this.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);
+    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 {
+          (_a = extension.onMount) == null ? void 0 : _a.call(extension, this.editor);
+        } catch (e) {
+          console.error(`Error in onMount hook for plugin "${extension.name}":`, e);
+        }
+      }
+    });
+    this.mounted = true;
+  }
+  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());
+    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();
+    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 });
+    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");
+    }
+    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();
+  }
+  enableExtension(name) {
+    this.extensionManager.enable(name);
+    this.emit("update", this.state);
+  }
+  disableExtension(name) {
+    this.extensionManager.disable(name);
+    this.emit("update", this.state);
+  }
+  registerCommand(name, command) {
+    this.commandManager.register(name, command);
+  }
+  unregisterCommand(name) {
+    this.commandManager.unregister(name);
+  }
+  executeCommand(name, ...args) {
+    if (this.destroyed) {
+      console.warn("Cannot execute command: Editor is destroyed");
+      return false;
+    }
+    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);
+  }
+  emit(event, ...args) {
+    this.eventBus.emit(event, ...args);
+  }
+  getObjects() {
+    if (this.destroyed) {
+      throw new Error("Cannot get objects: Editor is destroyed");
+    }
+    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 objs == null ? void 0 : objs.find((obj) => {
+      var _a2;
+      return ((_a2 = obj == null ? void 0 : obj.data) == null ? void 0 : _a2.id) === id;
+    });
+  }
+  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;
+    });
+  }
+  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() {
+    return {
+      width: this.state.width,
+      height: this.state.height,
+      metadata: this.state.metadata
+    };
+  }
+  async loadFromJSON(json) {
+  }
+  getState() {
+    return { ...this.state };
+  }
+  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;
+  }
+};
+
+// 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
+});