@node-edit-utils/core 2.3.2 → 2.3.4

package/src/lib/canvas/enableCanvasTextMode.test.ts

@@ -0,0 +1,53 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { enableCanvasTextMode } from "./enableCanvasTextMode";
+import * as getCanvasWindowValueModule from "./helpers/getCanvasWindowValue";
+
+vi.mock("./helpers/getCanvasWindowValue");
+
+describe("enableCanvasTextMode", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should call enableTextEditMode function from canvas window value", () => {
+    const mockEnableTextEditMode = vi.fn();
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(mockEnableTextEditMode);
+
+    enableCanvasTextMode();
+
+    expect(getCanvasWindowValueModule.getCanvasWindowValue).toHaveBeenCalledWith(["keyboard", "enableTextEditMode"], "canvas");
+    expect(mockEnableTextEditMode).toHaveBeenCalledTimes(1);
+  });
+
+  it("should use custom canvas name", () => {
+    const mockEnableTextEditMode = vi.fn();
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(mockEnableTextEditMode);
+
+    enableCanvasTextMode("custom-canvas");
+
+    expect(getCanvasWindowValueModule.getCanvasWindowValue).toHaveBeenCalledWith(["keyboard", "enableTextEditMode"], "custom-canvas");
+    expect(mockEnableTextEditMode).toHaveBeenCalledTimes(1);
+  });
+
+  it("should not throw when enableTextEditMode function is undefined", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(undefined);
+
+    expect(() => enableCanvasTextMode()).not.toThrow();
+  });
+
+  it("should not throw when enableTextEditMode function is null", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(null);
+
+    expect(() => enableCanvasTextMode()).not.toThrow();
+  });
+
+  it("should throw when getCanvasWindowValue returns non-function", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue("not-a-function");
+
+    expect(() => enableCanvasTextMode()).toThrow();
+  });
+});

package/src/lib/canvas/enableCanvasTextMode.ts

@@ -1,7 +1,7 @@
 import { getCanvasWindowValue } from "@/lib/canvas/helpers/getCanvasWindowValue";
 
 export const enableCanvasTextMode = (canvasName: string = "canvas") => {
-  const enableTextEditMode = getCanvasWindowValue(["keyboard", "enableTextEditMode"], canvasName);
+  const enableTextEditMode = getCanvasWindowValue(["keyboard", "enableTextEditMode"], canvasName) as (() => void) | undefined;
 
   enableTextEditMode?.();
 };

