@pooder/kit 5.4.0 → 6.0.1

package/dist/index.d.mts

@@ -1,33 +1,58 @@
-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?;
+    private configService?;
     private specs;
     private renderProducerDisposable?;
+    private configChangeDisposable?;
     private renderSeq;
-    private renderImageUrl;
+    private latestSceneLayout;
     private sourceSizeBySrc;
     private pendingSizeBySrc;
     private onCanvasResized;
-    constructor(options?: Partial<{
-        color: string;
-        url: string;
-    }>);
+    private onSceneLayoutChanged;
+    constructor(options?: Partial<BackgroundConfig>);
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     contribute(): {
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private getViewportSize;
+    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;
@@ -66,8 +91,10 @@ declare class ImageTool implements Extension {
     private cropShapeHatchPattern?;
     private cropShapeHatchPatternColor?;
     private cropShapeHatchPatternKey?;
+    private imageSpecs;
     private overlaySpecs;
     private renderProducerDisposable?;
+    private imageControlsByCapabilityKey;
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     private onToolActivated;
@@ -77,6 +104,11 @@ declare class ImageTool implements Extension {
     private onSceneGeometryChanged;
     private syncToolActiveFromWorkbench;
     private isImageEditingVisible;
+    private getEnabledImageControlCapabilities;
+    private getImageControls;
+    private getImageControlVisualConfig;
+    private applyImageObjectInteractionState;
+    private refreshImageObjectInteractionState;
     private isDebugEnabled;
     private debug;
     contribute(): {
@@ -122,6 +154,7 @@ declare class ImageTool implements Extension {
     private purgeSourceSizeCacheForItem;
     private rememberSourceSize;
     private getSourceSize;
+    private ensureSourceSize;
     private getCoverScale;
     private getFrameVisualConfig;
     private toSceneGeometryLike;
@@ -131,12 +164,9 @@ declare class ImageTool implements Extension {
     private buildCropShapeOverlaySpecs;
     private resolveRenderImageState;
     private computeCanvasProps;
-    private toScreenObjectProps;
     private toSceneObjectScale;
     private getCurrentSrc;
-    private applyImageControlVisibility;
-    private upsertImageObject;
-    private syncImageZOrder;
+    private buildImageSpecs;
     private buildOverlaySpecs;
     private updateImages;
     private updateImagesAsync;
@@ -245,7 +275,6 @@ interface DielineState {
     mainLine: LineStyle;
     offsetLine: LineStyle;
     insideColor: string;
-    outsideColor: string;
     showBleedLines: boolean;
     features: DielineFeature[];
     pathData?: string;
@@ -261,6 +290,7 @@ declare class DielineTool implements Extension {
     private canvasService?;
     private context?;
     private specs;
+    private effects;
     private renderSeq;
     private renderProducerDisposable?;
     private onCanvasResized;
@@ -282,10 +312,10 @@ declare class DielineTool implements Extension {
     };
     private createHatchPattern;
     private getConfigService;
+    private hasImageItems;
     private syncSizeState;
-    private bringFeatureMarkersToFront;
-    private ensureLayerStacking;
     private buildDielineSpecs;
+    private buildImageClipEffects;
     updateDieline(_emitEvent?: boolean): void;
     private updateDielineAsync;
     getGeometry(): DielineGeometry | null;
@@ -372,7 +402,6 @@ declare class FeatureTool implements Extension {
     private syncGroupFromCanvas;
     private redraw;
     private redrawAsync;
-    private syncOverlayOrder;
     private buildFeatureSpecs;
     private appendMarkerSpecs;
     private buildMarkerData;
@@ -587,11 +616,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;
@@ -677,17 +703,56 @@ interface RenderObjectSpec {
     space?: RenderCoordinateSpace;
     layout?: RenderObjectLayoutSpec;
 }
-interface RenderLayerSpec {
+type LayerObjectCountComparator = ">" | ">=" | "==" | "<" | "<=";
+type VisibilityExpr = {
+    op: "const";
+    value: boolean;
+} | {
+    op: "activeToolIn";
+    ids: string[];
+} | {
+    op: "sessionActive";
+    toolId: string;
+} | {
+    op: "anySessionActive";
+} | {
+    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;
+    visibility?: VisibilityExpr;
+    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 {
-    layerSpecs?: Record<string, RenderObjectSpec[]>;
-    rootLayerSpecs?: Record<string, RenderObjectSpec[]>;
-    replaceLayerIds?: string[];
-    replaceRootLayerIds?: string[];
+    passes?: RenderPassSpec[];
 }
 type RenderProducer = () => RenderProducerResult | undefined | Promise<RenderProducerResult | undefined>;
 interface RegisterRenderProducerOptions {
@@ -702,15 +767,34 @@ interface RectLike {
 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 managedProducerLayerIds;
-    private managedProducerRootLayerIds;
+    private producerApplyInProgress;
+    private visibilityRefreshScheduled;
+    private managedProducerPassIds;
+    private managedPassMetas;
+    private managedPassEffects;
+    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;
@@ -723,21 +807,25 @@ declare class CanvasService implements Service {
     private scheduleProducerLoop;
     private runProducerLoop;
     private sortedRenderProducerEntries;
-    private appendLayerSpecMap;
+    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 isSessionActive;
+    private hasAnyActiveSession;
+    private buildVisibilityEvalContext;
+    private applyManagedPassVisibility;
+    private scheduleManagedPassVisibilityRefresh;
     private collectAndApplyProducerSpecs;
-    /**
-     * 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;
+    private applyManagedPassEffects;
+    getObject(id: string, passId?: string): FabricObject | undefined;
     requestRenderAll(): void;
     resize(width: number, height: number): void;
     getSceneScale(): number;
@@ -799,23 +887,48 @@ declare class CanvasService implements Service {
     private normalizeOriginY;
     private originFactor;
     private resolveLayoutProps;
-    setLayerVisibility(layerId: string, visible: boolean): void;
+    setPassVisibility(passId: string, visible: boolean): boolean;
+    setLayerVisibility(layerId: string, visible: boolean): boolean;
+    bringPassToFront(passId: string): void;
     bringLayerToFront(layerId: string): void;
-    applyLayerSpec(spec: RenderLayerSpec): Promise<void>;
-    applyObjectSpecsToLayer(layerId: string, objects: RenderObjectSpec[], options?: {
+    applyPassSpec(spec: RenderPassSpec, options?: {
         render?: boolean;
     }): Promise<void>;
-    getRootLayerObjects(layerId: string): FabricObject[];
-    applyObjectSpecsToRootLayer(layerId: string, specs: RenderObjectSpec[], options?: {
+    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 applyObjectSpecsToContainer;
     private patchFabricObject;
+    private readPathDataFromSpec;
+    private hashText;
+    private getSpecRenderSourceKey;
+    private shouldRecreateObject;
     private resolveFabricProps;
-    private moveObjectInContainer;
+    private moveObjectInCanvas;
     private createFabricObject;
 }
 
+interface VisibilityLayerState {
+    exists: boolean;
+    objectCount: number;
+}
+interface VisibilityEvalContext {
+    activeToolId?: string | null;
+    isSessionActive?: (toolId: string) => boolean;
+    hasAnyActiveSession?: () => boolean;
+    layers: Map<string, VisibilityLayerState>;
+}
+declare function evaluateVisibilityExpr(expr: VisibilityExpr | undefined, context: VisibilityEvalContext): boolean;
+
 type CutMode = "trim" | "outset" | "inset";
 interface SceneRect {
     left: number;
@@ -872,15 +985,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 RenderCoordinateSpace, type RenderLayerSpec, type RenderLayoutAlign, type RenderLayoutInsets, type RenderLayoutLength, type RenderLayoutRect, type RenderLayoutReference, type RenderObjectLayoutSpec, 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 };