fabric 5.3.0 → 6.0.0-beta1

package/dist/src/Point.d.ts

@@ -0,0 +1,232 @@
+import { TMat2D, TRadian } from './typedefs';
+export interface IPoint {
+    x: number;
+    y: number;
+}
+/**
+ * Adaptation of work of Kevin Lindsey(kevin@kevlindev.com)
+ */
+export declare class Point implements IPoint {
+    x: number;
+    y: number;
+    constructor();
+    constructor(x: number, y: number);
+    constructor(point: IPoint);
+    /**
+     * Adds another point to this one and returns another one
+     * @param {IPoint} that
+     * @return {Point} new Point instance with added values
+     */
+    add(that: IPoint): Point;
+    /**
+     * Adds another point to this one
+     * @param {IPoint} that
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    addEquals(that: IPoint): Point;
+    /**
+     * Adds value to this point and returns a new one
+     * @param {Number} scalar
+     * @return {Point} new Point with added value
+     */
+    scalarAdd(scalar: number): Point;
+    /**
+     * Adds value to this point
+     * @param {Number} scalar
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    scalarAddEquals(scalar: number): Point;
+    /**
+     * Subtracts another point from this point and returns a new one
+     * @param {IPoint} that
+     * @return {Point} new Point object with subtracted values
+     */
+    subtract(that: IPoint): Point;
+    /**
+     * Subtracts another point from this point
+     * @param {IPoint} that
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    subtractEquals(that: IPoint): Point;
+    /**
+     * Subtracts value from this point and returns a new one
+     * @param {Number} scalar
+     * @return {Point}
+     */
+    scalarSubtract(scalar: number): Point;
+    /**
+     * Subtracts value from this point
+     * @param {Number} scalar
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    scalarSubtractEquals(scalar: number): Point;
+    /**
+     * Multiplies this point by another value and returns a new one
+     * @param {IPoint} that
+     * @return {Point}
+     */
+    multiply(that: IPoint): Point;
+    /**
+     * Multiplies this point by a value and returns a new one
+     * @param {Number} scalar
+     * @return {Point}
+     */
+    scalarMultiply(scalar: number): Point;
+    /**
+     * Multiplies this point by a value
+     * @param {Number} scalar
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    scalarMultiplyEquals(scalar: number): Point;
+    /**
+     * Divides this point by another and returns a new one
+     * @param {IPoint} that
+     * @return {Point}
+     */
+    divide(that: IPoint): Point;
+    /**
+     * Divides this point by a value and returns a new one
+     * @param {Number} scalar
+     * @return {Point}
+     */
+    scalarDivide(scalar: number): Point;
+    /**
+     * Divides this point by a value
+     * @param {Number} scalar
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    scalarDivideEquals(scalar: number): Point;
+    /**
+     * Returns true if this point is equal to another one
+     * @param {IPoint} that
+     * @return {Boolean}
+     */
+    eq(that: IPoint): boolean;
+    /**
+     * Returns true if this point is less than another one
+     * @param {IPoint} that
+     * @return {Boolean}
+     */
+    lt(that: IPoint): boolean;
+    /**
+     * Returns true if this point is less than or equal to another one
+     * @param {IPoint} that
+     * @return {Boolean}
+     */
+    lte(that: IPoint): boolean;
+    /**
+  
+     * Returns true if this point is greater another one
+     * @param {IPoint} that
+     * @return {Boolean}
+     */
+    gt(that: IPoint): boolean;
+    /**
+     * Returns true if this point is greater than or equal to another one
+     * @param {IPoint} that
+     * @return {Boolean}
+     */
+    gte(that: IPoint): boolean;
+    /**
+     * Returns new point which is the result of linear interpolation with this one and another one
+     * @param {IPoint} that
+     * @param {Number} t , position of interpolation, between 0 and 1 default 0.5
+     * @return {Point}
+     */
+    lerp(that: IPoint, t?: number): Point;
+    /**
+     * Returns distance from this point and another one
+     * @param {IPoint} that
+     * @return {Number}
+     */
+    distanceFrom(that: IPoint): number;
+    /**
+     * Returns the point between this point and another one
+     * @param {IPoint} that
+     * @return {Point}
+     */
+    midPointFrom(that: IPoint): Point;
+    /**
+     * Returns a new point which is the min of this and another one
+     * @param {IPoint} that
+     * @return {Point}
+     */
+    min(that: IPoint): Point;
+    /**
+     * Returns a new point which is the max of this and another one
+     * @param {IPoint} that
+     * @return {Point}
+     */
+    max(that: IPoint): Point;
+    /**
+     * Returns string representation of this point
+     * @return {String}
+     */
+    toString(): string;
+    /**
+     * Sets x/y of this point
+     * @param {Number} x
+     * @param {Number} y
+     * @chainable
+     */
+    setXY(x: number, y: number): this;
+    /**
+     * Sets x of this point
+     * @param {Number} x
+     * @chainable
+     */
+    setX(x: number): this;
+    /**
+     * Sets y of this point
+     * @param {Number} y
+     * @chainable
+     */
+    setY(y: number): this;
+    /**
+     * Sets x/y of this point from another point
+     * @param {IPoint} that
+     * @chainable
+     */
+    setFromPoint(that: IPoint): this;
+    /**
+     * Swaps x/y of this point and another point
+     * @param {IPoint} that
+     */
+    swap(that: IPoint): void;
+    /**
+     * return a cloned instance of the point
+     * @return {Point}
+     */
+    clone(): Point;
+    /**
+     * Rotates `point` around `origin` with `radians`
+     * @static
+     * @memberOf fabric.util
+     * @param {IPoint} origin The origin of the rotation
+     * @param {TRadian} radians The radians of the angle for the rotation
+     * @return {Point} The new rotated point
+     */
+    rotate(radians: TRadian, origin?: IPoint): Point;
+    /**
+     * Apply transform t to point p
+     * @static
+     * @memberOf fabric.util
+     * @param  {TMat2D} t The transform
+     * @param  {Boolean} [ignoreOffset] Indicates that the offset should not be applied
+     * @return {Point} The transformed point
+     */
+    transform(t: TMat2D, ignoreOffset?: boolean): Point;
+}
+//# sourceMappingURL=Point.d.ts.map

