fabric 5.3.0 → 6.0.0-beta3

package/dist/src/shapes/Object/types/BorderProps.d.ts

@@ -0,0 +1,37 @@
+export interface BorderProps {
+    /**
+     * Color of controlling borders of an object (when it's active)
+     * @type String
+     * @default rgb(178,204,255)
+     */
+    borderColor: string;
+    /**
+     * Array specifying dash pattern of an object's borders (hasBorder must be true)
+     * @since 1.6.2
+     * @type Array | null
+     * default null;
+     */
+    borderDashArray: number[] | null;
+    /**
+     * When set to `false`, object's controlling borders are not rendered
+     * @type Boolean
+     * @default
+     */
+    hasBorders: boolean;
+    /**
+     * Opacity of object's controlling borders when object is active and moving
+     * @type Number
+     * @default 0.4
+     */
+    borderOpacityWhenMoving: number;
+    /**
+     * Scale factor of object's controlling borders
+     * bigger number will make a thicker border
+     * border is 1, so this is basically a border thickness
+     * since there is no way to change the border itself.
+     * @type Number
+     * @default 1
+     */
+    borderScaleFactor: number;
+}
+//# sourceMappingURL=BorderProps.d.ts.map

package/dist/src/shapes/Object/types/ControlProps.d.ts

@@ -0,0 +1,62 @@
+export interface ControlProps {
+    /**
+     * Size of object's controlling corners (in pixels)
+     * @type Number
+     * @default 13
+     */
+    cornerSize: number;
+    /**
+     * Size of object's controlling corners when touch interaction is detected
+     * @type Number
+     * @default 24
+     */
+    touchCornerSize: number;
+    /**
+     * When true, object's controlling corners are rendered as transparent inside (i.e. stroke instead of fill)
+     * @type Boolean
+     * @default true
+     */
+    transparentCorners: boolean;
+    /**
+     * Color of controlling corners of an object (when it's active)
+     * @type String
+     * @default rgb(178,204,255)
+     */
+    cornerColor: string;
+    /**
+     * Color of controlling corners of an object (when it's active and transparentCorners false)
+     * @since 1.6.2
+     * @type String
+     * @default null
+     */
+    cornerStrokeColor: string;
+    /**
+     * Specify style of control, 'rect' or 'circle'
+     * This is deprecated. In the future there will be a standard control render
+     * And you can swap it with one of the alternative proposed with the control api
+     * @since 1.6.2
+     * @type 'rect' | 'circle'
+     * @default rect
+     * @deprecated
+     */
+    cornerStyle: 'rect' | 'circle';
+    /**
+     * Array specifying dash pattern of an object's control (hasBorder must be true)
+     * @since 1.6.2
+     * @type Array | null
+     */
+    cornerDashArray: number[] | null;
+    /**
+     * Padding between object and its controlling borders (in pixels)
+     * @type Number
+     * @default 0
+     */
+    padding: number;
+    /**
+     * When set to `false`, object's controls are not displayed and can not be used to manipulate object
+     * @type Boolean
+     * @default
+     */
+    hasControls: boolean;
+}
+//# sourceMappingURL=ControlProps.d.ts.map

package/dist/src/shapes/Object/types/FabricObjectProps.d.ts

