@pooder/core 2.0.0 → 2.2.0

package/src/run-test-full.ts

@@ -1,98 +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);
+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

@@ -1,25 +1,205 @@
+import type EventBus from "./event";
+
 export interface Service {
-  init?(): void;
-  dispose?(): void;
+  init?(context: ServiceContext): void | Promise<void>;
+  dispose?(context: ServiceContext): void | Promise<void>;
+}
+
+export interface ServiceToken<T extends Service = Service> {
+  readonly kind: "service-token";
+  readonly key: symbol;
+  readonly name: string;
+}
+
+export type ServiceIdentifier<T extends Service = Service> =
+  | string
+  | ServiceToken<T>;
+
+export interface ServiceContext {
+  readonly eventBus: EventBus;
+  get<T extends Service>(identifier: ServiceIdentifier<T>): T | undefined;
+  getOrThrow<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    errorMessage?: string,
+  ): T;
+  has(identifier: ServiceIdentifier<Service>): boolean;
+}
+
+export interface RegisterServiceOptions {
+  allowOverride?: boolean;
+}
+
+export interface RegisteredService<T extends Service = Service> {
+  readonly id: string;
+  readonly token?: ServiceToken<T>;
+  readonly service: T;
+}
+
+interface ServiceEntry<T extends Service = Service> {
+  token?: ServiceToken<T>;
+  name: string;
+  service: T;
+}
+
+interface NormalizedIdentifier<T extends Service = Service> {
+  token?: ServiceToken<T>;
+  name: string;
+}
+
+export function createServiceToken<T extends Service = Service>(
+  name: string,
+): ServiceToken<T> {
+  if (!name) {
+    throw new Error("Service token name is required.");
+  }
+
+  return Object.freeze({
+    kind: "service-token" as const,
+    key: Symbol(name),
+    name,
+  });
+}
+
+export function isServiceToken<T extends Service = Service>(
+  identifier: unknown,
+): identifier is ServiceToken<T> {
+  return (
+    typeof identifier === "object" &&
+    identifier !== null &&
+    "kind" in identifier &&
+    (identifier as { kind?: unknown }).kind === "service-token"
+  );
 }
 
 export class ServiceRegistry {
-  private services: Map<string, Service> = new Map();
+  private readonly servicesByName: Map<string, ServiceEntry> = new Map();
+  private readonly servicesByToken: Map<symbol, ServiceEntry> = new Map();
+  private readonly registrationOrder: ServiceEntry[] = [];
+
+  register<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    service: T,
+    options: RegisterServiceOptions = {},
+  ): T {
+    const normalized = this.normalizeIdentifier(identifier);
+    const existing = this.findEntry(normalized);
+
+    if (existing && !options.allowOverride) {
+      throw new Error(`Service "${normalized.name}" is already registered.`);
+    }
+    if (existing) {
+      this.removeEntry(existing);
+    }
 
-  register<T extends Service>(name: string, service: T): T {
-    this.services.set(name, service);
+    const entry: ServiceEntry<T> = {
+      token: normalized.token,
+      name: normalized.name,
+      service,
+    };
+
+    this.servicesByName.set(entry.name, entry);
+    if (entry.token) {
+      this.servicesByToken.set(entry.token.key, entry);
+    }
+    this.registrationOrder.push(entry as ServiceEntry);
     return service;
   }
 
-  get<T extends Service>(serviceName: string): T | undefined {
-    return this.services.get(serviceName) as T | undefined;
+  get<T extends Service>(identifier: ServiceIdentifier<T>): T | undefined;
+  get<T extends Service>(identifier: ServiceToken<T>): T | undefined;
+  get<T extends Service>(identifier: string): T | undefined;
+  get<T extends Service>(identifier: ServiceIdentifier<T>): T | undefined {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    return entry?.service as T | undefined;
+  }
+
+  getOrThrow<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    errorMessage?: string,
+  ): T;
+  getOrThrow<T extends Service>(
+    identifier: ServiceToken<T>,
+    errorMessage?: string,
+  ): T;
+  getOrThrow<T extends Service>(identifier: string, errorMessage?: string): T;
+  getOrThrow<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+    errorMessage?: string,
+  ): T {
+    const service = this.get(identifier);
+    if (service) {
+      return service;
+    }
+
+    const normalized = this.normalizeIdentifier(identifier);
+    throw new Error(errorMessage ?? `Service "${normalized.name}" not found.`);
   }
 
-  has(serviceName: string): boolean {
-    return this.services.has(serviceName);
+  has(identifier: ServiceIdentifier<Service>): boolean {
+    const normalized = this.normalizeIdentifier(identifier);
+    return Boolean(this.findEntry(normalized));
   }
 
-  delete(serviceName: string): void {
-    this.services.delete(serviceName);
+  delete(identifier: ServiceIdentifier<Service>): boolean {
+    const normalized = this.normalizeIdentifier(identifier);
+    const entry = this.findEntry(normalized);
+    if (!entry) {
+      return false;
+    }
+    this.removeEntry(entry);
+    return true;
+  }
+
+  list(): RegisteredService[] {
+    return this.registrationOrder.map((entry) => ({
+      id: entry.name,
+      token: entry.token,
+      service: entry.service,
+    }));
+  }
+
+  clear() {
+    this.servicesByName.clear();
+    this.servicesByToken.clear();
+    this.registrationOrder.length = 0;
+  }
+
+  private findEntry(
+    identifier: NormalizedIdentifier,
+  ): ServiceEntry | undefined {
+    if (identifier.token) {
+      return (
+        this.servicesByToken.get(identifier.token.key) ??
+        this.servicesByName.get(identifier.name)
+      );
+    }
+    return this.servicesByName.get(identifier.name);
+  }
+
+  private normalizeIdentifier<T extends Service>(
+    identifier: ServiceIdentifier<T>,
+  ): NormalizedIdentifier<T> {
+    if (isServiceToken(identifier)) {
+      return { token: identifier, name: identifier.name };
+    }
+
+    const name = identifier.trim();
+    if (!name) {
+      throw new Error("Service identifier must be a non-empty string.");
+    }
+    return { name };
+  }
+
+  private removeEntry(entry: ServiceEntry) {
+    this.servicesByName.delete(entry.name);
+    if (entry.token) {
+      this.servicesByToken.delete(entry.token.key);
+    }
+
+    const index = this.registrationOrder.lastIndexOf(entry);
+    if (index >= 0) {
+      this.registrationOrder.splice(index, 1);
+    }
   }
 }

package/src/services/CommandService.ts

@@ -1,79 +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();
-  }
-}
+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();
+  }
+}