@pooder/kit 5.3.0 → 5.3.1

package/src/extensions/size.ts

@@ -1,389 +1,389 @@
-import {
-  CommandContribution,
-  ConfigurationContribution,
-  ConfigurationService,
-  ContributionPointIds,
-  Extension,
-  ExtensionContext,
-} from "@pooder/core";
-import { CanvasService } from "../services";
-import {
-  fromMm,
-  normalizeConstraintMode,
-  normalizeCutMode,
-  normalizeUnit,
-  readSizeState,
-  sanitizeMmValue,
-  toMm,
-  type SizeConstraintMode,
-  computeSceneLayout,
-} from "./sceneLayoutModel";
-import type { Unit } from "../coordinate";
-
-type ChangedField = "width" | "height" | "both";
-
-interface UpdateSizeDimensionsInput {
-  width?: number;
-  height?: number;
-  unit?: Unit;
-  changed?: ChangedField;
-}
-
-export class SizeTool implements Extension {
-  id = "pooder.kit.size";
-  metadata = {
-    name: "SizeTool",
-  };
-
-  private context?: ExtensionContext;
-  private canvasService?: CanvasService;
-
-  activate(context: ExtensionContext) {
-    this.context = context;
-    this.canvasService = context.services.get<CanvasService>("CanvasService");
-    const configService = context.services.get<ConfigurationService>(
-      "ConfigurationService",
-    );
-    if (!configService) return;
-    this.ensureDefaults(configService);
-    this.emitStateChanged();
-  }
-
-  deactivate(_context: ExtensionContext) {
-    this.context = undefined;
-    this.canvasService = undefined;
-  }
-
-  contribute() {
-    return {
-      [ContributionPointIds.TOOLS]: [
-        {
-          id: this.id,
-          name: "Size",
-          interaction: "instant",
-        },
-      ],
-      [ContributionPointIds.CONFIGURATIONS]: [
-        {
-          id: "size.unit",
-          type: "select",
-          label: "Display Unit",
-          options: ["mm", "cm", "in"],
-          default: "mm",
-        },
-        {
-          id: "size.actualWidthMm",
-          type: "number",
-          label: "Actual Width (mm)",
-          min: 10,
-          max: 2000,
-          step: 0.1,
-          default: 500,
-        },
-        {
-          id: "size.actualHeightMm",
-          type: "number",
-          label: "Actual Height (mm)",
-          min: 10,
-          max: 2000,
-          step: 0.1,
-          default: 500,
-        },
-        {
-          id: "size.constraintMode",
-          type: "select",
-          label: "Constraint Mode",
-          options: ["free", "lockAspect", "equal"],
-          default: "free",
-        },
-        {
-          id: "size.aspectRatio",
-          type: "number",
-          label: "Aspect Ratio",
-          min: 0.01,
-          max: 100,
-          step: 0.01,
-          default: 1,
-        },
-        {
-          id: "size.cutMode",
-          type: "select",
-          label: "Cut Mode",
-          options: ["trim", "outset", "inset"],
-          default: "trim",
-        },
-        {
-          id: "size.cutMarginMm",
-          type: "number",
-          label: "Cut Margin (mm)",
-          min: 0,
-          max: 100,
-          step: 0.1,
-          default: 0,
-        },
-        {
-          id: "size.viewPadding",
-          type: "select",
-          label: "View Padding",
-          options: [0, 10, 20, 40, 60, 100, "2%", "5%", "10%", "15%", "20%"],
-          default: 140,
-        },
-        {
-          id: "size.minMm",
-          type: "number",
-          label: "Min Size (mm)",
-          min: 0.1,
-          max: 2000,
-          step: 0.1,
-          default: 10,
-        },
-        {
-          id: "size.maxMm",
-          type: "number",
-          label: "Max Size (mm)",
-          min: 1,
-          max: 10000,
-          step: 1,
-          default: 2000,
-        },
-        {
-          id: "size.stepMm",
-          type: "number",
-          label: "Size Step (mm)",
-          min: 0.001,
-          max: 100,
-          step: 0.001,
-          default: 0.1,
-        },
-      ] as ConfigurationContribution[],
-      [ContributionPointIds.COMMANDS]: [
-        {
-          command: "getSizeState",
-          title: "Get Size State",
-          handler: () => this.getStateForUI(),
-        },
-        {
-          command: "updateSizeDimensions",
-          title: "Update Size Dimensions",
-          handler: (input: UpdateSizeDimensionsInput = {}) =>
-            this.updateDimensions(input),
-        },
-        {
-          command: "setSizeConstraintMode",
-          title: "Set Size Constraint Mode",
-          handler: (mode: SizeConstraintMode) => this.setConstraintMode(mode),
-        },
-        {
-          command: "setSizeDisplayUnit",
-          title: "Set Size Display Unit",
-          handler: (unit: Unit) => this.setUnit(unit),
-        },
-        {
-          command: "setSizeCut",
-          title: "Set Size Cut",
-          handler: (cutMode: string, cutMarginMm: number = 0) =>
-            this.setCut(cutMode, cutMarginMm),
-        },
-        {
-          command: "getSelectedImageSize",
-          title: "Get Selected Image Size",
-          handler: (id?: string) => this.getSelectedImageSize(id),
-        },
-      ] as CommandContribution[],
-    };
-  }
-
-  private getConfigService(): ConfigurationService | undefined {
-    return this.context?.services.get<ConfigurationService>(
-      "ConfigurationService",
-    );
-  }
-
-  private ensureDefaults(configService: ConfigurationService) {
-    const state = readSizeState(configService);
-    configService.update("size.unit", state.unit);
-    configService.update("size.actualWidthMm", state.actualWidthMm);
-    configService.update("size.actualHeightMm", state.actualHeightMm);
-    configService.update("size.constraintMode", state.constraintMode);
-    configService.update(
-      "size.aspectRatio",
-      state.actualWidthMm / Math.max(0.001, state.actualHeightMm),
-    );
-    configService.update("size.cutMode", state.cutMode);
-    configService.update("size.cutMarginMm", state.cutMarginMm);
-    configService.update("size.viewPadding", state.viewPadding);
-    configService.update("size.minMm", state.minMm);
-    configService.update("size.maxMm", state.maxMm);
-    configService.update("size.stepMm", state.stepMm);
-  }
-
-  private emitStateChanged() {
-    const state = this.getStateForUI();
-    if (!state) return;
-    this.context?.eventBus.emit("size:state:changed", state);
-  }
-
-  private getStateForUI() {
-    const configService = this.getConfigService();
-    if (!configService) return null;
-    const state = readSizeState(configService);
-    return {
-      ...state,
-      actualWidth: fromMm(state.actualWidthMm, state.unit),
-      actualHeight: fromMm(state.actualHeightMm, state.unit),
-    };
-  }
-
-  private updateDimensions(input: UpdateSizeDimensionsInput) {
-    const configService = this.getConfigService();
-    if (!configService) return null;
-
-    const state = readSizeState(configService);
-    const inputUnit = normalizeUnit(input.unit ?? state.unit);
-    const changed: ChangedField = input.changed || "both";
-
-    const providedWidthMm = Number.isFinite(input.width as any)
-      ? toMm(Number(input.width), inputUnit)
-      : undefined;
-    const providedHeightMm = Number.isFinite(input.height as any)
-      ? toMm(Number(input.height), inputUnit)
-      : undefined;
-
-    const limits = {
-      minMm: state.minMm,
-      maxMm: state.maxMm,
-      stepMm: state.stepMm,
-    };
-
-    let nextWidthMm =
-      providedWidthMm !== undefined ? providedWidthMm : state.actualWidthMm;
-    let nextHeightMm =
-      providedHeightMm !== undefined ? providedHeightMm : state.actualHeightMm;
-
-    if (state.constraintMode === "equal") {
-      const anchor =
-        changed === "height"
-          ? nextHeightMm
-          : changed === "width"
-            ? nextWidthMm
-            : (providedWidthMm ?? providedHeightMm ?? nextWidthMm);
-      nextWidthMm = anchor;
-      nextHeightMm = anchor;
-    } else if (state.constraintMode === "lockAspect") {
-      const ratio = Math.max(0.0001, state.aspectRatio);
-      if (changed === "height") {
-        nextWidthMm = nextHeightMm * ratio;
-      } else {
-        nextHeightMm = nextWidthMm / ratio;
-      }
-    }
-
-    nextWidthMm = sanitizeMmValue(nextWidthMm, limits);
-    nextHeightMm = sanitizeMmValue(nextHeightMm, limits);
-
-    if (state.constraintMode === "equal") {
-      const value = Math.max(nextWidthMm, nextHeightMm);
-      nextWidthMm = value;
-      nextHeightMm = value;
-    } else if (state.constraintMode === "lockAspect") {
-      const ratio = Math.max(0.0001, state.aspectRatio);
-      if (changed === "height") {
-        nextWidthMm = sanitizeMmValue(nextHeightMm * ratio, limits);
-      } else {
-        nextHeightMm = sanitizeMmValue(nextWidthMm / ratio, limits);
-      }
-    }
-
-    configService.update("size.actualWidthMm", nextWidthMm);
-    configService.update("size.actualHeightMm", nextHeightMm);
-    configService.update("size.unit", inputUnit);
-    this.emitStateChanged();
-    return this.getStateForUI();
-  }
-
-  private setConstraintMode(modeRaw: string) {
-    const configService = this.getConfigService();
-    if (!configService) return null;
-    const state = readSizeState(configService);
-    const mode = normalizeConstraintMode(modeRaw);
-
-    configService.update("size.constraintMode", mode);
-    if (mode === "lockAspect") {
-      const ratio = state.actualWidthMm / Math.max(0.001, state.actualHeightMm);
-      configService.update("size.aspectRatio", ratio);
-    }
-    if (mode === "equal") {
-      const value = sanitizeMmValue(
-        Math.max(state.actualWidthMm, state.actualHeightMm),
-        {
-          minMm: state.minMm,
-          maxMm: state.maxMm,
-          stepMm: state.stepMm,
-        },
-      );
-      configService.update("size.actualWidthMm", value);
-      configService.update("size.actualHeightMm", value);
-      configService.update("size.aspectRatio", 1);
-    }
-    this.emitStateChanged();
-    return this.getStateForUI();
-  }
-
-  private setUnit(unitRaw: string) {
-    const configService = this.getConfigService();
-    if (!configService) return null;
-    const unit = normalizeUnit(unitRaw);
-    configService.update("size.unit", unit);
-    this.emitStateChanged();
-    return this.getStateForUI();
-  }
-
-  private setCut(cutModeRaw: string, cutMarginMm = 0) {
-    const configService = this.getConfigService();
-    if (!configService) return null;
-    const cutMode = normalizeCutMode(cutModeRaw);
-    const margin = Math.max(0, Number(cutMarginMm) || 0);
-    configService.update("size.cutMode", cutMode);
-    configService.update("size.cutMarginMm", margin);
-    this.emitStateChanged();
-    return this.getStateForUI();
-  }
-
-  private getSelectedImageSize(id?: string) {
-    const configService = this.getConfigService();
-    if (!configService || !this.canvasService) return null;
-    const sizeState = readSizeState(configService);
-    const layout = computeSceneLayout(this.canvasService, sizeState);
-    if (!layout || layout.scale <= 0) return null;
-
-    const all = this.canvasService.canvas.getObjects() as any[];
-    const active = this.canvasService.canvas.getActiveObject() as any;
-    const activeId =
-      active?.data?.layerId === "image.user" ? active?.data?.id : null;
-    const targetId = id || activeId;
-    const target =
-      all.find(
-        (obj) =>
-          obj?.data?.layerId === "image.user" && obj?.data?.id === targetId,
-      ) || all.find((obj) => obj?.data?.layerId === "image.user");
-    if (!target) return null;
-
-    const objectWidthPx = Math.abs((target.width || 0) * (target.scaleX || 1));
-    const objectHeightPx = Math.abs(
-      (target.height || 0) * (target.scaleY || 1),
-    );
-    if (objectWidthPx <= 0 || objectHeightPx <= 0) return null;
-
-    const widthMm = objectWidthPx / layout.scale;
-    const heightMm = objectHeightPx / layout.scale;
-
-    return {
-      id: target?.data?.id || null,
-      widthMm,
-      heightMm,
-      width: fromMm(widthMm, sizeState.unit),
-      height: fromMm(heightMm, sizeState.unit),
-      unit: sizeState.unit,
-    };
-  }
-}
+import {
+  CommandContribution,
+  ConfigurationContribution,
+  ConfigurationService,
+  ContributionPointIds,
+  Extension,
+  ExtensionContext,
+} from "@pooder/core";
+import { CanvasService } from "../services";
+import {
+  fromMm,
+  normalizeConstraintMode,
+  normalizeCutMode,
+  normalizeUnit,
+  readSizeState,
+  sanitizeMmValue,
+  toMm,
+  type SizeConstraintMode,
+  computeSceneLayout,
+} from "./sceneLayoutModel";
+import type { Unit } from "../coordinate";
+
+type ChangedField = "width" | "height" | "both";
+
+interface UpdateSizeDimensionsInput {
+  width?: number;
+  height?: number;
+  unit?: Unit;
+  changed?: ChangedField;
+}
+
+export class SizeTool implements Extension {
+  id = "pooder.kit.size";
+  metadata = {
+    name: "SizeTool",
+  };
+
+  private context?: ExtensionContext;
+  private canvasService?: CanvasService;
+
+  activate(context: ExtensionContext) {
+    this.context = context;
+    this.canvasService = context.services.get<CanvasService>("CanvasService");
+    const configService = context.services.get<ConfigurationService>(
+      "ConfigurationService",
+    );
+    if (!configService) return;
+    this.ensureDefaults(configService);
+    this.emitStateChanged();
+  }
+
+  deactivate(_context: ExtensionContext) {
+    this.context = undefined;
+    this.canvasService = undefined;
+  }
+
+  contribute() {
+    return {
+      [ContributionPointIds.TOOLS]: [
+        {
+          id: this.id,
+          name: "Size",
+          interaction: "instant",
+        },
+      ],
+      [ContributionPointIds.CONFIGURATIONS]: [
+        {
+          id: "size.unit",
+          type: "select",
+          label: "Display Unit",
+          options: ["mm", "cm", "in"],
+          default: "mm",
+        },
+        {
+          id: "size.actualWidthMm",
+          type: "number",
+          label: "Actual Width (mm)",
+          min: 10,
+          max: 2000,
+          step: 0.1,
+          default: 500,
+        },
+        {
+          id: "size.actualHeightMm",
+          type: "number",
+          label: "Actual Height (mm)",
+          min: 10,
+          max: 2000,
+          step: 0.1,
+          default: 500,
+        },
+        {
+          id: "size.constraintMode",
+          type: "select",
+          label: "Constraint Mode",
+          options: ["free", "lockAspect", "equal"],
+          default: "free",
+        },
+        {
+          id: "size.aspectRatio",
+          type: "number",
+          label: "Aspect Ratio",
+          min: 0.01,
+          max: 100,
+          step: 0.01,
+          default: 1,
+        },
+        {
+          id: "size.cutMode",
+          type: "select",
+          label: "Cut Mode",
+          options: ["trim", "outset", "inset"],
+          default: "trim",
+        },
+        {
+          id: "size.cutMarginMm",
+          type: "number",
+          label: "Cut Margin (mm)",
+          min: 0,
+          max: 100,
+          step: 0.1,
+          default: 0,
+        },
+        {
+          id: "size.viewPadding",
+          type: "select",
+          label: "View Padding",
+          options: [0, 10, 20, 40, 60, 100, "2%", "5%", "10%", "15%", "20%"],
+          default: 140,
+        },
+        {
+          id: "size.minMm",
+          type: "number",
+          label: "Min Size (mm)",
+          min: 0.1,
+          max: 2000,
+          step: 0.1,
+          default: 10,
+        },
+        {
+          id: "size.maxMm",
+          type: "number",
+          label: "Max Size (mm)",
+          min: 1,
+          max: 10000,
+          step: 1,
+          default: 2000,
+        },
+        {
+          id: "size.stepMm",
+          type: "number",
+          label: "Size Step (mm)",
+          min: 0.001,
+          max: 100,
+          step: 0.001,
+          default: 0.1,
+        },
+      ] as ConfigurationContribution[],
+      [ContributionPointIds.COMMANDS]: [
+        {
+          command: "getSizeState",
+          title: "Get Size State",
+          handler: () => this.getStateForUI(),
+        },
+        {
+          command: "updateSizeDimensions",
+          title: "Update Size Dimensions",
+          handler: (input: UpdateSizeDimensionsInput = {}) =>
+            this.updateDimensions(input),
+        },
+        {
+          command: "setSizeConstraintMode",
+          title: "Set Size Constraint Mode",
+          handler: (mode: SizeConstraintMode) => this.setConstraintMode(mode),
+        },
+        {
+          command: "setSizeDisplayUnit",
+          title: "Set Size Display Unit",
+          handler: (unit: Unit) => this.setUnit(unit),
+        },
+        {
+          command: "setSizeCut",
+          title: "Set Size Cut",
+          handler: (cutMode: string, cutMarginMm: number = 0) =>
+            this.setCut(cutMode, cutMarginMm),
+        },
+        {
+          command: "getSelectedImageSize",
+          title: "Get Selected Image Size",
+          handler: (id?: string) => this.getSelectedImageSize(id),
+        },
+      ] as CommandContribution[],
+    };
+  }
+
+  private getConfigService(): ConfigurationService | undefined {
+    return this.context?.services.get<ConfigurationService>(
+      "ConfigurationService",
+    );
+  }
+
+  private ensureDefaults(configService: ConfigurationService) {
+    const state = readSizeState(configService);
+    configService.update("size.unit", state.unit);
+    configService.update("size.actualWidthMm", state.actualWidthMm);
+    configService.update("size.actualHeightMm", state.actualHeightMm);
+    configService.update("size.constraintMode", state.constraintMode);
+    configService.update(
+      "size.aspectRatio",
+      state.actualWidthMm / Math.max(0.001, state.actualHeightMm),
+    );
+    configService.update("size.cutMode", state.cutMode);
+    configService.update("size.cutMarginMm", state.cutMarginMm);
+    configService.update("size.viewPadding", state.viewPadding);
+    configService.update("size.minMm", state.minMm);
+    configService.update("size.maxMm", state.maxMm);
+    configService.update("size.stepMm", state.stepMm);
+  }
+
+  private emitStateChanged() {
+    const state = this.getStateForUI();
+    if (!state) return;
+    this.context?.eventBus.emit("size:state:changed", state);
+  }
+
+  private getStateForUI() {
+    const configService = this.getConfigService();
+    if (!configService) return null;
+    const state = readSizeState(configService);
+    return {
+      ...state,
+      actualWidth: fromMm(state.actualWidthMm, state.unit),
+      actualHeight: fromMm(state.actualHeightMm, state.unit),
+    };
+  }
+
+  private updateDimensions(input: UpdateSizeDimensionsInput) {
+    const configService = this.getConfigService();
+    if (!configService) return null;
+
+    const state = readSizeState(configService);
+    const inputUnit = normalizeUnit(input.unit ?? state.unit);
+    const changed: ChangedField = input.changed || "both";
+
+    const providedWidthMm = Number.isFinite(input.width as any)
+      ? toMm(Number(input.width), inputUnit)
+      : undefined;
+    const providedHeightMm = Number.isFinite(input.height as any)
+      ? toMm(Number(input.height), inputUnit)
+      : undefined;
+
+    const limits = {
+      minMm: state.minMm,
+      maxMm: state.maxMm,
+      stepMm: state.stepMm,
+    };
+
+    let nextWidthMm =
+      providedWidthMm !== undefined ? providedWidthMm : state.actualWidthMm;
+    let nextHeightMm =
+      providedHeightMm !== undefined ? providedHeightMm : state.actualHeightMm;
+
+    if (state.constraintMode === "equal") {
+      const anchor =
+        changed === "height"
+          ? nextHeightMm
+          : changed === "width"
+            ? nextWidthMm
+            : (providedWidthMm ?? providedHeightMm ?? nextWidthMm);
+      nextWidthMm = anchor;
+      nextHeightMm = anchor;
+    } else if (state.constraintMode === "lockAspect") {
+      const ratio = Math.max(0.0001, state.aspectRatio);
+      if (changed === "height") {
+        nextWidthMm = nextHeightMm * ratio;
+      } else {
+        nextHeightMm = nextWidthMm / ratio;
+      }
+    }
+
+    nextWidthMm = sanitizeMmValue(nextWidthMm, limits);
+    nextHeightMm = sanitizeMmValue(nextHeightMm, limits);
+
+    if (state.constraintMode === "equal") {
+      const value = Math.max(nextWidthMm, nextHeightMm);
+      nextWidthMm = value;
+      nextHeightMm = value;
+    } else if (state.constraintMode === "lockAspect") {
+      const ratio = Math.max(0.0001, state.aspectRatio);
+      if (changed === "height") {
+        nextWidthMm = sanitizeMmValue(nextHeightMm * ratio, limits);
+      } else {
+        nextHeightMm = sanitizeMmValue(nextWidthMm / ratio, limits);
+      }
+    }
+
+    configService.update("size.actualWidthMm", nextWidthMm);
+    configService.update("size.actualHeightMm", nextHeightMm);
+    configService.update("size.unit", inputUnit);
+    this.emitStateChanged();
+    return this.getStateForUI();
+  }
+
+  private setConstraintMode(modeRaw: string) {
+    const configService = this.getConfigService();
+    if (!configService) return null;
+    const state = readSizeState(configService);
+    const mode = normalizeConstraintMode(modeRaw);
+
+    configService.update("size.constraintMode", mode);
+    if (mode === "lockAspect") {
+      const ratio = state.actualWidthMm / Math.max(0.001, state.actualHeightMm);
+      configService.update("size.aspectRatio", ratio);
+    }
+    if (mode === "equal") {
+      const value = sanitizeMmValue(
+        Math.max(state.actualWidthMm, state.actualHeightMm),
+        {
+          minMm: state.minMm,
+          maxMm: state.maxMm,
+          stepMm: state.stepMm,
+        },
+      );
+      configService.update("size.actualWidthMm", value);
+      configService.update("size.actualHeightMm", value);
+      configService.update("size.aspectRatio", 1);
+    }
+    this.emitStateChanged();
+    return this.getStateForUI();
+  }
+
+  private setUnit(unitRaw: string) {
+    const configService = this.getConfigService();
+    if (!configService) return null;
+    const unit = normalizeUnit(unitRaw);
+    configService.update("size.unit", unit);
+    this.emitStateChanged();
+    return this.getStateForUI();
+  }
+
+  private setCut(cutModeRaw: string, cutMarginMm = 0) {
+    const configService = this.getConfigService();
+    if (!configService) return null;
+    const cutMode = normalizeCutMode(cutModeRaw);
+    const margin = Math.max(0, Number(cutMarginMm) || 0);
+    configService.update("size.cutMode", cutMode);
+    configService.update("size.cutMarginMm", margin);
+    this.emitStateChanged();
+    return this.getStateForUI();
+  }
+
+  private getSelectedImageSize(id?: string) {
+    const configService = this.getConfigService();
+    if (!configService || !this.canvasService) return null;
+    const sizeState = readSizeState(configService);
+    const layout = computeSceneLayout(this.canvasService, sizeState);
+    if (!layout || layout.scale <= 0) return null;
+
+    const all = this.canvasService.canvas.getObjects() as any[];
+    const active = this.canvasService.canvas.getActiveObject() as any;
+    const activeId =
+      active?.data?.layerId === "image.user" ? active?.data?.id : null;
+    const targetId = id || activeId;
+    const target =
+      all.find(
+        (obj) =>
+          obj?.data?.layerId === "image.user" && obj?.data?.id === targetId,
+      ) || all.find((obj) => obj?.data?.layerId === "image.user");
+    if (!target) return null;
+
+    const objectWidthPx = Math.abs((target.width || 0) * (target.scaleX || 1));
+    const objectHeightPx = Math.abs(
+      (target.height || 0) * (target.scaleY || 1),
+    );
+    if (objectWidthPx <= 0 || objectHeightPx <= 0) return null;
+
+    const widthMm = objectWidthPx / layout.scale;
+    const heightMm = objectHeightPx / layout.scale;
+
+    return {
+      id: target?.data?.id || null,
+      widthMm,
+      heightMm,
+      width: fromMm(widthMm, sizeState.unit),
+      height: fromMm(heightMm, sizeState.unit),
+      unit: sizeState.unit,
+    };
+  }
+}