@pooder/kit 5.2.0 → 5.3.1

package/.test-dist/src/extensions/wrappedOffsets.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrappedDistance = wrappedDistance;
+exports.sampleWrappedOffsets = sampleWrappedOffsets;
+function wrappedDistance(total, start, end) {
+    if (!Number.isFinite(total) || total <= 0)
+        return 0;
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return 0;
+    const s = ((start % total) + total) % total;
+    const e = ((end % total) + total) % total;
+    return e >= s ? e - s : total - s + e;
+}
+function sampleWrappedOffsets(total, start, end, count) {
+    if (!Number.isFinite(total) || total <= 0)
+        return [];
+    if (!Number.isFinite(start) || !Number.isFinite(end))
+        return [];
+    const n = Math.max(0, Math.floor(count));
+    if (n <= 0)
+        return [];
+    const dist = wrappedDistance(total, start, end);
+    if (n === 1)
+        return [((start % total) + total) % total];
+    const step = dist / (n - 1);
+    const offsets = [];
+    for (let i = 0; i < n; i++) {
+        const raw = start + step * i;
+        const wrapped = ((raw % total) + total) % total;
+        offsets.push(wrapped);
+    }
+    return offsets;
+}

package/.test-dist/src/index.js

@@ -13,23 +13,6 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CanvasService = void 0;
-__exportStar(require("./background"), exports);
-__exportStar(require("./dieline"), exports);
-__exportStar(require("./film"), exports);
-__exportStar(require("./feature"), exports);
-__exportStar(require("./image"), exports);
-__exportStar(require("./white-ink"), exports);
-__exportStar(require("./ruler"), exports);
-__exportStar(require("./mirror"), exports);
-__exportStar(require("./size"), exports);
-__exportStar(require("./sceneLayout"), exports);
-__exportStar(require("./sceneLayoutModel"), exports);
-__exportStar(require("./sceneVisibility"), exports);
-__exportStar(require("./units"), exports);
-var CanvasService_1 = require("./CanvasService");
-Object.defineProperty(exports, "CanvasService", { enumerable: true, get: function () { return __importDefault(CanvasService_1).default; } });
+__exportStar(require("./extensions"), exports);
+__exportStar(require("./services"), exports);

package/.test-dist/src/services/CanvasService.js

