@pooder/core 0.1.0 → 1.0.0

package/src/index.ts

@@ -1,31 +1,140 @@
-export { PooderEditor } from "./editor";
-
-export { PooderCanvas } from "./canvas";
-export { PooderLayer } from "./layer";
-export { PooderObject } from "./obj";
-
-export type {
-  Editor,
-  EditorState,
-  Command,
-  Event,
-  EventHandler,
-  Extension,
-  ExtensionOptions,
-  OptionSchema,
-} from "./types";
-
-export {
-  FabricImage as Image,
-  Ellipse,
-  Rect,
-  Circle,
-  Line,
-  Text,
-  Group,
-  Path,
-  Point,
-  Pattern,
-  filters,
-  util,
-} from "fabric";
+import { Service, ServiceRegistry } from "./service";
+import EventBus from "./event";
+import { ExtensionManager } from "./extension";
+import Disposable from "./disposable";
+import {
+  Contribution,
+  ContributionPoint,
+  ContributionPointIds,
+  ContributionRegistry,
+} from "./contribution";
+import { CommandService, ConfigurationService } from "./services";
+import { ExtensionContext } from "./context";
+
+export * from "./extension";
+export * from "./context";
+export * from "./contribution";
+export * from "./service";
+export * from "./services";
+
+export class Pooder {
+  readonly eventBus: EventBus = new EventBus();
+  private readonly services: ServiceRegistry = new ServiceRegistry();
+  private readonly contributions: ContributionRegistry =
+    new ContributionRegistry();
+  readonly extensionManager: ExtensionManager;
+
+  constructor() {
+    // Initialize default contribution points
+    this.initDefaultContributionPoints();
+
+    const commandService = new CommandService();
+    this.registerService(commandService);
+
+    const configurationService = new ConfigurationService();
+    this.registerService(configurationService);
+
+    // Create a restricted context for extensions
+    const context: ExtensionContext = {
+      eventBus: this.eventBus,
+      services: {
+        get: <T extends Service>(serviceName: string) =>
+          this.services.get<T>(serviceName),
+      },
+      contributions: {
+        get: <T>(pointId: string) => this.getContributions<T>(pointId),
+        register: <T>(pointId: string, contribution: Contribution<T>) =>
+          this.registerContribution(pointId, contribution),
+      },
+    };
+
+    this.extensionManager = new ExtensionManager(context);
+  }
+
+  private 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: Service) {
+    const serviceId = service.constructor.name;
+
+    try {
+      service?.init?.();
+    } 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: Service) {
+    const serviceId = service.constructor.name;
+    if (!this.services.has(serviceId)) {
+      console.warn(`Service ${serviceId} is not registered.`);
+      return true;
+    }
+
+    try {
+      service?.dispose?.();
+    } catch (e) {
+      console.error(`Error disposing service ${serviceId}:`, e);
+      return false;
+    }
+
+    this.services.delete(serviceId);
+    this.eventBus.emit("service:unregister", service);
+    return true;
+  }
+
+  getService<T extends Service>(id: string): T | undefined {
+    return this.services.get<T>(id);
+  }
+
+  // --- Contribution Management ---
+
+  registerContributionPoint<T>(point: ContributionPoint<T>): void {
+    this.contributions.registerPoint(point);
+    this.eventBus.emit("contribution:point:register", point);
+  }
+
+  registerContribution<T>(
+    pointId: string,
+    contribution: Contribution<T>,
+  ): Disposable {
+    const disposable = this.contributions.register(pointId, contribution);
+    this.eventBus.emit("contribution:register", { ...contribution, pointId });
+    return disposable;
+  }
+
+  getContributions<T>(pointId: string): Contribution<T>[] {
+    return this.contributions.get<T>(pointId);
+  }
+}

package/src/run-test-full.ts

