@pooder/kit 4.3.1 → 5.0.1

package/.test-dist/src/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/tests/run.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bridgeSelection_1 = require("../src/bridgeSelection");
+const wrappedOffsets_1 = require("../src/wrappedOffsets");
+const maskOps_1 = require("../src/maskOps");
+const edgeScale_1 = require("../src/edgeScale");
+function assert(condition, message) {
+    if (!condition)
+        throw new Error(message);
+}
+function testWrappedOffsets() {
+    assert((0, wrappedOffsets_1.wrappedDistance)(100, 10, 30) === 20, "distance 10->30 should be 20");
+    assert((0, wrappedOffsets_1.wrappedDistance)(100, 90, 10) === 20, "distance 90->10 should wrap to 20");
+    const a = (0, wrappedOffsets_1.sampleWrappedOffsets)(100, 10, 30, 5);
+    assert(JSON.stringify(a) === JSON.stringify([10, 15, 20, 25, 30]), `unexpected sample: ${JSON.stringify(a)}`);
+    const b = (0, wrappedOffsets_1.sampleWrappedOffsets)(100, 90, 10, 3);
+    assert(JSON.stringify(b) === JSON.stringify([90, 0, 10]), `unexpected wrap sample: ${JSON.stringify(b)}`);
+}
+function testBridgeSelection() {
+    const idx = (0, bridgeSelection_1.pickExitIndex)([
+        { insideAbove: true, insideBelow: true },
+        { insideAbove: false, insideBelow: true },
+        { insideAbove: false, insideBelow: false },
+    ]);
+    assert(idx === 1, `expected exit index 1, got ${idx}`);
+    const none = (0, bridgeSelection_1.pickExitIndex)([{ insideAbove: true, insideBelow: true }]);
+    assert(none === -1, `expected -1, got ${none}`);
+    const score = (0, bridgeSelection_1.scoreOutsideAbove)([
+        { outsideAbove: true },
+        { outsideAbove: false },
+        { outsideAbove: true },
+    ]);
+    assert(score === 2, `expected score 2, got ${score}`);
+}
+function testMaskOps() {
+    const width = 50;
+    const height = 50;
+    const mask = new Uint8Array(width * height);
+    mask[10 * width + 10] = 1;
+    mask[10 * width + 20] = 1;
+    const r = (0, maskOps_1.findMinimalConnectRadius)(mask, width, height, 20);
+    const closed = (0, maskOps_1.circularMorphology)(mask, width, height, r, "closing");
+    assert((0, maskOps_1.isMaskConnected8)(closed, width, height), `closed mask should be connected (r=${r})`);
+    if (r > 0) {
+        const closedPrev = (0, maskOps_1.circularMorphology)(mask, width, height, r - 1, "closing");
+        assert(!(0, maskOps_1.isMaskConnected8)(closedPrev, width, height), `r should be minimal (r=${r})`);
+    }
+    const donut = new Uint8Array(9 * 9);
+    for (let y = 1; y <= 7; y++) {
+        for (let x = 1; x <= 7; x++)
+            donut[y * 9 + x] = 1;
+    }
+    for (let y = 3; y <= 5; y++) {
+        for (let x = 3; x <= 5; x++)
+            donut[y * 9 + x] = 0;
+    }
+    const filled = (0, maskOps_1.fillHoles)(donut, 9, 9);
+    assert(filled[4 * 9 + 4] === 1, "hole should be filled");
+    const imgW = 2;
+    const imgH = 1;
+    const rgba = new Uint8ClampedArray([
+        255, 255, 255, 255, 10, 10, 10, 254,
+    ]);
+    const imageData = { width: imgW, height: imgH, data: rgba };
+    const paddedWidth = imgW + 4;
+    const paddedHeight = imgH + 4;
+    const created = (0, maskOps_1.createMask)(imageData, {
+        threshold: 10,
+        padding: 2,
+        paddedWidth,
+        paddedHeight,
+        maskMode: "auto",
+        alphaOpaqueCutoff: 250,
+    });
+    assert(created[2 * paddedWidth + 2] === 0, "white pixel should be background");
+    assert(created[2 * paddedWidth + 3] === 1, "non-white pixel should be foreground");
+}
+function testEdgeScale() {
+    const currentMax = 100;
+    const baseBounds = { width: 50, height: 20 };
+    const expandedBounds = { width: 70, height: 40 };
+    const { width, height, scale } = (0, edgeScale_1.computeDetectEdgeSize)(currentMax, baseBounds, expandedBounds);
+    assert(scale === 2, `expected scale 2, got ${scale}`);
+    assert(width === 140, `expected width 140, got ${width}`);
+    assert(height === 80, `expected height 80, got ${height}`);
+}
+function main() {
+    testWrappedOffsets();
+    testBridgeSelection();
+    testMaskOps();
+    testEdgeScale();
+    console.log("ok");
+}
+main();

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @pooder/kit
 
