@pooder/core 0.0.2

package/src/extension.ts

@@ -0,0 +1,189 @@
+import {Editor, Extension} from "./types";
+
+export { ExtensionManager, DefaultExtensionManager, ExtensionMap }
+
+interface ExtensionManager{
+    register(extension: Extension):void
+    unregister(name:string):void
+    enable(name:string):void
+    disable(name:string):void
+    get(name:string):Extension | undefined
+    has(name:string):boolean
+    count():number
+    list():Extension[]
+    mount():void
+    update():void
+    destroy():void
+}
+class ExtensionMap extends Map<string, Extension> {}
+class DefaultExtensionManager implements ExtensionManager{
+    private readonly editor: Editor;
+    private mounted: boolean = false;
+
+    constructor(editor: Editor) {
+        this.editor = editor
+    }
+
+    private _registerCommands(extension: Extension) {
+        if(extension.commands){
+            Object.entries(extension.commands).forEach(([name, command]) => {
+                const commandName = `${extension.name}.${name}`;
+                this.editor.registerCommand(commandName, command);
+            })
+        }
+    }
+
+    private _unregisterCommands(extension: Extension) {
+        if(extension.commands){
+            Object.keys(extension.commands).forEach((name) => {
+                const commandName = `${extension.name}.${name}`;
+                this.editor.unregisterCommand(commandName);
+            })
+        }
+    }
+
+    register(extension: Extension){
+        if (this.editor.extensions.has(extension.name)) {
+            console.warn(`Plugin "${extension.name}" already registered. It will be overwritten.`);
+        }
+
+        try {
+            if(extension.enabled === undefined) {
+                extension.enabled = true;
+            }
+            this.editor.extensions.set(extension.name, extension);
+            extension.onCreate?.(this.editor)
+        } catch (error) {
+            console.error(`Error in onCreate hook for plugin "${extension.name}":`, error);
+        }
+
+        if (extension.enabled) {
+            this._registerCommands(extension);
+
+            if(this.mounted) {
+                try {
+                    extension.onMount?.(this.editor);
+                } catch (error) {
+                    console.error(`Error in onMount hook for plugin "${extension.name}":`, error);
+                }
+            }
+        }
+
+        console.log(`Plugin "${extension.name}" registered successfully`);
+    }
+    
+    unregister(name: string){
+        const extension = this.editor.extensions.get(name);
+        if (!extension) {
+            console.warn(`Plugin "${name}" not found.`);
+            return;
+        }
+
+        if (this.mounted && extension.enabled) {
+            try {
+                extension.onUnmount?.(this.editor);
+            } catch (error) {
+                console.error(`Error in onUnmount hook for plugin "${name}":`, error);
+            }
+        }
+
+        try {
+            extension.onDestroy?.(this.editor);
+        } catch (error) {
+            console.error(`Error in onDestroy hook for plugin "${name}":`, error);
+        }
+
+        this._unregisterCommands(extension);
+
+        this.editor.extensions.delete(name);
+        console.log(`Plugin "${name}" unregistered`);
+        return true;
+    }
+
+    enable(name: string) {
+        const extension = this.get(name);
+        if (!extension) {
+            console.warn(`Plugin "${name}" not found.`);
+            return;
+        }
+        if (extension.enabled) return;
+
+        extension.enabled = true;
+        this._registerCommands(extension);
+
+        if (this.mounted) {
+            try {
+                extension.onMount?.(this.editor);
+            } catch (error) {
+                console.error(`Error in onMount hook for plugin "${name}":`, error);
+            }
+        }
+    }
+
+    disable(name: string) {
+        const extension = this.get(name);
+        if (!extension) {
+            console.warn(`Plugin "${name}" not found.`);
+            return;
+        }
+        if (!extension.enabled) return;
+
+        extension.enabled = false;
+        this._unregisterCommands(extension);
+
+        if (this.mounted) {
+            try {
+                extension.onUnmount?.(this.editor);
+            } catch (error) {
+                console.error(`Error in onUnmount hook for plugin "${name}":`, error);
+            }
+        }
+    }
+
+    get(name:string){
+        return this.editor.extensions.get( name)
+    }
+    has(name:string){
+        return this.editor.extensions.has(name)
+    }
+    count(){
+        return this.editor.extensions.size
+    }
+    list(){
+        return Array.from(this.editor.extensions.values())
+    }
+    mount(){
+        if(this.mounted)return
+
+        this.editor.extensions.forEach((extension) => {
+            if (extension.enabled) {
+                try {
+                    extension.onMount?.(this.editor);
+                }catch (e){
+                    console.error(`Error in onMount hook for plugin "${extension.name}":`, e);
+                }
+            }
+        })
+
+        this.mounted=true
+    }
+    update(){
+        const state = this.editor.getState();
+
+        this.editor.extensions.forEach((extension) => {
+            if (extension.enabled) {
+                try {
+                    extension.onUpdate?.(this.editor, state);
+                }catch (e){
+                    console.error(`Error in onUpdate hook for plugin "${extension.name}":`, e);
+                }
+            }
+        })
+    }
+
+    destroy(){
+        const extensionNames = Array.from(this.editor.extensions.keys());
+        extensionNames.forEach(name => this.unregister(name))
+        this.mounted=false
+    }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+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 } from "fabric"