package/dist/src/Shadow.d.ts

@@ -0,0 +1,87 @@
+import type { FabricObject } from './shapes/Object/FabricObject';
+import { TClassProperties } from './typedefs';
+export declare class Shadow {
+    /**
+     * Shadow color
+     * @type String
+     * @default
+     */
+    color: string;
+    /**
+     * Shadow blur
+     * @type Number
+     */
+    blur: number;
+    /**
+     * Shadow horizontal offset
+     * @type Number
+     * @default
+     */
+    offsetX: number;
+    /**
+     * Shadow vertical offset
+     * @type Number
+     * @default
+     */
+    offsetY: number;
+    /**
+     * Whether the shadow should affect stroke operations
+     * @type Boolean
+     * @default
+     */
+    affectStroke: boolean;
+    /**
+     * Indicates whether toObject should include default values
+     * @type Boolean
+     * @default
+     */
+    includeDefaultValues: boolean;
+    /**
+     * When `false`, the shadow will scale with the object.
+     * When `true`, the shadow's offsetX, offsetY, and blur will not be affected by the object's scale.
+     * default to false
+     * @type Boolean
+     * @default
+     */
+    nonScaling: boolean;
+    id: number;
+    /**
+     * @see {@link http://fabricjs.com/shadows|Shadow demo}
+     * @param {Object|String} [options] Options object with any of color, blur, offsetX, offsetY properties or string (e.g. "rgba(0,0,0,0.2) 2px 2px 10px")
+     */
+    constructor(options: Partial<TClassProperties<Shadow>>);
+    constructor(svgAttribute: string);
+    /**
+     * @param {String} value Shadow value to parse
+     * @return {Object} Shadow object with color, offsetX, offsetY and blur
+     */
+    static parseShadow(value: string): {
+        color: string;
+        offsetX: number;
+        offsetY: number;
+        blur: number;
+    };
+    /**
+     * Returns a string representation of an instance
+     * @see http://www.w3.org/TR/css-text-decor-3/#text-shadow
+     * @return {String} Returns CSS3 text-shadow declaration
+     */
+    toString(): string;
+    /**
+     * Returns SVG representation of a shadow
+     * @param {FabricObject} object
+     * @return {String} SVG representation of a shadow
+     */
+    toSVG(object: FabricObject): string;
+    /**
+     * Returns object representation of a shadow
+     * @return {Object} Object representation of a shadow instance
+     */
+    toObject(): Record<string, unknown>;
+    /**
+     * Regex matching shadow offsetX, offsetY and blur (ex: "2px 2px 10px rgba(0,0,0,0.2)", "rgb(0,255,0) 2px 2px")
+     */
+    static reOffsetsAndBlur: RegExp;
+}
+export declare const shadowDefaultValues: Partial<TClassProperties<Shadow>>;
+//# sourceMappingURL=Shadow.d.ts.map