@@ -0,0 +1,96 @@
+import { TDegree } from '../../../typedefs';
+import { BorderProps } from './BorderProps';
+import { ControlProps } from './ControlProps';
+import { LockInteractionProps } from './LockInteractionProps';
+import { ObjectProps } from './ObjectProps';
+export interface FabricObjectProps extends ObjectProps, ControlProps, BorderProps, LockInteractionProps {
+    /**
+     * When `true`, cache does not get updated during scaling. The picture will get blocky if scaled
+     * too much and will be redrawn with correct details at the end of scaling.
+     * this setting is performance and application dependant.
+     * default to true
+     * since 1.7.0
+     * @type Boolean
+     * @default true
+     */
+    noScaleCache?: boolean;
+    /**
+     * When true, this object will use center point as the origin of transformation
+     * when being scaled via the controls.
+     * <b>Backwards incompatibility note:</b> This property replaces "centerTransform" (Boolean).
+     * @since 1.3.4
+     * @type Boolean
+     * @default
+     */
+    centeredScaling: false;
+    /**
+     * When true, this object will use center point as the origin of transformation
+     * when being rotated via the controls.
+     * <b>Backwards incompatibility note:</b> This property replaces "centerTransform" (Boolean).
+     * @since 1.3.4
+     * @type Boolean
+     * @default
+     */
+    centeredRotation: boolean;
+    /**
+     * The angle that an object will lock to while rotating.
+     * @type [TDegree]
+     */
+    snapAngle?: TDegree;
+    /**
+     * The angle difference from the current snapped angle in which snapping should occur.
+     * When undefined, the snapThreshold will default to the snapAngle.
+     * @type [TDegree]
+     */
+    snapThreshold?: TDegree;
+    /**
+     * Default cursor value used when hovering over this object on canvas
+     * @type CSSStyleDeclaration['cursor'] | null
+     * @default null
+     */
+    hoverCursor: CSSStyleDeclaration['cursor'] | null;
+    /**
+     * Default cursor value used when moving this object on canvas
+     * @type CSSStyleDeclaration['cursor'] | null
+     * @default null
+     */
+    moveCursor: CSSStyleDeclaration['cursor'] | null;
+    /**
+     * Selection Background color of an object. colored layer behind the object when it is active.
+     * does not mix good with globalCompositeOperation methods.
+     * @type String
+     * @deprecated
+     * @default
+     */
+    selectionBackgroundColor: string;
+    /**
+     * When set to `true`, objects are "found" on canvas on per-pixel basis rather than according to bounding box
+     * @type Boolean
+     * @default
+     */
+    perPixelTargetFind: boolean;
+    /**
+     * When set to `false`, an object can not be selected for modification (using either point-click-based or group-based selection).
+     * But events still fire on it.
+     * @type Boolean
+     * @default
+     */
+    selectable: boolean;
+    /**
+     * When set to `false`, an object can not be a target of events. All events propagate through it. Introduced in v1.3.4
+     * @type Boolean
+     * @default
+     */
+    evented: boolean;
+    /**
+     * When 'down', object is set to active on mousedown/touchstart
+     * When 'up', object is set to active on mouseup/touchend
+     * Experimental. Let's see if this breaks anything before supporting officially
+     * @private
+     * since 4.4.0
+     * @type String
+     * @default 'down'
+     */
+    activeOn: 'down' | 'up';
+}
+//# sourceMappingURL=FabricObjectProps.d.ts.map

package/dist/src/shapes/Object/types/FillStrokeProps.d.ts

