@jetprint/editor-sdk 1.0.0

package/dist/components/Editor/composables/index.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Composables 统一导出
+ */
+export { useLicense } from './useLicense';
+export { useFontLoader, loadFont } from './useFontLoader';
+export { useProductData } from './useProductData';
+export { useToolState } from './useToolState';
+export { useTemplateManager } from './useTemplateManager';
+export { useCanvasManager } from './useCanvasManager';
+export { useLayerManager } from './useLayerManager';
+export { useImageHandler } from './useImageHandler';
+export { useTextHandler } from './useTextHandler';
+export { useDiecutManager } from './useDiecutManager';
+export { useTemplateLoader } from './useTemplateLoader';
+export { usePreviewManager } from './usePreviewManager';
+export { usePreviewRenderer } from './usePreviewRenderer';
+export { useCompleteScreenshot } from './useCompleteScreenshot';
+export { usePreviewUpdateQueue } from './usePreviewUpdateQueue';
+export type { QueuePreviewUpdateMeta } from './usePreviewUpdateQueue';
+export { useWorkerManager } from './useWorkerManager';
+export { useEventHandlers } from './useEventHandlers';
+export { useDiecutScreenshot, type TryBuildZoneInverseMaskBlobs } from './useDiecutScreenshot';
+export { useCanvasStateByDiecut } from './useCanvasStateByDiecut';
+export { useCanvasViewport, CANVAS_LOGICAL_HEIGHT, CANVAS_VIEWPORT_ZOOM_MIN, CANVAS_VIEWPORT_ZOOM_MAX, computeLogicalCanvasSizeFromWrapClientSize, } from './useCanvasViewport';
+export type { TemplateItem, UseTemplateLoaderOptions } from './useTemplateLoader';
+export { useObjectAdder } from './useObjectAdder';
+export type { UseObjectAdderOptions, FabricImageInstance } from './useObjectAdder';
+export { useLayerOperations } from './useLayerOperations';
+export type { UseLayerOperationsOptions } from './useLayerOperations';
+export type { UseWorkerManagerOptions } from './useWorkerManager';
+export { useCanvasEventWiring } from './useCanvasEventWiring';
+export { useGuideResources } from './useGuideResources';
+export { usePatternHandler } from './usePatternHandler';
+export { useToolStateSync } from './useToolStateSync';
+export { useLayerSync } from './useLayerSync';
+export { useCanvasObjectHelpers } from './useCanvasObjectHelpers';
+export { useEditorWatchers } from './useEditorWatchers';
+export type { UseEditorWatchersOptions } from './useEditorWatchers';
+export { useCopyToDiecuts } from './useCopyToDiecuts';
+export type { UseCopyToDiecutsOptions } from './useCopyToDiecuts';
+export { useClearCanvas } from './useClearCanvas';
+export type { UseClearCanvasOptions } from './useClearCanvas';
+export { useEditorReset } from './useEditorReset';
+export type { UseEditorResetOptions } from './useEditorReset';
+export { useDownloadPng } from './useDownloadPng';
+export type { UseDownloadPngOptions } from './useDownloadPng';
+export { useCanvasHistory } from './useCanvasHistory';
+export type { UseCanvasHistoryOptions, UseCanvasHistoryReturn } from './useCanvasHistory';
+export { useEditorShortcuts } from './useEditorShortcuts';
+export type { EditorShortcutsController } from './useEditorShortcuts';
+export { useEditorI18n, getEditorI18nKeys, defaultZh, defaultEn } from '../../../composables/useEditorI18n';
+export { useEditorTopbarContext, useEditorTopbarContextOptional, } from './useEditorTopbarContext';
+export type { Layer } from './useLayerManager';
+export type { LayerItem } from './useLayerSync';
+export type { DiecutResource, DiecutGroup, DiecutOption } from './useDiecutManager';
+export type { CanvasStateOptions } from './useCanvasStateByDiecut';