@@ -0,0 +1,249 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fabric_1 = require("fabric");
+const ViewportSystem_1 = require("./ViewportSystem");
+class CanvasService {
+    constructor(el, options) {
+        if (el instanceof fabric_1.Canvas) {
+            this.canvas = el;
+        }
+        else {
+            this.canvas = new fabric_1.Canvas(el, {
+                preserveObjectStacking: true,
+                ...options,
+            });
+        }
+        this.viewport = new ViewportSystem_1.ViewportSystem();
+        if (this.canvas.width !== undefined && this.canvas.height !== undefined) {
+            this.viewport.updateContainer(this.canvas.width, this.canvas.height);
+        }
+        if (options?.eventBus) {
+            this.setEventBus(options.eventBus);
+        }
+    }
+    setEventBus(eventBus) {
+        this.eventBus = eventBus;
+        this.setupEvents();
+    }
+    setupEvents() {
+        if (!this.eventBus)
+            return;
+        const bus = this.eventBus;
+        const forward = (name) => (e) => bus.emit(name, e);
+        this.canvas.on("selection:created", forward("selection:created"));
+        this.canvas.on("selection:updated", forward("selection:updated"));
+        this.canvas.on("selection:cleared", forward("selection:cleared"));
+        this.canvas.on("object:modified", forward("object:modified"));
+        this.canvas.on("object:added", forward("object:added"));
+        this.canvas.on("object:removed", forward("object:removed"));
+    }
+    dispose() {
+        this.canvas.dispose();
+    }
+    /**
+     * Get a layer (Group) by its ID.
+     * We assume layers are Groups directly on the canvas with a data.id property.
+     */
+    getLayer(id) {
+        return this.canvas.getObjects().find((obj) => obj.data?.id === id);
+    }
+    /**
+     * Create a layer (Group) with the given ID if it doesn't exist.
+     */
+    createLayer(id, options = {}) {
+        let layer = this.getLayer(id);
+        if (!layer) {
+            const defaultOptions = {
+                selectable: false,
+                evented: false,
+                ...options,
+                data: { ...options.data, id },
+            };
+            layer = new fabric_1.Group([], defaultOptions);
+            this.canvas.add(layer);
+        }
+        return layer;
+    }
+    /**
+     * Find an object by ID, optionally within a specific layer.
+     */
+    getObject(id, layerId) {
+        if (layerId) {
+            const layer = this.getLayer(layerId);
+            if (!layer)
+                return undefined;
+            return layer.getObjects().find((obj) => obj.data?.id === id);
+        }
+        return this.canvas.getObjects().find((obj) => obj.data?.id === id);
+    }
+    requestRenderAll() {
+        this.canvas.requestRenderAll();
+    }
+    resize(width, height) {
+        this.canvas.setDimensions({ width, height });
+        this.viewport.updateContainer(width, height);
+        this.eventBus?.emit("canvas:resized", { width, height });
+        this.requestRenderAll();
+    }
+    async applyLayerSpec(spec) {
+        const layer = this.createLayer(spec.id, spec.props || {});
+        await this.applyObjectSpecsToContainer(layer, spec.objects);
+    }
+    async applyObjectSpecsToLayer(layerId, objects) {
+        const layer = this.createLayer(layerId, {});
+        await this.applyObjectSpecsToContainer(layer, objects);
+    }
+    getRootLayerObjects(layerId) {
+        return this.canvas
+            .getObjects()
+            .filter((obj) => obj?.data?.layerId === layerId);
+    }
+    async applyObjectSpecsToRootLayer(layerId, specs) {
+        const desiredIds = new Set(specs.map((s) => s.id));
+        const existing = this.getRootLayerObjects(layerId);
+        existing.forEach((obj) => {
+            const id = obj?.data?.id;
+            if (typeof id === "string" && !desiredIds.has(id)) {
+                this.canvas.remove(obj);
+            }
+        });
+        const byId = new Map();
+        this.getRootLayerObjects(layerId).forEach((obj) => {
+            const id = obj?.data?.id;
+            if (typeof id === "string")
+                byId.set(id, obj);
+        });
+        for (let index = 0; index < specs.length; index += 1) {
+            const spec = specs[index];
+            let current = byId.get(spec.id);
+            if (current &&
+                spec.type === "image" &&
+                spec.src &&
+                current.getSrc &&
+                current.getSrc() !== spec.src) {
+                this.canvas.remove(current);
+                byId.delete(spec.id);
+                current = undefined;
+            }
+            if (!current) {
+                const created = await this.createFabricObject(spec);
+                if (!created)
+                    continue;
+                this.patchFabricObject(created, spec, { layerId });
+                this.canvas.add(created);
+                byId.set(spec.id, created);
+                continue;
+            }
+            this.patchFabricObject(current, spec, { layerId });
+        }
+        this.requestRenderAll();
+    }
+    async applyObjectSpecsToContainer(container, specs) {
+        const desiredIds = new Set(specs.map((s) => s.id));
+        const existing = container.getObjects();
+        existing.forEach((obj) => {
+            const id = obj?.data?.id;
+            if (typeof id === "string" && !desiredIds.has(id)) {
+                container.remove(obj);
+            }
+        });
+        const byId = new Map();
+        container.getObjects().forEach((obj) => {
+            const id = obj?.data?.id;
+            if (typeof id === "string")
+                byId.set(id, obj);
+        });
+        for (let index = 0; index < specs.length; index += 1) {
+            const spec = specs[index];
+            let current = byId.get(spec.id);
+            if (current &&
+                spec.type === "image" &&
+                spec.src &&
+                current.getSrc &&
+                current.getSrc() !== spec.src) {
+                container.remove(current);
+                byId.delete(spec.id);
+                current = undefined;
+            }
+            if (!current) {
+                const created = await this.createFabricObject(spec);
+                if (!created)
+                    continue;
+                container.add(created);
+                current = created;
+                byId.set(spec.id, current);
+            }
+            else {
+                this.patchFabricObject(current, spec);
+            }
+            this.moveObjectInContainer(container, current, index);
+        }
+        container.dirty = true;
+        this.requestRenderAll();
+    }
+    patchFabricObject(obj, spec, extraData) {
+        const nextData = {
+            ...(obj.data || {}),
+            ...(spec.data || {}),
+            ...(extraData || {}),
+            id: spec.id,
+        };
+        obj.set({ ...(spec.props || {}), data: nextData });
+        obj.setCoords();
+    }
+    moveObjectInContainer(container, obj, index) {
+        if (!obj)
+            return;
+        const moveObjectTo = container.moveObjectTo;
+        if (typeof moveObjectTo === "function") {
+            moveObjectTo.call(container, obj, index);
+            return;
+        }
+        const list = container._objects;
+        if (!Array.isArray(list))
+            return;
+        const from = list.indexOf(obj);
+        if (from < 0 || from === index)
+            return;
+        list.splice(from, 1);
+        const target = Math.max(0, Math.min(index, list.length));
+        list.splice(target, 0, obj);
+        if (typeof container._onStackOrderChanged === "function") {
+            container._onStackOrderChanged();
+        }
+    }
+    async createFabricObject(spec) {
+        if (spec.type === "rect") {
+            const rect = new fabric_1.Rect({
+                ...(spec.props || {}),
+                data: { ...(spec.data || {}), id: spec.id },
+            });
+            rect.setCoords();
+            return rect;
+        }
+        if (spec.type === "path") {
+            const pathData = spec.props?.path || spec.props?.pathData;
+            if (!pathData)
+                return undefined;
+            const path = new fabric_1.Path(pathData, {
+                ...(spec.props || {}),
+                data: { ...(spec.data || {}), id: spec.id },
+            });
+            path.setCoords();
+            return path;
+        }
+        if (spec.type === "image") {
+            if (!spec.src)
+                return undefined;
+            const image = await fabric_1.Image.fromURL(spec.src, { crossOrigin: "anonymous" });
+            image.set({
+                ...(spec.props || {}),
+                data: { ...(spec.data || {}), id: spec.id },
+            });
+            image.setCoords();
+            return image;
+        }
+        return undefined;
+    }
+}
+exports.default = CanvasService;

