fabric 5.3.0 → 6.0.0-beta3

package/dist/src/Pattern.d.ts

@@ -0,0 +1,113 @@
+import { TCrossOrigin, TMat2D, TSize } from './typedefs';
+export type TPatternRepeat = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+type TExportedKeys = 'crossOrigin' | 'offsetX' | 'offsetY' | 'patternTransform' | 'repeat' | 'source';
+export type TPatternOptions = Partial<Pick<Pattern, TExportedKeys>>;
+export type TPatternSerialized = TPatternOptions & {
+    source: string;
+};
+export type TPatternHydrationOptions = {
+    /**
+     * handle aborting
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/AbortController/signal
+     */
+    signal?: AbortSignal;
+};
+type TImageSource = {
+    source: HTMLImageElement;
+};
+type TCanvasSource = {
+    source: HTMLCanvasElement;
+};
+/**
+ * @see {@link http://fabricjs.com/patterns demo}
+ * @see {@link http://fabricjs.com/dynamic-patterns demo}
+ */
+export declare class Pattern {
+    /**
+     * Legacy identifier of the class. Prefer using this.constructor.name 'Pattern'
+     * or utils like isPattern
+     * Will be removed in fabric 7 or 8.
+     * @TODO add sustainable warning message
+     * @type string
+     * @deprecated
+     */
+    get type(): string;
+    set type(value: string);
+    /**
+     * @type TPatternRepeat
+     * @defaults
+     */
+    repeat: TPatternRepeat;
+    /**
+     * Pattern horizontal offset from object's left/top corner
+     * @type Number
+     * @default
+     */
+    offsetX: number;
+    /**
+     * Pattern vertical offset from object's left/top corner
+     * @type Number
+     * @default
+     */
+    offsetY: number;
+    /**
+     * @type TCrossOrigin
+     * @default
+     */
+    crossOrigin: TCrossOrigin;
+    /**
+     * transform matrix to change the pattern, imported from svgs.
+     * @todo verify if using the identity matrix as default makes the rest of the code more easy
+     * @type Array
+     * @default
+     */
+    patternTransform: TMat2D | null;
+    /**
+     * The actual pixel source of the pattern
+     */
+    source: CanvasImageSource;
+    /**
+     * If true, this object will not be exported during the serialization of a canvas
+     * @type boolean
+     */
+    excludeFromExport?: boolean;
+    /**
+     * ID used for SVG export functionalities
+     * @type number
+     */
+    readonly id: number;
+    /**
+     * Constructor
+     * @param {Object} [options] Options object
+     * @param {option.source} [source] the pattern source, eventually empty or a drawable
+     */
+    constructor(options?: TPatternOptions);
+    /**
+     * @returns true if {@link source} is an <img> element
+     */
+    isImageSource(): this is TImageSource;
+    /**
+     * @returns true if {@link source} is a <canvas> element
+     */
+    isCanvasSource(): this is TCanvasSource;
+    sourceToString(): string;
+    /**
+     * Returns an instance of CanvasPattern
+     * @param {CanvasRenderingContext2D} ctx Context to create pattern
+     * @return {CanvasPattern}
+     */
+    toLive(ctx: CanvasRenderingContext2D): CanvasPattern | null;
+    /**
+     * Returns object representation of a pattern
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {object} Object representation of a pattern instance
+     */
+    toObject(propertiesToInclude?: string[]): Record<string, any>;
+    /**
+     * Returns SVG representation of a pattern
+     */
+    toSVG({ width, height }: TSize): string;
+    static fromObject({ source, ...serialized }: TPatternSerialized, options: TPatternHydrationOptions): Promise<Pattern>;
+}
+export {};
+//# sourceMappingURL=Pattern.d.ts.map

package/dist/src/Point.d.ts

