@pooder/core 0.1.0 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pooder/core
 
+## 1.1.0
+
+### Minor Changes
+
+- bugfix
+
+## 1.0.0
+
+### Major Changes
+
+- Architecture upgrade
+
 ## 0.1.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -1,158 +1,267 @@
-import { Canvas, FabricObject, Group } from 'fabric';
-export { Circle, Ellipse, Group, FabricImage as Image, Line, Path, Pattern, Point, Canvas as PooderCanvas, Group as PooderLayer, FabricObject as PooderObject, Rect, Text, filters, util } from 'fabric';
-
-declare module "fabric" {
-    interface FabricObject {
-        data?: any;
-    }
-}
-
-declare module "fabric" {
-    interface Group {
-        data?: any;
-    }
-    interface GroupProps {
-        data?: any;
-    }
-    interface SerializedGroupProps {
-        data?: any;
-    }
+interface Service {
+    init?(): void;
+    dispose?(): void;
 }
-
-declare class ExtensionMap extends Map<string, Extension> {
+declare class ServiceRegistry {
+    private services;
+    register<T extends Service>(name: string, service: T): T;
+    get<T extends Service>(serviceName: string): T | undefined;
+    has(serviceName: string): boolean;
+    delete(serviceName: string): void;
 }
 
-declare class CommandMap extends Map<string, Command> {
+type EventHandler = (...args: any[]) => void | boolean;
+declare class EventBus {
+    private events;
+    on(event: string, handler: EventHandler, priority?: number): void;
+    off(event: string, handler: EventHandler): void;
+    emit(event: string, ...args: any[]): void;
+    clear(): void;
+    count(event: string): number;
 }
 
-interface CommandArgSchema {
-    type: "string" | "number" | "boolean" | "object" | "any";
-    label?: string;
+interface ContributionPoint<T = any> {
+    id: string;
     description?: string;
-    required?: boolean;
+    validate?: (data: T) => boolean;
+}
+/**
+ * Command Contribution Data Definition
+ */
+interface CommandContribution {
+    id: string;
+    command: string;
+    title: string;
+    handler?: (...args: any[]) => any;
+}
+/**
+ * Tool Contribution Data Definition
+ */
+interface ToolContribution {
+    id: string;
+    name: string;
+    description: string;
+    parameters?: Record<string, any>;
+    execute: (...args: any[]) => Promise<any>;
+}
+/**
+ * View Contribution Data Definition
+ */
+interface ViewContribution {
+    id: string;
+    name: string;
+    type: "sidebar" | "panel" | "editor" | "dialog" | "status-bar";
+    component: any;
+    location?: string;
+    icon?: string;
+    priority?: number;
+}
+/**
+ * Configuration Contribution Data Definition
+ */
+interface ConfigurationContribution {
+    id: string;
+    type: "string" | "number" | "boolean" | "color" | "select" | "json";
+    label: string;
     default?: any;
-    options?: string[] | {
-        label: string;
-        value: any;
-    }[];
+    description?: string;
+    options?: string[];
     min?: number;
     max?: number;
+    step?: number;
 }
-interface CommandSchema {
-    [argName: string]: CommandArgSchema;
+declare const ContributionPointIds: {
+    CONTRIBUTIONS: string;
+    COMMANDS: string;
+    TOOLS: string;
+    VIEWS: string;
+    CONFIGURATIONS: string;
+};
+
+interface Disposable {
+    dispose(): void;
 }
-interface Command {
-    execute(...args: any[]): any;
-    schema?: CommandSchema;
+
+declare class ContributionRegistry {
+    private points;
+    private contributions;
+    /**
+     * Register a new contribution point
+     */
+    registerPoint<T>(point: ContributionPoint<T>): void;
+    /**
+     * Register a contribution to a specific point
+     * @returns Disposable to unregister the contribution
+     */
+    register<T>(pointId: string, contribution: Contribution<T>): Disposable;
+    /**
+     * Get all contributions for a given point
+     */
+    get<T>(pointId: string): Contribution<T>[];
+    /**
+     * Get a specific contribution by ID
+     */
+    getById<T>(id: string): Contribution<T> | undefined;
+    /**
+     * Get the contribution point definition
+     */
+    getPoint(pointId: string): ContributionPoint | undefined;
+    /**
+     * Unregister a contribution
+     */
+    private unregister;
 }
-interface Event {
+
+interface ContributionMetadata {
     name: string;
-    data: any;
+    extensionId: string;
 }
-type EventHandler = (...args: any[]) => void | boolean;
-interface ExtensionOptions {
-    [key: string]: any;
+interface Contribution<T = any> {
+    id: string;
+    data: T;
+    metadata?: Partial<ContributionMetadata>;
 }
-interface OptionSchema {
-    type: "string" | "number" | "boolean" | "color" | "select";
-    options?: string[] | {
-        label: string;
-        value: any;
-    }[];
-    min?: number;
-    max?: number;
-    step?: number;
-    label?: string;
+
+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;
+    };
 }
-interface Extension<T extends ExtensionOptions = ExtensionOptions> {
+
+interface ExtensionMetadata {
     name: string;
-    priority?: number;
-    options?: T;
-    schema?: Record<keyof T, OptionSchema>;
-    enabled?: boolean;
-    onCreate?(editor: Editor): void;
-    onMount?(editor: Editor): void;
-    onUpdate?(editor: Editor, state: EditorState): void;
-    onUnmount?(editor: Editor): void;
-    onDestroy?(editor: Editor): void;
-    toJSON?(): any;
-    loadFromJSON?(data: any): void | Promise<void>;
-    commands?: Record<string, Command>;
-}
-interface EditorState {
-    width: number;
-    height: number;
-    metadata?: Record<string, any>;
-}
-interface Editor {
-    state: EditorState;
-    canvas: Canvas;
-    extensions: ExtensionMap;
-    commands: CommandMap;
-    use(extension: Extension): void;
-    unuse(name: string): void;
-    getExtension(name: string): Extension | undefined;
-    getExtensions(): Extension[];
-    enableExtension(name: string): void;
-    disableExtension(name: string): void;
-    registerCommand(name: string, command: Command): void;
-    unregisterCommand(name: string): void;
-    executeCommand(name: string, ...args: any[]): void;
-    on(event: string, handler: EventHandler, priority?: number): void;
-    off(event: string, handler: EventHandler): void;
-    emit(event: string, ...args: any[]): void;
-    getObjects(): FabricObject[];
-    getObject(id: string, layerId?: string): FabricObject | undefined;
-    getLayers(): Group[];
-    getLayer(id: string): Group | undefined;
-    updateState(updater: (state: EditorState) => EditorState): void;
-    getState(): EditorState;
-    toJSON(): any;
-    loadFromJSON(json: any): Promise<void>;
+}
+interface Extension {
+    id: string;
+    metadata?: Partial<ExtensionMetadata>;
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute?(): Record<string, any[]>;
+}
+declare class ExtensionRegistry extends Map<string, Extension> {
+}
+declare class ExtensionManager {
+    private readonly context;
+    private extensionRegistry;
+    private extensionDisposables;
+    constructor(context: ExtensionContext);
+    register(extension: Extension): void;
+    collectContribution(pointId: string, item: any): Disposable | undefined;
+    unregister(name: string): true | undefined;
+    enable(name: string): void;
+    disable(name: string): void;
+    update(): void;
     destroy(): void;
 }
 
-declare class PooderEditor implements Editor {
-    state: EditorState;
-    canvas: Canvas;
-    extensions: ExtensionMap;
-    commands: CommandMap;
+interface CommandArgSchema {
+}
+interface Command {
+    id: string;
+    handler: (...args: any[]) => any;
+    title?: string;
+    category?: string;
+    description?: string;
+    schema?: Record<string, CommandArgSchema>;
+}
+
+declare class CommandService implements Service {
+    private commands;
+    /**
+     * 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;
+    /**
+     * Execute a command
+     * @param commandId Command Name (ID)
+     * @param args Arguments to pass to the handler
+     * @returns The result of the command handler
+     */
+    executeCommand<T = any>(commandId: string, ...args: any[]): Promise<T>;
+    /**
+     * Get all registered commands
+     */
+    getCommands(): Map<string, Command>;
+    /**
+     * Get a specific command
+     */
+    getCommand(commandId: string): Command | undefined;
+    dispose(): void;
+}
+
+declare class ConfigurationService implements Service {
+    private configValues;
     private eventBus;
-    private commandManager;
-    private extensionManager;
-    private destroyed;
-    constructor(el: HTMLCanvasElement, options?: {
-        width?: number;
-        height?: number;
-        extensions?: Extension[];
-    });
-    use(extension: Extension): void;
-    unuse(name: string): void;
-    getExtension(name: string): Extension | undefined;
-    getExtensions(): Extension[];
-    enableExtension(name: string): void;
-    disableExtension(name: string): void;
-    registerCommand(name: string, command: Command): void;
-    unregisterCommand(name: string): void;
-    executeCommand(name: string, ...args: any[]): any;
-    on(event: string, handler: EventHandler, priority?: number): void;
-    off(event: string, handler: EventHandler): void;
-    emit(event: string, ...args: any[]): void;
-    getObjects(): FabricObject[];
-    getObject(id: string, layerId?: string): FabricObject | undefined;
-    getLayers(): Group[];
-    getLayer(id: string): Group | undefined;
-    updateState(updater: (state: EditorState) => EditorState): void;
-    toJSON(): {
-        width: number;
-        height: number;
-        metadata: Record<string, any> | undefined;
-        extensions: Record<string, any>;
+    /**
+     * Get a configuration value.
+     */
+    get<T = any>(key: string, defaultValue?: T): T;
+    /**
+     * Update a configuration value.
+     * Emits 'change' event.
+     */
+    update(key: string, value: any): void;
+    /**
+     * Listen for changes to a specific configuration key.
+     */
+    onDidChange(key: string, callback: (event: {
+        key: string;
+        value: any;
+        oldValue: any;
+    }) => void): {
+        dispose: () => void;
     };
-    loadFromJSON(json: any): Promise<void>;
-    getState(): EditorState;
-    destroy(): void;
-    isDestroyed(): boolean;
+    /**
+     * Listen for any configuration change.
+     */
+    onAnyChange(callback: (event: {
+        key: string;
+        value: any;
+        oldValue: any;
+    }) => void): {
+        dispose: () => void;
+    };
+    /**
+     * Export current configuration state as a JSON-serializable object.
+     * Useful for saving configuration templates.
+     */
+    export(): Record<string, any>;
+    /**
+     * 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;
+    /**
+     * Initialize configuration with defaults from contributions.
+     * This should be called when a contribution is registered.
+     */
+    initializeDefaults(contributions: ConfigurationContribution[]): void;
+    dispose(): void;
+}
+
+declare class Pooder {
+    readonly eventBus: EventBus;
+    private readonly services;
+    private readonly contributions;
+    readonly extensionManager: ExtensionManager;
+    constructor();
+    private initDefaultContributionPoints;
+    registerService(service: Service, id?: string): boolean;
+    unregisterService(service: Service, id?: string): boolean;
+    getService<T extends Service>(id: string): T | undefined;
+    registerContributionPoint<T>(point: ContributionPoint<T>): void;
+    registerContribution<T>(pointId: string, contribution: Contribution<T>): Disposable;
+    getContributions<T>(pointId: string): Contribution<T>[];
 }
 
-export { type Command, type Editor, type EditorState, type Event, type EventHandler, type Extension, type ExtensionOptions, type OptionSchema, PooderEditor };
+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 };