@pooder/kit 6.2.2 → 6.3.0

package/.test-dist/tests/run.js

@@ -12,6 +12,7 @@ const config_2 = require("../src/extensions/white-ink/config");
 const commands_3 = require("../src/extensions/dieline/commands");
 const config_3 = require("../src/extensions/dieline/config");
 const featureCoordinates_1 = require("../src/extensions/featureCoordinates");
+const model_1 = require("../src/extensions/image/model");
 function assert(condition, message) {
     if (!condition)
         throw new Error(message);
@@ -169,6 +170,39 @@ function testVisibilityDsl() {
         ],
     }, context) === true, "any failed");
 }
+function testImageViewStateHelper() {
+    assert((0, model_1.hasAnyImageInViewState)(null) === false, "null image state should be empty");
+    assert((0, model_1.hasAnyImageInViewState)({
+        items: [],
+        hasAnyImage: false,
+        focusedId: null,
+        focusedItem: null,
+        isToolActive: false,
+        isImageSelectionActive: false,
+        hasWorkingChanges: false,
+        source: "committed",
+    }) === false, "empty image state should report false");
+    assert((0, model_1.hasAnyImageInViewState)({
+        items: [
+            {
+                id: "img-1",
+                url: "blob:test",
+                opacity: 1,
+            },
+        ],
+        hasAnyImage: true,
+        focusedId: "img-1",
+        focusedItem: {
+            id: "img-1",
+            url: "blob:test",
+            opacity: 1,
+        },
+        isToolActive: true,
+        isImageSelectionActive: true,
+        hasWorkingChanges: true,
+        source: "working",
+    }) === true, "non-empty image state should report true");
+}
 function testContributionCompatibility() {
     const imageCommandNames = (0, commands_1.createImageCommands)({}).map((entry) => entry.command);
     const whiteInkCommandNames = (0, commands_2.createWhiteInkCommands)({}).map((entry) => entry.command);
@@ -179,13 +213,12 @@ function testContributionCompatibility() {
     const expectedImageCommands = [
         "addImage",
         "upsertImage",
-        "getWorkingImages",
-        "setWorkingImage",
-        "resetWorkingImages",
+        "applyImageOperation",
+        "getImageViewState",
+        "setImageTransform",
+        "imageSessionReset",
         "completeImages",
         "exportUserCroppedImage",
-        "fitImageToArea",
-        "fitImageToDefaultArea",
         "focusImage",
         "removeImage",
         "updateImage",
@@ -285,6 +318,7 @@ function main() {
     testEdgeScale();
     testFeaturePlacementProjection();
     testVisibilityDsl();
+    testImageViewStateHelper();
     testContributionCompatibility();
     console.log("ok");
 }

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pooder/kit
 
+## 6.3.0
+
+### Minor Changes
+
+- pooder facade
+
 ## 6.2.2
 
 ### Patch Changes

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import * as _pooder_core from '@pooder/core';
-import { Extension, ExtensionContext, ContributionPointIds, ConfigurationContribution, CommandContribution, ConfigurationService, Service, ServiceContext, EventBus } from '@pooder/core';
+import { Extension, ExtensionContext, ContributionPointIds, ConfigurationContribution, CommandContribution, Service, ServiceContext, EventBus, ConfigurationService } from '@pooder/core';
 import { Canvas, FabricObject } from 'fabric';
 
 type BackgroundLayerKind = "color" | "image";
@@ -87,6 +87,23 @@ interface ImageItem {
     sourceUrl?: string;
     committedUrl?: string;
 }
+interface ImageTransformUpdates {
+    scale?: number;
+    angle?: number;
+    left?: number;
+    top?: number;
+    opacity?: number;
+}
+interface ImageViewState {
+    items: ImageItem[];
+    hasAnyImage: boolean;
+    focusedId: string | null;
+    focusedItem: ImageItem | null;
+    isToolActive: boolean;
+    isImageSelectionActive: boolean;
+    hasWorkingChanges: boolean;
+    source: "working" | "committed";
+}
 declare class ImageTool implements Extension {
     id: string;
     metadata: {
@@ -175,21 +192,21 @@ declare class ImageTool implements Extension {
     private normalizeItem;
     private normalizeItems;
     private cloneItems;
+    private getViewItems;
+    private getImageViewState;
+    private emitImageStateChange;
     private emitWorkingChange;
     private generateId;
     private hasImageItem;
     private setImageFocus;
     private addImageEntry;
     private upsertImageEntry;
-    private addItemToWorkingSessionIfNeeded;
     private updateImage;
     private getConfig;
     private applyCommittedItems;
     private updateConfig;
     private getFrameRect;
     private getFrameRectScreen;
-    private resolveDefaultFitArea;
-    private fitImageToDefaultArea;
     private getImageObjects;
     private getOverlayObjects;
     private getImageObject;
@@ -212,12 +229,14 @@ declare class ImageTool implements Extension {
     private updateImages;
     private updateImagesAsync;
     private clampNormalized;
+    private setImageTransform;
+    private resetImageSession;
     private onObjectModified;
     private updateImageInWorking;
     private updateImageInConfig;
     private waitImageLoaded;
-    private refitImageToFrame;
-    private fitImageToArea;
+    private resolveImageSourceSize;
+    private applyImageOperation;
     private commitWorkingImagesAsCropped;
     private exportCroppedImageByIds;
     private exportUserCroppedImage;
@@ -227,160 +246,6 @@ declare function createImageCommands(tool: any): CommandContribution[];
 
 declare function createImageConfigurations(): ConfigurationContribution[];
 
-interface RectLike$1 {
-    width: number;
-    height: number;
-}
-declare function getCoverScale(frame: RectLike$1, source: RectLike$1): number;
-
-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 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";
-type FeatureShape = "rect" | "circle";
-interface DielineFeature {
-    id: string;
-    groupId?: string;
-    operation: FeatureOperation;
-    shape: FeatureShape;
-    x: number;
-    y: number;
-    width?: number;
-    height?: number;
-    radius?: number;
-    rotation?: number;
-    renderBehavior?: "edge" | "surface";
-    color?: string;
-    strokeDash?: number[];
-    skipCut?: boolean;
-    bridge?: {
-        type: "vertical";
-    };
-}
-
-interface DielineGeometry {
-    shape: DielineShape;
-    shapeStyle: DielineShapeStyle;
-    unit: "px";
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-    radius: number;
-    offset: number;
-    borderLength?: number;
-    scale?: number;
-    strokeWidth?: number;
-    pathData?: string;
-    customSourceWidthPx?: number;
-    customSourceHeightPx?: number;
-}
-interface LineStyle {
-    width: number;
-    color: string;
-    dashLength: number;
-    style: "solid" | "dashed" | "hidden";
-}
-interface DielineState {
-    shape: DielineShape;
-    shapeStyle: DielineShapeStyle;
-    width: number;
-    height: number;
-    radius: number;
-    offset: number;
-    padding: number | string;
-    mainLine: LineStyle;
-    offsetLine: LineStyle;
-    insideColor: string;
-    showBleedLines: boolean;
-    features: DielineFeature[];
-    pathData?: string;
-    customSourceWidthPx?: number;
-    customSourceHeightPx?: number;
-}
-declare function createDefaultDielineState(): DielineState;
-declare function readDielineState(configService: ConfigurationService, fallback?: Partial<DielineState>): DielineState;
-
-declare class DielineTool implements Extension {
-    id: string;
-    metadata: {
-        name: string;
-    };
-    private state;
-    private canvasService?;
-    private context?;
-    private specs;
-    private effects;
-    private renderSeq;
-    private renderProducerDisposable?;
-    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]: _pooder_core.ConfigurationContribution[];
-        [ContributionPointIds.COMMANDS]: _pooder_core.CommandContribution[];
-    };
-    private createHatchPattern;
-    private getConfigService;
-    private hasImageItems;
-    private buildDielineSpecs;
-    private buildImageClipEffects;
-    updateDieline(_emitEvent?: boolean): void;
-    private updateDielineAsync;
-    getGeometry(): DielineGeometry | null;
-    exportCutImage(options?: {
-        debug?: boolean;
-    }): Promise<string | null>;
-}
-
-declare function createDielineCommands(tool: any, state: any): CommandContribution[];
-
-declare function createDielineConfigurations(state: any): ConfigurationContribution[];
-
 interface Point {
     x: number;
     y: number;
@@ -510,7 +375,7 @@ type RenderProducer = () => RenderProducerResult | undefined | Promise<RenderPro
 interface RegisterRenderProducerOptions {
     priority?: number;
 }
-interface RectLike {
+interface RectLike$1 {
     left: number;
     top: number;
     width: number;
@@ -629,7 +494,7 @@ declare class CanvasService implements Service {
         width: number;
         height: number;
     };
-    getScreenViewportRect(): RectLike;
+    getScreenViewportRect(): RectLike$1;
     private toSpaceRect;
     private resolveLayoutLength;
     private resolveLayoutInsets;
@@ -669,6 +534,14 @@ declare class CanvasService implements Service {
     private createFabricObject;
 }
 
+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 CutMode = "trim" | "outset" | "inset";
 interface SceneRect {
     left: number;
@@ -737,6 +610,220 @@ interface VisibilityEvalContext {
 }
 declare function evaluateVisibilityExpr(expr: VisibilityExpr | undefined, context: VisibilityEvalContext): boolean;
 
+interface FrameRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+
+interface SourceSize {
+    width: number;
+    height: number;
+}
+interface RectLike {
+    width: number;
+    height: number;
+}
+declare function getCoverScale(frame: RectLike, source: RectLike): number;
+
+interface ImageOperationArea {
+    width: number;
+    height: number;
+    centerX: number;
+    centerY: number;
+}
+interface ImageOperationViewport {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+type ImageOperationAreaSpec = {
+    type: "frame";
+} | {
+    type: "viewport";
+} | ({
+    type: "custom";
+} & ImageOperationArea);
+type ImageOperation = {
+    type: "cover";
+    area?: ImageOperationAreaSpec;
+} | {
+    type: "contain";
+    area?: ImageOperationAreaSpec;
+} | {
+    type: "maximizeWidth";
+    area?: ImageOperationAreaSpec;
+} | {
+    type: "maximizeHeight";
+    area?: ImageOperationAreaSpec;
+} | {
+    type: "center";
+    area?: ImageOperationAreaSpec;
+} | {
+    type: "resetTransform";
+};
+interface ComputeImageOperationArgs {
+    frame: FrameRect;
+    source: SourceSize;
+    operation: ImageOperation;
+    area: ImageOperationArea;
+}
+declare function resolveImageOperationArea(args: {
+    frame: FrameRect;
+    viewport: ImageOperationViewport;
+    area?: ImageOperationAreaSpec;
+}): ImageOperationArea;
+declare function computeImageOperationUpdates(args: ComputeImageOperationArgs): {
+    scale?: number;
+    left?: number;
+    top?: number;
+    angle?: number;
+};
+
+declare function hasAnyImageInViewState(state: ImageViewState | null | undefined): boolean;
+
+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;
+}
+
+type FeatureOperation = "add" | "subtract";
+type FeatureShape = "rect" | "circle";
+interface DielineFeature {
+    id: string;
+    groupId?: string;
+    operation: FeatureOperation;
+    shape: FeatureShape;
+    x: number;
+    y: number;
+    width?: number;
+    height?: number;
+    radius?: number;
+    rotation?: number;
+    renderBehavior?: "edge" | "surface";
+    color?: string;
+    strokeDash?: number[];
+    skipCut?: boolean;
+    bridge?: {
+        type: "vertical";
+    };
+}
+
+interface DielineGeometry {
+    shape: DielineShape;
+    shapeStyle: DielineShapeStyle;
+    unit: "px";
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    radius: number;
+    offset: number;
+    borderLength?: number;
+    scale?: number;
+    strokeWidth?: number;
+    pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
+}
+interface LineStyle {
+    width: number;
+    color: string;
+    dashLength: number;
+    style: "solid" | "dashed" | "hidden";
+}
+interface DielineState {
+    shape: DielineShape;
+    shapeStyle: DielineShapeStyle;
+    width: number;
+    height: number;
+    radius: number;
+    offset: number;
+    padding: number | string;
+    mainLine: LineStyle;
+    offsetLine: LineStyle;
+    insideColor: string;
+    showBleedLines: boolean;
+    features: DielineFeature[];
+    pathData?: string;
+    customSourceWidthPx?: number;
+    customSourceHeightPx?: number;
+}
+declare function createDefaultDielineState(): DielineState;
+declare function readDielineState(configService: ConfigurationService, fallback?: Partial<DielineState>): DielineState;
+
+declare class DielineTool implements Extension {
+    id: string;
+    metadata: {
+        name: string;
+    };
+    private state;
+    private canvasService?;
+    private context?;
+    private specs;
+    private effects;
+    private renderSeq;
+    private renderProducerDisposable?;
+    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]: _pooder_core.ConfigurationContribution[];
+        [ContributionPointIds.COMMANDS]: _pooder_core.CommandContribution[];
+    };
+    private createHatchPattern;
+    private getConfigService;
+    private hasImageItems;
+    private buildDielineSpecs;
+    private buildImageClipEffects;
+    updateDieline(_emitEvent?: boolean): void;
+    private updateDielineAsync;
+    getGeometry(): DielineGeometry | null;
+    exportCutImage(options?: {
+        debug?: boolean;
+    }): Promise<string | null>;
+}
+
+declare function createDielineCommands(tool: any, state: any): CommandContribution[];
+
+declare function createDielineConfigurations(state: any): ConfigurationContribution[];
+
 interface ConstraintFeature extends DielineFeature {
     constraints?: Array<{
         type: string;
@@ -1059,4 +1146,4 @@ declare function createWhiteInkCommands(tool: any): CommandContribution[];
 
 declare function createWhiteInkConfigurations(): ConfigurationContribution[];
 
-export { type BackgroundConfig, type BackgroundFitMode, type BackgroundLayer, type BackgroundLayerKind, type BackgroundRegionUnit, type BackgroundRegistration, type BackgroundRegistrationFrame, type BackgroundRegistrationRegion, 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, getCoverScale as computeImageCoverScale, getCoverScale as computeWhiteInkCoverScale, createDefaultDielineState, createDielineCommands, createDielineConfigurations, createImageCommands, createImageConfigurations, createWhiteInkCommands, createWhiteInkConfigurations, evaluateVisibilityExpr, readDielineState };
+export { type BackgroundConfig, type BackgroundFitMode, type BackgroundLayer, type BackgroundLayerKind, type BackgroundRegionUnit, type BackgroundRegistration, type BackgroundRegistrationFrame, type BackgroundRegistrationRegion, BackgroundTool, CanvasService, type ComputeImageOperationArgs, type DielineGeometry, type DielineState, DielineTool, FeatureTool, FilmTool, type ImageItem, type ImageOperation, type ImageOperationArea, type ImageOperationAreaSpec, type ImageOperationViewport, ImageTool, type ImageTransformUpdates, type ImageViewState, 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, getCoverScale as computeImageCoverScale, computeImageOperationUpdates, getCoverScale as computeWhiteInkCoverScale, createDefaultDielineState, createDielineCommands, createDielineConfigurations, createImageCommands, createImageConfigurations, createWhiteInkCommands, createWhiteInkConfigurations, evaluateVisibilityExpr, hasAnyImageInViewState, readDielineState, resolveImageOperationArea };