@@ -0,0 +1,232 @@
+import { TMat2D, TRadian } from './typedefs';
+export interface XY {
+    x: number;
+    y: number;
+}
+/**
+ * Adaptation of work of Kevin Lindsey(kevin@kevlindev.com)
+ */
+export declare class Point implements XY {
+    x: number;
+    y: number;
+    constructor();
+    constructor(x: number, y: number);
+    constructor(point: XY);
+    /**
+     * Adds another point to this one and returns another one
+     * @param {XY} that
+     * @return {Point} new Point instance with added values
+     */
+    add(that: XY): Point;
+    /**
+     * Adds another point to this one
+     * @param {XY} that
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    addEquals(that: XY): 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 {XY} that
+     * @return {Point} new Point object with subtracted values
+     */
+    subtract(that: XY): Point;
+    /**
+     * Subtracts another point from this point
+     * @param {XY} that
+     * @return {Point} thisArg
+     * @chainable
+     * @deprecated
+     */
+    subtractEquals(that: XY): 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 {XY} that
+     * @return {Point}
+     */
+    multiply(that: XY): 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 {XY} that
+     * @return {Point}
+     */
+    divide(that: XY): 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 {XY} that
+     * @return {Boolean}
+     */
+    eq(that: XY): boolean;
+    /**
+     * Returns true if this point is less than another one
+     * @param {XY} that
+     * @return {Boolean}
+     */
+    lt(that: XY): boolean;
+    /**
+     * Returns true if this point is less than or equal to another one
+     * @param {XY} that
+     * @return {Boolean}
+     */
+    lte(that: XY): boolean;
+    /**
+  
+     * Returns true if this point is greater another one
+     * @param {XY} that
+     * @return {Boolean}
+     */
+    gt(that: XY): boolean;
+    /**
+     * Returns true if this point is greater than or equal to another one
+     * @param {XY} that
+     * @return {Boolean}
+     */
+    gte(that: XY): boolean;
+    /**
+     * Returns new point which is the result of linear interpolation with this one and another one
+     * @param {XY} that
+     * @param {Number} t , position of interpolation, between 0 and 1 default 0.5
+     * @return {Point}
+     */
+    lerp(that: XY, t?: number): Point;
+    /**
+     * Returns distance from this point and another one
+     * @param {XY} that
+     * @return {Number}
+     */
+    distanceFrom(that: XY): number;
+    /**
+     * Returns the point between this point and another one
+     * @param {XY} that
+     * @return {Point}
+     */
+    midPointFrom(that: XY): Point;
+    /**
+     * Returns a new point which is the min of this and another one
+     * @param {XY} that
+     * @return {Point}
+     */
+    min(that: XY): Point;
+    /**
+     * Returns a new point which is the max of this and another one
+     * @param {XY} that
+     * @return {Point}
+     */
+    max(that: XY): 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 {XY} that
+     * @chainable
+     */
+    setFromPoint(that: XY): this;
+    /**
+     * Swaps x/y of this point and another point
+     * @param {XY} that
+     */
+    swap(that: XY): void;
+    /**
+     * return a cloned instance of the point
+     * @return {Point}
+     */
+    clone(): Point;
+    /**
+     * Rotates `point` around `origin` with `radians`
+     * @static
+     * @memberOf fabric.util
+     * @param {XY} 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?: XY): 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,97 @@
+import type { FabricObject } from './shapes/Object/FabricObject';
+import { TClassProperties } from './typedefs';
+export declare const shadowDefaultValues: Partial<TClassProperties<Shadow>>;
+type TShadowSerializedProps = {
+    color: string;
+    blur: number;
+    offsetX: number;
+    offsetY: number;
+    affectStroke: boolean;
+    nonScaling: boolean;
+};
+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;
+    static ownDefaults: Partial<TClassProperties<Shadow>>;
+    /**
+     * @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(): Partial<TShadowSerializedProps>;
+    /**
+     * 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 {};
+//# 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 type { Canvas } from '../canvas/Canvas';
+import { PencilBrush } from './PencilBrush';
+import { TSimplePathData } from '../util/path/typedefs';
+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: TSimplePathData): import("../..").Path<Partial<import("../shapes/Path").PathProps>, import("../shapes/Path").SerializedPathProps, import("../EventTypeDefs").ObjectEvents>;
+}
+//# sourceMappingURL=PatternBrush.d.ts.map