package/dist/src/brushes/BaseBrush.d.ts

@@ -0,0 +1,105 @@
+import type { Point } from '../Point';
+import { TEvent } from '../EventTypeDefs';
+import type { Shadow } from '../Shadow';
+import type { Canvas } from '../canvas/Canvas';
+type TBrushEventData = TEvent & {
+    pointer: Point;
+};
+/**
+ * @see {@link http://fabricjs.com/freedrawing|Freedrawing demo}
+ */
+export declare abstract class BaseBrush {
+    /**
+     * Color of a brush
+     * @type String
+     * @default
+     */
+    color: string;
+    /**
+     * Width of a brush, has to be a Number, no string literals
+     * @type Number
+     * @default
+     */
+    width: number;
+    /**
+     * Shadow object representing shadow of this shape.
+     * <b>Backwards incompatibility note:</b> This property replaces "shadowColor" (String), "shadowOffsetX" (Number),
+     * "shadowOffsetY" (Number) and "shadowBlur" (Number) since v1.2.12
+     * @type Shadow
+     * @default
+     */
+    shadow: Shadow | null;
+    /**
+     * Line endings style of a brush (one of "butt", "round", "square")
+     * @type String
+     * @default
+     */
+    strokeLineCap: CanvasLineCap;
+    /**
+     * Corner style of a brush (one of "bevel", "round", "miter")
+     * @type String
+     * @default
+     */
+    strokeLineJoin: CanvasLineJoin;
+    /**
+     * Maximum miter length (used for strokeLineJoin = "miter") of a brush's
+     * @type Number
+     * @default
+     */
+    strokeMiterLimit: number;
+    /**
+     * Stroke Dash Array.
+     * @type Array
+     * @default
+     */
+    strokeDashArray: number[] | null;
+    /**
+     * When `true`, the free drawing is limited to the whiteboard size. Default to false.
+     * @type Boolean
+     * @default false
+     */
+    limitedToCanvasSize: boolean;
+    /**
+     * @todo add type
+     */
+    canvas: Canvas;
+    constructor(canvas: Canvas);
+    abstract _render(): void;
+    abstract onMouseDown(pointer: Point, ev: TBrushEventData): void;
+    abstract onMouseMove(pointer: Point, ev: TBrushEventData): void;
+    /**
+     * @returns true if brush should continue blocking interaction
+     */
+    abstract onMouseUp(ev: TBrushEventData): boolean | void;
+    /**
+     * Sets brush styles
+     * @private
+     * @param {CanvasRenderingContext2D} ctx
+     */
+    _setBrushStyles(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Sets the transformation on given context
+     * @param {CanvasRenderingContext2D} ctx context to render on
+     * @private
+     */
+    protected _saveAndTransform(ctx: CanvasRenderingContext2D): void;
+    protected needsFullRender(): boolean;
+    /**
+     * Sets brush shadow styles
+     * @private
+     */
+    protected _setShadow(): void;
+    /**
+     * Removes brush shadow styles
+     * @private
+     */
+    protected _resetShadow(): void;
+    /**
+     * Check is pointer is outside canvas boundaries
+     * @param {Object} pointer
+     * @private
+     */
+    protected _isOutSideCanvas(pointer: Point): boolean;
+}
+export {};
+//# sourceMappingURL=BaseBrush.d.ts.map

package/dist/src/brushes/CircleBrush.d.ts

@@ -0,0 +1,49 @@
+import { Point } from '../Point';
+import type { Canvas } from '../canvas/Canvas';
+import { BaseBrush } from './BaseBrush';
+export type CircleBrushPoint = {
+    x: number;
+    y: number;
+    radius: number;
+    fill: string;
+};
+export declare class CircleBrush extends BaseBrush {
+    /**
+     * Width of a brush
+     * @type Number
+     * @default
+     */
+    width: number;
+    points: CircleBrushPoint[];
+    constructor(canvas: Canvas);
+    /**
+     * Invoked inside on mouse down and mouse move
+     * @param {Point} pointer
+     */
+    drawDot(pointer: Point): void;
+    dot(ctx: CanvasRenderingContext2D, point: CircleBrushPoint): void;
+    /**
+     * Invoked on mouse down
+     */
+    onMouseDown(pointer: Point): void;
+    /**
+     * Render the full state of the brush
+     * @private
+     */
+    _render(): void;
+    /**
+     * Invoked on mouse move
+     * @param {Point} pointer
+     */
+    onMouseMove(pointer: Point): void;
+    /**
+     * Invoked on mouse up
+     */
+    onMouseUp(): void;
+    /**
+     * @param {Object} pointer
+     * @return {Point} Just added pointer point
+     */
+    addPoint({ x, y }: Point): CircleBrushPoint;
+}
+//# sourceMappingURL=CircleBrush.d.ts.map

package/dist/src/brushes/PatternBrush.d.ts

@@ -0,0 +1,23 @@
+import { PathData } from '../typedefs';
+import type { Canvas } from '../canvas/Canvas';
+import { PencilBrush } from './PencilBrush';
+export declare class PatternBrush extends PencilBrush {
+    source?: CanvasImageSource;
+    constructor(canvas: Canvas);
+    getPatternSrc(): HTMLCanvasElement;
+    /**
+     * Creates "pattern" instance property
+     * @param {CanvasRenderingContext2D} ctx
+     */
+    getPattern(ctx: CanvasRenderingContext2D): CanvasPattern | null;
+    /**
+     * Sets brush styles
+     * @param {CanvasRenderingContext2D} ctx
+     */
+    _setBrushStyles(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Creates path
+     */
+    createPath(pathData: PathData): import("../..").Path;
+}
+//# sourceMappingURL=PatternBrush.d.ts.map

package/dist/src/brushes/PencilBrush.d.ts

@@ -0,0 +1,92 @@
+import { ModifierKey, TEvent } from '../EventTypeDefs';
+import { Point } from '../Point';
+import { Path } from '../shapes/Path';
+import { PathData } from '../typedefs';
+import type { Canvas } from '../canvas/Canvas';
+import { BaseBrush } from './BaseBrush';
+export declare class PencilBrush extends BaseBrush {
+    /**
+     * Discard points that are less than `decimate` pixel distant from each other
+     * @type Number
+     * @default 0.4
+     */
+    decimate: number;
+    /**
+     * Draws a straight line between last recorded point to current pointer
+     * Used for `shift` functionality
+     *
+     * @type boolean
+     * @default false
+     */
+    drawStraightLine: boolean;
+    /**
+     * The event modifier key that makes the brush draw a straight line.
+     * If `null` or 'none' or any other string that is not a modifier key the feature is disabled.
+     * @type {ModifierKey | undefined | null}
+     */
+    straightLineKey: ModifierKey | undefined | null;
+    private _points;
+    private _hasStraightLine;
+    private oldEnd?;
+    constructor(canvas: Canvas);
+    needsFullRender(): boolean;
+    static drawSegment(ctx: CanvasRenderingContext2D, p1: Point, p2: Point): Point;
+    /**
+     * Invoked on mouse down
+     * @param {Point} pointer
+     */
+    onMouseDown(pointer: Point, { e }: TEvent): void;
+    /**
+     * Invoked on mouse move
+     * @param {Point} pointer
+     */
+    onMouseMove(pointer: Point, { e }: TEvent): void;
+    /**
+     * Invoked on mouse up
+     */
+    onMouseUp({ e }: TEvent): boolean;
+    /**
+     * @private
+     * @param {Point} pointer Actual mouse position related to the canvas.
+     */
+    _prepareForDrawing(pointer: Point): void;
+    /**
+     * @private
+     * @param {Point} point Point to be added to points array
+     */
+    _addPoint(point: Point): boolean;
+    /**
+     * Clear points array and set contextTop canvas style.
+     * @private
+     */
+    _reset(): void;
+    /**
+     * Draw a smooth path on the topCanvas using quadraticCurveTo
+     * @private
+     * @param {CanvasRenderingContext2D} [ctx]
+     */
+    _render(ctx?: CanvasRenderingContext2D): void;
+    /**
+     * Converts points to SVG path
+     * @param {Array} points Array of points
+     * @return {PathData} SVG path commands
+     */
+    convertPointsToSVGPath(points: Point[]): PathData;
+    /**
+     * Creates a Path object to add on canvas
+     * @param {PathData} pathData Path data
+     * @return {Path} Path to add on canvas
+     */
+    createPath(pathData: PathData): Path;
+    /**
+     * Decimate points array with the decimate value
+     */
+    decimatePoints(points: Point[], distance: number): Point[];
+    /**
+     * On mouseup after drawing the path on contextTop canvas
+     * we use the points captured to create an new Path object
+     * and add it to the canvas.
+     */
+    _finalizeAndAddPath(): void;
+}
+//# sourceMappingURL=PencilBrush.d.ts.map

package/dist/src/brushes/SprayBrush.d.ts

@@ -0,0 +1,79 @@
+import { Point } from '../Point';
+import type { Canvas } from '../canvas/Canvas';
+import { BaseBrush } from './BaseBrush';
+export type SprayBrushPoint = {
+    x: number;
+    y: number;
+    width: number;
+    opacity: number;
+};
+export declare class SprayBrush extends BaseBrush {
+    /**
+     * Width of a spray
+     * @type Number
+     * @default
+     */
+    width: number;
+    /**
+     * Density of a spray (number of dots per chunk)
+     * @type Number
+     * @default
+     */
+    density: number;
+    /**
+     * Width of spray dots
+     * @type Number
+     * @default
+     */
+    dotWidth: number;
+    /**
+     * Width variance of spray dots
+     * @type Number
+     * @default
+     */
+    dotWidthVariance: number;
+    /**
+     * Whether opacity of a dot should be random
+     * @type Boolean
+     * @default
+     */
+    randomOpacity: boolean;
+    /**
+     * Whether overlapping dots (rectangles) should be removed (for performance reasons)
+     * @type Boolean
+     * @default
+     */
+    optimizeOverlapping: boolean;
+    private sprayChunks;
+    private sprayChunk;
+    /**
+     * Constructor
+     * @param {Canvas} canvas
+     * @return {SprayBrush} Instance of a spray brush
+     */
+    constructor(canvas: Canvas);
+    /**
+     * Invoked on mouse down
+     * @param {Point} pointer
+     */
+    onMouseDown(pointer: Point): void;
+    /**
+     * Invoked on mouse move
+     * @param {Point} pointer
+     */
+    onMouseMove(pointer: Point): void;
+    /**
+     * Invoked on mouse up
+     */
+    onMouseUp(): void;
+    renderChunck(sprayChunck: SprayBrushPoint[]): void;
+    /**
+     * Render all spray chunks
+     */
+    _render(): void;
+    /**
+     * @param {Point} pointer
+     */
+    addSprayChunk(pointer: Point): void;
+}
+//# sourceMappingURL=SprayBrush.d.ts.map