package/src/lib/canvas/helpers/applyCanvasState.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { applyCanvasState } from "./applyCanvasState";
+import * as getCanvasWindowValueModule from "./getCanvasWindowValue";
+
+vi.mock("./getCanvasWindowValue");
+
+describe("applyCanvasState", () => {
+  beforeEach(() => {
+    // Clear body styles and data attributes
+    document.body.style.removeProperty("--zoom");
+    document.body.style.removeProperty("--stroke-width");
+    delete document.body.dataset.zoom;
+    delete document.body.dataset.strokeWidth;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+    document.body.style.removeProperty("--zoom");
+    document.body.style.removeProperty("--stroke-width");
+    delete document.body.dataset.zoom;
+    delete document.body.dataset.strokeWidth;
+  });
+
+  it("should set zoom and stroke-width CSS variables", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(1);
+
+    applyCanvasState();
+
+    expect(document.body.style.getPropertyValue("--zoom")).toBe("1.00000");
+    expect(document.body.style.getPropertyValue("--stroke-width")).toBe("2.000");
+  });
+
+  it("should set zoom and stroke-width data attributes", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(1);
+
+    applyCanvasState();
+
+    expect(document.body.dataset.zoom).toBe("1.00000");
+    expect(document.body.dataset.strokeWidth).toBe("2.000");
+  });
+
+  it("should use default zoom of 1 when zoom is undefined", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(undefined);
+
+    applyCanvasState();
+
+    expect(document.body.style.getPropertyValue("--zoom")).toBe("1.00000");
+    expect(document.body.style.getPropertyValue("--stroke-width")).toBe("2.000");
+    expect(document.body.dataset.zoom).toBe("1.00000");
+    expect(document.body.dataset.strokeWidth).toBe("2.000");
+  });
+
+  it("should calculate stroke-width based on zoom", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(2);
+
+    applyCanvasState();
+
+    expect(document.body.style.getPropertyValue("--zoom")).toBe("2.00000");
+    expect(document.body.style.getPropertyValue("--stroke-width")).toBe("1.000");
+    expect(document.body.dataset.zoom).toBe("2.00000");
+    expect(document.body.dataset.strokeWidth).toBe("1.000");
+  });
+
+  it("should handle fractional zoom values", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(0.5);
+
+    applyCanvasState();
+
+    expect(document.body.style.getPropertyValue("--zoom")).toBe("0.50000");
+    expect(document.body.style.getPropertyValue("--stroke-width")).toBe("4.000");
+    expect(document.body.dataset.zoom).toBe("0.50000");
+    expect(document.body.dataset.strokeWidth).toBe("4.000");
+  });
+
+  it("should use custom canvas name", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(1.5);
+
+    applyCanvasState("custom-canvas");
+
+    expect(getCanvasWindowValueModule.getCanvasWindowValue).toHaveBeenCalledWith(["zoom", "current"], "custom-canvas");
+    expect(document.body.style.getPropertyValue("--zoom")).toBe("1.50000");
+    expect(document.body.style.getPropertyValue("--stroke-width")).toBe("1.333");
+  });
+
+  it("should format zoom with 5 decimal places", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(1.123456789);
+
+    applyCanvasState();
+
+    expect(document.body.style.getPropertyValue("--zoom")).toBe("1.12346");
+    expect(document.body.dataset.zoom).toBe("1.12346");
+  });
+
+  it("should format stroke-width with 3 decimal places", () => {
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(1.333333);
+
+    applyCanvasState();
+
+    // 2 / 1.333333 = 1.500000... which rounds to 1.500
+    expect(document.body.style.getPropertyValue("--stroke-width")).toBe("1.500");
+    expect(document.body.dataset.strokeWidth).toBe("1.500");
+  });
+
+  it("should update existing values", () => {
+    document.body.style.setProperty("--zoom", "0.50000");
+    document.body.style.setProperty("--stroke-width", "4.000");
+    document.body.dataset.zoom = "0.50000";
+    document.body.dataset.strokeWidth = "4.000";
+
+    vi.mocked(getCanvasWindowValueModule.getCanvasWindowValue).mockReturnValue(2);
+
+    applyCanvasState();
+
+    expect(document.body.style.getPropertyValue("--zoom")).toBe("2.00000");
+    expect(document.body.style.getPropertyValue("--stroke-width")).toBe("1.000");
+    expect(document.body.dataset.zoom).toBe("2.00000");
+    expect(document.body.dataset.strokeWidth).toBe("1.000");
+  });
+});

package/src/lib/canvas/helpers/applyCanvasState.ts