@@ -0,0 +1,80 @@
+import { TFiller } from '../../../typedefs';
+export interface FillStrokeProps {
+    /**
+     * Determines if the fill or the stroke is drawn first (one of "fill" or "stroke")
+     * @type String
+     * @default
+     */
+    paintFirst: 'fill' | 'stroke';
+    /**
+     * Color of object's fill
+     * takes css colors https://www.w3.org/TR/css-color-3/
+     * @type String
+     * @default rgb(0,0,0)
+     */
+    fill: ReturnType<TFiller['toObject']> | string | null;
+    /**
+     * Fill rule used to fill an object
+     * accepted values are nonzero, evenodd
+     * <b>Backwards incompatibility note:</b> This property was used for setting globalCompositeOperation until v1.4.12 (use `globalCompositeOperation` instead)
+     * @type String
+     * @default nonzero
+     */
+    fillRule: CanvasFillRule;
+    /**
+     * When defined, an object is rendered via stroke and this property specifies its color
+     * takes css colors https://www.w3.org/TR/css-color-3/
+     * @type String
+     * @default null
+     */
+    stroke: ReturnType<TFiller['toObject']> | string | null;
+    /**
+     * Width of a stroke used to render this object
+     * @type Number
+     * @default 1
+     */
+    strokeWidth: number;
+    /**
+     * Array specifying dash pattern of an object's stroke (stroke must be defined)
+     * @type Array
+     * @default null;
+     */
+    strokeDashArray: number[] | null;
+    /**
+     * Line offset of an object's stroke
+     * @type Number
+     * @default 0
+     */
+    strokeDashOffset: number;
+    /**
+     * Line endings style of an object's stroke (one of "butt", "round", "square")
+     * @type String
+     * @default butt
+     */
+    strokeLineCap: CanvasLineCap;
+    /**
+     * Corner style of an object's stroke (one of "bevel", "round", "miter")
+     * @type String
+     * @default
+     */
+    strokeLineJoin: CanvasLineJoin;
+    /**
+     * Maximum miter length (used for strokeLineJoin = "miter") of an object's stroke
+     * @type Number
+     * @default 4
+     */
+    strokeMiterLimit: number;
+    /**
+     * When `false`, the stoke width will scale with the object.
+     * When `true`, the stroke will always match the exact pixel size entered for stroke width.
+     * this Property does not work on Text classes or drawing call that uses strokeText,fillText methods
+     * default to false
+     * @since 2.6.0
+     * @type Boolean
+     * @default false
+     * @type Boolean
+     * @default false
+     */
+    strokeUniform: boolean;
+}
+//# sourceMappingURL=FillStrokeProps.d.ts.map

package/dist/src/shapes/Object/types/LockInteractionProps.d.ts

@@ -0,0 +1,51 @@
+export interface LockInteractionProps {
+    /**
+     * When `true`, object horizontal movement is locked
+     * @type Boolean
+     * @default
+     */
+    lockMovementX: boolean;
+    /**
+     * When `true`, object vertical movement is locked
+     * @type Boolean
+     * @default
+     */
+    lockMovementY: boolean;
+    /**
+     * When `true`, object rotation is locked
+     * @type Boolean
+     * @default
+     */
+    lockRotation: boolean;
+    /**
+     * When `true`, object horizontal scaling is locked
+     * @type Boolean
+     * @default
+     */
+    lockScalingX: boolean;
+    /**
+     * When `true`, object vertical scaling is locked
+     * @type Boolean
+     * @default
+     */
+    lockScalingY: boolean;
+    /**
+     * When `true`, object horizontal skewing is locked
+     * @type Boolean
+     * @default
+     */
+    lockSkewingX: boolean;
+    /**
+     * When `true`, object vertical skewing is locked
+     * @type Boolean
+     * @default
+     */
+    lockSkewingY: boolean;
+    /**
+     * When `true`, object cannot be flipped by scaling into negative values
+     * @type Boolean
+     * @default
+     */
+    lockScalingFlip: boolean;
+}
+//# sourceMappingURL=LockInteractionProps.d.ts.map

package/dist/src/shapes/Object/types/ObjectProps.d.ts

@@ -0,0 +1,42 @@
+import type { Shadow } from '../../../Shadow';
+import type { Canvas } from '../../../canvas/Canvas';
+import type { StaticCanvas } from '../../../canvas/StaticCanvas';
+import { TFiller } from '../../../typedefs';
+import type { FabricObject } from '../Object';
+import { ClipPathProps, SerializedObjectProps } from './SerializedObjectProps';
+export interface ObjectProps extends SerializedObjectProps, ClipPathProps {
+    clipPath?: FabricObject;
+    fill: TFiller | string | null;
+    stroke: TFiller | string | null;
+    shadow: Shadow | null;
+    canvas?: StaticCanvas | Canvas;
+    /**
+     * Minimum allowed scale value of an object
+     * @type Number
+     * @default 0
+     */
+    minScaleLimit: number;
+    /**
+     * When `true`, object is cached on an additional canvas.
+     * When `false`, object is not cached unless necessary ( clipPath )
+     * default to true
+     * @since 1.7.0
+     * @type Boolean
+     * @default true
+     */
+    objectCaching: boolean;
+    /**
+     * When `false`, default object's values are not included in its serialization
+     * @type Boolean
+     * @default
+     */
+    includeDefaultValues: boolean;
+    /**
+     * When `true`, object is not exported in OBJECT/JSON
+     * @since 1.6.3
+     * @type Boolean
+     * @default
+     */
+    excludeFromExport: boolean;
+}
+//# sourceMappingURL=ObjectProps.d.ts.map

