@pooder/core 1.2.0 → 2.1.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pooder/core
 
+## 2.1.0
+
+### Minor Changes
+
+- white ink tool and size tool
+
+## 2.0.0
+
+### Major Changes
+
+- Virtual Features
+
 ## 1.2.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -37,12 +37,33 @@ interface CommandContribution {
 /**
  * Tool Contribution Data Definition
  */
+type ToolInteraction = "instant" | "session" | "hybrid";
+type ToolSessionLeavePolicy = "block" | "commit" | "rollback";
+interface ToolCommandBindings {
+    execute?: string;
+    begin?: string;
+    validate?: string;
+    commit?: string;
+    rollback?: string;
+    reset?: string;
+}
 interface ToolContribution {
     id: string;
     name: string;
-    description: string;
+    description?: string;
+    icon?: string;
+    interaction: ToolInteraction;
     parameters?: Record<string, any>;
-    execute: (...args: any[]) => Promise<any>;
+    commands?: ToolCommandBindings;
+    view?: {
+        id?: string;
+        type?: "sidebar" | "panel" | "editor" | "dialog";
+        location?: string;
+    };
+    session?: {
+        autoBegin?: boolean;
+        leavePolicy?: ToolSessionLeavePolicy;
+    };
 }
 /**
  * View Contribution Data Definition
@@ -249,6 +270,91 @@ declare class ConfigurationService implements Service {
     dispose(): void;
 }
 
+declare class ToolRegistryService implements Service {
+    private tools;
+    registerTool(tool: ToolContribution): Disposable;
+    unregisterTool(toolId: string): void;
+    getTool(toolId: string): ToolContribution | undefined;
+    listTools(): ToolContribution[];
+    hasTool(toolId: string): boolean;
+    dispose(): void;
+}
+
+type ToolSessionStatus = "idle" | "active";
+interface ToolSessionState {
+    toolId: string;
+    status: ToolSessionStatus;
+    dirty: boolean;
+    startedAt?: number;
+    lastUpdatedAt?: number;
+}
+type LeaveDecision = "allow" | "blocked";
+interface LeaveResult {
+    decision: LeaveDecision;
+    reason?: string;
+}
+declare class ToolSessionService implements Service {
+    private readonly sessions;
+    private commandService?;
+    private toolRegistry?;
+    setCommandService(commandService: CommandService): void;
+    setToolRegistry(toolRegistry: ToolRegistryService): void;
+    registerDirtyTracker(toolId: string, callback: () => boolean): Disposable;
+    private readonly dirtyTrackers;
+    private ensureSession;
+    getState(toolId: string): ToolSessionState;
+    isDirty(toolId: string): boolean;
+    markDirty(toolId: string, dirty?: boolean): void;
+    private resolveTool;
+    private runCommand;
+    begin(toolId: string): Promise<void>;
+    validate(toolId: string): Promise<{
+        ok: boolean;
+        result?: any;
+    }>;
+    commit(toolId: string): Promise<{
+        ok: boolean;
+        result?: any;
+    }>;
+    rollback(toolId: string): Promise<void>;
+    deactivateSession(toolId: string): void;
+    handleBeforeLeave(toolId: string): Promise<LeaveResult>;
+    dispose(): void;
+}
+
+interface ToolSwitchContext {
+    from: string | null;
+    to: string | null;
+    reason?: string;
+}
+interface ToolSwitchResult {
+    ok: boolean;
+    from: string | null;
+    to: string | null;
+    reason?: string;
+}
+type ToolSwitchGuard = (context: ToolSwitchContext) => boolean | Promise<boolean>;
+declare class WorkbenchService implements Service {
+    private _activeToolId;
+    private eventBus?;
+    private toolRegistry?;
+    private sessionService?;
+    private guards;
+    init(): void;
+    dispose(): void;
+    setEventBus(bus: EventBus): void;
+    setToolRegistry(toolRegistry: ToolRegistryService): void;
+    setToolSessionService(sessionService: ToolSessionService): void;
+    get activeToolId(): string | null;
+    registerSwitchGuard(guard: ToolSwitchGuard, priority?: number): Disposable;
+    private runGuards;
+    switchTool(id: string | null, options?: {
+        reason?: string;
+    }): Promise<ToolSwitchResult>;
+    activate(id: string | null): Promise<ToolSwitchResult>;
+    deactivate(): Promise<ToolSwitchResult>;
+}
+
 declare class Pooder {
     readonly eventBus: EventBus;
     private readonly services;
@@ -264,4 +370,4 @@ declare class Pooder {
     getContributions<T>(pointId: string): Contribution<T>[];
 }
 
-export { type CommandContribution, CommandService, type ConfigurationContribution, ConfigurationService, type Contribution, type ContributionMetadata, type ContributionPoint, ContributionPointIds, ContributionRegistry, type Extension, type ExtensionContext, ExtensionManager, type ExtensionMetadata, ExtensionRegistry, Pooder, type Service, ServiceRegistry, type ToolContribution, type ViewContribution };
+export { type CommandContribution, CommandService, type ConfigurationContribution, ConfigurationService, type Contribution, type ContributionMetadata, type ContributionPoint, ContributionPointIds, ContributionRegistry, EventBus, type Extension, type ExtensionContext, ExtensionManager, type ExtensionMetadata, ExtensionRegistry, Pooder, type Service, ServiceRegistry, type ToolCommandBindings, type ToolContribution, type ToolInteraction, ToolRegistryService, type ToolSessionLeavePolicy, ToolSessionService, type ViewContribution, WorkbenchService };

package/dist/index.d.ts

@@ -37,12 +37,33 @@ interface CommandContribution {
 /**
  * Tool Contribution Data Definition
  */