package/src/layer.ts

@@ -0,0 +1,13 @@
+import { Group } from "fabric";
+declare module "fabric" {
+    interface Group {
+        data?: any;
+    }
+    interface GroupProps {
+        data?: any;
+    }
+    interface SerializedGroupProps {
+        data?: any;
+    }
+}
+export { Group as PooderLayer }

package/src/obj.ts

@@ -0,0 +1,7 @@
+import { FabricObject } from "fabric";
+declare module "fabric" {
+    interface FabricObject {
+        data?: any;
+    }
+}
+export { FabricObject as PooderObject }

package/src/types.ts

@@ -0,0 +1,102 @@
+import {PooderCanvas} from "./canvas";
+import {PooderObject} from "./obj";
+import {PooderLayer} from "./layer";
+import {ExtensionMap} from "./extension";
+import {CommandMap} from "./command";
+
+export interface CommandArgSchema {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'any';
+    label?: string;
+    description?: string;
+    required?: boolean;
+    default?: any;
+    // Type-specific constraints
+    options?: string[] | { label: string; value: any }[];
+    min?: number;
+    max?: number;
+}
+
+export interface CommandSchema {
+     [argName: string]: CommandArgSchema;
+}
+
+export interface Command {
+    execute(...args: any[]): boolean;
+    schema?: CommandSchema;
+}
+
+export interface Event{
+    name:string;
+    data:any;
+}
+
+export type EventHandler = (...args: any[]) => void|boolean;
+
+export interface ExtensionOptions {
+    [key: string]: any;
+}
+export interface OptionSchema {
+    type: 'string' | 'number' | 'boolean' | 'color' | 'select';
+    options?: string[] | { label: string; value: any }[];
+    min?: number;
+    max?: number;
+    step?: number;
+    label?: string;
+}
+
+export interface Extension<T extends ExtensionOptions=ExtensionOptions>{
+    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
+
+    commands?: Record<string, Command>
+}
+
+export interface EditorState{
+    width: number
+    height: number
+    metadata?: Record<string, any>
+}
+
+export interface Editor{
+    state: EditorState
+    canvas: PooderCanvas
+    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():PooderObject[]
+    getObject(id:string,layerId?:string):PooderObject | undefined
+    getLayers():PooderLayer[]
+    getLayer(id:string):PooderLayer | undefined
+
+    updateState(updater:(state:EditorState)=>EditorState):void
+    getState():EditorState
+
+    toJSON(): any;
+    loadFromJSON(json: any): Promise<void>;
+
+    destroy():void
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2018",
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "lib": ["esnext", "dom"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true
+  },
+  "include": ["src"]
+}