@pooder/core 0.0.2 → 1.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pooder/core",
-  "version": "0.0.2",
+  "version": "1.0.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[]):boolean
-    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,48 +1,53 @@
-import {EventHandler} from "./types";
-
-export { EventBus, EventListener }
-
-interface EventListener {
-    handler:EventHandler;
-    priority:number;
-}
-type EventListenersMap = Map<string, EventListener[]>
-class EventBus{
-    private events: EventListenersMap = new Map()
-
-    on(event:string,handler:EventHandler,priority:number=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:string,handler:EventHandler){
-        const listeners=this.events.get(event)
-        if(!listeners)return
-
-        const index=listeners.findIndex(l=>l.handler===handler)
-        listeners.splice(index,1)
-    }
-
-    emit(event:string,...args:any[]){
-        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:string){
-        return this.events.get(event)?.length ?? 0
-    }
-}
+type EventHandler = (...args: any[]) => void | boolean;
+type EventListenersMap = Map<string, EventListener[]>;
+
+interface Event {
+  name: string;
+  data: any;
+}
+interface EventListener {
+  handler: EventHandler;
+  priority: number;
+}
+
+class EventBus {
+  private events: EventListenersMap = new Map();
+
+  on(event: string, handler: EventHandler, priority: number = 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: string, handler: EventHandler) {
+    const listeners = this.events.get(event);
+    if (!listeners) return;
+
+    const index = listeners.findIndex((l) => l.handler === handler);
+    listeners.splice(index, 1);
+  }
+
+  emit(event: string, ...args: any[]) {
+    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: string) {
+    return this.events.get(event)?.length ?? 0;
+  }
+}
+
+export default EventBus;