@pooder/kit 1.0.0 → 3.0.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @pooder/kit
 
+## 3.0.0
+
+### Major Changes
+
+- Architecture upgrade
+
+### Patch Changes
+
+- Updated dependencies
+  - @pooder/core@1.0.0
+
+## 2.0.0
+
+### Major Changes
+
+- update
+
+### Patch Changes
+
+- Updated dependencies
+  - @pooder/core@0.1.0
+
 ## 1.0.0
 
 ### Major Changes

package/dist/index.d.mts

@@ -1,167 +1,302 @@
-import { Extension, OptionSchema, Editor, EditorState, Command } from '@pooder/core';
+import { Extension, ExtensionContext, ContributionPointIds, ConfigurationContribution, CommandContribution, Service } from '@pooder/core';
+import { Canvas, Group, FabricObject } from 'fabric';
 
-interface BackgroundToolOptions {
-    color: string;
-    url: string;
-}
-declare class BackgroundTool implements Extension<BackgroundToolOptions> {
-    name: string;
-    options: BackgroundToolOptions;
-    schema: Record<keyof BackgroundToolOptions, OptionSchema>;
+declare class BackgroundTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private color;
+    private url;
+    private canvasService?;
+    constructor(options?: Partial<{
+        color: string;
+        url: string;
+    }>);
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
     private initLayer;
-    onMount(editor: Editor): void;
-    onUnmount(editor: Editor): void;
-    onUpdate(editor: Editor, state: EditorState): void;
     private updateBackground;
-    commands: Record<string, Command>;
 }
 