package/dist/components/Editor/composables/useCanvasEventWiring.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Editor Canvas 事件绑定（抽离 index.vue 中的复杂事件逻辑）
+ * 拖拽结束：入队 queuePreviewUpdate（可 debounce，管道内 saveCanvasState 落盘 diecutStateMap），
+ * 并跳过紧随的 object:modified，避免与松手入队重复触发。
+ */
+import type { Canvas } from 'fabric';
+export declare function useCanvasEventWiring(options: {
+    getCanvas: () => Canvas | null;
+    guideResourceRole: string;
+    insertBelowGuideLayers: (obj: any) => void;
+    bringGuideLayersToFront: () => void;
+    syncLayers: () => void;
+    updateActive: (autoSwitchTab?: boolean) => void;
+    shouldAutoSwitchTabOnSelection?: () => boolean;
+    /** mouse:up 且本轮曾处于拖拽态：松手后触发（如 COMPLETE 分片全量预览） */
+    onCanvasDragInteractionEnd?: () => void;
+    /** 松手后重放拖拽期间延迟的预览更新（在 onCanvasDragInteractionEnd 之后调用） */
+    flushDeferredPreviewAfterDrag?: () => void;
+    /** object:moving 期间触发（用于轻量实时预览） */
+    onCanvasDragging?: (target?: any) => void;
+    handleObjectModified: (reason: string) => void;
+    getSelectedDiecutId: () => string;
+    saveCanvasState: (diecutId: string) => Promise<void>;
+    notifyObjectModified: () => void;
+    queuePreviewUpdate: (reason: string, meta?: {
+        source?: string;
+        startTime?: number;
+        immediate?: boolean;
+        commitHd?: boolean;
+    }) => void;
+    getIsDraggingObject: () => boolean;
+    setIsDraggingObject: (v: boolean, target?: any, moveEvent?: any) => void;
+    getHasPendingDragUpdate: () => boolean;
+    setHasPendingDragUpdate: (v: boolean) => void;
+    setSkipNextObjectModified: (v: boolean) => void;
+    /** loadDesignStateMap 等批量回放：勿在 object:added 里 insertBelow，避免与回放末尾 bringToFront 栈序冲突 */
+    skipObjectAddedGuideReorder?: () => boolean;
+}): {
+    setup: () => () => void;
+};

package/dist/components/Editor/composables/useCanvasHistory.d.ts

@@ -0,0 +1,18 @@
+export interface UseCanvasHistoryOptions {
+    maxSteps?: number;
+    getHistoryKey: () => string;
+    captureState: () => Promise<unknown | null>;
+    applyState: (state: unknown) => Promise<void>;
+    isEnabled?: () => boolean;
+}
+export declare function useCanvasHistory(options: UseCanvasHistoryOptions): {
+    canUndo: import("vue").ComputedRef<boolean>;
+    canRedo: import("vue").ComputedRef<boolean>;
+    isApplyingHistory: import("vue").ComputedRef<boolean>;
+    record: () => Promise<boolean>;
+    ensureBaseline: () => Promise<void>;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    clear: (key?: string) => void;
+};
+export type UseCanvasHistoryReturn = ReturnType<typeof useCanvasHistory>;