package/.test-dist/src/services/ViewportSystem.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ViewportSystem = void 0;
+const coordinate_1 = require("../coordinate");
+class ViewportSystem {
+    constructor(containerSize = { width: 0, height: 0 }, physicalSize = { width: 0, height: 0 }, padding = 40) {
+        this._containerSize = { width: 0, height: 0 };
+        this._physicalSize = { width: 0, height: 0 };
+        this._padding = 0;
+        this._layout = {
+            scale: 1,
+            offsetX: 0,
+            offsetY: 0,
+            width: 0,
+            height: 0,
+        };
+        this._containerSize = containerSize;
+        this._physicalSize = physicalSize;
+        this._padding = padding;
+        this.updateLayout();
+    }
+    get layout() {
+        return this._layout;
+    }
+    get scale() {
+        return this._layout.scale;
+    }
+    get offset() {
+        return { x: this._layout.offsetX, y: this._layout.offsetY };
+    }
+    updateContainer(width, height) {
+        if (this._containerSize.width === width &&
+            this._containerSize.height === height)
+            return;
+        this._containerSize = { width, height };
+        this.updateLayout();
+    }
+    updatePhysical(width, height) {
+        if (this._physicalSize.width === width &&
+            this._physicalSize.height === height)
+            return;
+        this._physicalSize = { width, height };
+        this.updateLayout();
+    }
+    setPadding(padding) {
+        if (this._padding === padding)
+            return;
+        this._padding = padding;
+        this.updateLayout();
+    }
+    updateLayout() {
+        this._layout = coordinate_1.Coordinate.calculateLayout(this._containerSize, this._physicalSize, this._padding);
+    }
+    toPixel(value) {
+        return value * this._layout.scale;
+    }
+    toPhysical(value) {
+        return this._layout.scale === 0 ? 0 : value / this._layout.scale;
+    }
+    toPixelPoint(point) {
+        return {
+            x: point.x * this._layout.scale + this._layout.offsetX,
+            y: point.y * this._layout.scale + this._layout.offsetY,
+        };
+    }
+    // Convert screen coordinate (e.g. mouse event) to physical coordinate (relative to content origin)
+    toPhysicalPoint(point) {
+        if (this._layout.scale === 0)
+            return { x: 0, y: 0 };
+        return {
+            x: (point.x - this._layout.offsetX) / this._layout.scale,
+            y: (point.y - this._layout.offsetY) / this._layout.scale,
+        };
+    }
+}
+exports.ViewportSystem = ViewportSystem;