+## 5.0.1
+
+### Patch Changes
+
+- bugfix
+
+## 5.0.0
+
+### Major Changes
+
+- white ink tool and size tool
+
+### Patch Changes
+
+- Updated dependencies
+  - @pooder/core@2.1.0
+
 ## 4.3.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Extension, ExtensionContext, ContributionPointIds, ConfigurationContribution, CommandContribution, Service, EventBus } from '@pooder/core';
+import { Extension, ExtensionContext, ContributionPointIds, ConfigurationContribution, CommandContribution, Service, EventBus, ConfigurationService } from '@pooder/core';
 import { Canvas, Group, FabricObject } from 'fabric';
 
 declare class BackgroundTool implements Extension {
@@ -107,10 +107,20 @@ declare class DielineTool implements Extension {
     private state;
     private canvasService?;
     private context?;
+    private onCanvasResized;
     constructor(options?: Partial<DielineState>);
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     contribute(): {
+        [ContributionPointIds.TOOLS]: {
+            id: string;
+            name: string;
+            interaction: string;
+            session: {
+                autoBegin: boolean;
+                leavePolicy: string;
+            };
+        }[];
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
@@ -118,10 +128,14 @@ declare class DielineTool implements Extension {
     private createLayer;
     private destroyLayer;
     private createHatchPattern;
-    private resolvePadding;
-    updateDieline(emitEvent?: boolean): void;
+    private getConfigService;
+    private syncSizeState;
+    private bringFeatureMarkersToFront;
+    updateDieline(_emitEvent?: boolean): void;
     getGeometry(): DielineGeometry | null;
-    exportCutImage(): Promise<string | null>;
+    exportCutImage(options?: {
+        debug?: boolean;
+    }): Promise<string | null>;
 }
 
 declare class FilmTool implements Extension {
@@ -164,9 +178,11 @@ declare class FeatureTool implements Extension {
     private context?;
     private isUpdatingConfig;
     private isToolActive;
+    private hasWorkingChanges;
+    private dirtyTrackerDisposable?;
     private handleMoving;
     private handleModified;
-    private handleDielineChange;
+    private handleSceneGeometryChange;
     private currentGeometry;
     constructor(options?: Partial<{
         features: ConstraintFeature[];
@@ -176,6 +192,20 @@ declare class FeatureTool implements Extension {
     private onToolActivated;
     private updateVisibility;
     contribute(): {
+        [ContributionPointIds.TOOLS]: {
+            id: string;
+            name: string;
+            interaction: string;
+            commands: {
+                begin: string;
+                commit: string;
+                rollback: string;
+            };
+            session: {
+                autoBegin: boolean;
+                leavePolicy: string;
+            };
+        }[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
     private cloneFeatures;
@@ -203,6 +233,8 @@ interface ImageItem {
     angle?: number;
     left?: number;
     top?: number;
+    sourceUrl?: string;
+    committedUrl?: string;
 }
 declare class ImageTool implements Extension {
     id: string;
@@ -210,59 +242,182 @@ declare class ImageTool implements Extension {
         name: string;
     };
     private items;
-    private objectMap;
+    private workingItems;
+    private hasWorkingChanges;
     private loadResolvers;
+    private sourceSizeBySrc;
     private canvasService?;
     private context?;
     private isUpdatingConfig;
     private isToolActive;
+    private isImageSelectionActive;
+    private focusedImageId;
+    private suppressSelectionClearUntil;
+    private renderSeq;
+    private dirtyTrackerDisposable?;
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     private onToolActivated;
-    private updateInteractivity;
+    private onSelectionChanged;
+    private onSelectionCleared;
+    private onSceneLayoutChanged;
+    private syncToolActiveFromWorkbench;
+    private isImageEditingVisible;
+    private isDebugEnabled;
+    private debug;
     contribute(): {
+        [ContributionPointIds.TOOLS]: {
+            id: string;
+            name: string;
+            interaction: string;
+            commands: {
+                begin: string;
+                commit: string;
+                rollback: string;
+            };
+            session: {
+                autoBegin: boolean;
+                leavePolicy: string;
+            };
+        }[];
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
+    private normalizeItem;
+    private normalizeItems;
+    private cloneItems;
     private generateId;
+    private getImageIdFromActiveObject;
+    private resolveReplaceTargetId;
+    private addImageEntry;
+    private upsertImageEntry;
+    private addItemToWorkingSessionIfNeeded;
+    private updateImage;
+    private getConfig;
     private updateConfig;
-    private ensureLayer;
-    private getLayoutInfo;
+    private getFrameRect;
+    private resolveDefaultFitArea;
+    private fitImageToDefaultArea;
+    private getImageObjects;
+    private getOverlayObjects;
+    private getImageObject;
+    private clearRenderedImages;
+    private purgeSourceSizeCacheForItem;
+    private rememberSourceSize;
+    private getSourceSize;
+    private getCoverScale;
+    private getFrameVisualConfig;
+    private resolveRenderImageState;
+    private computeCanvasProps;
+    private getCurrentSrc;
+    private upsertImageObject;
+    private syncImageZOrder;
+    private buildOverlaySpecs;
     private updateImages;
-    private updateObjectProperties;
-    private loadImage;
-    private handleObjectModified;
+    private updateImagesAsync;
+    private clampNormalized;
+    private onObjectModified;
+    private updateImageInWorking;
     private updateImageInConfig;
+    private waitImageLoaded;
+    private refitImageToFrame;
+    private focusImageSelection;
+    private fitImageToArea;
+    private commitWorkingImagesAsCropped;
+    private exportCroppedImageByIds;
+    private exportImageFrameUrl;
 }
 
+interface WhiteInkItem {
+    id: string;
+    sourceUrl?: string;
+    url?: string;
+    opacity: number;
+}
 declare class WhiteInkTool implements Extension {
     id: string;
     metadata: {
         name: string;
     };
-    private customMask;
-    private opacity;
-    private enableClip;
+    private items;
+    private workingItems;
+    private hasWorkingChanges;
+    private sourceSizeBySrc;
+    private previewMaskBySource;
+    private pendingPreviewMaskBySource;
     private canvasService?;
-    private syncHandler;
-    private _loadingUrl;
-    constructor(options?: Partial<{
-        customMask: string;
-        opacity: number;
-        enableClip: boolean;
-    }>);
+    private context?;
+    private isUpdatingConfig;
+    private isToolActive;
+    private printWithWhiteInk;
+    private previewImageVisible;
+    private renderSeq;
+    private dirtyTrackerDisposable?;
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     contribute(): {
+        [ContributionPointIds.TOOLS]: {
+            id: string;
+            name: string;
+            interaction: string;
+            commands: {
+                begin: string;
+                commit: string;
+                rollback: string;
+            };
+            session: {
+                autoBegin: boolean;
+                leavePolicy: string;
+            };
+        }[];
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private setup;
-    private teardown;
-    private updateWhiteInk;
-    private loadWhiteInk;
-    private applyClipPath;
-    private syncWithUserImage;
+    private onToolActivated;
+    private onSceneLayoutChanged;
+    private onObjectAdded;
+    private migrateLegacyConfigIfNeeded;
+    private syncToolActiveFromWorkbench;
+    private isPreviewActive;
+    private isDebugEnabled;
+    private debug;
+    private resolveSourceUrl;
+    private clampOpacity;
+    private normalizeItem;
+    private normalizeItems;
+    private cloneItems;
+    private generateId;
+    private getConfig;
+    private resolveReplaceTargetId;
+    private updateConfig;
+    private addWhiteInkEntry;
+    private upsertWhiteInkEntry;
+    private addItemToWorkingSessionIfNeeded;
+    private updateWhiteInkItem;
+    private updateWhiteInkInWorking;
+    private updateWhiteInkInConfig;
+    private removeWhiteInk;
+    private clearWhiteInks;
+    private completeWhiteInks;
+    private getFrameRect;
+    private getWhiteInkObjects;
+    private getWhiteInkObject;
+    private clearRenderedWhiteInks;
+    private purgeSourceCaches;
+    private rememberSourceSize;
+    private getSourceSize;
+    private getCoverScale;
+    private resolveRenderState;
+    private computeCanvasProps;
+    private getCurrentSrc;
+    private upsertWhiteInkObject;
+    private syncZOrder;
+    private applyImagePreviewVisibility;
+    private updateWhiteInks;
+    private updateWhiteInksAsync;
+    private getPreviewMaskSource;
+    private createOpaqueMaskSource;
+    private loadImageElement;
 }
 
 declare class RulerTool implements Extension {
@@ -276,12 +431,9 @@ declare class RulerTool implements Extension {
     private textColor;
     private lineColor;
     private fontSize;
-    private dielineWidth;
-    private dielineHeight;
-    private dielineDisplayUnit;
-    private dielinePadding;
-    private dielineOffset;
     private canvasService?;
+    private context?;
+    private onCanvasResized;
     constructor(options?: Partial<{
         thickness: number;
         backgroundColor: string;
@@ -299,7 +451,6 @@ declare class RulerTool implements Extension {
     private createLayer;
     private destroyLayer;
     private createArrowLine;
-    private resolvePadding;
     private updateRuler;
 }
 
@@ -326,8 +477,56 @@ declare class MirrorTool implements Extension {
     private applyMirror;
 }
 
-declare function parseLengthToMm(input: number | string, defaultUnit: Unit): number;
-declare function formatMm(valueMm: number, displayUnit: Unit, fractionDigits?: number): string;
+declare class SizeTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private context?;
+    private canvasService?;
+    activate(context: ExtensionContext): void;
+    deactivate(_context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.TOOLS]: {
+            id: string;
+            name: string;
+            interaction: string;
+        }[];
+        [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
+    private getConfigService;
+    private ensureDefaults;
+    private emitStateChanged;
+    private getStateForUI;
+    private updateDimensions;
+    private setConstraintMode;
+    private setUnit;
+    private setCut;
+    private getSelectedImageSize;
+}
+
+declare class SceneLayoutService implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private context?;
+    private canvasService?;
+    private configService?;
+    private lastLayout;
+    private lastGeometry;
+    private onConfigChange?;
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    contribute(): {
+        [ContributionPointIds.COMMANDS]: CommandContribution[];
+    };
+    private onCanvasResized;
+    private refresh;
+    private getLayout;
+    private getGeometry;
+}
 
 declare class ViewportSystem {
     private _containerSize;
@@ -348,6 +547,21 @@ declare class ViewportSystem {
     toPhysicalPoint(point: Point): Point;
 }
 
+type RenderObjectType = "rect" | "image" | "path";
+type RenderProps = Record<string, any>;
+interface RenderObjectSpec {
+    id: string;
+    type: RenderObjectType;
+    props: RenderProps;
+    data?: Record<string, any>;
+    src?: string;
+}
+interface RenderLayerSpec {
+    id: string;
+    objects: RenderObjectSpec[];
+    props?: RenderProps;
+}
+
 declare class CanvasService implements Service {
     canvas: Canvas;
     viewport: ViewportSystem;
@@ -370,6 +584,97 @@ declare class CanvasService implements Service {
      */
     getObject(id: string, layerId?: string): FabricObject | undefined;
     requestRenderAll(): void;
+    resize(width: number, height: number): void;
+    applyLayerSpec(spec: RenderLayerSpec): Promise<void>;
+    applyObjectSpecsToLayer(layerId: string, objects: RenderObjectSpec[]): Promise<void>;
+    getRootLayerObjects(layerId: string): FabricObject[];
+    applyObjectSpecsToRootLayer(layerId: string, specs: RenderObjectSpec[]): Promise<void>;
+    private applyObjectSpecsToContainer;
+    private patchFabricObject;
+    private moveObjectInContainer;
+    private createFabricObject;
+}
+
+type SizeConstraintMode = "free" | "lockAspect" | "equal";
+type CutMode = "trim" | "outset" | "inset";
+interface SizeState {
+    unit: Unit;
+    actualWidthMm: number;
+    actualHeightMm: number;
+    constraintMode: SizeConstraintMode;
+    aspectRatio: number;
+    cutMode: CutMode;
+    cutMarginMm: number;
+    viewPadding: number | string;
+    minMm: number;
+    maxMm: number;
+    stepMm: number;
+}
+interface SceneRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+}
+interface SceneLayoutSnapshot {
+    scale: number;
+    canvasWidth: number;
+    canvasHeight: number;
+    trimRect: SceneRect;
+    cutRect: SceneRect;
+    bleedRect: SceneRect;
+    trimWidthMm: number;
+    trimHeightMm: number;
+    cutWidthMm: number;
+    cutHeightMm: number;
+    cutMode: CutMode;
+    cutMarginMm: number;
+}
+interface SceneGeometrySnapshot {
+    shape: "rect" | "circle" | "ellipse" | "custom";
+    unit: "mm";
+    displayUnit: Unit;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    offset: number;
+    scale: number;
+    pathData?: string;
+}
+declare function sanitizeMmValue(valueMm: number, limits: {
+    minMm: number;
+    maxMm: number;
+    stepMm: number;
+}): number;
+declare function normalizeUnit(value: unknown): Unit;
+declare function normalizeConstraintMode(value: unknown): SizeConstraintMode;
+declare function normalizeCutMode(value: unknown): CutMode;
+declare function toMm(value: number, fromUnit: Unit): number;
+declare function fromMm(valueMm: number, toUnit: Unit): number;
+declare function resolvePaddingPx(raw: number | string, containerWidth: number, containerHeight: number): number;
+declare function readSizeState(configService: ConfigurationService): SizeState;
+declare function computeSceneLayout(canvasService: CanvasService, size: SizeState): SceneLayoutSnapshot | null;
+declare function buildSceneGeometry(configService: ConfigurationService, layout: SceneLayoutSnapshot): SceneGeometrySnapshot;
+
+declare class SceneVisibilityService implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private canvasService?;
+    private activeToolId;
+    activate(context: ExtensionContext): void;
+    deactivate(context: ExtensionContext): void;
+    private onToolActivated;
+    private onObjectAdded;
+    private apply;
 }
 
-export { BackgroundTool, CanvasService, type DielineGeometry, type DielineState, DielineTool, FeatureTool, FilmTool, type ImageItem, ImageTool, type LineStyle, MirrorTool, RulerTool, WhiteInkTool, formatMm, parseLengthToMm };
+declare function parseLengthToMm(input: number | string, defaultUnit: Unit): number;
+declare function formatMm(valueMm: number, displayUnit: Unit, fractionDigits?: number): string;
+
+export { BackgroundTool, CanvasService, type CutMode, type DielineGeometry, type DielineState, DielineTool, FeatureTool, FilmTool, type ImageItem, ImageTool, type LineStyle, MirrorTool, RulerTool, type SceneGeometrySnapshot, SceneLayoutService, type SceneLayoutSnapshot, type SceneRect, SceneVisibilityService, type SizeConstraintMode, type SizeState, SizeTool, type WhiteInkItem, WhiteInkTool, buildSceneGeometry, computeSceneLayout, formatMm, fromMm, normalizeConstraintMode, normalizeCutMode, normalizeUnit, parseLengthToMm, readSizeState, resolvePaddingPx, sanitizeMmValue, toMm };