@pooder/core 0.1.0 → 1.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pooder/core",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "Core logic for Pooder editor",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -15,9 +15,7 @@
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"
   },
-  "dependencies": {
-    "fabric": "^7.0.0"
-  },
+  "dependencies": {},
   "scripts": {
     "build": "tsup src/index.ts --format cjs,esm --dts",
     "dev": "tsup src/index.ts --format cjs,esm --dts --watch"

package/src/command.ts

@@ -1,61 +1,10 @@
-import { Command, Editor } from "./types";
-
-export { CommandManager, DefaultCommandManager, CommandMap };
-
-interface CommandManager {
-  register(name: string, command: Command): void;
-  unregister(name: string): void;
-  execute(name: string, ...args: any[]): any;
-  get(name: string): Command | undefined;
-  has(name: string): boolean;
-  count(): number;
-  list(): string[];
-  clear(): void;
-}
-class CommandMap extends Map<string, Command> {}
-class DefaultCommandManager implements CommandManager {
-  private editor: Editor;
-  constructor(editor: Editor) {
-    this.editor = editor;
-  }
-
-  register(name: string, command: 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: string) {
-    this.editor.commands.delete(name);
-  }
-  execute(name: string, ...args: any[]) {
-    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: string) {
-    return this.editor.commands.get(name);
-  }
-  has(name: string) {
-    return this.editor.commands.has(name);
-  }
-  count(): number {
-    return this.editor.commands.size;
-  }
-  list() {
-    return Array.from(this.editor.commands.keys());
-  }
-  clear() {
-    this.editor.commands.clear();
-  }
+export interface CommandArgSchema {}
+
+export interface Command {
+  id: string;
+  handler: (...args: any[]) => any;
+  title?: string;
+  category?: string;
+  description?: string;
+  schema?: Record<string, CommandArgSchema>;
 }

package/src/context.ts

@@ -0,0 +1,17 @@
+import EventBus from "./event";
+import { Contribution } from "./contribution";
+import { Service } from "./service";
+import Disposable from "./disposable";
+
+interface ExtensionContext {
+  readonly eventBus: EventBus;
+  readonly services: {
+    get<T extends Service>(serviceName: string): T | undefined;
+  };
+  readonly contributions: {
+    get<T>(pointId: string): Contribution<T>[];
+    register<T>(pointId: string, contribution: Contribution<T>): Disposable;
+  };
+}
+
+export { ExtensionContext };

package/src/contribution/index.ts

@@ -0,0 +1,12 @@
+export * from "./points";
+export * from "./registry";
+
+export interface ContributionMetadata {
+  name: string;
+  extensionId: string;
+}
+export interface Contribution<T = any> {
+  id: string;
+  data: T;
+  metadata?: Partial<ContributionMetadata>;
+}

package/src/contribution/points.ts

@@ -0,0 +1,63 @@
+export interface ContributionPoint<T = any> {
+  id: string;
+  description?: string;
+  validate?: (data: T) => boolean;
+}
+
+/**
+ * Command Contribution Data Definition
+ */
+export interface CommandContribution {
+  id: string;
+  command: string;
+  title: string;
+  handler?: (...args: any[]) => any;
+}
+
+/**
+ * Tool Contribution Data Definition
+ */
+export interface ToolContribution {
+  id: string;
+  name: string;
+  description: string;
+  parameters?: Record<string, any>; // JSON Schema for parameters
+  execute: (...args: any[]) => Promise<any>;
+}
+
+/**
+ * View Contribution Data Definition
+ */
+export interface ViewContribution {
+  id: string;
+  name: string;
+  type: "sidebar" | "panel" | "editor" | "dialog" | "status-bar";
+  component: any; // The component implementation (e.g., React component or generic render function)
+  location?: string;
+  icon?: string;
+  priority?: number;
+}
+
+/**
+ * Configuration Contribution Data Definition
+ */
+export interface ConfigurationContribution {
+  id: string;
+  type: "string" | "number" | "boolean" | "color" | "select" | "json";
+  label: string;
+  default?: any;
+  description?: string;
+  options?: string[]; // For select type
+  min?: number;
+  max?: number;
+  step?: number;
+}
+
+// Built-in Contribution Point IDs
+export const ContributionPointIds = {
+  CONTRIBUTIONS: "contribution.point.contributions",
+  COMMANDS: "contribution.point.commands",
+  TOOLS: "contribution.point.tools",
+  VIEWS: "contribution.point.views",
+  CONFIGURATIONS: "contribution.point.configurations",
+};

package/src/contribution/registry.ts

@@ -0,0 +1,118 @@
+import { Contribution, ContributionPoint, ContributionPointIds } from "./index";
+import Disposable from "../disposable";
+
+export class ContributionRegistry {
+  private points: Map<string, ContributionPoint> = new Map();
+  private contributions = {
+    byId: new Map<string, Contribution>(),
+    byPointId: new Map<string, Contribution[]>(),
+  };
+
+  /**
+   * Register a new contribution point
+   */
+  registerPoint<T>(point: ContributionPoint<T>): void {
+    if (this.points.has(point.id)) {
+      console.warn(
+        `Contribution point ${point.id} already exists. Overwriting definitions may cause issues.`,
+      );
+    }
+    this.points.set(point.id, point);
+    if (!this.contributions.byPointId.has(point.id)) {
+      this.contributions.byPointId.set(point.id, []);
+    }
+  }
+
+  /**
+   * Register a contribution to a specific point
+   * @returns Disposable to unregister the contribution
+   */
+  register<T>(pointId: string, contribution: Contribution<T>): Disposable {
+    if (this.contributions.byId.has(contribution.id)) {
+      console.warn(
+        `Contribution with ID "${contribution.id}" is already registered. Overwriting.`,
+      );
+      // We could choose to throw, or overwrite. Let's overwrite for now but warn.
+      // If we overwrite, we should probably remove the old one from the list first to avoid duplicates.
+      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?.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);
+
+    // Auto-register if this is a contribution point contribution
+    if (pointId === ContributionPointIds.CONTRIBUTIONS) {
+      this.registerPoint(contribution.data as ContributionPoint);
+    }
+
+    return {
+      dispose: () => {
+        this.unregister(pointId, contribution.id);
+      },
+    };
+  }
+
+  /**
+   * Get all contributions for a given point
+   */
+  get<T>(pointId: string): Contribution<T>[] {
+    return Array.from(
+      this.contributions.byPointId.get(pointId)?.values() || [],
+    ) as Contribution<T>[];
+  }
+
+  /**
+   * Get a specific contribution by ID
+   */
+  getById<T>(id: string): Contribution<T> | undefined {
+    return this.contributions.byId.get(id) as Contribution<T> | undefined;
+  }
+
+  /**
+   * Get the contribution point definition
+   */
+  getPoint(pointId: string): ContributionPoint | undefined {
+    return this.points.get(pointId);
+  }
+
+  /**
+   * Unregister a contribution
+   */
+  private unregister(pointId: string, contributionId: string): void {
+    const arr = this.contributions.byPointId.get(pointId);
+    arr?.splice(
+      arr.findIndex((c) => c.id === contributionId),
+      1,
+    );
+    this.contributions.byId.delete(contributionId);
+  }
+}

package/src/disposable.ts

@@ -0,0 +1,3 @@
+export default interface Disposable {
+  dispose(): void;
+}

package/src/event.ts

@@ -1,12 +1,15 @@
-import { EventHandler } from "./types";
-
-export { EventBus, EventListener };
+type EventHandler = (...args: any[]) => void | boolean;
+type EventListenersMap = Map<string, EventListener[]>;
 
+interface Event {
+  name: string;
+  data: any;
+}
 interface EventListener {
   handler: EventHandler;
   priority: number;
 }
-type EventListenersMap = Map<string, EventListener[]>;
+
 class EventBus {
   private events: EventListenersMap = new Map();
 
@@ -46,3 +49,5 @@ class EventBus {
     return this.events.get(event)?.length ?? 0;
   }
 }
+
+export default EventBus;

package/src/extension.ts

@@ -1,227 +1,164 @@
-import { Editor, Extension } from "./types";
-
-export { ExtensionManager, DefaultExtensionManager, ExtensionMap };
-
-interface ExtensionManager {
-  register(extension: Extension): void;
-  unregister(name: string): void;
-  enable(name: string): void;
-  disable(name: string): void;
-  get(name: string): Extension | undefined;
-  has(name: string): boolean;
-  count(): number;
-  list(): Extension[];
-  mount(): void;
-  unmount(): void;
-  update(): void;
-  destroy(): void;
+import { ExtensionContext } from "./context";
+import { Contribution, ContributionPointIds } from "./contribution";
+import Disposable from "./disposable";
+import CommandService from "./services/CommandService";
+import { ConfigurationService } from "./services";
+
+interface ExtensionMetadata {
+  name: string;
 }
-class ExtensionMap extends Map<string, Extension> {}
-class DefaultExtensionManager implements ExtensionManager {
-  private readonly editor: Editor;
-  private mounted: boolean = false;
 
-  constructor(editor: Editor) {
-    this.editor = editor;
-  }
+interface Extension {
+  id: string;
+  metadata?: Partial<ExtensionMetadata>;
 
-  private _registerCommands(extension: Extension) {
-    if (extension.commands) {
-      Object.entries(extension.commands).forEach(([name, command]) => {
-        const commandName = `${extension.name}.${name}`;
-        this.editor.registerCommand(commandName, command);
-      });
-    }
-  }
+  activate(context: ExtensionContext): void;
+  deactivate(context: ExtensionContext): void;
+  contribute?(): Record<string, any[]>;
+}
 
-  private _unregisterCommands(extension: Extension) {
-    if (extension.commands) {
-      Object.keys(extension.commands).forEach((name) => {
-        const commandName = `${extension.name}.${name}`;
-        this.editor.unregisterCommand(commandName);
-      });
-    }
+class ExtensionRegistry extends Map<string, Extension> {}
+
+class ExtensionManager {
+  private readonly context: ExtensionContext;
+  private extensionRegistry: ExtensionRegistry = new ExtensionRegistry();
+  private extensionDisposables: Map<string, Disposable[]> = new Map();
+
+  constructor(context: ExtensionContext) {
+    this.context = context;
   }
 
   register(extension: Extension) {
-    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 === undefined) {
-        extension.enabled = true;
+    // Initialize disposables for this extension
+    this.extensionDisposables.set(extension.id, []);
+    const disposables = this.extensionDisposables.get(extension.id)!;
+
+    // Process declarative contributions
+    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: Contribution = {
+              id: contributionId,
+              metadata: {
+                extensionId: extension.id,
+                ...item?.metadata,
+              },
+              data: item,
+            };
+            const disposable = this.context.contributions.register(
+              pointId,
+              contribution,
+            );
+
+            // Track contribution registration to unregister later
+            disposables.push(disposable);
+
+            const dispose = this.collectContribution(pointId, contribution);
+            if (dispose) {
+              disposables.push(dispose);
+            }
+          });
+        }
       }
-      this.editor.extensions.set(extension.name, extension);
-      extension.onCreate?.(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 {
-          extension.onMount?.(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: string, item: any): Disposable | undefined {
+    // If registering configurations, update ConfigurationService defaults
+    if (pointId === ContributionPointIds.CONFIGURATIONS) {
+      const configService = this.context.services.get<ConfigurationService>(
+        "ConfigurationService",
+      );
+      configService?.initializeDefaults([item.data]);
     }
+    if (pointId === ContributionPointIds.COMMANDS && item.data.handler) {
+      const commandService =
+        this.context.services.get<CommandService>("CommandService")!;
 
-    console.log(`Plugin "${extension.name}" registered successfully`);
+      return commandService.registerCommand(item.id, item.data.handler);
+    }
   }
 
   unregister(name: string) {
-    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 {
-        extension.onUnmount?.(this.editor);
-      } catch (error) {
-        console.error(`Error in onUnmount hook for plugin "${name}":`, error);
-      }
-    }
-
     try {
-      extension.onDestroy?.(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);
     }
 
-    this._unregisterCommands(extension);
+    // Dispose all resources associated with this extension
+    const disposables = this.extensionDisposables.get(name);
+    if (disposables) {
+      disposables.forEach((d) => d.dispose());
+      this.extensionDisposables.delete(name);
+    }
 
-    this.editor.extensions.delete(name);
+    this.extensionRegistry.delete(name);
     console.log(`Plugin "${name}" unregistered`);
     return true;
   }
 
   enable(name: string) {
-    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 {
-        extension.onMount?.(this.editor);
-      } catch (error) {
-        console.error(`Error in onMount hook for plugin "${name}":`, error);
-      }
-    }
   }
 
   disable(name: string) {
-    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 {
-        extension.onUnmount?.(this.editor);
-      } catch (error) {
-        console.error(`Error in onUnmount hook for plugin "${name}":`, error);
-      }
-    }
   }
 
-  get(name: string) {
-    return this.editor.extensions.get(name);
-  }
-  has(name: string) {
-    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) => {
-      if (extension.enabled) {
-        try {
-          console.log(`Mounting plugin "${extension.name}"`);
-          extension.onMount?.(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) => {
-      if (extension.enabled) {
-        try {
-          extension.onUnmount?.(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) => {
-      if (extension.enabled) {
-        try {
-          extension.onUpdate?.(this.editor, state);
-        } catch (e) {
-          console.error(
-            `Error in onUpdate hook for plugin "${extension.name}":`,
-            e,
-          );
-        }
-      }
-    });
-  }
+  update() {}
 
   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;
   }
 }
+
+export { Extension, ExtensionMetadata, ExtensionRegistry, ExtensionManager };