@overtone-art/canvas-editor-core 0.6.4 → 0.8.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { Canvas, FabricObject, Point, ImageFormat, Group } from 'fabric';
-import { b as EditorEvents, o as LayerType, m as LayerMeta, L as LayerData, X as SerializedLayer, P as PatternConfig, K as PatternLocks, a1 as TextCurveConfig, a2 as TextCurveInput, t as MaskPresetId, Y as ShapeMaskPresetId, a4 as TextureMaskPresetId, a6 as Unit, J as MockupPrintArea, z as MockupConfig, e as FontDefinition, p as LicenseConfig, r as LicenseStatus, T as ProjectState, M as MaskBrushOptions, s as MaskPoint, v as MaskRefinementProvider, u as MaskRefinementPrompt, x as MaskRefinementResult, k as LayerMaskEntry, l as LayerMaskMode, E as EditorConfig, Z as ShapePlugin, $ as TemplateDefinition, I as ImageAdjustments, c as EditorState, V as SemanticExportOptions, _ as SvgExportOptions, R as PrintifyPositioning, N as NormalizedLayerPosition, Q as PositioningAdapter, h as ImageProviderResult, i as ImageSearchOptions, j as ImageSearchResult, F as FileAdapter, g as ImageProvider, W as SerializedBackgroundImageOptions, B as BackgroundImageOptions, U as ResizeOptions, a as DpiIssue, n as LayerShadowConfig, C as CanvasSizePreset, A as MockupDisplacement } from './types-DSu2jbiV.js';
-export { D as DEFAULT_PATTERN_CONFIG, d as ExportFormat, f as ImageAttribution, q as LicensePayload, w as MaskRefinementRequest, y as MockupBlendMode, G as MockupDisplacementChannel, H as MockupOverlay, O as PatternState, S as ProjectPage, a0 as TemplateParameter, a3 as TextCurveShape, a5 as TileMode } from './types-DSu2jbiV.js';
+import { Canvas, FabricObject, Point, ImageFormat, Group, Gradient } from 'fabric';
+import { e as EditorEvents, r as LayerType, p as LayerMeta, L as LayerData, _ as SerializedLayer, Q as PatternConfig, R as PatternLocks, a4 as TextCurveConfig, a5 as TextCurveInput, a8 as TextWrapMode, a7 as TextOverflow, w as MaskPresetId, $ as ShapeMaskPresetId, a9 as TextureMaskPresetId, ab as Unit, O as MockupPrintArea, H as MockupConfig, h as FontDefinition, s as LicenseConfig, u as LicenseStatus, W as ProjectState, M as MaskBrushOptions, v as MaskPoint, y as MaskRefinementProvider, x as MaskRefinementPrompt, A as MaskRefinementResult, n as LayerMaskEntry, o as LayerMaskMode, E as EditorConfig, a0 as ShapePlugin, c as BlendMode, a2 as TemplateDefinition, I as ImageAdjustments, f as EditorState, Y as SemanticExportOptions, a1 as SvgExportOptions, U as PrintifyPositioning, P as NormalizedLayerPosition, T as PositioningAdapter, k as ImageProviderResult, l as ImageSearchOptions, m as ImageSearchResult, F as FileAdapter, j as ImageProvider, Z as SerializedBackgroundImageOptions, b as BackgroundImageOptions, X as ResizeOptions, d as DpiIssue, q as LayerShadowConfig, C as CanvasSizePreset, J as MockupDisplacement } from './types-DmintAiu.js';
+export { B as BLEND_GROUPS, a as BLEND_MODES, D as DEFAULT_PATTERN_CONFIG, g as ExportFormat, i as ImageAttribution, t as LicensePayload, z as MaskRefinementRequest, G as MockupBlendMode, K as MockupDisplacementChannel, N as MockupOverlay, S as PatternState, V as ProjectPage, a3 as TemplateParameter, a6 as TextCurveShape, aa as TileMode, ac as blendModeLabel, ad as blendModeOf, ae as blendOperation } from './types-DmintAiu.js';
 
 type EventHandler<T> = (data: T) => void;
 declare class EventEmitter<TEvents extends {} = Record<string, unknown>> {
@@ -594,6 +594,80 @@ declare class TextCurveManager {
     private detach;
 }
 
+/** Both properties as they apply to a layer, defaults filled in. */
+interface TextWrapState {
+    wrap: TextWrapMode;
+    overflow: TextOverflow;
+}
+declare function readTextWrap(meta: LayerMeta | undefined): TextWrapState;
+/** Builds the clip rect. A parameter because a Node renderer's `Rect` (from
+ * `fabric/node`) and the browser's `Rect` (from `fabric`) are different
+ * classes — a clip built by one does not render on the other's canvas. */
+type RectFactory = (options: Record<string, unknown>) => FabricObject;
+/**
+ * The renderer-agnostic half of {@link TextWrapManager.derive}: the fabric
+ * state a wrap mode implies once the box's width is already settled.
+ *
+ * Deliberately does NOT touch width — re-fitting here would let a Node
+ * renderer, which sees only the serialized state and never `meta.wrapWidth`,
+ * shift a box the browser already fitted at authoring time. Width is the
+ * manager's job (`fitTextWidth` for `'none'`, `meta.wrapWidth` restore for
+ * everything else); this only sets the levers fabric does not serialize on
+ * its own (`wordSplit`) or that depend on the box the manager just settled
+ * (the clip). Call it AFTER any width decision, never before — the clip below
+ * is sized to `text.width`/`text.height` as they stand when this runs.
+ */
+declare function applyTextWrapToObject(object: FabricObject, meta: LayerMeta | undefined, makeRect?: RectFactory): void;
+/**
+ * How a text layer breaks its lines, and whether it paints past its box.
+ *
+ * `meta` is the authoring record; what actually renders — and what a print
+ * pipeline that never reads `meta` sees — is the fabric state derived here:
+ * `width`, `splitByGrapheme` and `clipPath`, all of which fabric serializes on
+ * its own. That is the same division `TextCurveManager` draws between
+ * `meta.curve` and the `path` it installs.
+ */
+declare class TextWrapManager {
+    private canvas;
+    private layers;
+    private history;
+    private events;
+    /**
+     * Typing changes the run the box was fitted to, so an auto-width layer has to
+     * re-fit. No history entry: fabric records the edit when editing exits, and a
+     * save per keystroke would bury every earlier step.
+     */
+    private readonly onTextChanged;
+    /**
+     * Both mask owners — the preset manager and every mask-stack mutation —
+     * install their clip straight onto `clipPath`, dropping whatever was there,
+     * and neither knows this layer had a box clip. Re-deriving on the one event
+     * they both announce puts it back where it now belongs: nested under the new
+     * mask, or at the top level when the last mask leaves. Waiting for the next
+     * keystroke instead would leave a layer that should clip inside its box
+     * serialized unclipped — which is what the print renderer reads.
+     */
+    private readonly onMasksChanged;
+    constructor(canvas: Canvas, layers: LayerManager, history: HistoryManager, events: EventEmitter<EditorEvents>);
+    dispose(): void;
+    /** Both properties for a text layer, or null when it is not text. */
+    get(layerId: string): TextWrapState | null;
+    apply(layerId: string, wrap: TextWrapMode, save?: boolean): boolean;
+    setOverflow(layerId: string, overflow: TextOverflow, save?: boolean): boolean;
+    /** Back to the defaults: auto-width, unclipped. */
+    clear(layerId: string, save?: boolean): boolean;
+    /** Re-derive from the stored mode — after a text, font or size change. */
+    refresh(layerId: string, save?: boolean): boolean;
+    /**
+     * Re-derive every text layer — used after a state restore.
+     *
+     * Recursive because a template inserts as a group of real child layers, and
+     * text inside one would otherwise keep whatever box it was restored with.
+     */
+    refreshAll(): void;
+    private derive;
+}
+
 declare function isMaskPresetId(value: unknown): value is MaskPresetId;
 /**
  * Clips a layer to a preset silhouette or soft texture.
@@ -892,6 +966,22 @@ declare abstract class MaskStackStore {
     protected host(target: string, create?: boolean): FabricObject | null;
     /** Re-pin the design overlay, guarding the reorder that re-triggers this. */
     protected pin(): void;
+    /**
+     * Is the host's own `clipPath` the wrap manager's box clip rather than a mask?
+     *
+     * Adoption rescues a clip whose provenance is UNKNOWN — a mask preset, or a
+     * hand-set `clipPath` from before stacks existed — so the first add() cannot
+     * silently throw it away. A text layer's box clip is the opposite case: its
+     * provenance is known exactly (the wrap manager derives it from
+     * `meta.overflow` on every pass and re-installs it under whatever owns the
+     * property next), and it is not a mask. Adopted, it becomes a stack row the
+     * user never made whose 'add' union covers the whole box — swallowing the mask
+     * they actually added.
+     *
+     * Only meaningful with an empty stack: once there are entries the top-level
+     * clip is the composed group and the box clip is nested underneath it.
+     */
+    protected holdsBoxClip(meta: LayerMeta | undefined): boolean;
     /**
      * Take the current geometry back out of the composed clip, entry-aligned.
      *
@@ -1068,6 +1158,71 @@ declare function fitToBox(object: FabricObject, box: {
  */
 declare function unwrapGroup(group: Group): FabricObject[];
 
+type GradientKind = 'linear' | 'radial';
+interface GradientStop {
+    /** `#rrggbb`. Alpha lives in `opacity`, so a colour input stays a colour input. */
+    color: string;
+    /** 0…1. */
+    opacity: number;
+    /** 0…1 along the gradient line. */
+    position: number;
+}
+interface GradientConfig {
+    kind: GradientKind;
+    /** Degrees, CSS convention: 0 paints towards the top, 90 towards the right. Linear only. */
+    angle: number;
+    /** 0…1 of the layer box. Radial only. */
+    center: {
+        x: number;
+        y: number;
+    };
+    /** 0…1 of the layer box. An ellipse, because percentage units follow the box. Radial only. */
+    radius: number;
+    /** At least two, ascending by position. */
+    stops: GradientStop[];
+}
+/** The layer's UNSCALED box — the space fabric paints a percentage filler in. */
+interface GradientBox {
+    width: number;
+    height: number;
+}
+declare const DEFAULT_GRADIENT_CONFIG: GradientConfig;
+/**
+ * Endpoints of the gradient line, in percentage space.
+ *
+ * fabric paints a percentage filler through `ctx.transform(width, 0, 0, height, …)`
+ * (`_applyPatternGradientTransform`), so the space is the unit box under a
+ * NON-UNIFORM scale — not a rotation. Drawing the line naively there would put
+ * the gradient's iso-lines at some angle other than the one asked for. These
+ * endpoints are solved the other way round: `v` is the direction whose iso-lines
+ * land perpendicular to `angle` in the box, and `length` is the CSS gradient-line
+ * length, which is what makes the run cover the box corners at every angle.
+ *
+ * A consequence, and the reason the test asserts it: at angles that are not
+ * axis-aligned in a non-square box the endpoints sit OUTSIDE 0…1. Clamping them
+ * would shorten the run and bunch the stops.
+ */
+declare function linearCoords(angle: number, box: GradientBox): {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+};
+/** Inverse of {@link linearCoords}. */
+declare function angleFromCoords(coords: {
+    x1: number;
+    y1: number;
+    x2: number;
+    y2: number;
+}, box: GradientBox): number;
+declare function toFabricGradient(config: GradientConfig, box: GradientBox): Gradient<'linear'> | Gradient<'radial'>;
+/**
+ * The config an object's gradient fill was built from, or null when the fill is
+ * flat. This is the ONLY reader: `fill` is the single source of truth, so a
+ * panel never has to be told what it is already looking at.
+ */
+declare function readGradientConfig(object: FabricObject): GradientConfig | null;
+
 declare class CanvasEditor {
     readonly canvas: Canvas;
     readonly layers: LayerManager;
@@ -1078,6 +1233,7 @@ declare class CanvasEditor {
     readonly crop: CropController;
     readonly patterns: PatternManager;
     readonly curves: TextCurveManager;
+    readonly wrap: TextWrapManager;
     readonly maskPresets: MaskPresetManager;
     /** Stacked boolean masks, per layer and for the design as a whole. */
     readonly layerMasks: LayerMaskManager;
@@ -1099,6 +1255,23 @@ declare class CanvasEditor {
     replaceImageSource(layerId: string, url: string): Promise<Layer>;
     addText(text: string, options?: Partial<Record<string, unknown>>): Layer;
     addShape(plugin: ShapePlugin, options?: Record<string, unknown>): Layer;
+    /**
+     * Insert a gradient layer. It is an ordinary `Rect` with a gradient fill —
+     * which is exactly why the Node print compositor needs no code for it.
+     */
+    addGradient(config?: GradientConfig, box?: {
+        left?: number;
+        top?: number;
+        width: number;
+        height: number;
+    }): Layer;
+    /**
+     * Repaint a layer's gradient. `save: false` while a slider is being dragged —
+     * the settled value is the one worth an undo step.
+     */
+    setGradient(layerId: string, config: GradientConfig, save?: boolean): void;
+    /** Set a layer's blend mode. Applied to the render proxy too, like opacity. */
+    setBlend(layerId: string, mode: BlendMode): void;
     addTemplate(template: TemplateDefinition, params: Record<string, string | number>): Promise<Layer>;
     removeLayer(id: string): void;
     selectLayer(id: string | null): void;
@@ -1191,6 +1364,9 @@ declare class CanvasEditor {
     applyTextCurve(layerId: string, config: Partial<TextCurveConfig>): boolean;
     clearTextCurve(layerId: string): boolean;
     getTextCurve(layerId: string): TextCurveConfig | null;
+    applyTextWrap(layerId: string, wrap: TextWrapMode): boolean;
+    setTextOverflow(layerId: string, overflow: TextOverflow): boolean;
+    getTextWrap(layerId: string): TextWrapState | null;
     applyMaskPreset(layerId: string, id: MaskPresetId | null): boolean;
     clearMaskPreset(layerId: string): boolean;
     getMaskPreset(layerId: string): MaskPresetId | null;
@@ -1250,6 +1426,8 @@ declare class CanvasEditor {
  */
 declare function fitTextWidth(object: FabricObject | null | undefined): boolean;
 
+declare function preWrapWordSplit(value: string): string[];
+
 /**
  * A template is a bootstrap, not a frozen picture: it is taken apart into the
  * layers it is drawn from, so every run of copy stays editable afterwards.
@@ -1406,4 +1584,4 @@ declare class AnnotationOverlay {
  */
 declare function displaceRgba(source: Uint8ClampedArray, map: Uint8ClampedArray, width: number, height: number, options: Omit<MockupDisplacement, 'image'>): Uint8ClampedArray;
 
-export { type AddMaskOptions, AnnotationOverlay, type AnnotationPrimitive, BackgroundImageOptions, CANVAS_MASK_TARGET, CANVAS_SIZE_PRESETS, CanvasEditor, type CanvasRenderingProtocol, CanvasSizePreset, type CoverPlacement, CropController, type CurvePath, DEFAULT_LAYER_SHADOW, DEFAULT_SELECTION_STYLE, DEFAULT_TEXT_CURVE, DpiIssue, EditorConfig, EditorEvents, EditorState, EventEmitter, FileAdapter, FontDefinition, FontRegistry, HistoryManager, ImageAdjustments, ImageProvider, ImageProviderResult, ImageSearchOptions, ImageSearchResult, Layer, LayerData, LayerManager, LayerMaskEntry, LayerMaskManager, LayerMaskMode, LayerMeta, LayerShadowConfig, LayerType, LicenseConfig, LicenseManager, LicenseStatus, MaskBrushOptions, MaskController, type MaskPerformanceSample, MaskPoint, MaskPresetId, MaskPresetManager, MaskRefinementError, type MaskRefinementErrorCode, MaskRefinementPrompt, MaskRefinementProvider, MaskRefinementResult, MockupConfig, MockupDisplacement, MockupPrintArea, NormalizedLayerPosition, PatternConfig, PatternLocks, PatternManager, type PatternOrigin, type PngExportOptions, PositioningAdapter, PrintifyPositioning, ProjectManager, ProjectState, ResizeOptions, SHAPE_MASK_BOX, SHAPE_MASK_IDS, type SelectionStyle, SemanticExportOptions, SerializedBackgroundImageOptions, SerializedLayer, ShapeMaskPresetId, ShapePlugin, SnapManager, SvgExportOptions, TEXTURE_MASK_IDS, TEXTURE_MASK_SIZE, TemplateDefinition, type TemplateLayerSpec, TextCurveConfig, TextCurveInput, TextCurveManager, TextureMaskPresetId, type TileDrawSize, type TilePlacement, TiledPatternObject, Unit, UnitConverter, type ViewportTransform, applyAspectLock, applyLayerShadow, applyObjectSelectionStyle, applySelectionStyle, buildCurveLinePaths, buildCurvePathData, clamp, clearTextureMaskCache, composeMaskGroup, computeCoverPlacement, computePrintAreaClip, computeTilePositions, deserializeEditor, displaceRgba, drawTiles, escapeXml, explodeTemplateSvg, exportDataURL, exportMockup, exportPNG, exportPrintArea, exportSVG, fitTextWidth, fitToBox, generateId, isCssColor, isMaskPresetId, isShapeMaskId, isTextureMaskId, needsAbsoluteSpace, normalizeTextCurve, readLayerShadow, renderTextureMask, resetTransform, restoreLocks, round2, sanitizeSvg, serializeEditor, shapeMaskPathData, textPathCurve, textPathSpec, toCanvasSpace, toHostSpace, unwrapGroup };
+export { type AddMaskOptions, AnnotationOverlay, type AnnotationPrimitive, BackgroundImageOptions, BlendMode, CANVAS_MASK_TARGET, CANVAS_SIZE_PRESETS, CanvasEditor, type CanvasRenderingProtocol, CanvasSizePreset, type CoverPlacement, CropController, type CurvePath, DEFAULT_GRADIENT_CONFIG, DEFAULT_LAYER_SHADOW, DEFAULT_SELECTION_STYLE, DEFAULT_TEXT_CURVE, DpiIssue, EditorConfig, EditorEvents, EditorState, EventEmitter, FileAdapter, FontDefinition, FontRegistry, type GradientBox, type GradientConfig, type GradientKind, type GradientStop, HistoryManager, ImageAdjustments, ImageProvider, ImageProviderResult, ImageSearchOptions, ImageSearchResult, Layer, LayerData, LayerManager, LayerMaskEntry, LayerMaskManager, LayerMaskMode, LayerMeta, LayerShadowConfig, LayerType, LicenseConfig, LicenseManager, LicenseStatus, MaskBrushOptions, MaskController, type MaskPerformanceSample, MaskPoint, MaskPresetId, MaskPresetManager, MaskRefinementError, type MaskRefinementErrorCode, MaskRefinementPrompt, MaskRefinementProvider, MaskRefinementResult, MockupConfig, MockupDisplacement, MockupPrintArea, NormalizedLayerPosition, PatternConfig, PatternLocks, PatternManager, type PatternOrigin, type PngExportOptions, PositioningAdapter, PrintifyPositioning, ProjectManager, ProjectState, ResizeOptions, SHAPE_MASK_BOX, SHAPE_MASK_IDS, type SelectionStyle, SemanticExportOptions, SerializedBackgroundImageOptions, SerializedLayer, ShapeMaskPresetId, ShapePlugin, SnapManager, SvgExportOptions, TEXTURE_MASK_IDS, TEXTURE_MASK_SIZE, TemplateDefinition, type TemplateLayerSpec, TextCurveConfig, TextCurveInput, TextCurveManager, TextOverflow, TextWrapManager, TextWrapMode, type TextWrapState, TextureMaskPresetId, type TileDrawSize, type TilePlacement, TiledPatternObject, Unit, UnitConverter, type ViewportTransform, angleFromCoords, applyAspectLock, applyLayerShadow, applyObjectSelectionStyle, applySelectionStyle, applyTextWrapToObject, buildCurveLinePaths, buildCurvePathData, clamp, clearTextureMaskCache, composeMaskGroup, computeCoverPlacement, computePrintAreaClip, computeTilePositions, deserializeEditor, displaceRgba, drawTiles, escapeXml, explodeTemplateSvg, exportDataURL, exportMockup, exportPNG, exportPrintArea, exportSVG, fitTextWidth, fitToBox, generateId, isCssColor, isMaskPresetId, isShapeMaskId, isTextureMaskId, linearCoords, needsAbsoluteSpace, normalizeTextCurve, preWrapWordSplit, readGradientConfig, readLayerShadow, readTextWrap, renderTextureMask, resetTransform, restoreLocks, round2, sanitizeSvg, serializeEditor, shapeMaskPathData, textPathCurve, textPathSpec, toCanvasSpace, toFabricGradient, toHostSpace, unwrapGroup };