package/dist/src/shapes/Object/types/SerializedObjectProps.d.ts

@@ -0,0 +1,66 @@
+import { Shadow } from '../../../Shadow';
+import { BaseProps } from './BaseProps';
+import { FillStrokeProps } from './FillStrokeProps';
+export interface SerializedObjectProps extends BaseProps, FillStrokeProps {
+    /**
+     * Opacity of an object
+     * @type Number
+     * @default 1
+     */
+    opacity: number;
+    /**
+     * Composite rule used for canvas globalCompositeOperation
+     * @type String
+     * @default
+     */
+    globalCompositeOperation: GlobalCompositeOperation;
+    /**
+     * Background color of an object.
+     * takes css colors https://www.w3.org/TR/css-color-3/
+     * @type String
+     * @default
+     */
+    backgroundColor: string;
+    /**
+     * Shadow object representing shadow of this shape
+     * @type Shadow
+     * @default null
+     */
+    shadow: ReturnType<Shadow['toObject']> | null;
+    /**
+     * When set to `false`, an object is not rendered on canvas
+     * @type Boolean
+     * @default
+     */
+    visible: boolean;
+    /**
+     * a fabricObject that, without stroke define a clipping area with their shape. filled in black
+     * the clipPath object gets used when the object has rendered, and the context is placed in the center
+     * of the object cacheCanvas.
+     * If you want 0,0 of a clipPath to align with an object center, use clipPath.originX/Y to 'center'
+     * @type FabricObject
+     */
+    clipPath?: Partial<SerializedObjectProps> & ClipPathProps;
+}
+export interface ClipPathProps {
+    /**
+     * Meaningful ONLY when the object is used as clipPath.
+     * if true, the clipPath will make the object clip to the outside of the clipPath
+     * since 2.4.0
+     * @type boolean
+     * @default false
+     */
+    inverted: boolean;
+    /**
+     * Meaningful ONLY when the object is used as clipPath.
+     * if true, the clipPath will have its top and left relative to canvas, and will
+     * not be influenced by the object transform. This will make the clipPath relative
+     * to the canvas, but clipping just a particular object.
+     * WARNING this is beta, this feature may change or be renamed.
+     * since 2.4.0
+     * @type boolean
+     * @default false
+     */
+    absolutePositioned: boolean;
+}
+//# sourceMappingURL=SerializedObjectProps.d.ts.map

package/dist/src/shapes/Object/types/index.d.ts

@@ -0,0 +1,6 @@
+import { FabricObjectProps } from './FabricObjectProps';
+export { SerializedObjectProps } from './SerializedObjectProps';
+export { FabricObjectProps };
+export type TProps<T> = Partial<T> & Record<string, any>;
+export type TFabricObjectProps = TProps<FabricObjectProps>;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/shapes/Path.d.ts