package/dist/components/Editor/composables/useCanvasManager.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Canvas 管理 Composable
+ * 负责 Canvas 初始化、缩放、调整大小等核心功能
+ */
+import { type Ref } from 'vue';
+import { Canvas } from 'fabric';
+export declare function useCanvasManager(enableGrid?: boolean): {
+    canvasEl: Ref<HTMLCanvasElement | null, HTMLCanvasElement | null>;
+    canvasWrap: Ref<HTMLElement | null, HTMLElement | null>;
+    showGrid: Ref<boolean, boolean>;
+    zoom: Ref<number, number>;
+    getCanvas: () => Canvas | null;
+    getCanvasSize: () => {
+        width: number;
+        height: number;
+    };
+    handleCanvasReady: ({ canvasEl: el, canvasWrap: wrap }: {
+        canvasEl: HTMLCanvasElement;
+        canvasWrap: HTMLElement;
+    }) => void;
+    setZoom: (value: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    fitCanvas: () => void;
+    toggleGrid: () => void;
+    clearCanvas: () => void;
+    renderAll: () => void;
+    cleanup: () => void;
+};

package/dist/components/Editor/composables/useCanvasObjectHelpers.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 画布对象操作辅助 Composable
+ * bringObjectToFront / insertBelowGuideLayers / insertBelowGuideLayersTopMost / bringGuideLayersToFront / scaleResourceToCanvas / loadFabricImage
+ */
+import { Image as FabricImage } from 'fabric';
+export type FabricImageInstance = InstanceType<typeof FabricImage> & {
+    customData?: Record<string, unknown>;
+};
+/** 画布上最靠前的 guide / guide-resource 索引；无则 -1 */
+export declare function getMinGuideLayerIndex(canvas: any, guideResourceRole?: string, guideRole?: string): number;
+/** 替换对象时恢复到原栈位，且不超过 guide 层之下 */
+export declare function resolvePreservedStackIndex(originalIndex: number, minGuideIndex: number): number;
+export declare function isGuideLikeCanvasObject(obj: any, guideResourceRole?: string, guideRole?: string): boolean;
+/** 对象在可编辑图层中的序号（不含 guide / guide-resource） */
+export declare function getEditableOrdinalInStack(objects: any[], obj: any, isGuide?: (o: any) => boolean): number;
+/** 将可编辑层序号映射为 canvas 绝对 index（须在 bringGuideLayersToFront 之后调用） */
+export declare function resolveAbsoluteIndexForEditableOrdinal(objects: any[], editableOrdinal: number, isGuide?: (o: any) => boolean): number;
+export declare function moveObjectToStackIndex(canvas: any, obj: any, targetIndex: number): void;
+export interface UseCanvasObjectHelpersOptions {
+    getCanvas: () => any;
+    resolveImageUrl: (src: string) => Promise<string | null>;
+    guideResourceRole?: string;
+    guideRole?: string;
+}
+export declare function useCanvasObjectHelpers(options: UseCanvasObjectHelpersOptions): {
+    bringObjectToFront: (obj: any) => void;
+    insertBelowGuideLayers: (obj: any) => void;
+    insertBelowGuideLayersTopMost: (obj: any) => void;
+    bringGuideLayersToFront: () => void;
+    scaleResourceToCanvas: (img: any, resource: any) => void;
+    loadFabricImage: (src: string, callback: (img: FabricImageInstance) => void, opts?: {
+        crossOrigin?: string;
+    }) => Promise<void>;
+};

package/dist/components/Editor/composables/useCanvasStateByDiecut.d.ts

@@ -0,0 +1,50 @@
+import type { Canvas } from 'fabric';
+export interface CanvasStateOptions {
+    getCanvas: () => Canvas | null;
+    syncLayers: () => void;
+    notifyObjectModified?: () => void;
+    buildMaskGroups: () => Array<{
+        id: string;
+        name: string;
+        mask?: {
+            url?: string;
+            width?: number;
+            height?: number;
+        };
+    }>;
+    diecutOptions: () => Array<{
+        id: string;
+        name: string;
+    }>;
+    convertImageUrlToBase64: (url: string) => Promise<string | null>;
+    guideResourceRole: string;
+    /** 当前尺码：使 per-分片画布状态按 diecutId+尺码 分桶，避免不同尺码共用 groupId 互相覆盖（修跨尺码串图） */
+    getSelectedSize?: () => string;
+    /** 加载 JSON 完成后调用，用于从 customData 重建图案矩形 fill（Fabric 序列化会丢失 Pattern source） */
+    afterLoadCanvasJson?: (canvas: any) => void | Promise<void>;
+    /** 将 HTTP 图片 URL 解析为 blob URL（通过 fetchWithFileToken 加载），用于 loadFromJSON 前预处理 */
+    resolveImageUrl?: (url: string) => Promise<string>;
+}
+export declare function useCanvasStateByDiecut(options: CanvasStateOptions): {
+    exportCanvasState: () => Promise<any>;
+    saveCanvasState: (diecutId: string, sizeOverride?: string) => Promise<void>;
+    restoreCanvasState: (diecutId: string) => boolean;
+    restoreCanvasStateAsync: (diecutId: string) => Promise<boolean>;
+    restoreCanvasStateAsyncNoWait: (diecutId: string) => Promise<boolean>;
+    loadCanvasJson: (json: any, onDone?: () => void | Promise<void>, loadOptions?: {
+        skipRender?: boolean;
+    }) => Promise<void>;
+    filterUserContent: (fabricJson: any) => any;
+    getAllDiecutFabricData: () => Promise<{
+        version: string;
+        diecuts: Record<string, unknown>;
+    }>;
+    getDiecutStateMap: () => Record<string, unknown>;
+    getDesignedSizes: () => Set<string>;
+    clearAllStates: () => void;
+    clearState: (diecutId: string) => void;
+    getState: (diecutId: string) => {} | null;
+    getStateForSize: (diecutId: string, size: string) => {} | null;
+    setState: (diecutId: string, state: unknown) => void;
+    setStates: (updates: Record<string, unknown>) => void;
+};

package/dist/components/Editor/composables/useCanvasViewport.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Canvas Viewport 管理 Composable
+ * 负责 Canvas 的 viewport transform 缩放、适配、resize 等
+ */
+import { type Ref } from 'vue';
+import type { Canvas } from 'fabric';
+export interface CanvasViewportOptions {
+    getCanvas: () => Canvas | null;
+    canvasWrap: Ref<HTMLElement | null>;
+    refreshGuideResources?: () => void;
+    /** 视口矩阵提交后调用（缩放/平移）；勿在此做全量引导重载，fitCanvas 末尾仍会调 refreshGuideResources */
+    onViewportCommitted?: () => void;
+    /** 返回当前 PSD 画布尺寸，用于 contain-fit 映射实现对象与蒙版同步缩放 */
+    getGuidelinePsdSize?: () => {
+        width: number;
+        height: number;
+    } | null;
+    /** SPLIT 当前分片蒙版在指定逻辑画布尺寸下的图稿矩形；优先用于与遮罩完全同源缩放 */
+    getSplitPieceMaskRect?: (canvasWidth: number, canvasHeight: number) => {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    } | null;
+    /** 当前模板模式；Classic（SPLIT）下 fitCanvas 固定为工具栏显示 100% 的内部 zoom */
+    getSelectedMode?: () => string;
+}
+/** 主画布视口缩放百分比范围（工具栏 / 滚轮 / fitCanvas 共用） */
+export declare const CANVAS_VIEWPORT_ZOOM_MIN = 10;
+export declare const CANVAS_VIEWPORT_ZOOM_MAX = 400;
+/**
+ * 实际视口缩放 = (界面 zoom% / 100) × 该系数。
+ * 界面默认显示 100% 时，内容相对旧版「100%=满基准」为 0.8。
+ */
+export declare const CANVAS_VIEWPORT_INITIAL_ZOOM_RATIO = 0.8;
+/** Classic 默认内部 zoom（工具栏展示为 100%） */
+export declare const CLASSIC_DEFAULT_INTERNAL_ZOOM: number;
+/**
+ * 工具栏展示的缩放百分比（仅 UI）。
+ * Classic（SPLIT）：内部 zoom 经 INITIAL_ZOOM_RATIO 后再 fit 时常为 80，对用户显示为 100。
+ * Zone（COMPLETE）及其它：与内部 zoom 一致。
+ */
+export declare function toToolbarZoomPercent(zoom: number, selectedMode: string): number;
+/** 画布逻辑高度（逻辑像素固定）；宽度在 resizeCanvasLogicalToWrap 中按与展示框相同的宽高比计算 */
+export declare const CANVAS_LOGICAL_HEIGHT = 1600;
+/**
+ * 逻辑画布尺寸：高度固定为 CANVAS_LOGICAL_HEIGHT，宽度 = CANVAS_LOGICAL_HEIGHT × (展示宽 / 展示高)，
+ * 展示宽高与 resizeCanvasCssToWrap 一致（容器 client 尺寸 capped），避免位图与 CSS 框宽高比不一致导致非等比变形。
+ */
+export declare function computeLogicalCanvasSizeFromWrapClientSize(ww: number, wh: number): {
+    width: number;
+    height: number;
+};
+/** Classic = SPLIT，Zone = COMPLETE */
+export type EditorTemplateViewportMode = 'SPLIT' | 'COMPLETE';
+export declare function useCanvasViewport(options: CanvasViewportOptions): {
+    zoom: Ref<number, number>;
+    getCanvasSize: () => {
+        width: number;
+        height: number;
+    };
+    resizeCanvasCssToWrap: () => void;
+    resizeCanvasLogicalToWrap: () => boolean;
+    commitViewportTransform: () => void;
+    applyPanDelta: (dx: number, dy: number) => void;
+    resetViewportPan: () => void;
+    applyViewportZoom: (value: number) => void;
+    setZoom: (value: number) => void;
+    zoomIn: () => void;
+    zoomOut: () => void;
+    fitCanvas: () => void;
+    handleWrapResize: () => void;
+    refreshGuideResourcesCentered: () => void;
+    setupWindowResize: () => void;
+    removeWindowResize: () => void;
+    focusSceneRect: (rect: {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+    }, paddingVp?: number, options?: {
+        lockZoom?: boolean;
+    }) => void;
+    focusViewportOnFabricObject: (obj: any, paddingVp?: number) => void;
+    initTemplateViewportMode: (mode: string) => void;
+    switchTemplateViewportMode: (mode: string) => void;
+    resetTemplateViewportByMode: () => void;
+    applyClassicDefaultToolbarZoom: () => void;
+};

package/dist/components/Editor/composables/useClearCanvas.d.ts

@@ -0,0 +1,32 @@
+import type { Ref } from 'vue';
+export interface UseClearCanvasOptions {
+    getCanvas: () => any;
+    syncLayers: () => void;
+    syncImageToolState: (active?: any, autoSwitchTab?: boolean) => void;
+    syncLayerToolState: (active?: any) => void;
+    syncTextToolState: (active?: any, autoSwitchTab?: boolean) => void;
+    queuePreviewUpdate: (reason: string) => void;
+    /** 当前模板模式（例如 COMPLETE / SPLIT），可选传入 */
+    getSelectedMode?: () => string | null;
+    /** 清空所有分片状态（多片模式下一起清） */
+    clearAllDiecutStates?: () => void;
+    /** 多片模式下刷新所有分片预览（可选） */
+    refreshAllDiecutPreviews?: () => void | Promise<void>;
+    /** 单片模式下立即刷新预览（可选，不依赖 queue 延迟） */
+    refreshPreviewImmediate?: () => void | Promise<void>;
+    /** 清空所有分片相关缓存（状态、截图、预览大图等） */
+    clearAllSplitCaches?: () => void;
+    /** 判断当前操作是否有可清空内容；SPLIT 下可包含其他分片的已保存状态 */
+    hasClearableContent?: () => boolean;
+    /** 画布上无可清空元素时调用（不打开确认弹窗） */
+    onNoContentToClear?: () => void;
+    /** 清空完成后调用，用于记录历史栈等收尾 */
+    onAfterClear?: () => void | Promise<void>;
+}
+export declare function useClearCanvas(options: UseClearCanvasOptions): {
+    showClearConfirm: Ref<boolean, boolean>;
+    doClearCanvas: () => Promise<void>;
+    clearCanvas: () => void;
+    confirmClearCanvas: () => Promise<void>;
+    cancelClearCanvas: () => void;
+};

package/dist/components/Editor/composables/useCompleteScreenshot.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 单片模式（COMPLETE）：fabricScreenshotList
+ * SPLIT 每片小 MASK + 可选 DOTTED_LINE，按 Guideline bounds 从主画布位图裁切并行生成。
+ */
+import { Canvas } from 'fabric';
+import type { IFabricScreenshot } from '../../../utils/renderService';
+import { type FabricMainCanvasSnapshotOptions } from '../utils/fabricMainCanvasSnapshot';
+type ZoneScreenshotBuildOptions = {
+    forceFreshBase?: boolean;
+    /** quick 构建时仅处理这些分片 id（拖动态只更新 armed 分片） */
+    onlyZoneIds?: Array<string | number>;
+};
+/** 调试：打印 fabricScreenshotList 各条 url 与构建耗时（ms） */
+export declare function logFabricScreenshotListDebug(source: string, list: IFabricScreenshot[], startedAt: number): void;
+export declare function useCompleteScreenshot(options: {
+    getCanvas: () => Canvas | null;
+    toProxyUrl: (url: string) => string;
+    loadImage: (url: string) => Promise<HTMLImageElement>;
+    guideResourceRole?: string;
+    /** 编辑区域宽度，用作合成图基准尺寸；未传时回退 660 */
+    getEditorAreaWidth?: () => number;
+    /** 当前选中尺码，多尺码时用于取对应 COMPLETE 的 groupId，使 fabricScreenshotList id 与 psdJson 一致 */
+    getSelectedSize?: () => string;
+    /** 用户拖动分片后内存中的 Guideline；有则不再 fetch SPLIT 的 jsonURL */
+    getCachedSplitGuidelineJson?: (templateJsonUrl: string) => Record<string, unknown> | null | undefined;
+    /** Zone 模式下分片实时位置与对应 MASK，优先用它生成 fabricScreenshotList（对齐 dev-29-new） */
+    getZonesForScreenshot?: () => Array<{
+        id: number;
+        name?: string;
+        placed: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskUrl: string;
+    }>;
+}): {
+    buildCompleteFabricScreenshotList: (diecutData: any, selectedSize?: string, baseBlob?: Blob | null) => Promise<IFabricScreenshot[]>;
+    getCanvasBaseScreenshot: (snapshotOpts?: FabricMainCanvasSnapshotOptions) => Promise<Blob | null>;
+    buildZoneFabricScreenshotList: (zones: Array<{
+        id: number;
+        name?: string;
+        placed: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskUrl: string;
+    }>, baseBlob?: Blob | null) => Promise<IFabricScreenshot[]>;
+    buildZoneFabricScreenshotListQuick: (zones: Array<{
+        id: number;
+        name?: string;
+        placed: {
+            left: number;
+            top: number;
+            width: number;
+            height: number;
+        };
+        maskUrl: string;
+    }>, buildOptions?: ZoneScreenshotBuildOptions) => Promise<IFabricScreenshot[]>;
+    prewarmZoneQuickBaseScreenshot: (target?: any) => Promise<void>;
+    endZoneQuickDragPreview: () => void;
+    clearZoneScreenshotCache: () => void;
+    disposeZoneScreenshotWorker: () => void;
+};
+export {};

package/dist/components/Editor/composables/useCopyToDiecuts.d.ts

@@ -0,0 +1,56 @@
+/**
+ * 复制当前画布内容到其他刀板（Worker 或降级克隆）
+ * 支持「跨尺码」复制：目标用 { id, size } 标识，按复合键 `${id}::${size}` 写入状态 Map。
+ * 几何换算只依赖「当前画布尺寸（各尺码一致，视口决定）+ 目标分片在目标尺码下的遮罩尺寸」，
+ * 因此为其他尺码计算出的坐标在切到该尺码时按 mask-anchored 恢复为恒等映射（不会二次缩放）。
+ */
+import type { Ref } from 'vue';
+/** 复制目标：分片 id + 状态键尺码维度（SIZE_SPECIFIC 为 S/M/L；COMMON 为 ''） */
+export interface CopyTarget {
+    id: string;
+    size: string;
+}
+export interface UseCopyToDiecutsOptions {
+    getCanvas: () => any;
+    selectedDiecutId: Ref<string>;
+    /** 当前状态键尺码（stateSizeKey()：SIZE_SPECIFIC=当前尺码 / COMMON=''） */
+    selectedSize: Ref<string>;
+    objectIndex: Ref<number>;
+    incrementObjectIndex: () => void;
+    copyToDiecutsInWorker: (payload: {
+        sourceObjects: any[];
+        targetJsonMap: Record<string, any>;
+        objectIndex: number;
+        targetScaleMap?: Record<string, number>;
+        sourceCenter?: {
+            x: number;
+            y: number;
+        };
+        targetCenterMap?: Record<string, {
+            x: number;
+            y: number;
+        }>;
+        canvasCenter?: {
+            x: number;
+            y: number;
+        };
+    }) => Promise<{
+        updates?: Record<string, any>;
+        nextObjectIndex?: number;
+    } | void>;
+    notifyObjectModified: () => void;
+    queuePreviewUpdate: (reason: string) => void;
+    isCopyableJsonObject: (obj: any) => boolean;
+    /** 取分片遮罩尺寸；size 为空/不传则用当前尺码（与截图管线一致） */
+    getDiecutDimensions: (diecutId: string, size?: string) => {
+        width: number;
+        height: number;
+    } | null;
+    /** 读取「指定尺码」下分片的现有状态（复合键 `${id}::${size}`，不回退当前尺码） */
+    getStateForSize: (diecutId: string, size: string) => any;
+    /** 批量写入状态：键为复合键 `${id}::${size}`，原样写入不再追加尺码 */
+    setStates: (updates: Record<string, any>) => void;
+}
+export declare function useCopyToDiecuts(options: UseCopyToDiecutsOptions): {
+    copyToDiecuts: (targets?: CopyTarget[]) => Promise<void>;
+};

package/dist/components/Editor/composables/useDiecutManager.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 刀板管理 Composable
+ * 负责刀板数据、切换、状态保存和恢复
+ */
+import { type Ref } from 'vue';
+import type { DiecutResponse } from '../../../types';
+export interface DiecutResource {
+    groupId?: string;
+    groupName?: string;
+    url?: string;
+    type?: string;
+    width?: number;
+    height?: number;
+}
+export interface DiecutGroup {
+    id: string;
+    name: string;
+    mask: DiecutResource | null;
+    dotted: DiecutResource | null;
+    resources: DiecutResource[];
+}
+export interface DiecutOption {
+    id: string;
+    name: string;
+    url: string;
+}
+export declare function useDiecutManager(effectiveDiecutData: () => DiecutResponse | null, 
+/** 与 buildMaskGroups 一致：当前尺码（可复选）下的 SPLIT */
+getSelectedSize?: () => string | string[]): {
+    selectedDiecutId: Ref<string, string>;
+    diecutResourceMap: import("vue").ComputedRef<Map<string, DiecutGroup>>;
+    diecutOptions: import("vue").ComputedRef<{
+        id: string;
+        name: string;
+        url: string;
+    }[]>;
+    selectedDiecut: import("vue").ComputedRef<DiecutGroup | null>;
+    getDiecutResources: (diecutId: string) => DiecutResource[];
+    getDiecutMask: (diecutId: string) => DiecutResource | null;
+    saveDiecutState: (diecutId: string, state: unknown) => void;
+    getDiecutState: (diecutId: string) => unknown | null;
+    clearDiecutState: (diecutId: string) => void;
+    clearAllDiecutStates: () => void;
+    getAllDiecutStates: () => Record<string, unknown>;
+    isGuideResource: (resource: any) => boolean;
+};

package/dist/components/Editor/composables/useDiecutScreenshot.d.ts

@@ -0,0 +1,50 @@
+/**
+ * 刀板遮罩截图 Composable
+ * 负责生成每个刀板的遮罩截图，并提供 URL 查询与资源释放
+ */
+import { Canvas } from 'fabric';
+import type { DiecutResource } from './useDiecutManager';
+import { type FabricMainCanvasSnapshotOptions } from '../utils/fabricMainCanvasSnapshot';
+type MaskGroup = {
+    id: string;
+    name: string;
+    mask?: DiecutResource | null;
+};
+export type RenderMaskInWorker = (payload: {
+    baseBlob: Blob;
+    maskBlob: Blob;
+    maskWidth: number;
+    maskHeight: number;
+    left: number;
+    top: number;
+    canvasWidth: number;
+    canvasHeight: number;
+}) => Promise<Blob | null>;
+export type TryBuildZoneInverseMaskBlobs = (ctx: {
+    baseBlob: Blob;
+    snapshotOpts?: FabricMainCanvasSnapshotOptions;
+    diecutIds?: string[];
+}) => Promise<Map<string, Blob> | null>;
+export declare function useDiecutScreenshot(options: {
+    getCanvas: () => Canvas | null;
+    buildMaskGroups: () => MaskGroup[];
+    loadImage: (url: string) => Promise<HTMLImageElement>;
+    renderMaskInWorker?: RenderMaskInWorker;
+    guideResourceRole?: string;
+    /** 当前尺码：使设计截图缓存按 groupId+尺码 分桶，避免不同尺码（含复制到其他分片后）共用 groupId 互相覆盖 */
+    getSelectedSize?: () => string;
+    /**
+     * SPLIT + Zone 管线：用与预览相同的分片裁切生成各 groupId 的 inverse mask Blob；
+     * 返回 null 或缺某 id 时回退居中 mask 方案。
+     */
+    tryBuildZoneInverseMaskBlobs?: TryBuildZoneInverseMaskBlobs;
+}): {
+    generateDiecutScreenshot: (diecutId: string, snapshotOpts?: FabricMainCanvasSnapshotOptions, precapturedBaseBlob?: Blob | null) => Promise<void>;
+    generateDiecutScreenshotsForIds: (diecutIds: string[]) => Promise<void>;
+    getInverseMaskUrl: (groupId: string) => string;
+    getInverseMaskBlob: (groupId: string) => Blob | undefined;
+    getInverseMaskVersion: (groupId: string) => number;
+    clearCache: () => void;
+    dispose: () => void;
+};
+export {};

package/dist/components/Editor/composables/useDownloadPng.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 将当前画布导出为 PNG 并触发下载
+ */
+export interface UseDownloadPngOptions {
+    getCanvas: () => any;
+    canvasToBlob: (el: HTMLCanvasElement, type: string) => Promise<Blob>;
+    filename?: string;
+}
+export declare function useDownloadPng(options: UseDownloadPngOptions): {
+    downloadPng: () => Promise<void>;
+};

package/dist/components/Editor/composables/useEditorReset.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 产品切换时重置画布与选中状态
+ */
+import type { Ref } from 'vue';
+export interface UseEditorResetOptions {
+    getCanvas: () => any;
+    resetForProductChange: () => void;
+    clearAllDiecutStates: () => void;
+    resetCanvasForTemplate: () => void;
+    syncLayers: () => void;
+    syncImageToolState: (active?: any, autoSwitchTab?: boolean) => void;
+    syncLayerToolState: (active?: any) => void;
+    syncTextToolState: (active?: any, autoSwitchTab?: boolean) => void;
+    previewRenderData: Ref<any>;
+    selectedDiecutId: Ref<string>;
+    selectedTemplateIndex: Ref<number>;
+    previewTemplateIndex: Ref<number>;
+}
+export declare function useEditorReset(options: UseEditorResetOptions): {
+    doResetForProduct: () => void;
+};