@pooder/kit 5.3.1 → 6.0.0

package/dist/index.d.mts

@@ -1,26 +1,62 @@
-import { Extension, ExtensionContext, ContributionPointIds, ConfigurationContribution, CommandContribution, Service, EventBus, ServiceContext } from '@pooder/core';
-import { Canvas, Group, FabricObject } from 'fabric';
+import { Extension, ExtensionContext, ContributionPointIds, ConfigurationContribution, CommandContribution, Service, ServiceContext, EventBus } from '@pooder/core';
+import { Canvas, FabricObject } from 'fabric';
 
+type BackgroundLayerKind = "color" | "image";
+type BackgroundFitMode = "cover" | "contain" | "stretch";
+interface BackgroundLayer {
+    id: string;
+    kind: BackgroundLayerKind;
+    anchor: string;
+    fit: BackgroundFitMode;
+    opacity: number;
+    order: number;
+    enabled: boolean;
+    exportable: boolean;
+    color?: string;
+    src?: string;
+}
+interface BackgroundConfig {
+    version: number;
+    layers: BackgroundLayer[];
+}
 declare class BackgroundTool implements Extension {
     id: string;
     metadata: {
         name: string;
     };
-    private color;
-    private url;
+    private config;
     private canvasService?;
-    constructor(options?: Partial<{
-        color: string;
-        url: string;
-    }>);
+    private configService?;
+    private specs;
+    private renderProducerDisposable?;
+    private configChangeDisposable?;
+    private renderSeq;
+    private latestSceneLayout;
+    private sourceSizeBySrc;
+    private pendingSizeBySrc;
+    private onCanvasResized;
+    private onSceneLayoutChanged;
+    constructor(options?: Partial<BackgroundConfig>);
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     contribute(): {
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private initLayer;
+    private commitConfig;
+    private getViewportRect;
+    private resolveSceneLayout;
+    private resolveFocusRect;
+    private resolveAnchorRect;
+    private resolveImagePlacement;
+    private buildColorLayerSpec;
+    private buildImageLayerSpec;
+    private buildBackgroundSpecs;
+    private collectActiveImageUrls;
+    private ensureImageSize;
+    private loadImageSize;
     private updateBackground;
+    private updateBackgroundAsync;
 }
 
 interface ImageItem {
@@ -54,6 +90,10 @@ declare class ImageTool implements Extension {
     private dirtyTrackerDisposable?;
     private cropShapeHatchPattern?;
     private cropShapeHatchPatternColor?;
+    private cropShapeHatchPatternKey?;
+    private imageSpecs;
+    private overlaySpecs;
+    private renderProducerDisposable?;
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     private onToolActivated;
@@ -97,6 +137,8 @@ declare class ImageTool implements Extension {
     private getConfig;
     private updateConfig;
     private getFrameRect;
+    private getFrameRectScreen;
+    private toLayoutSceneRect;
     private resolveDefaultFitArea;
     private fitImageToDefaultArea;
     private getImageObjects;
@@ -106,6 +148,7 @@ declare class ImageTool implements Extension {
     private purgeSourceSizeCacheForItem;
     private rememberSourceSize;
     private getSourceSize;
+    private ensureSourceSize;
     private getCoverScale;
     private getFrameVisualConfig;
     private toSceneGeometryLike;
@@ -115,10 +158,9 @@ declare class ImageTool implements Extension {
     private buildCropShapeOverlaySpecs;
     private resolveRenderImageState;
     private computeCanvasProps;
+    private toSceneObjectScale;
     private getCurrentSrc;
-    private applyImageControlVisibility;
-    private upsertImageObject;
-    private syncImageZOrder;
+    private buildImageSpecs;
     private buildOverlaySpecs;
     private updateImages;
     private updateImagesAsync;
@@ -163,21 +205,12 @@ declare class SizeTool implements Extension {
     private getSelectedImageSize;
 }
 
-interface Point {
-    x: number;
-    y: number;
-}
-interface Size {
-    width: number;
-    height: number;
-}
-type Unit = "px" | "mm" | "cm" | "in";
-interface Layout {
-    scale: number;
-    offsetX: number;
-    offsetY: number;
-    width: number;
-    height: number;
+declare const DIELINE_SHAPES: readonly ["rect", "circle", "ellipse", "heart", "custom"];
+type DielineShape = (typeof DIELINE_SHAPES)[number];
+type ShapeFitMode = "contain" | "stretch";
+interface DielineShapeStyle {
+    fitMode: ShapeFitMode;
+    [key: string]: unknown;
 }
 
 type FeatureOperation = "add" | "subtract";
@@ -203,9 +236,9 @@ interface DielineFeature {
 }
 
 interface DielineGeometry {
-    shape: "rect" | "circle" | "ellipse" | "custom";
-    unit: "mm";
-    displayUnit: Unit;
+    shape: DielineShape;
+    shapeStyle: DielineShapeStyle;
+    unit: "px";
     x: number;
     y: number;
     width: number;
@@ -226,8 +259,8 @@ interface LineStyle {
     style: "solid" | "dashed" | "hidden";
 }
 interface DielineState {
-    displayUnit: Unit;
-    shape: "rect" | "circle" | "ellipse" | "custom";
+    shape: DielineShape;
+    shapeStyle: DielineShapeStyle;
     width: number;
     height: number;
     radius: number;
@@ -236,7 +269,6 @@ interface DielineState {
     mainLine: LineStyle;
     offsetLine: LineStyle;
     insideColor: string;
-    outsideColor: string;
     showBleedLines: boolean;
     features: DielineFeature[];
     pathData?: string;
@@ -251,6 +283,10 @@ declare class DielineTool implements Extension {
     private state;
     private canvasService?;
     private context?;
+    private specs;
+    private effects;
+    private renderSeq;
+    private renderProducerDisposable?;
     private onCanvasResized;
     constructor(options?: Partial<DielineState>);
     activate(context: ExtensionContext): void;
@@ -268,14 +304,14 @@ declare class DielineTool implements Extension {
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private getLayer;
-    private createLayer;
-    private destroyLayer;
     private createHatchPattern;
     private getConfigService;
+    private hasImageItems;
     private syncSizeState;
-    private bringFeatureMarkersToFront;
+    private buildDielineSpecs;
+    private buildImageClipEffects;
     updateDieline(_emitEvent?: boolean): void;
+    private updateDielineAsync;
     getGeometry(): DielineGeometry | null;
     exportCutImage(options?: {
         debug?: boolean;
@@ -304,6 +340,9 @@ declare class FeatureTool implements Extension {
     private sessionOriginalFeatures;
     private hasWorkingChanges;
     private dirtyTrackerDisposable?;
+    private renderProducerDisposable?;
+    private specs;
+    private renderSeq;
     private handleMoving;
     private handleModified;
     private handleSceneGeometryChange;
@@ -349,9 +388,24 @@ declare class FeatureTool implements Extension {
     private getGeometryForFeature;
     private setup;
     private teardown;
+    private getDraggableMarkerTarget;
+    private getFeatureForMarker;
     private constrainPosition;
+    private toNormalizedPoint;
     private syncFeatureFromCanvas;
+    private syncGroupFromCanvas;
     private redraw;
+    private redrawAsync;
+    private buildFeatureSpecs;
+    private appendMarkerSpecs;
+    private buildMarkerData;
+    private markerId;
+    private bridgeIndicatorId;
+    private toFeatureIndex;
+    private readGroupIndices;
+    private readGroupMemberOffsets;
+    private syncMarkerVisualsByTarget;
+    private syncMarkerVisualObjectsToCenter;
     private enforceConstraints;
 }
 
@@ -363,6 +417,13 @@ declare class FilmTool implements Extension {
     private url;
     private opacity;
     private canvasService?;
+    private specs;
+    private renderProducerDisposable?;
+    private renderSeq;
+    private renderImageUrl;
+    private sourceSizeBySrc;
+    private pendingSizeBySrc;
+    private onCanvasResized;
     constructor(options?: Partial<{
         url: string;
         opacity: number;
@@ -373,8 +434,13 @@ declare class FilmTool implements Extension {
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private initLayer;
+    private getViewportSize;
+    private clampOpacity;
+    private buildFilmSpecs;
+    private ensureImageSize;
+    private loadImageSize;
     private updateFilm;
+    private updateFilmAsync;
 }
 
 declare class MirrorTool implements Extension {
@@ -411,6 +477,10 @@ declare class RulerTool implements Extension {
     private textColor;
     private lineColor;
     private fontSize;
+    private renderSeq;
+    private readonly numericProps;
+    private specs;
+    private renderProducerDisposable?;
     private canvasService?;
     private context?;
     private onCanvasResized;
@@ -420,6 +490,7 @@ declare class RulerTool implements Extension {
         textColor: string;
         lineColor: string;
         fontSize: number;
+        gap: number;
     }>);
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
@@ -427,11 +498,19 @@ declare class RulerTool implements Extension {
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private getLayer;
-    private createLayer;
-    private destroyLayer;
-    private createArrowLine;
+    private log;
+    private syncConfig;
+    private toFiniteNumber;
+    private toSceneDisplayLength;
+    private formatLengthMm;
+    private buildLinePath;
+    private buildStartArrowPath;
+    private buildEndArrowPath;
+    private createPathSpec;
+    private createTextSpec;
+    private buildRulerSpecs;
     private updateRuler;
+    private updateRulerAsync;
 }
 
 interface WhiteInkItem {
@@ -459,6 +538,10 @@ declare class WhiteInkTool implements Extension {
     private previewImageVisible;
     private renderSeq;
     private dirtyTrackerDisposable?;
+    private whiteSpecs;
+    private coverSpecs;
+    private overlaySpecs;
+    private renderProducerDisposable?;
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     contribute(): {
@@ -509,6 +592,7 @@ declare class WhiteInkTool implements Extension {
     private clearWhiteInks;
     private completeWhiteInks;
     private getFrameRect;
+    private toLayoutSceneRect;
     private getImageObjects;
     private getPrimaryImageObject;
     private getPrimaryImageSource;
@@ -526,11 +610,8 @@ declare class WhiteInkTool implements Extension {
     private computeCoverOpacity;
     private buildCloneImageSpec;
     private buildFrameSpecs;
-    private applyImageVisibilityForWhiteInk;
     private resolveRenderItems;
     private resolveRenderSources;
-    private resolveDefaultInsertIndex;
-    private syncZOrder;
     private clearRenderedWhiteInks;
     private purgeSourceCaches;
     private updateWhiteInks;
@@ -542,6 +623,22 @@ declare class WhiteInkTool implements Extension {
     private loadImageElement;
 }
 
+interface Point {
+    x: number;
+    y: number;
+}
+interface Size {
+    width: number;
+    height: number;
+}
+interface Layout {
+    scale: number;
+    offsetX: number;
+    offsetY: number;
+    width: number;
+    height: number;
+}
+
 declare class ViewportSystem {
     private _containerSize;
     private _physicalSize;
@@ -561,54 +658,263 @@ declare class ViewportSystem {
     toPhysicalPoint(point: Point): Point;
 }
 
-type RenderObjectType = "rect" | "image" | "path";
+type RenderObjectType = "rect" | "image" | "path" | "text";
 type RenderProps = Record<string, any>;
+type RenderCoordinateSpace = "scene" | "screen";
+type RenderLayoutLength = number | string;
+type RenderLayoutAlign = "start" | "center" | "end";
+type RenderLayoutReference = "sceneViewport" | "screenViewport" | "custom";
+interface RenderLayoutInsets {
+    top?: RenderLayoutLength;
+    right?: RenderLayoutLength;
+    bottom?: RenderLayoutLength;
+    left?: RenderLayoutLength;
+}
+interface RenderLayoutRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+    space?: RenderCoordinateSpace;
+}
+interface RenderObjectLayoutSpec {
+    reference?: RenderLayoutReference;
+    referenceRect?: RenderLayoutRect;
+    inset?: RenderLayoutLength | RenderLayoutInsets;
+    alignX?: RenderLayoutAlign;
+    alignY?: RenderLayoutAlign;
+    offsetX?: RenderLayoutLength;
+    offsetY?: RenderLayoutLength;
+    width?: RenderLayoutLength;
+    height?: RenderLayoutLength;
+}
 interface RenderObjectSpec {
     id: string;
     type: RenderObjectType;
     props: RenderProps;
     data?: Record<string, any>;
     src?: string;
+    space?: RenderCoordinateSpace;
+    layout?: RenderObjectLayoutSpec;
 }
-interface RenderLayerSpec {
+type LayerObjectCountComparator = ">" | ">=" | "==" | "<" | "<=";
+type VisibilityExpr = {
+    op: "const";
+    value: boolean;
+} | {
+    op: "activeToolIn";
+    ids: string[];
+} | {
+    op: "sessionActive";
+    toolId: string;
+} | {
+    op: "layerExists";
+    layerId: string;
+} | {
+    op: "layerObjectCount";
+    layerId: string;
+    cmp: LayerObjectCountComparator;
+    value: number;
+} | {
+    op: "not";
+    expr: VisibilityExpr;
+} | {
+    op: "all";
+    exprs: VisibilityExpr[];
+} | {
+    op: "any";
+    exprs: VisibilityExpr[];
+};
+interface RenderClipPathEffectSpec {
+    type: "clipPath";
+    id?: string;
+    source: RenderObjectSpec;
+    targetPassIds: string[];
+}
+type RenderEffectSpec = RenderClipPathEffectSpec;
+interface RenderPassSpec {
     id: string;
+    stack?: number;
+    order?: number;
+    replace?: boolean;
+    visibility?: VisibilityExpr;
+    effects?: RenderEffectSpec[];
     objects: RenderObjectSpec[];
-    props?: RenderProps;
 }
 
+interface RenderProducerResult {
+    passes?: RenderPassSpec[];
+}
+type RenderProducer = () => RenderProducerResult | undefined | Promise<RenderProducerResult | undefined>;
+interface RegisterRenderProducerOptions {
+    priority?: number;
+}
+interface RectLike {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
 declare class CanvasService implements Service {
     canvas: Canvas;
     viewport: ViewportSystem;
+    private context?;
     private eventBus?;
+    private workbenchService?;
+    private toolSessionService?;
+    private renderProducers;
+    private producerOrder;
+    private producerFlushRequested;
+    private producerLoopPending;
+    private producerLoopPromise;
+    private producerApplyInProgress;
+    private visibilityRefreshScheduled;
+    private managedProducerPassIds;
+    private managedPassMetas;
+    private canvasForwardersBound;
+    private readonly forwardSelectionCreated;
+    private readonly forwardSelectionUpdated;
+    private readonly forwardSelectionCleared;
+    private readonly forwardObjectModified;
+    private readonly forwardObjectAdded;
+    private readonly forwardObjectRemoved;
+    private readonly onToolActivated;
+    private readonly onToolSessionChanged;
+    private readonly onCanvasObjectChanged;
     constructor(el: HTMLCanvasElement | string | Canvas, options?: any);
+    init(context: ServiceContext): void;
+    private attachContextEvents;
+    private detachContextEvents;
     setEventBus(eventBus: EventBus): void;
     private setupEvents;
     dispose(): void;
-    /**
-     * Get a layer (Group) by its ID.
-     * We assume layers are Groups directly on the canvas with a data.id property.
-     */
-    getLayer(id: string): Group | undefined;
-    /**
-     * Create a layer (Group) with the given ID if it doesn't exist.
-     */
-    createLayer(id: string, options?: any): Group;
-    /**
-     * Find an object by ID, optionally within a specific layer.
-     */
-    getObject(id: string, layerId?: string): FabricObject | undefined;
+    registerRenderProducer(toolId: string, producer: RenderProducer, options?: RegisterRenderProducerOptions): {
+        dispose: () => void;
+    };
+    unregisterRenderProducer(toolId: string): boolean;
+    requestRenderFromProducers(): void;
+    flushRenderFromProducers(): Promise<void>;
+    private scheduleProducerLoop;
+    private runProducerLoop;
+    private sortedRenderProducerEntries;
+    private normalizePassSpecValue;
+    private normalizeClipPathEffectSpec;
+    private mergePassSpec;
+    private comparePassMeta;
+    private getPassObjectOrder;
+    private getPassCanvasObjects;
+    getPassObjects(passId: string): FabricObject[];
+    getRootLayerObjects(layerId: string): FabricObject[];
+    private isManagedPassObject;
+    private syncManagedPassStacking;
+    private getPassRuntimeState;
+    private applyManagedPassVisibility;
+    private scheduleManagedPassVisibilityRefresh;
+    private collectAndApplyProducerSpecs;
+    private applyManagedPassEffects;
+    getObject(id: string, passId?: 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;
+    getSceneScale(): number;
+    getSceneOffset(): {
+        x: number;
+        y: number;
+    };
+    toScreenPoint(point: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    toScenePoint(point: {
+        x: number;
+        y: number;
+    }): {
+        x: number;
+        y: number;
+    };
+    toScreenLength(value: number): number;
+    toSceneLength(value: number): number;
+    toScreenRect(rect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    toSceneRect(rect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    getSceneViewportRect(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    };
+    getScreenViewportRect(): RectLike;
+    private toSpaceRect;
+    private resolveLayoutLength;
+    private resolveLayoutInsets;
+    private resolveLayoutReferenceRect;
+    private alignFactor;
+    private normalizeOriginX;
+    private normalizeOriginY;
+    private originFactor;
+    private resolveLayoutProps;
+    setPassVisibility(passId: string, visible: boolean): boolean;
+    setLayerVisibility(layerId: string, visible: boolean): boolean;
+    bringPassToFront(passId: string): void;
+    bringLayerToFront(layerId: string): void;
+    applyPassSpec(spec: RenderPassSpec, options?: {
+        render?: boolean;
+    }): Promise<void>;
+    applyObjectSpecsToRootLayer(passId: string, specs: RenderObjectSpec[], options?: {
+        render?: boolean;
+    }): Promise<void>;
+    private normalizeObjectSpecs;
+    private cloneFabricObject;
+    private createClipPathTemplate;
+    private isClipPathEffectManaged;
+    private clearClipPathEffectFromObject;
+    private applyClipPathEffectToObject;
+    applyObjectSpecsToPass(passId: string, specs: RenderObjectSpec[], options?: {
+        render?: boolean;
+        replace?: boolean;
+    }): Promise<void>;
     private patchFabricObject;
-    private moveObjectInContainer;
+    private readPathDataFromSpec;
+    private hashText;
+    private getSpecRenderSourceKey;
+    private shouldRecreateObject;
+    private resolveFabricProps;
+    private moveObjectInCanvas;
     private createFabricObject;
 }
 
+interface VisibilityLayerState {
+    exists: boolean;
+    objectCount: number;
+}
+interface VisibilityEvalContext {
+    activeToolId?: string | null;
+    isSessionActive?: (toolId: string) => boolean;
+    layers: Map<string, VisibilityLayerState>;
+}
+declare function evaluateVisibilityExpr(expr: VisibilityExpr | undefined, context: VisibilityEvalContext): boolean;
+
 type CutMode = "trim" | "outset" | "inset";
 interface SceneRect {
     left: number;
@@ -633,9 +939,9 @@ interface SceneLayoutSnapshot {
     cutMarginMm: number;
 }
 interface SceneGeometrySnapshot {
-    shape: "rect" | "circle" | "ellipse" | "custom";
-    unit: "mm";
-    displayUnit: Unit;
+    shape: DielineShape;
+    shapeStyle: DielineShapeStyle;
+    unit: "px";
     x: number;
     y: number;
     width: number;
@@ -665,15 +971,4 @@ declare class SceneLayoutService implements Service {
     getGeometry(forceRefresh?: boolean): SceneGeometrySnapshot | null;
 }
 
-declare class SceneVisibilityService implements Service {
-    private context?;
-    private activeToolId;
-    private canvasService?;
-    init(context: ServiceContext): void;
-    dispose(context: ServiceContext): void;
-    private onToolActivated;
-    private onObjectAdded;
-    private apply;
-}
-
-export { BackgroundTool, CanvasService, type DielineGeometry, type DielineState, DielineTool, FeatureTool, FilmTool, type ImageItem, ImageTool, type LineStyle, MirrorTool, type RenderLayerSpec, type RenderObjectSpec, type RenderObjectType, type RenderProps, RulerTool, SceneLayoutService, SceneVisibilityService, SizeTool, ViewportSystem, type WhiteInkItem, WhiteInkTool };
+export { type BackgroundConfig, type BackgroundFitMode, type BackgroundLayer, type BackgroundLayerKind, BackgroundTool, CanvasService, type DielineGeometry, type DielineState, DielineTool, FeatureTool, FilmTool, type ImageItem, ImageTool, type LayerObjectCountComparator, type LineStyle, MirrorTool, type RenderClipPathEffectSpec, type RenderCoordinateSpace, type RenderEffectSpec, type RenderLayoutAlign, type RenderLayoutInsets, type RenderLayoutLength, type RenderLayoutRect, type RenderLayoutReference, type RenderObjectLayoutSpec, type RenderObjectSpec, type RenderObjectType, type RenderPassSpec, type RenderProps, RulerTool, SceneLayoutService, SizeTool, ViewportSystem, type VisibilityEvalContext, type VisibilityExpr, type VisibilityLayerState, type WhiteInkItem, WhiteInkTool, evaluateVisibilityExpr };