-interface DielineToolOptions {
-    shape: 'rect' | 'circle' | 'ellipse';
-    width: number;
-    height: number;
-    radius: number;
-    position?: {
-        x: number;
-        y: number;
-    };
-    borderLength?: number;
-    offset: number;
-    style: 'solid' | 'dashed';
-    insideColor: string;
-    outsideColor: string;
+interface HoleData {
+    x: number;
+    y: number;
+    innerRadius: number;
+    outerRadius: number;
 }
-type DielineConfig = DielineToolOptions;
+
 interface DielineGeometry {
-    shape: 'rect' | 'circle' | 'ellipse';
+    shape: "rect" | "circle" | "ellipse" | "custom";
     x: number;
     y: number;
     width: number;
     height: number;
     radius: number;
+    offset: number;
+    borderLength?: number;
+    pathData?: string;
 }
-declare class DielineTool implements Extension<DielineToolOptions> {
-    name: string;
-    options: DielineToolOptions;
-    schema: Record<keyof DielineToolOptions, OptionSchema>;
-    onMount(editor: Editor): void;
-    onUnmount(editor: Editor): void;
-    onUpdate(editor: Editor, state: EditorState): void;
-    onDestroy(editor: Editor): void;
+declare class DielineTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private shape;
+    private width;
+    private height;
+    private radius;
+    private offset;
+    private style;
+    private insideColor;
+    private outsideColor;
+    private showBleedLines;
+    private holes;
+    private position?;
+    private borderLength?;
+    private pathData?;
+    private canvasService?;
+    private context?;
+    constructor(options?: Partial<{
+        shape: "rect" | "circle" | "ellipse" | "custom";
+        width: number;
+        height: number;
+        radius: number;
+        position: {
+            x: number;
+            y: number;
+        };
+        borderLength: number;
+        offset: number;
+        style: "solid" | "dashed";
+        insideColor: string;
+        outsideColor: string;
+        showBleedLines: boolean;
+        holes: HoleData[];
+        pathData: string;
+    }>);
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
     private getLayer;
     private createLayer;
     private destroyLayer;
     private createHatchPattern;
-    updateDieline(editor: Editor): void;
-    commands: Record<string, Command>;
-    getGeometry(editor: Editor): DielineGeometry | null;
+    updateDieline(emitEvent?: boolean): void;
+    getGeometry(): DielineGeometry | null;
+    exportCutImage(): string | null;
 }
 
-interface FilmToolOptions {
-    url: string;
-    opacity: number;
-}
-declare class FilmTool implements Extension<FilmToolOptions> {
-    name: string;
-    options: FilmToolOptions;
-    schema: Record<keyof FilmToolOptions, OptionSchema>;
-    onMount(editor: Editor): void;
-    onUnmount(editor: Editor): void;
-    onUpdate(editor: Editor, state: EditorState): void;
+declare class FilmTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private url;
+    private opacity;
+    private canvasService?;
+    constructor(options?: Partial<{
+        url: string;
+        opacity: number;
+    }>);
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
     private initLayer;
     private updateFilm;
-    commands: Record<string, Command>;
 }
 
-interface HoleToolOptions {
-    innerRadius: number;
-    outerRadius: number;
-    style: 'solid' | 'dashed';
-    holes?: Array<{
-        x: number;
-        y: number;
-    }>;
-}
-declare class HoleTool implements Extension<HoleToolOptions> {
-    name: string;
-    options: HoleToolOptions;
-    schema: Record<keyof HoleToolOptions, OptionSchema>;
+declare class HoleTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private innerRadius;
+    private outerRadius;
+    private style;
+    private holes;
+    private constraintTarget;
+    private canvasService?;
+    private context?;
+    private isUpdatingConfig;
     private handleMoving;
     private handleModified;
-    onMount(editor: Editor): void;
-    onUnmount(editor: Editor): void;
-    onDestroy(editor: Editor): void;
-    private getDielineGeometry;
+    private handleDielineChange;
+    private currentGeometry;
+    constructor(options?: Partial<{
+        innerRadius: number;
+        outerRadius: number;
+        style: "solid" | "dashed";
+        holes: Array<{
+            x: number;
+            y: number;
+        }>;
+        constraintTarget: "original" | "bleed";
+    }>);
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
     private setup;
+    private initializeHoles;
     private teardown;
-    onUpdate(editor: Editor, state: EditorState): void;
-    commands: Record<string, Command>;
     private syncHolesFromCanvas;
+    private syncHolesToDieline;
     private redraw;
+    enforceConstraints(): boolean;
     private calculateConstrainedPosition;
 }
 
-interface ImageToolOptions {
-    url: string;
-    opacity: number;
-}
-declare class ImageTool implements Extension<ImageToolOptions> {
-    name: string;
-    options: ImageToolOptions;
-    schema: Record<keyof ImageToolOptions, OptionSchema>;
-    onMount(editor: Editor): void;
-    onUnmount(editor: Editor): void;
-    onUpdate(editor: Editor, state: EditorState): void;
+declare class ImageTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private _loadingUrl;
+    private url;
+    private opacity;
+    private width?;
+    private height?;
+    private angle?;
+    private left?;
+    private top?;
+    private canvasService?;
+    private context?;
+    constructor(options?: Partial<{
+        url: string;
+        opacity: number;
+        width: number;
+        height: number;
+        angle: number;
+        left: number;
+        top: number;
+    }>);
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
     private ensureLayer;
     private updateImage;
     private loadImage;
-    commands: Record<string, Command>;
 }
 
-interface WhiteInkToolOptions {
-    customMask: string;
-    opacity: number;
-    enableClip: boolean;
-}
-declare class WhiteInkTool implements Extension<WhiteInkToolOptions> {
-    name: string;
-    options: WhiteInkToolOptions;
-    schema: Record<keyof WhiteInkToolOptions, OptionSchema>;
+declare class WhiteInkTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private customMask;
+    private opacity;
+    private enableClip;
+    private canvasService?;
     private syncHandler;
-    onMount(editor: Editor): void;
-    onUnmount(editor: Editor): void;
-    onDestroy(editor: Editor): void;
+    private _loadingUrl;
+    constructor(options?: Partial<{
+        customMask: string;
+        opacity: number;
+        enableClip: boolean;
+    }>);
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
     private setup;
     private teardown;
-    onUpdate(editor: Editor, state: EditorState): void;
-    commands: Record<string, Command>;
     private updateWhiteInk;
     private loadWhiteInk;
     private applyClipPath;
     private syncWithUserImage;
 }
 
-interface RulerToolOptions {
-    unit: 'px' | 'mm' | 'cm' | 'in';
-    thickness: number;
-    backgroundColor: string;
-    textColor: string;
-    lineColor: string;
-    fontSize: number;
-}
-declare class RulerTool implements Extension<RulerToolOptions> {
-    name: string;
-    options: RulerToolOptions;
-    schema: Record<keyof RulerToolOptions, OptionSchema>;
-    onMount(editor: Editor): void;
-    onUnmount(editor: Editor): void;
-    onUpdate(editor: Editor, state: EditorState): void;
-    onDestroy(editor: Editor): void;
+declare class RulerTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private unit;
+    private thickness;
+    private backgroundColor;
+    private textColor;
+    private lineColor;
+    private fontSize;
+    private canvasService?;
+    constructor(options?: Partial<{
+        unit: "px" | "mm" | "cm" | "in";
+        thickness: number;
+        backgroundColor: string;
+        textColor: string;
+        lineColor: string;
+        fontSize: number;
+    }>);
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
     private getLayer;
     private createLayer;
     private destroyLayer;
     private updateRuler;
-    commands: Record<string, Command>;
 }
 
-export { BackgroundTool, type DielineConfig, type DielineGeometry, DielineTool, type DielineToolOptions, FilmTool, HoleTool, type HoleToolOptions, ImageTool, RulerTool, type RulerToolOptions, WhiteInkTool };
+declare class MirrorTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private enabled;
+    private canvasService?;
+    constructor(options?: Partial<{
+        enabled: boolean;
+    }>);
+    toJSON(): {
+        enabled: boolean;
+    };
+    loadFromJSON(json: any): void;
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
+    private applyMirror;
+}
+
+declare class CanvasService implements Service {
+    canvas: Canvas;
+    constructor(el: HTMLCanvasElement | string | Canvas, options?: any);
+    dispose(): void;
+    /**
+     * Get a layer (Group) by its ID.
+     * We assume layers are Groups directly on the canvas with a data.id property.
+     */
+    getLayer(id: string): Group | undefined;
+    /**
+     * Create a layer (Group) with the given ID if it doesn't exist.
+     */
+    createLayer(id: string, options?: any): Group;
+    /**
+     * Find an object by ID, optionally within a specific layer.
+     */
+    getObject(id: string, layerId?: string): FabricObject | undefined;
+    requestRenderAll(): void;
+}
+
+export { BackgroundTool, CanvasService, type DielineGeometry, DielineTool, FilmTool, HoleTool, ImageTool, MirrorTool, RulerTool, WhiteInkTool };