@pooder/kit 5.2.0 → 5.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pooder/kit",
-  "version": "5.2.0",
+  "version": "5.3.0",
   "description": "Standard plugins for Pooder editor",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",

package/src/coordinate.ts

@@ -1,106 +1,106 @@
-export interface Point {
-  x: number;
-  y: number;
-}
-
-export interface Size {
-  width: number;
-  height: number;
-}
-
-export type Unit = "px" | "mm" | "cm" | "in";
-
-export interface Layout {
-  scale: number;
-  offsetX: number;
-  offsetY: number;
-  width: number;
-  height: number;
-}
-
-export class Coordinate {
-  /**
-   * Calculate layout to fit content within container while preserving aspect ratio.
-   */
-  static calculateLayout(
-    container: Size,
-    content: Size,
-    padding: number = 0,
-  ): Layout {
-    const availableWidth = Math.max(0, container.width - padding * 2);
-    const availableHeight = Math.max(0, container.height - padding * 2);
-
-    if (content.width === 0 || content.height === 0) {
-      return { scale: 1, offsetX: 0, offsetY: 0, width: 0, height: 0 };
-    }
-
-    const scaleX = availableWidth / content.width;
-    const scaleY = availableHeight / content.height;
-    const scale = Math.min(scaleX, scaleY);
-
-    const width = content.width * scale;
-    const height = content.height * scale;
-
-    const offsetX = (container.width - width) / 2;
-    const offsetY = (container.height - height) / 2;
-
-    return { scale, offsetX, offsetY, width, height };
-  }
-
-  /**
-   * Convert an absolute value to a normalized value (0-1).
-   * @param value Absolute value (e.g., pixels)
-   * @param total Total dimension size (e.g., canvas width)
-   */
-  static toNormalized(value: number, total: number): number {
-    return total === 0 ? 0 : value / total;
-  }
-
-  /**
-   * Convert a normalized value (0-1) to an absolute value.
-   * @param normalized Normalized value (0-1)
-   * @param total Total dimension size (e.g., canvas width)
-   */
-  static toAbsolute(normalized: number, total: number): number {
-    return normalized * total;
-  }
-
-  /**
-   * Normalize a point's coordinates.
-   */
-  static normalizePoint(point: Point, size: Size): Point {
-    return {
-      x: this.toNormalized(point.x, size.width),
-      y: this.toNormalized(point.y, size.height),
-    };
-  }
-
-  /**
-   * Denormalize a point's coordinates to absolute pixels.
-   */
-  static denormalizePoint(point: Point, size: Size): Point {
-    return {
-      x: this.toAbsolute(point.x, size.width),
-      y: this.toAbsolute(point.y, size.height),
-    };
-  }
-
-  static convertUnit(value: number, from: Unit, to: Unit): number {
-    if (from === to) return value;
-    
-    // Base unit: mm
-    const toMM: Record<Unit, number> = {
-      px: 0.264583, // 1px = 0.264583mm (96 DPI)
-      mm: 1,
-      cm: 10,
-      in: 25.4
-    };
-
-    const mmValue = value * (from === 'px' ? toMM.px : toMM[from] || 1);
-    
-    if (to === 'px') {
-        return mmValue / toMM.px;
-    }
-    return mmValue / (toMM[to] || 1);
-  }
-}
+export interface Point {
+  x: number;
+  y: number;
+}
+
+export interface Size {
+  width: number;
+  height: number;
+}
+
+export type Unit = "px" | "mm" | "cm" | "in";
+
+export interface Layout {
+  scale: number;
+  offsetX: number;
+  offsetY: number;
+  width: number;
+  height: number;
+}
+
+export class Coordinate {
+  /**
+   * Calculate layout to fit content within container while preserving aspect ratio.
+   */
+  static calculateLayout(
+    container: Size,
+    content: Size,
+    padding: number = 0,
+  ): Layout {
+    const availableWidth = Math.max(0, container.width - padding * 2);
+    const availableHeight = Math.max(0, container.height - padding * 2);
+
+    if (content.width === 0 || content.height === 0) {
+      return { scale: 1, offsetX: 0, offsetY: 0, width: 0, height: 0 };
+    }
+
+    const scaleX = availableWidth / content.width;
+    const scaleY = availableHeight / content.height;
+    const scale = Math.min(scaleX, scaleY);
+
+    const width = content.width * scale;
+    const height = content.height * scale;
+
+    const offsetX = (container.width - width) / 2;
+    const offsetY = (container.height - height) / 2;
+
+    return { scale, offsetX, offsetY, width, height };
+  }
+
+  /**
+   * Convert an absolute value to a normalized value (0-1).
+   * @param value Absolute value (e.g., pixels)
+   * @param total Total dimension size (e.g., canvas width)
+   */
+  static toNormalized(value: number, total: number): number {
+    return total === 0 ? 0 : value / total;
+  }
+
+  /**
+   * Convert a normalized value (0-1) to an absolute value.
+   * @param normalized Normalized value (0-1)
+   * @param total Total dimension size (e.g., canvas width)
+   */
+  static toAbsolute(normalized: number, total: number): number {
+    return normalized * total;
+  }
+
+  /**
+   * Normalize a point's coordinates.
+   */
+  static normalizePoint(point: Point, size: Size): Point {
+    return {
+      x: this.toNormalized(point.x, size.width),
+      y: this.toNormalized(point.y, size.height),
+    };
+  }
+
+  /**
+   * Denormalize a point's coordinates to absolute pixels.
+   */
+  static denormalizePoint(point: Point, size: Size): Point {
+    return {
+      x: this.toAbsolute(point.x, size.width),
+      y: this.toAbsolute(point.y, size.height),
+    };
+  }
+
+  static convertUnit(value: number, from: Unit, to: Unit): number {
+    if (from === to) return value;
+    
+    // Base unit: mm
+    const toMM: Record<Unit, number> = {
+      px: 0.264583, // 1px = 0.264583mm (96 DPI)
+      mm: 1,
+      cm: 10,
+      in: 25.4
+    };
+
+    const mmValue = value * (from === 'px' ? toMM.px : toMM[from] || 1);
+    
+    if (to === 'px') {
+        return mmValue / toMM.px;
+    }
+    return mmValue / (toMM[to] || 1);
+  }
+}