package/.test-dist/src/services/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CanvasService = void 0;
+var CanvasService_1 = require("./CanvasService");
+Object.defineProperty(exports, "CanvasService", { enumerable: true, get: function () { return __importDefault(CanvasService_1).default; } });
+__exportStar(require("./renderSpec"), exports);
+__exportStar(require("./ViewportSystem"), exports);

package/.test-dist/src/services/renderSpec.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @pooder/kit
 
+## 5.3.1
+
+### Patch Changes
+
+- fix edge detection and expand
+
+## 5.3.0
+
+### Minor Changes
+
+- refactor tracer and white ink bugfix
+
 ## 5.2.0
 
 ### Minor Changes

package/dist/index.d.mts

@@ -216,6 +216,8 @@ interface DielineGeometry {
     scale?: number;
     strokeWidth?: number;
     pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
 }
 interface LineStyle {
     width: number;
@@ -238,6 +240,8 @@ interface DielineState {
     showBleedLines: boolean;
     features: DielineFeature[];
     pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
 }
 declare class DielineTool implements Extension {
     id: string;
@@ -510,6 +514,11 @@ declare class WhiteInkTool implements Extension {
     private getPrimaryImageSource;
     private getCurrentSrc;
     private getImageSnapshot;
+    private getImagePlacementState;
+    private shouldRestoreSnapshotToSource;
+    private getCoverScale;
+    private ensureSourceSize;
+    private resolveAlignedImageSnapshot;
     private getImageElementFromObject;
     private rememberSourceSize;
     private getSourceSize;
@@ -635,6 +644,8 @@ interface SceneGeometrySnapshot {
     offset: number;
     scale: number;
     pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
 }
 
 declare class SceneLayoutService implements Service {

package/dist/index.d.ts

@@ -216,6 +216,8 @@ interface DielineGeometry {
     scale?: number;
     strokeWidth?: number;
     pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
 }
 interface LineStyle {
     width: number;
@@ -238,6 +240,8 @@ interface DielineState {
     showBleedLines: boolean;
     features: DielineFeature[];
     pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
 }
 declare class DielineTool implements Extension {
     id: string;
@@ -510,6 +514,11 @@ declare class WhiteInkTool implements Extension {
     private getPrimaryImageSource;
     private getCurrentSrc;
     private getImageSnapshot;
+    private getImagePlacementState;
+    private shouldRestoreSnapshotToSource;
+    private getCoverScale;
+    private ensureSourceSize;
+    private resolveAlignedImageSnapshot;
     private getImageElementFromObject;
     private rememberSourceSize;
     private getSourceSize;
@@ -635,6 +644,8 @@ interface SceneGeometrySnapshot {
     offset: number;
     scale: number;
     pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
 }
 
 declare class SceneLayoutService implements Service {