@@ -0,0 +1,130 @@
+import { Point } from '../Point';
+import { FabricObject } from './Object/FabricObject';
+import { TPathSegmentInfo, TSimplePathData } from '../util/path/typedefs';
+import type { FabricObjectProps, SerializedObjectProps, TProps } from './Object/types';
+import type { ObjectEvents } from '../EventTypeDefs';
+import { TClassProperties, TSVGReviver } from '../typedefs';
+interface UniquePathProps {
+    sourcePath?: string;
+    path?: TSimplePathData;
+}
+export interface SerializedPathProps extends SerializedObjectProps, UniquePathProps {
+}
+export interface PathProps extends FabricObjectProps, UniquePathProps {
+}
+export declare class Path<Props extends TProps<PathProps> = Partial<PathProps>, SProps extends SerializedPathProps = SerializedPathProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricObject<Props, SProps, EventSpec> {
+    /**
+     * Array of path points
+     * @type Array
+     * @default
+     */
+    path: TSimplePathData;
+    pathOffset: Point;
+    fromSVG?: boolean;
+    sourcePath?: string;
+    segmentsInfo?: TPathSegmentInfo[];
+    static cacheProperties: string[];
+    /**
+     * Constructor
+     * @param {TSimplePathData} path Path data (sequence of coordinates and corresponding "command" tokens)
+     * @param {Object} [options] Options object
+     * @return {Path} thisArg
+     */
+    constructor(path: TSimplePathData | string, { path, left, top, ...options }?: Props);
+    /**
+     * @private
+     * @param {TSimplePathData | string} path Path data (sequence of coordinates and corresponding "command" tokens)
+     * @param {boolean} [adjustPosition] pass true to reposition the object according to the bounding box
+     * @returns {Point} top left position of the bounding box, useful for complementary positioning
+     */
+    _setPath(path: TSimplePathData | string, adjustPosition?: boolean): Point;
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx context to render path on
+     */
+    _renderPathCommands(ctx: CanvasRenderingContext2D): void;
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx context to render path on
+     */
+    _render(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Returns string representation of an instance
+     * @return {string} string representation of an instance
+     */
+    toString(): string;
+    /**
+     * Returns object representation of an instance
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {Object} object representation of an instance
+     */
+    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
+    /**
+     * Returns dataless object representation of an instance
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {Object} object representation of an instance
+     */
+    toDatalessObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
+    /**
+     * Returns svg representation of an instance
+     * @return {Array} an array of strings with the specific svg representation
+     * of the instance
+     */
+    _toSVG(): string[];
+    _getOffsetTransform(): string;
+    /**
+     * Returns svg clipPath representation of an instance
+     * @param {Function} [reviver] Method for further parsing of svg representation.
+     * @return {string} svg representation of an instance
+     */
+    toClipPathSVG(reviver: TSVGReviver): string;
+    /**
+     * Returns svg representation of an instance
+     * @param {Function} [reviver] Method for further parsing of svg representation.
+     * @return {string} svg representation of an instance
+     */
+    toSVG(reviver: TSVGReviver): string;
+    /**
+     * Returns number representation of an instance complexity
+     * @return {number} complexity of this instance
+     */
+    complexity(): number;
+    setDimensions(): Point;
+    /**
+     * @private
+     */
+    _calcDimensions(): {
+        left: number;
+        top: number;
+        pathOffset: Point;
+        width: number;
+        height: number;
+    };
+    /**
+     * List of attribute names to account for when parsing SVG element (used by `Path.fromElement`)
+     * @static
+     * @memberOf Path
+     * @see http://www.w3.org/TR/SVG/paths.html#PathElement
+     */
+    static ATTRIBUTE_NAMES: string[];
+    /**
+     * Creates an instance of Path from an object
+     * @static
+     * @memberOf Path
+     * @param {Object} object
+     * @returns {Promise<Path>}
+     */
+    static fromObject<T extends TProps<SerializedPathProps>>(object: T): Promise<Path<Partial<PathProps>, SerializedPathProps, ObjectEvents>>;
+    /**
+     * Creates an instance of Path from an SVG <path> element
+     * @static
+     * @memberOf Path
+     * @param {SVGElement} element to parse
+     * @param {Function} callback Callback to invoke when an Path instance is created
+     * @param {Object} [options] Options object
+     * @param {Function} [callback] Options callback invoked after parsing is finished
+     */
+    static fromElement(element: SVGElement, callback: (path: Path) => void, options: any): void;
+}
+export {};
+//# sourceMappingURL=Path.d.ts.map

package/dist/src/shapes/Polygon.d.ts

@@ -0,0 +1,9 @@
+import { Polyline } from './Polyline';
+export declare class Polygon extends Polyline {
+    static ownDefaults: Record<string, any>;
+    static getDefaults(): {
+        [x: string]: any;
+    };
+    protected isOpen(): boolean;
+}
+//# sourceMappingURL=Polygon.d.ts.map