@@ -0,0 +1,98 @@
+import { Pooder } from "./index";
+import { fullExtension } from "./test-extension-full";
+import { ContributionPointIds } from "./contribution";
+import CommandService from "./services/CommandService";
+
+async function runTest() {
+  console.log("Starting Test...");
+  const app = new Pooder();
+
+  // Register the full extension
+  console.log("Registering extension...");
+  app.extensionManager.register(fullExtension);
+  const commandService = app.getService<CommandService>("CommandService")!;
+
+  // 1. Verify Command Contributions
+  console.log("\n--- Verifying Commands ---");
+
+  // 1.1 Imperative Command
+  try {
+    const res = await commandService.executeCommand(
+      "test.imperative.hello",
+      "User",
+    );
+    console.log(
+      `[Imperative] "test.imperative.hello" result: "${res}"` ===
+        `[Imperative] "test.imperative.hello" result: "Hello Imperative User"`
+        ? "✅ PASS"
+        : "❌ FAIL",
+    );
+  } catch (e) {
+    console.error("❌ FAIL: Imperative command failed", e);
+  }
+
+  // 1.2 Declarative Auto-Registered Command
+  try {
+    const res = await commandService.executeCommand("test.declarative.auto");
+    console.log(
+      `[Declarative] "test.declarative.auto" result: "${res}"` ===
+        `[Declarative] "test.declarative.auto" result: "Auto Registered Result"`
+        ? "✅ PASS"
+        : "❌ FAIL",
+    );
+  } catch (e) {
+    console.error("❌ FAIL: Declarative auto-registered command failed", e);
+  }
+
+  // 2. Verify Registry Entries
+  console.log("\n--- Verifying Contribution Registry ---");
+
+  const commands = app.getContributions(ContributionPointIds.COMMANDS);
+  console.log(
+    `Commands registered: ${commands.length}` === "Commands registered: 2"
+      ? "✅ PASS (2 commands found)"
+      : `❌ FAIL (${commands.length} commands found)`,
+  );
+
+  const tools = app.getContributions(ContributionPointIds.TOOLS);
+  console.log(
+    `Tools registered: ${tools.length}` === "Tools registered: 1"
+      ? "✅ PASS (1 tool found)"
+      : `❌ FAIL (${tools.length} tools found)`,
+  );
+
+  const views = app.getContributions(ContributionPointIds.VIEWS);
+  console.log(
+    `Views registered: ${views.length}` === "Views registered: 1"
+      ? "✅ PASS (1 view found)"
+      : `❌ FAIL (${views.length} views found)`,
+  );
+
+  // 3. Unregister and Verify Cleanup
+  console.log("\n--- Verifying Unregistration/Cleanup ---");
+  // The ID is now explicit: "full-feature-test-extension"
+  const extensionId = "full-feature-test-extension";
+  app.extensionManager.unregister(extensionId);
+
+  const commandsAfter = app.getContributions(ContributionPointIds.COMMANDS);
+  console.log(
+    `Commands after unregister: ${commandsAfter.length}` ===
+      "Commands after unregister: 0"
+      ? "✅ PASS"
+      : `❌ FAIL (${commandsAfter.length} left)`,
+  );
+
+  // Verify command service cleanup
+  const cmdMap = commandService.getCommands();
+  const hasCmd = cmdMap.has("test.declarative.auto");
+  console.log(
+    `Command service cleaned up: ${!hasCmd}` ===
+      "Command service cleaned up: true"
+      ? "✅ PASS"
+      : "❌ FAIL (Command still exists)",
+  );
+
+  console.log("\nTest Completed.");
+}
+
+runTest().catch(console.error);

package/src/service.ts

@@ -0,0 +1,25 @@
+export interface Service {
+  init?(): void;
+  dispose?(): void;
+}
+
+export class ServiceRegistry {
+  private services: Map<string, Service> = new Map();
+
+  register<T extends Service>(name: string, service: T): T {
+    this.services.set(name, service);
+    return service;
+  }
+
+  get<T extends Service>(serviceName: string): T | undefined {
+    return this.services.get(serviceName) as T | undefined;
+  }
+
+  has(serviceName: string): boolean {
+    return this.services.has(serviceName);
+  }
+
+  delete(serviceName: string): void {
+    this.services.delete(serviceName);
+  }
+}

package/src/services/CommandService.ts

@@ -0,0 +1,79 @@
+import { Command } from "../command";
+import Disposable from "../disposable";
+import { Service } from "../service";
+
+export default class CommandService implements Service {
+  private commands: Map<string, Command> = new Map();
+
+  /**
+   * 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: string,
+    handler: (...args: any[]) => any,
+    thisArg?: any,
+  ): Disposable {
+    if (this.commands.has(commandId)) {
+      console.warn(
+        `Command "${commandId}" is already registered. Overwriting.`,
+      );
+    }
+
+    const command: 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);
+        }
+      },
+    };
+  }
+
+  /**
+   * 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<T = any>(commandId: string, ...args: any[]): Promise<T> {
+    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;
+    }
+  }
+
+  /**
+   * Get all registered commands
+   */
+  getCommands(): Map<string, Command> {
+    return this.commands;
+  }
+
+  /**
+   * Get a specific command
+   */
+  getCommand(commandId: string): Command | undefined {
+    return this.commands.get(commandId);
+  }
+
+  dispose() {
+    this.commands.clear();
+  }
+}

package/src/services/ConfigurationService.ts