@@ -1,7 +1,7 @@
 import { getCanvasWindowValue } from "./getCanvasWindowValue";
 
 export const applyCanvasState = (canvasName: string = "canvas") => {
-  const zoom: number = getCanvasWindowValue(["zoom", "current"], canvasName) ?? 1;
+  const zoom: number = (getCanvasWindowValue(["zoom", "current"], canvasName) as number | undefined) ?? 1;
 
   document.body.style.setProperty("--zoom", zoom.toFixed(5));
   document.body.style.setProperty("--stroke-width", (2 / zoom).toFixed(3));

package/src/lib/canvas/helpers/getCanvasContainer.test.ts

@@ -0,0 +1,62 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { getCanvasContainer } from "./getCanvasContainer";
+
+describe("getCanvasContainer", () => {
+  let canvasContainer: HTMLElement;
+
+  beforeEach(() => {
+    canvasContainer = document.createElement("div");
+    canvasContainer.classList.add("canvas-container");
+  });
+
+  afterEach(() => {
+    if (document.body.contains(canvasContainer)) {
+      document.body.removeChild(canvasContainer);
+    }
+    // Remove any other canvas containers that might exist
+    const existingContainers = document.querySelectorAll(".canvas-container");
+    existingContainers.forEach((container) => {
+      if (document.body.contains(container)) {
+        document.body.removeChild(container);
+      }
+    });
+  });
+
+  it("should return canvas container element when it exists", () => {
+    document.body.appendChild(canvasContainer);
+
+    const result = getCanvasContainer();
+
+    expect(result).toBe(canvasContainer);
+  });
+
+  it("should return null when canvas container does not exist", () => {
+    const result = getCanvasContainer();
+
+    expect(result).toBeNull();
+  });
+
+  it("should return first canvas container when multiple exist", () => {
+    const firstContainer = document.createElement("div");
+    firstContainer.classList.add("canvas-container");
+    const secondContainer = document.createElement("div");
+    secondContainer.classList.add("canvas-container");
+
+    document.body.appendChild(firstContainer);
+    document.body.appendChild(secondContainer);
+
+    const result = getCanvasContainer();
+
+    expect(result).toBe(firstContainer);
+  });
+
+  it("should return null after container is removed", () => {
+    document.body.appendChild(canvasContainer);
+    const result1 = getCanvasContainer();
+    expect(result1).toBe(canvasContainer);
+
+    document.body.removeChild(canvasContainer);
+    const result2 = getCanvasContainer();
+    expect(result2).toBeNull();
+  });
+});

package/src/lib/canvas/helpers/getCanvasContainerOrBody.test.ts

@@ -0,0 +1,51 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import * as getCanvasContainerModule from "./getCanvasContainer";
+import { getCanvasContainerOrBody } from "./getCanvasContainerOrBody";
+
+vi.mock("./getCanvasContainer");
+
+describe("getCanvasContainerOrBody", () => {
+  let canvasContainer: HTMLElement;
+
+  beforeEach(() => {
+    canvasContainer = document.createElement("div");
+    canvasContainer.classList.add("canvas-container");
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("should return canvas container when it exists", () => {
+    vi.mocked(getCanvasContainerModule.getCanvasContainer).mockReturnValue(canvasContainer);
+
+    const result = getCanvasContainerOrBody();
+
+    expect(result).toBe(canvasContainer);
+  });
+
+  it("should return document.body when canvas container does not exist", () => {
+    vi.mocked(getCanvasContainerModule.getCanvasContainer).mockReturnValue(null);
+
+    const result = getCanvasContainerOrBody();
+
+    expect(result).toBe(document.body);
+  });
+
+  it("should always return an HTMLElement", () => {
+    vi.mocked(getCanvasContainerModule.getCanvasContainer).mockReturnValue(canvasContainer);
+
+    const result = getCanvasContainerOrBody();
+
+    expect(result).toBeInstanceOf(HTMLElement);
+  });
+
+  it("should return document.body when canvas container is null", () => {
+    vi.mocked(getCanvasContainerModule.getCanvasContainer).mockReturnValue(null);
+
+    const result = getCanvasContainerOrBody();
+
+    expect(result).toBe(document.body);
+    expect(result).toBeInstanceOf(HTMLElement);
+  });
+});

package/src/lib/canvas/helpers/getCanvasContainerOrBody.ts

@@ -0,0 +1,6 @@
+import { getCanvasContainer } from "./getCanvasContainer";
+
+export const getCanvasContainerOrBody = (): HTMLElement => {
+  return getCanvasContainer() || document.body;
+};
+

package/src/lib/canvas/helpers/getCanvasWindowValue.test.ts

@@ -0,0 +1,116 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { getCanvasWindowValue } from "./getCanvasWindowValue";
+
+describe("getCanvasWindowValue", () => {
+  beforeEach(() => {
+    // Clear any existing canvas properties
+    delete (window as unknown as Record<string, unknown>).canvas;
+    delete (window as unknown as Record<string, unknown>).customCanvas;
+  });
+
+  afterEach(() => {
+    // Clean up
+    delete (window as unknown as Record<string, unknown>).canvas;
+    delete (window as unknown as Record<string, unknown>).customCanvas;
+  });
+
+  it("should return value from nested path", () => {
+    const mockValue = { keyboard: { enable: vi.fn() } };
+    (window as unknown as Record<string, unknown>).canvas = mockValue;
+
+    const result = getCanvasWindowValue(["keyboard", "enable"], "canvas");
+
+    expect(result).toBe(mockValue.keyboard.enable);
+  });
+
+  it("should return undefined when canvas does not exist", () => {
+    const result = getCanvasWindowValue(["keyboard", "enable"], "nonExistentCanvas");
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should return undefined when path does not exist", () => {
+    (window as unknown as Record<string, unknown>).canvas = {};
+
+    const result = getCanvasWindowValue(["nonExistent", "path"], "canvas");
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should return undefined when intermediate path is null", () => {
+    (window as unknown as Record<string, unknown>).canvas = { keyboard: null };
+
+    const result = getCanvasWindowValue(["keyboard", "enable"], "canvas");
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should return undefined when intermediate path is undefined", () => {
+    (window as unknown as Record<string, unknown>).canvas = { keyboard: undefined };
+
+    const result = getCanvasWindowValue(["keyboard", "enable"], "canvas");
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should use default canvas name when not provided", () => {
+    const mockValue = { keyboard: { enable: vi.fn() } };
+    (window as unknown as Record<string, unknown>).canvas = mockValue;
+
+    const result = getCanvasWindowValue(["keyboard", "enable"]);
+
+    expect(result).toBe(mockValue.keyboard.enable);
+  });
+
+  it("should handle custom canvas name", () => {
+    const mockValue = { keyboard: { enable: vi.fn() } };
+    (window as unknown as Record<string, unknown>).customCanvas = mockValue;
+
+    const result = getCanvasWindowValue(["keyboard", "enable"], "customCanvas");
+
+    expect(result).toBe(mockValue.keyboard.enable);
+  });
+
+  it("should handle single level path", () => {
+    const mockValue = { property: "value" };
+    (window as unknown as Record<string, unknown>).canvas = mockValue;
+
+    const result = getCanvasWindowValue(["property"], "canvas");
+
+    expect(result).toBe("value");
+  });
+
+  it("should handle deep nested path", () => {
+    const mockValue = {
+      level1: {
+        level2: {
+          level3: {
+            level4: "deep-value",
+          },
+        },
+      },
+    };
+    (window as unknown as Record<string, unknown>).canvas = mockValue;
+
+    const result = getCanvasWindowValue(["level1", "level2", "level3", "level4"], "canvas");
+
+    expect(result).toBe("deep-value");
+  });
+
+  it("should handle empty path array", () => {
+    const mockValue = { property: "value" };
+    (window as unknown as Record<string, unknown>).canvas = mockValue;
+
+    const result = getCanvasWindowValue([], "canvas");
+
+    expect(result).toBe(mockValue);
+  });
+
+  it("should handle when canvas is not an object", () => {
+    (window as unknown as Record<string, unknown>).canvas = "not-an-object";
+
+    const result = getCanvasWindowValue(["keyboard", "enable"], "canvas");
+
+    expect(result).toBeUndefined();
+  });
+});

package/src/lib/canvas/helpers/getCanvasWindowValue.ts

@@ -1,5 +1,4 @@
 export const getCanvasWindowValue = (path: string[], canvasName: string = "canvas") => {
-  // biome-ignore lint/suspicious/noExplicitAny: global window extension
-  const canvas = (window as any)[canvasName];
-  return path.reduce((obj, prop) => obj?.[prop], canvas);
+  const canvas = (window as unknown as Record<string, unknown>)[canvasName];
+  return path.reduce((obj: unknown, prop: string) => (obj as Record<string, unknown>)?.[prop], canvas);
 };

package/src/lib/helpers/adjustForZoom.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { adjustForZoom } from "./adjustForZoom";
+
+describe("adjustForZoom", () => {
+  it("should divide value by zoom", () => {
+    const result = adjustForZoom(100, 2);
+
+    expect(result).toBe(50);
+  });
+
+  it("should handle zoom of 1", () => {
+    const result = adjustForZoom(100, 1);
+
+    expect(result).toBe(100);
+  });
+
+  it("should handle fractional zoom", () => {
+    const result = adjustForZoom(100, 0.5);
+
+    expect(result).toBe(200);
+  });
+
+  it("should handle decimal values", () => {
+    const result = adjustForZoom(123.456, 2.5);
+
+    expect(result).toBe(49.3824);
+  });
+
+  it("should use default precision of 5", () => {
+    const result = adjustForZoom(100, 3);
+
+    expect(result).toBe(33.33333);
+  });
+
+  it("should use custom precision", () => {
+    const result = adjustForZoom(100, 3, 2);
+
+    expect(result).toBe(33.33);
+  });
+
+  it("should handle zero value", () => {
+    const result = adjustForZoom(0, 2);
+
+    expect(result).toBe(0);
+  });
+
+  it("should handle negative values", () => {
+    const result = adjustForZoom(-100, 2);
+
+    expect(result).toBe(-50);
+  });
+
+  it("should handle precision of 0", () => {
+    const result = adjustForZoom(100, 3, 0);
+
+    expect(result).toBe(33);
+  });
+
+  it("should handle very small zoom values", () => {
+    const result = adjustForZoom(100, 0.1);
+
+    expect(result).toBe(1000);
+  });
+});
+

package/src/lib/helpers/adjustForZoom.ts

@@ -0,0 +1,4 @@
+export const adjustForZoom = (value: number, zoom: number, precision: number = 5): number => {
+  return parseFloat((value / zoom).toFixed(precision));
+};
+