@pooder/kit 5.3.1 → 5.4.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @pooder/kit
 
+## 5.4.0
+
+### Minor Changes
+
+- spec framework
+
 ## 5.3.1
 
 ### Patch Changes

package/dist/index.d.mts

@@ -9,6 +9,13 @@ declare class BackgroundTool implements Extension {
     private color;
     private url;
     private canvasService?;
+    private specs;
+    private renderProducerDisposable?;
+    private renderSeq;
+    private renderImageUrl;
+    private sourceSizeBySrc;
+    private pendingSizeBySrc;
+    private onCanvasResized;
     constructor(options?: Partial<{
         color: string;
         url: string;
@@ -19,8 +26,12 @@ declare class BackgroundTool implements Extension {
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private initLayer;
+    private getViewportSize;
+    private buildBackgroundSpecs;
+    private ensureImageSize;
+    private loadImageSize;
     private updateBackground;
+    private updateBackgroundAsync;
 }
 
 interface ImageItem {
@@ -54,6 +65,9 @@ declare class ImageTool implements Extension {
     private dirtyTrackerDisposable?;
     private cropShapeHatchPattern?;
     private cropShapeHatchPatternColor?;
+    private cropShapeHatchPatternKey?;
+    private overlaySpecs;
+    private renderProducerDisposable?;
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
     private onToolActivated;
@@ -97,6 +111,8 @@ declare class ImageTool implements Extension {
     private getConfig;
     private updateConfig;
     private getFrameRect;
+    private getFrameRectScreen;
+    private toLayoutSceneRect;
     private resolveDefaultFitArea;
     private fitImageToDefaultArea;
     private getImageObjects;
@@ -115,6 +131,8 @@ declare class ImageTool implements Extension {
     private buildCropShapeOverlaySpecs;
     private resolveRenderImageState;
     private computeCanvasProps;
+    private toScreenObjectProps;
+    private toSceneObjectScale;
     private getCurrentSrc;
     private applyImageControlVisibility;
     private upsertImageObject;
@@ -163,21 +181,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 +212,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 +235,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;
@@ -251,6 +260,9 @@ declare class DielineTool implements Extension {
     private state;
     private canvasService?;
     private context?;
+    private specs;
+    private renderSeq;
+    private renderProducerDisposable?;
     private onCanvasResized;
     constructor(options?: Partial<DielineState>);
     activate(context: ExtensionContext): void;
@@ -268,14 +280,14 @@ declare class DielineTool implements Extension {
         [ContributionPointIds.CONFIGURATIONS]: ConfigurationContribution[];
         [ContributionPointIds.COMMANDS]: CommandContribution[];
     };
-    private getLayer;
-    private createLayer;
-    private destroyLayer;
     private createHatchPattern;
     private getConfigService;
     private syncSizeState;
     private bringFeatureMarkersToFront;
+    private ensureLayerStacking;
+    private buildDielineSpecs;
     updateDieline(_emitEvent?: boolean): void;
+    private updateDielineAsync;
     getGeometry(): DielineGeometry | null;
     exportCutImage(options?: {
         debug?: boolean;
@@ -304,6 +316,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 +364,25 @@ 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 syncOverlayOrder;
+    private buildFeatureSpecs;
+    private appendMarkerSpecs;
+    private buildMarkerData;
+    private markerId;
+    private bridgeIndicatorId;
+    private toFeatureIndex;
+    private readGroupIndices;
+    private readGroupMemberOffsets;
+    private syncMarkerVisualsByTarget;
+    private syncMarkerVisualObjectsToCenter;
     private enforceConstraints;
 }
 
@@ -363,6 +394,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 +411,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 +454,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 +467,7 @@ declare class RulerTool implements Extension {
         textColor: string;
         lineColor: string;
         fontSize: number;
+        gap: number;
     }>);
     activate(context: ExtensionContext): void;
     deactivate(context: ExtensionContext): void;
@@ -427,11 +475,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 +515,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 +569,7 @@ declare class WhiteInkTool implements Extension {
     private clearWhiteInks;
     private completeWhiteInks;
     private getFrameRect;
+    private toLayoutSceneRect;
     private getImageObjects;
     private getPrimaryImageObject;
     private getPrimaryImageSource;
@@ -542,6 +603,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,14 +638,44 @@ 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 {
     id: string;
@@ -576,14 +683,48 @@ interface RenderLayerSpec {
     props?: RenderProps;
 }
 
+interface RenderProducerResult {
+    layerSpecs?: Record<string, RenderObjectSpec[]>;
+    rootLayerSpecs?: Record<string, RenderObjectSpec[]>;
+    replaceLayerIds?: string[];
+    replaceRootLayerIds?: string[];
+}
+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 eventBus?;
+    private renderProducers;
+    private producerOrder;
+    private producerFlushRequested;
+    private producerLoopPending;
+    private producerLoopPromise;
+    private managedProducerLayerIds;
+    private managedProducerRootLayerIds;
     constructor(el: HTMLCanvasElement | string | Canvas, options?: any);
     setEventBus(eventBus: EventBus): void;
     private setupEvents;
     dispose(): void;
+    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 appendLayerSpecMap;
+    private collectAndApplyProducerSpecs;
     /**
      * Get a layer (Group) by its ID.
      * We assume layers are Groups directly on the canvas with a data.id property.
@@ -599,12 +740,78 @@ declare class CanvasService implements Service {
     getObject(id: string, layerId?: string): FabricObject | undefined;
     requestRenderAll(): void;
     resize(width: number, height: number): void;
+    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;
+    setLayerVisibility(layerId: string, visible: boolean): void;
+    bringLayerToFront(layerId: string): void;
     applyLayerSpec(spec: RenderLayerSpec): Promise<void>;
-    applyObjectSpecsToLayer(layerId: string, objects: RenderObjectSpec[]): Promise<void>;
+    applyObjectSpecsToLayer(layerId: string, objects: RenderObjectSpec[], options?: {
+        render?: boolean;
+    }): Promise<void>;
     getRootLayerObjects(layerId: string): FabricObject[];
-    applyObjectSpecsToRootLayer(layerId: string, specs: RenderObjectSpec[]): Promise<void>;
+    applyObjectSpecsToRootLayer(layerId: string, specs: RenderObjectSpec[], options?: {
+        render?: boolean;
+    }): Promise<void>;
     private applyObjectSpecsToContainer;
     private patchFabricObject;
+    private resolveFabricProps;
     private moveObjectInContainer;
     private createFabricObject;
 }
@@ -633,9 +840,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;
@@ -676,4 +883,4 @@ declare class SceneVisibilityService implements Service {
     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 { 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 };