@@ -0,0 +1,107 @@
+import { Service } from "../service";
+import EventBus from "../event";
+import { ConfigurationContribution } from "../contribution";
+
+export default class ConfigurationService implements Service {
+  private configValues: Map<string, any> = new Map();
+  private eventBus: EventBus = new EventBus();
+
+  /**
+   * Get a configuration value.
+   */
+  get<T = any>(key: string, defaultValue?: T): T {
+    if (this.configValues.has(key)) {
+      return this.configValues.get(key);
+    }
+    return defaultValue as T;
+  }
+
+  /**
+   * Update a configuration value.
+   * Emits 'change' event.
+   */
+  update(key: string, value: any) {
+    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 });
+    }
+  }
+
+  /**
+   * Listen for changes to a specific configuration key.
+   */
+  onDidChange(
+    key: string,
+    callback: (event: { key: string; value: any; oldValue: any }) => void,
+  ) {
+    this.eventBus.on(`change:${key}`, callback);
+    return {
+      dispose: () => this.eventBus.off(`change:${key}`, callback),
+    };
+  }
+
+  /**
+   * Listen for any configuration change.
+   */
+  onAnyChange(
+    callback: (event: { key: string; value: any; oldValue: any }) => void,
+  ) {
+    this.eventBus.on("change", callback);
+    return {
+      dispose: () => this.eventBus.off("change", callback),
+    };
+  }
+
+  /**
+   * Export current configuration state as a JSON-serializable object.
+   * Useful for saving configuration templates.
+   */
+  export(): Record<string, any> {
+    const exportData: Record<string, any> = {};
+    for (const [key, value] of this.configValues) {
+      exportData[key] = value;
+    }
+    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: Record<string, any>): void {
+    if (!data || typeof data !== "object") {
+      console.warn("ConfigurationService: Import data must be an object.");
+      return;
+    }
+    Object.entries(data).forEach(([key, value]) => {
+      this.update(key, value);
+    });
+  }
+
+  /**
+   * Initialize configuration with defaults from contributions.
+   * This should be called when a contribution is registered.
+   */
+  initializeDefaults(contributions: ConfigurationContribution[]) {
+    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 !== undefined) {
+        this.configValues.set(contrib.id, contrib.default);
+      }
+    });
+  }
+
+  dispose() {
+    this.configValues.clear();
+    // EventBus doesn't have a clear/dispose in the snippet, but it's fine for now.
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,4 @@
+import CommandService from "./CommandService";
+import ConfigurationService from "./ConfigurationService";
+
+export { CommandService, ConfigurationService };

package/src/test-extension-full.ts

@@ -0,0 +1,79 @@
+import { ExtensionContext } from "./context";
+import {
+  ContributionPointIds,
+  CommandContribution,
+  ToolContribution,
+  ViewContribution,
+} from "./contribution";
+import { Extension } from "./extension";
+import CommandService from "./services/CommandService";
+
+export const fullExtension: Extension = {
+  id: "full-feature-test-extension",
+  metadata: {
+    name: "Full Feature Test Extension",
+  },
+
+  activate(context: ExtensionContext) {
+    console.log("Full Feature Test Extension activated!");
+
+    // Manually register a command (imperative way)
+    const commandService =
+      context.services.get<CommandService>("CommandService");
+    commandService!.registerCommand("test.imperative.hello", (name: string) => {
+      return `Hello Imperative ${name}`;
+    });
+  },
+
+  deactivate(context: ExtensionContext) {
+    console.log("Full Feature Test Extension deactivated!");
+  },
+
+  contribute() {
+    return {
+      // 1. Command Contributions
+      [ContributionPointIds.COMMANDS]: [
+        // Declarative command with handler (auto-registered by our updated ExtensionManager)
+        {
+          id: "test.declarative.auto",
+          command: "test.declarative.auto",
+          title: "Auto Registered Command",
+          handler: () => {
+            return "Auto Registered Result";
+          },
+        } as CommandContribution,
+
+        // Declarative command without handler (just definition, maybe handled elsewhere)
+        {
+          id: "test.declarative.no-handler",
+          command: "test.declarative.no-handler",
+          title: "No Handler Command",
+        } as CommandContribution,
+      ],
+
+      // 2. Tool Contributions
+      [ContributionPointIds.TOOLS]: [
+        {
+          id: "test.tool.calculator",
+          name: "Calculator",
+          description: "Simple calculator",
+          execute: async (op: string, a: number, b: number) => {
+            if (op === "add") return a + b;
+            return 0;
+          },
+        } as ToolContribution,
+      ],
+
+      // 3. View Contributions
+      [ContributionPointIds.VIEWS]: [
+        {
+          id: "test.view.sidebar",
+          name: "Test Sidebar",
+          type: "sidebar",
+          component: "SidebarComponent", // Mock component string
+          location: "left",
+        } as ViewContribution,
+      ],
+    };
+  },
+};

package/tsconfig.test.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "moduleResolution": "node"
+  }
+}

package/src/canvas.ts

@@ -1,3 +0,0 @@
-import { Canvas } from "fabric";
-
-export { Canvas as PooderCanvas };