package/src/extensions/background.ts

@@ -1,230 +1,230 @@
-import {
-  Extension,
-  ExtensionContext,
-  ContributionPointIds,
-  CommandContribution,
-  ConfigurationContribution,
-} from "@pooder/core";
-import { Rect, FabricImage as Image } from "fabric";
-import { CanvasService } from "../services";
-
-export class BackgroundTool implements Extension {
-  id = "pooder.kit.background";
-  public metadata = {
-    name: "BackgroundTool",
-  };
-
-  private color: string = "";
-  private url: string = "";
-
-  private canvasService?: CanvasService;
-
-  constructor(
-    options?: Partial<{
-      color: string;
-      url: string;
-    }>,
-  ) {
-    if (options) {
-      Object.assign(this, options);
-    }
-  }
-
-  activate(context: ExtensionContext) {
-    this.canvasService = context.services.get<CanvasService>("CanvasService");
-    if (!this.canvasService) {
-      console.warn("CanvasService not found for BackgroundTool");
-      return;
-    }
-
-    const configService = context.services.get<any>("ConfigurationService");
-    if (configService) {
-      // Load initial config
-      this.color = configService.get("background.color", this.color);
-      this.url = configService.get("background.url", this.url);
-
-      // Listen for changes
-      configService.onAnyChange((e: { key: string; value: any }) => {
-        if (e.key.startsWith("background.")) {
-          const prop = e.key.split(".")[1];
-          console.log(
-            `[BackgroundTool] Config change detected: ${e.key} -> ${e.value}, prop: ${prop}`,
-          );
-          if (prop && prop in this) {
-            console.log(
-              `[BackgroundTool] Updating option ${prop} to ${e.value}`,
-            );
-            (this as any)[prop] = e.value;
-            this.updateBackground();
-          } else {
-            console.warn(
-              `[BackgroundTool] Property ${prop} not found in options`,
-            );
-          }
-        }
-      });
-    }
-
-    this.initLayer();
-    this.updateBackground();
-  }
-
-  deactivate(context: ExtensionContext) {
-    if (this.canvasService) {
-      const layer = this.canvasService.getLayer("background");
-      if (layer) {
-        this.canvasService.canvas.remove(layer);
-      }
-      this.canvasService = undefined;
-    }
-  }
-
-  contribute() {
-    return {
-      [ContributionPointIds.CONFIGURATIONS]: [
-        {
-          id: "background.color",
-          type: "color",
-          label: "Background Color",
-          default: "",
-        },
-        {
-          id: "background.url",
-          type: "string",
-          label: "Image URL",
-          default: "",
-        },
-      ] as ConfigurationContribution[],
-      [ContributionPointIds.COMMANDS]: [
-        {
-          command: "reset",
-          title: "Reset Background",
-          handler: () => {
-            this.updateBackground();
-            return true;
-          },
-        },
-        {
-          command: "clear",
-          title: "Clear Background",
-          handler: () => {
-            this.color = "transparent";
-            this.url = "";
-            this.updateBackground();
-            return true;
-          },
-        },
-        {
-          command: "setBackgroundColor",
-          title: "Set Background Color",
-          handler: (color: string) => {
-            if (this.color === color) return true;
-            this.color = color;
-            this.updateBackground();
-            return true;
-          },
-        },
-        {
-          command: "setBackgroundImage",
-          title: "Set Background Image",
-          handler: (url: string) => {
-            if (this.url === url) return true;
-            this.url = url;
-            this.updateBackground();
-            return true;
-          },
-        },
-      ] as CommandContribution[],
-    };
-  }
-
-  private initLayer() {
-    if (!this.canvasService) return;
-    let backgroundLayer = this.canvasService.getLayer("background");
-    if (!backgroundLayer) {
-      backgroundLayer = this.canvasService.createLayer("background", {
-        width: this.canvasService.canvas.width,
-        height: this.canvasService.canvas.height,
-        selectable: false,
-        evented: false,
-      });
-      this.canvasService.canvas.sendObjectToBack(backgroundLayer);
-    }
-  }
-
-  private async updateBackground() {
-    if (!this.canvasService) return;
-    const layer = this.canvasService.getLayer("background");
-    if (!layer) {
-      console.warn("[BackgroundTool] Background layer not found");
-      return;
-    }
-
-    const { color, url } = this;
-
-    const width = this.canvasService.canvas.width || 800;
-    const height = this.canvasService.canvas.height || 600;
-
-    let rect = this.canvasService.getObject(
-      "background-color-rect",
-      "background",
-    ) as Rect;
-    if (rect) {
-      rect.set({
-        fill: color,
-      });
-    } else {
-      rect = new Rect({
-        width,
-        height,
-        fill: color,
-        selectable: false,
-        evented: false,
-        data: {
-          id: "background-color-rect",
-        },
-      });
-      layer.add(rect);
-      layer.sendObjectToBack(rect);
-    }
-
-    let img = this.canvasService.getObject(
-      "background-image",
-      "background",
-    ) as Image;
-    try {
-      if (img) {
-        if (img.getSrc() !== url) {
-          if (url) {
-            await img.setSrc(url);
-          } else {
-            layer.remove(img);
-          }
-        }
-      } else {
-        if (url) {
-          img = await Image.fromURL(url, { crossOrigin: "anonymous" });
-          img.set({
-            originX: "left",
-            originY: "top",
-            left: 0,
-            top: 0,
-            selectable: false,
-            evented: false,
-            data: {
-              id: "background-image",
-            },
-          });
-          img.scaleToWidth(width);
-          if (img.getScaledHeight() < height) img.scaleToHeight(height);
-          layer.add(img);
-        }
-      }
-      this.canvasService.requestRenderAll();
-    } catch (e) {
-      console.error("[BackgroundTool] Failed to load image", e);
-    }
-    layer.dirty = true;
-    this.canvasService.requestRenderAll();
-  }
-}
+import {
+  Extension,
+  ExtensionContext,
+  ContributionPointIds,
+  CommandContribution,
+  ConfigurationContribution,
+} from "@pooder/core";
+import { Rect, FabricImage as Image } from "fabric";
+import { CanvasService } from "../services";
+
+export class BackgroundTool implements Extension {
+  id = "pooder.kit.background";
+  public metadata = {
+    name: "BackgroundTool",
+  };
+
+  private color: string = "";
+  private url: string = "";
+
+  private canvasService?: CanvasService;
+
+  constructor(
+    options?: Partial<{
+      color: string;
+      url: string;
+    }>,
+  ) {
+    if (options) {
+      Object.assign(this, options);
+    }
+  }
+
+  activate(context: ExtensionContext) {
+    this.canvasService = context.services.get<CanvasService>("CanvasService");
+    if (!this.canvasService) {
+      console.warn("CanvasService not found for BackgroundTool");
+      return;
+    }
+
+    const configService = context.services.get<any>("ConfigurationService");
+    if (configService) {
+      // Load initial config
+      this.color = configService.get("background.color", this.color);
+      this.url = configService.get("background.url", this.url);
+
+      // Listen for changes
+      configService.onAnyChange((e: { key: string; value: any }) => {
+        if (e.key.startsWith("background.")) {
+          const prop = e.key.split(".")[1];
+          console.log(
+            `[BackgroundTool] Config change detected: ${e.key} -> ${e.value}, prop: ${prop}`,
+          );
+          if (prop && prop in this) {
+            console.log(
+              `[BackgroundTool] Updating option ${prop} to ${e.value}`,
+            );
+            (this as any)[prop] = e.value;
+            this.updateBackground();
+          } else {
+            console.warn(
+              `[BackgroundTool] Property ${prop} not found in options`,
+            );
+          }
+        }
+      });
+    }
+
+    this.initLayer();
+    this.updateBackground();
+  }
+
+  deactivate(context: ExtensionContext) {
+    if (this.canvasService) {
+      const layer = this.canvasService.getLayer("background");
+      if (layer) {
+        this.canvasService.canvas.remove(layer);
+      }
+      this.canvasService = undefined;
+    }
+  }
+
+  contribute() {
+    return {
+      [ContributionPointIds.CONFIGURATIONS]: [
+        {
+          id: "background.color",
+          type: "color",
+          label: "Background Color",
+          default: "",
+        },
+        {
+          id: "background.url",
+          type: "string",
+          label: "Image URL",
+          default: "",
+        },
+      ] as ConfigurationContribution[],
+      [ContributionPointIds.COMMANDS]: [
+        {
+          command: "reset",
+          title: "Reset Background",
+          handler: () => {
+            this.updateBackground();
+            return true;
+          },
+        },
+        {
+          command: "clear",
+          title: "Clear Background",
+          handler: () => {
+            this.color = "transparent";
+            this.url = "";
+            this.updateBackground();
+            return true;
+          },
+        },
+        {
+          command: "setBackgroundColor",
+          title: "Set Background Color",
+          handler: (color: string) => {
+            if (this.color === color) return true;
+            this.color = color;
+            this.updateBackground();
+            return true;
+          },
+        },
+        {
+          command: "setBackgroundImage",
+          title: "Set Background Image",
+          handler: (url: string) => {
+            if (this.url === url) return true;
+            this.url = url;
+            this.updateBackground();
+            return true;
+          },
+        },
+      ] as CommandContribution[],
+    };
+  }
+
+  private initLayer() {
+    if (!this.canvasService) return;
+    let backgroundLayer = this.canvasService.getLayer("background");
+    if (!backgroundLayer) {
+      backgroundLayer = this.canvasService.createLayer("background", {
+        width: this.canvasService.canvas.width,
+        height: this.canvasService.canvas.height,
+        selectable: false,
+        evented: false,
+      });
+      this.canvasService.canvas.sendObjectToBack(backgroundLayer);
+    }
+  }
+
+  private async updateBackground() {
+    if (!this.canvasService) return;
+    const layer = this.canvasService.getLayer("background");
+    if (!layer) {
+      console.warn("[BackgroundTool] Background layer not found");
+      return;
+    }
+
+    const { color, url } = this;
+
+    const width = this.canvasService.canvas.width || 800;
+    const height = this.canvasService.canvas.height || 600;
+
+    let rect = this.canvasService.getObject(
+      "background-color-rect",
+      "background",
+    ) as Rect;
+    if (rect) {
+      rect.set({
+        fill: color,
+      });
+    } else {
+      rect = new Rect({
+        width,
+        height,
+        fill: color,
+        selectable: false,
+        evented: false,
+        data: {
+          id: "background-color-rect",
+        },
+      });
+      layer.add(rect);
+      layer.sendObjectToBack(rect);
+    }
+
+    let img = this.canvasService.getObject(
+      "background-image",
+      "background",
+    ) as Image;
+    try {
+      if (img) {
+        if (img.getSrc() !== url) {
+          if (url) {
+            await img.setSrc(url);
+          } else {
+            layer.remove(img);
+          }
+        }
+      } else {
+        if (url) {
+          img = await Image.fromURL(url, { crossOrigin: "anonymous" });
+          img.set({
+            originX: "left",
+            originY: "top",
+            left: 0,
+            top: 0,
+            selectable: false,
+            evented: false,
+            data: {
+              id: "background-image",
+            },
+          });
+          img.scaleToWidth(width);
+          if (img.getScaledHeight() < height) img.scaleToHeight(height);
+          layer.add(img);
+        }
+      }
+      this.canvasService.requestRenderAll();
+    } catch (e) {
+      console.error("[BackgroundTool] Failed to load image", e);
+    }
+    layer.dirty = true;
+    this.canvasService.requestRenderAll();
+  }
+}