+type ToolInteraction = "instant" | "session" | "hybrid";
+type ToolSessionLeavePolicy = "block" | "commit" | "rollback";
+interface ToolCommandBindings {
+    execute?: string;
+    begin?: string;
+    validate?: string;
+    commit?: string;
+    rollback?: string;
+    reset?: string;
+}
 interface ToolContribution {
     id: string;
     name: string;
-    description: string;
+    description?: string;
+    icon?: string;
+    interaction: ToolInteraction;
     parameters?: Record<string, any>;
-    execute: (...args: any[]) => Promise<any>;
+    commands?: ToolCommandBindings;
+    view?: {
+        id?: string;
+        type?: "sidebar" | "panel" | "editor" | "dialog";
+        location?: string;
+    };
+    session?: {
+        autoBegin?: boolean;
+        leavePolicy?: ToolSessionLeavePolicy;
+    };
 }
 /**
  * View Contribution Data Definition
@@ -249,6 +270,91 @@ declare class ConfigurationService implements Service {
     dispose(): void;
 }
 
+declare class ToolRegistryService implements Service {
+    private tools;
+    registerTool(tool: ToolContribution): Disposable;
+    unregisterTool(toolId: string): void;
+    getTool(toolId: string): ToolContribution | undefined;
+    listTools(): ToolContribution[];
+    hasTool(toolId: string): boolean;
+    dispose(): void;
+}
+
+type ToolSessionStatus = "idle" | "active";
+interface ToolSessionState {
+    toolId: string;
+    status: ToolSessionStatus;
+    dirty: boolean;
+    startedAt?: number;
+    lastUpdatedAt?: number;
+}
+type LeaveDecision = "allow" | "blocked";
+interface LeaveResult {
+    decision: LeaveDecision;
+    reason?: string;
+}
+declare class ToolSessionService implements Service {
+    private readonly sessions;
+    private commandService?;
+    private toolRegistry?;
+    setCommandService(commandService: CommandService): void;
+    setToolRegistry(toolRegistry: ToolRegistryService): void;
+    registerDirtyTracker(toolId: string, callback: () => boolean): Disposable;
+    private readonly dirtyTrackers;
+    private ensureSession;
+    getState(toolId: string): ToolSessionState;
+    isDirty(toolId: string): boolean;
+    markDirty(toolId: string, dirty?: boolean): void;
+    private resolveTool;
+    private runCommand;
+    begin(toolId: string): Promise<void>;
+    validate(toolId: string): Promise<{
+        ok: boolean;
+        result?: any;
+    }>;
+    commit(toolId: string): Promise<{
+        ok: boolean;
+        result?: any;
+    }>;
+    rollback(toolId: string): Promise<void>;
+    deactivateSession(toolId: string): void;
+    handleBeforeLeave(toolId: string): Promise<LeaveResult>;
+    dispose(): void;
+}
+
+interface ToolSwitchContext {
+    from: string | null;
+    to: string | null;
+    reason?: string;
+}
+interface ToolSwitchResult {
+    ok: boolean;
+    from: string | null;
+    to: string | null;
+    reason?: string;
+}
+type ToolSwitchGuard = (context: ToolSwitchContext) => boolean | Promise<boolean>;
+declare class WorkbenchService implements Service {
+    private _activeToolId;
+    private eventBus?;
+    private toolRegistry?;
+    private sessionService?;
+    private guards;
+    init(): void;
+    dispose(): void;
+    setEventBus(bus: EventBus): void;
+    setToolRegistry(toolRegistry: ToolRegistryService): void;
+    setToolSessionService(sessionService: ToolSessionService): void;
+    get activeToolId(): string | null;
+    registerSwitchGuard(guard: ToolSwitchGuard, priority?: number): Disposable;
+    private runGuards;
+    switchTool(id: string | null, options?: {
+        reason?: string;
+    }): Promise<ToolSwitchResult>;
+    activate(id: string | null): Promise<ToolSwitchResult>;
+    deactivate(): Promise<ToolSwitchResult>;
+}
+
 declare class Pooder {
     readonly eventBus: EventBus;
     private readonly services;
@@ -264,4 +370,4 @@ declare class Pooder {
     getContributions<T>(pointId: string): Contribution<T>[];
 }
 
-export { type CommandContribution, CommandService, type ConfigurationContribution, ConfigurationService, type Contribution, type ContributionMetadata, type ContributionPoint, ContributionPointIds, ContributionRegistry, type Extension, type ExtensionContext, ExtensionManager, type ExtensionMetadata, ExtensionRegistry, Pooder, type Service, ServiceRegistry, type ToolContribution, type ViewContribution };
+export { type CommandContribution, CommandService, type ConfigurationContribution, ConfigurationService, type Contribution, type ContributionMetadata, type ContributionPoint, ContributionPointIds, ContributionRegistry, EventBus, type Extension, type ExtensionContext, ExtensionManager, type ExtensionMetadata, ExtensionRegistry, Pooder, type Service, ServiceRegistry, type ToolCommandBindings, type ToolContribution, type ToolInteraction, ToolRegistryService, type ToolSessionLeavePolicy, ToolSessionService, type ViewContribution, WorkbenchService };

package/dist/index.js

@@ -24,10 +24,14 @@ __export(index_exports, {
   ConfigurationService: () => ConfigurationService,
   ContributionPointIds: () => ContributionPointIds,
   ContributionRegistry: () => ContributionRegistry,
+  EventBus: () => event_default,
   ExtensionManager: () => ExtensionManager,
   ExtensionRegistry: () => ExtensionRegistry,
   Pooder: () => Pooder,
-  ServiceRegistry: () => ServiceRegistry
+  ServiceRegistry: () => ServiceRegistry,
+  ToolRegistryService: () => ToolRegistryService,
+  ToolSessionService: () => ToolSessionService,
+  WorkbenchService: () => WorkbenchService
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -278,6 +282,11 @@ var ExtensionManager = class {
       const commandService = this.context.services.get("CommandService");
       return commandService.registerCommand(item.id, item.data.handler);
     }
+    if (pointId === ContributionPointIds.TOOLS) {
+      const toolRegistry = this.context.services.get("ToolRegistryService");
+      if (!toolRegistry) return;
+      return toolRegistry.registerTool(item.data);
+    }
   }
   unregister(name) {
     const extension = this.extensionRegistry.get(name);
@@ -480,6 +489,289 @@ var ConfigurationService = class {
   }
 };
 
+// src/services/ToolRegistryService.ts
+var ToolRegistryService = class {
+  constructor() {
+    this.tools = /* @__PURE__ */ new Map();
+  }
+  registerTool(tool) {
+    if (!(tool == null ? void 0 : tool.id)) {
+      throw new Error("ToolContribution.id is required.");
+    }
+    this.tools.set(tool.id, tool);
+    return {
+      dispose: () => {
+        if (this.tools.get(tool.id) === tool) {
+          this.tools.delete(tool.id);
+        }
+      }
+    };
+  }
+  unregisterTool(toolId) {
+    this.tools.delete(toolId);
+  }
+  getTool(toolId) {
+    return this.tools.get(toolId);
+  }
+  listTools() {
+    return Array.from(this.tools.values());
+  }
+  hasTool(toolId) {
+    return this.tools.has(toolId);
+  }
+  dispose() {
+    this.tools.clear();
+  }
+};
+
+// src/services/ToolSessionService.ts
+var ToolSessionService = class {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.dirtyTrackers = /* @__PURE__ */ new Map();
+  }
+  setCommandService(commandService) {
+    this.commandService = commandService;
+  }
+  setToolRegistry(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+  registerDirtyTracker(toolId, callback) {
+    const wrapped = () => {
+      try {
+        return callback();
+      } catch (e) {
+        return false;
+      }
+    };
+    this.dirtyTrackers.set(toolId, wrapped);
+    return {
+      dispose: () => {
+        if (this.dirtyTrackers.get(toolId) === wrapped) {
+          this.dirtyTrackers.delete(toolId);
+        }
+      }
+    };
+  }
+  ensureSession(toolId) {
+    const existing = this.sessions.get(toolId);
+    if (existing) return existing;
+    const created = {
+      toolId,
+      status: "idle",
+      dirty: false
+    };
+    this.sessions.set(toolId, created);
+    return created;
+  }
+  getState(toolId) {
+    return { ...this.ensureSession(toolId) };
+  }
+  isDirty(toolId) {
+    const tracker = this.dirtyTrackers.get(toolId);
+    if (tracker) return tracker();
+    return this.ensureSession(toolId).dirty;
+  }
+  markDirty(toolId, dirty = true) {
+    const session = this.ensureSession(toolId);
+    session.dirty = dirty;
+    session.lastUpdatedAt = Date.now();
+  }
+  resolveTool(toolId) {
+    var _a;
+    return (_a = this.toolRegistry) == null ? void 0 : _a.getTool(toolId);
+  }
+  async runCommand(commandId, ...args) {
+    if (!commandId || !this.commandService) return void 0;
+    return await this.commandService.executeCommand(commandId, ...args);
+  }
+  async begin(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    const session = this.ensureSession(toolId);
+    if (session.status === "active") return;
+    await this.runCommand((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.begin);
+    session.status = "active";
+    session.startedAt = Date.now();
+    session.lastUpdatedAt = session.startedAt;
+  }
+  async validate(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    if (!((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.validate)) {
+      return { ok: true };
+    }
+    const result = await this.runCommand(tool.commands.validate);
+    if (result === false) return { ok: false, result };
+    if (result && typeof result === "object" && "ok" in result) {
+      return { ok: Boolean(result.ok), result };
+    }
+    return { ok: true, result };
+  }
+  async commit(toolId) {
+    var _a;
+    const tool = this.resolveTool(toolId);
+    const validateResult = await this.validate(toolId);
+    if (!validateResult.ok) return validateResult;
+    const result = await this.runCommand((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.commit);
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+    return { ok: true, result };
+  }
+  async rollback(toolId) {
+    var _a, _b;
+    const tool = this.resolveTool(toolId);
+    await this.runCommand(((_a = tool == null ? void 0 : tool.commands) == null ? void 0 : _a.rollback) || ((_b = tool == null ? void 0 : tool.commands) == null ? void 0 : _b.reset));
+    const session = this.ensureSession(toolId);
+    session.dirty = false;
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+  deactivateSession(toolId) {
+    const session = this.ensureSession(toolId);
+    session.status = "idle";
+    session.lastUpdatedAt = Date.now();
+  }
+  async handleBeforeLeave(toolId) {
+    var _a, _b;
+    const tool = this.resolveTool(toolId);
+    if (!tool) return { decision: "allow" };
+    if (tool.interaction !== "session") return { decision: "allow" };
+    const dirty = this.isDirty(toolId);
+    if (!dirty) return { decision: "allow" };
+    const leavePolicy = (_b = (_a = tool.session) == null ? void 0 : _a.leavePolicy) != null ? _b : "block";
+    if (leavePolicy === "commit") {
+      const committed = await this.commit(toolId);
+      if (!committed.ok) {
+        return { decision: "blocked", reason: "session-validation-failed" };
+      }
+      return { decision: "allow" };
+    }
+    if (leavePolicy === "rollback") {
+      await this.rollback(toolId);
+      return { decision: "allow" };
+    }
+    return { decision: "blocked", reason: "session-dirty" };
+  }
+  dispose() {
+    this.sessions.clear();
+    this.dirtyTrackers.clear();
+  }
+};
+
+// src/services/WorkbenchService.ts
+var WorkbenchService = class {
+  constructor() {
+    this._activeToolId = null;
+    this.guards = [];
+  }
+  init() {
+  }
+  dispose() {
+    this.guards = [];
+  }
+  setEventBus(bus) {
+    this.eventBus = bus;
+  }
+  setToolRegistry(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+  }
+  setToolSessionService(sessionService) {
+    this.sessionService = sessionService;
+  }
+  get activeToolId() {
+    return this._activeToolId;
+  }
+  registerSwitchGuard(guard, priority = 0) {
+    const item = { guard, priority };
+    this.guards.push(item);
+    this.guards.sort((a, b) => b.priority - a.priority);
+    return {
+      dispose: () => {
+        const index = this.guards.indexOf(item);
+        if (index >= 0) this.guards.splice(index, 1);
+      }
+    };
+  }
+  async runGuards(context) {
+    for (const { guard } of this.guards) {
+      const allowed = await Promise.resolve(guard(context));
+      if (!allowed) return false;
+    }
+    return true;
+  }
+  async switchTool(id, options) {
+    var _a, _b, _c, _d, _e;
+    if (this._activeToolId === id) {
+      return { ok: true, from: this._activeToolId, to: id };
+    }
+    if (id && this.toolRegistry && !this.toolRegistry.hasTool(id)) {
+      return {
+        ok: false,
+        from: this._activeToolId,
+        to: id,
+        reason: `tool-not-registered:${id}`
+      };
+    }
+    const context = {
+      from: this._activeToolId,
+      to: id,
+      reason: options == null ? void 0 : options.reason
+    };
+    const guardAllowed = await this.runGuards(context);
+    if (!guardAllowed) {
+      (_a = this.eventBus) == null ? void 0 : _a.emit("tool:switch:blocked", {
+        ...context,
+        reason: "blocked-by-guard"
+      });
+      return {
+        ok: false,
+        from: this._activeToolId,
+        to: id,
+        reason: "blocked-by-guard"
+      };
+    }
+    if (context.from && this.sessionService) {
+      const leaveResult = await this.sessionService.handleBeforeLeave(
+        context.from
+      );
+      if (leaveResult.decision === "blocked") {
+        (_b = this.eventBus) == null ? void 0 : _b.emit("tool:switch:blocked", {
+          ...context,
+          reason: leaveResult.reason || "session-blocked"
+        });
+        return {
+          ok: false,
+          from: this._activeToolId,
+          to: id,
+          reason: leaveResult.reason || "session-blocked"
+        };
+      }
+      this.sessionService.deactivateSession(context.from);
+    }
+    if (id && this.sessionService && this.toolRegistry) {
+      const tool = this.toolRegistry.getTool(id);
+      if ((tool == null ? void 0 : tool.interaction) === "session" && ((_c = tool.session) == null ? void 0 : _c.autoBegin) !== false) {
+        await this.sessionService.begin(id);
+      }
+    }
+    const previous = this._activeToolId;
+    this._activeToolId = id;
+    const reason = options == null ? void 0 : options.reason;
+    (_d = this.eventBus) == null ? void 0 : _d.emit("tool:activated", { id, previous, reason });
+    (_e = this.eventBus) == null ? void 0 : _e.emit("tool:switch", { from: previous, to: id, reason });
+    return { ok: true, from: previous, to: id };
+  }
+  async activate(id) {
+    return await this.switchTool(id, { reason: "activate" });
+  }
+  async deactivate() {
+    return await this.switchTool(null, { reason: "deactivate" });
+  }
+};
+
 // src/index.ts
 var Pooder = class {
   constructor() {
@@ -491,6 +783,17 @@ var Pooder = class {
     this.registerService(commandService, "CommandService");
     const configurationService = new ConfigurationService();
     this.registerService(configurationService, "ConfigurationService");
+    const toolRegistryService = new ToolRegistryService();
+    this.registerService(toolRegistryService, "ToolRegistryService");
+    const toolSessionService = new ToolSessionService();
+    toolSessionService.setCommandService(commandService);
+    toolSessionService.setToolRegistry(toolRegistryService);
+    this.registerService(toolSessionService, "ToolSessionService");
+    const workbenchService = new WorkbenchService();
+    workbenchService.setEventBus(this.eventBus);
+    workbenchService.setToolRegistry(toolRegistryService);
+    workbenchService.setToolSessionService(toolSessionService);
+    this.registerService(workbenchService, "WorkbenchService");
     const context = {
       eventBus: this.eventBus,
       services: {
@@ -579,8 +882,12 @@ var Pooder = class {
   ConfigurationService,
   ContributionPointIds,
   ContributionRegistry,
+  EventBus,
   ExtensionManager,
   ExtensionRegistry,
   Pooder,
-  ServiceRegistry
+  ServiceRegistry,
+  ToolRegistryService,
+  ToolSessionService,
+  WorkbenchService
 });