pixijs-fabric 1.1.2 → 1.1.3

package/build/index.d.ts

@@ -1,4 +1,4 @@
-import { Application, Container, Graphics, Matrix } from 'pixi.js';
+import { FederatedPointerEvent, Application, Container, Matrix, Graphics, Rectangle } from 'pixi.js';
 
 interface BorderProps {
     /**
@@ -539,10 +539,24 @@ declare class InteractiveFabricObject<Props extends TFabricObjectProps = Partial
     static getDefaults(): Record<string, any>;
     constructor(options?: Props);
     strokeBorders(ctx: CanvasRenderingContext2D, size: Point): void;
+    onDeselect(_options?: {
+        e?: TPointerEvent;
+        object?: InteractiveFabricObject;
+    }): boolean;
+    onSelect(_options?: {
+        e?: TPointerEvent;
+    }): boolean;
     setControlVisible(controlKey: string, visible: boolean): void;
     setControlsVisibility(options?: Record<string, boolean>): void;
+    shouldStartDragging(_e: FederatedPointerEvent): boolean;
+    onDragStart(_e: DragEvent): boolean;
 }
 
+declare module 'pixi.js' {
+    interface Container {
+        fabricContent: FabricObject;
+    }
+}
 declare class FabricObject<Props extends TFabricObjectProps = Partial<FabricObjectProps>, SProps extends SerializedObjectProps = SerializedObjectProps, EventSpec extends ObjectEvents = ObjectEvents> extends InteractiveFabricObject<Props, SProps, EventSpec> {
 }
 
@@ -799,6 +813,7 @@ declare class StaticCanvas extends StaticCanvas_base implements StaticCanvasOpti
         height: number;
     }): void;
     getZoom(): number;
+    getViewportTransform(): Matrix;
     setViewportTransform(vpt: TMat2D): void;
     zoomToPoint(point: Point, value: number): void;
     setZoom(value: number): void;
@@ -816,6 +831,10 @@ declare class StaticCanvas extends StaticCanvas_base implements StaticCanvasOpti
     insertAt(index: number, ...objects: FabricObject[]): number;
     remove(...objects: FabricObject[]): FabricObject<Partial<FabricObjectProps>, SerializedObjectProps, ObjectEvents>[];
     get lowerCanvasEl(): HTMLCanvasElement;
+    /**
+     * @deprecated
+     * 没有upperCanvasEl，返回的依然是lowerCanvasEl
+     */
     get upperCanvasEl(): HTMLCanvasElement;
     getContext(): CanvasRenderingContext2D;
     getElement(): HTMLCanvasElement;
@@ -847,6 +866,710 @@ declare class StaticCanvas extends StaticCanvas_base implements StaticCanvasOpti
     toBlob(options?: TDataUrlOptions): Promise<Blob | null>;
     toCanvasElement(multiplier?: number): HTMLCanvasElement;
     toString(): string;
+    destroy(): void;
+}
+
+interface CanvasTransformOptions {
+    /**
+     * When true, objects can be transformed by one side (unproportionately)
+     * when dragged on the corners that normally would not do that.
+     * @type Boolean
+     * @since fabric 4.0 // changed name and default value
+     */
+    uniformScaling: boolean;
+    /**
+     * Indicates which key switches uniform scaling.
+     * values: 'altKey', 'shiftKey', 'ctrlKey'.
+     * If `null` or 'none' or any other string that is not a modifier key
+     * feature is disabled.
+     * totally wrong named. this sounds like `uniform scaling`
+     * if Canvas.uniformScaling is true, pressing this will set it to false
+     * and viceversa.
+     * @since 1.6.2
+     * @type ModifierKey
+     */
+    uniScaleKey: TOptionalModifierKey;
+    /**
+     * When true, objects use center point as the origin of scale transformation.
+     * <b>Backwards incompatibility note:</b> This property replaces "centerTransform" (Boolean).
+     * @since 1.3.4
+     * @type Boolean
+     */
+    centeredScaling: boolean;
+    /**
+     * When true, objects use center point as the origin of rotate transformation.
+     * <b>Backwards incompatibility note:</b> This property replaces "centerTransform" (Boolean).
+     * @since 1.3.4
+     * @type Boolean
+     */
+    centeredRotation: boolean;
+    /**
+     * Indicates which key enable centered Transform
+     * values: 'altKey', 'shiftKey', 'ctrlKey'.
+     * If `null` or 'none' or any other string that is not a modifier key
+     * feature is disabled feature disabled.
+     * @since 1.6.2
+     * @type ModifierKey
+     */
+    centeredKey: TOptionalModifierKey;
+    /**
+     * Indicates which key enable alternate action on corner
+     * values: 'altKey', 'shiftKey', 'ctrlKey'.
+     * If `null` or 'none' or any other string that is not a modifier key
+     * feature is disabled feature disabled.
+     * @since 1.6.2
+     * @type ModifierKey
+     */
+    altActionKey: TOptionalModifierKey;
+}
+interface CanvasSelectionOptions {
+    /**
+     * Indicates whether group selection should be enabled
+     * @type Boolean
+     */
+    selection: boolean;
+    /**
+     * Indicates which key or keys enable multiple click selection
+     * Pass value as a string or array of strings
+     * values: 'altKey', 'shiftKey', 'ctrlKey'.
+     * If `null` or empty or containing any other string that is not a modifier key
+     * feature is disabled.
+     * @since 1.6.2
+     * @type ModifierKey|ModifierKey[]
+     */
+    selectionKey: TOptionalModifierKey | ModifierKey[];
+    /**
+     * Indicates which key enable alternative selection
+     * in case of a target overlapping with active object and we don't want to loose the
+     * active selection, we can press this modifier key and continue selecting the current
+     * selected object also when is covered by another or many valid targets for selection.
+     * values: 'altKey', 'shiftKey', 'ctrlKey'.
+     * For a series of reason that come from the general expectations on how
+     * things should work, this feature works only for preserveObjectStacking true.
+     * If `null` or 'none' or any other string that is not a modifier key
+     * feature is disabled.
+     * @since 1.6.5
+     * @type null|ModifierKey
+     */
+    altSelectionKey: TOptionalModifierKey;
+    /**
+     * Color of selection
+     * @type String
+     */
+    selectionColor: string;
+    /**
+     * Default dash array pattern
+     * If not empty the selection border is dashed
+     * @type Array
+     */
+    selectionDashArray: number[];
+    /**
+     * Color of the border of selection (usually slightly darker than color of selection itself)
+     * @type String
+     */
+    selectionBorderColor: string;
+    /**
+     * Width of a line used in object/group selection
+     * @type Number
+     */
+    selectionLineWidth: number;
+    /**
+     * Select only shapes that are fully contained in the dragged selection rectangle.
+     * @type Boolean
+     */
+    selectionFullyContained: boolean;
+}
+interface CanvasCursorOptions {
+    /**
+     * Default cursor value used when hovering over an object on canvas
+     * @type CSSStyleDeclaration['cursor']
+     * @default move
+     */
+    hoverCursor: CSSStyleDeclaration['cursor'];
+    /**
+     * Default cursor value used when moving an object on canvas
+     * @type CSSStyleDeclaration['cursor']
+     * @default move
+     */
+    moveCursor: CSSStyleDeclaration['cursor'];
+    /**
+     * Default cursor value used for the entire canvas
+     * @type String
+     * @default default
+     */
+    defaultCursor: CSSStyleDeclaration['cursor'];
+    /**
+     * Cursor value used during free drawing
+     * @type String
+     * @default crosshair
+     */
+    freeDrawingCursor: CSSStyleDeclaration['cursor'];
+    /**
+     * Cursor value used for disabled elements ( corners with disabled action )
+     * @type String
+     * @since 2.0.0
+     * @default not-allowed
+     */
+    notAllowedCursor: CSSStyleDeclaration['cursor'];
+}
+interface TargetFindOptions {
+    /**
+     * When true, target detection is skipped. Target detection will return always undefined.
+     * click selection won't work anymore, events will fire with no targets.
+     * if something is selected before setting it to true, it will be deselected at the first click.
+     * area selection will still work. check the `selection` property too.
+     * if you deactivate both, you should look into staticCanvas.
+     * @type Boolean
+     */
+    skipTargetFind: boolean;
+}
+interface CanvasEventsOptions {
+    /**
+     * Indicates if the right click on canvas can output the context menu or not
+     * The default value changed from false to true in Fabric 7.0
+     * @see https://fabricjs.com/docs/upgrading/upgrading-to-fabric-70/
+     * @deprecated since 7.0, Will be removed in Fabric 8.0
+     * @type Boolean
+     * @since 1.6.5
+     */
+    stopContextMenu: boolean;
+    /**
+     * Indicates if the canvas can fire right click events
+     * The default value changed from false to true in Fabric 7.0
+     * @see https://fabricjs.com/docs/upgrading/upgrading-to-fabric-70/
+     * @deprecated since 7.0, Will be removed in Fabric 8.0
+     * @type Boolean
+     * @since 1.6.5
+     */
+    fireRightClick: boolean;
+    /**
+     * Indicates if the canvas can fire middle click events
+     * The default value changed from false to true in Fabric 7.0
+     * @see https://fabricjs.com/docs/upgrading/upgrading-to-fabric-70/
+     * @deprecated since 7.0, Will be removed in Fabric 8.0
+     * @type Boolean
+     * @since 1.7.8
+     */
+    fireMiddleClick: boolean;
+    /**
+     * When the option is enabled, PointerEvent is used instead of TPointerEvent.
+     * @type Boolean
+     */
+    enablePointerEvents: boolean;
+}
+interface CanvasOptions extends StaticCanvasOptions, CanvasTransformOptions, CanvasSelectionOptions, CanvasCursorOptions, TargetFindOptions, CanvasEventsOptions {
+    /**
+     * Default element class that's given to wrapper (div) element of canvas
+     * @type String
+     * @deprecated customize {@link CanvasDOMManager} instead or access {@link elements} directly
+     */
+    containerClass: string;
+    /**
+     * Indicates whether objects should remain in current stack position when selected.
+     * When false objects are brought to top and rendered as part of the selection group
+     * @type Boolean
+     * @default true
+     */
+    preserveObjectStacking: boolean;
+}
+type TCanvasOptions = TOptions<CanvasOptions>;
+
+type TargetsInfoWithContainer = {
+    target?: FabricObject;
+    subTargets: FabricObject[];
+    container?: FabricObject;
+};
+type FullTargetsInfoWithContainer = TargetsInfoWithContainer & {
+    currentTarget?: FabricObject;
+    currentContainer?: FabricObject;
+    currentSubTargets: FabricObject[];
+};
+declare class SelectableCanvas extends StaticCanvas implements Omit<CanvasOptions, 'enablePointerEvents'> {
+    _objects: FabricObject[];
+    uniformScaling: boolean;
+    uniScaleKey: TOptionalModifierKey;
+    centeredScaling: boolean;
+    centeredRotation: boolean;
+    centeredKey: TOptionalModifierKey;
+    altActionKey: TOptionalModifierKey;
+    selection: boolean;
+    selectionKey: TOptionalModifierKey | ModifierKey[];
+    altSelectionKey: TOptionalModifierKey;
+    selectionColor: string;
+    selectionDashArray: number[];
+    selectionBorderColor: string;
+    selectionLineWidth: number;
+    selectionFullyContained: boolean;
+    hoverCursor: CSSStyleDeclaration['cursor'];
+    moveCursor: CSSStyleDeclaration['cursor'];
+    defaultCursor: CSSStyleDeclaration['cursor'];
+    freeDrawingCursor: CSSStyleDeclaration['cursor'];
+    notAllowedCursor: CSSStyleDeclaration['cursor'];
+    containerClass: string;
+    skipTargetFind: boolean;
+    preserveObjectStacking: boolean;
+    stopContextMenu: boolean;
+    fireRightClick: boolean;
+    fireMiddleClick: boolean;
+    /**
+     * Keep track of the hovered target in the previous event
+     * @type FabricObject | null
+     * @private
+     */
+    _hoveredTarget?: FabricObject;
+    /**
+     * hold the list of nested targets hovered in the previous events
+     * @type FabricObject[]
+     * @private
+     */
+    _hoveredTargets: FabricObject[];
+    /**
+     * hold the list of objects to render
+     * @type FabricObject[]
+     * @private
+     */
+    _objectsToRender?: FabricObject[];
+    /**
+     * hold a reference to a data structure that contains information
+     * on the current on going transform
+     * @type
+     * @private
+     */
+    _currentTransform: Transform | null;
+    /**
+     * hold a reference to a data structure used to track the selection
+     * box on canvas drag
+     * on the current on going transform
+     * x, y, deltaX and deltaY are in scene plane
+     * @type
+     * @private
+     */
+    protected _groupSelector: {
+        x: number;
+        y: number;
+        deltaX: number;
+        deltaY: number;
+    } | null;
+    /**
+     * internal flag used to understand if the context top requires a cleanup
+     * in case this is true, the contextTop will be cleared at the next render
+     * @type boolean
+     * @private
+     */
+    contextTopDirty: boolean;
+    /**
+     * During a mouse event we may need the pointer multiple times in multiple functions.
+     * _scenePoint holds a reference to the pointer in fabricCanvas/design coordinates that is valid for the event
+     * lifespan. Every fabricJS mouse event create and delete the cache every time
+     * We do this because there are some HTML DOM inspection functions to get the actual pointer coordinates
+     * @type {Point}
+     */
+    protected _scenePoint?: Point;
+    /**
+     * During a mouse event we may need the pointer multiple times in multiple functions.
+     * _viewportPoint holds a reference to the pointer in html coordinates that is valid for the event
+     * lifespan. Every fabricJS mouse event create and delete the cache every time
+     * We do this because there are some HTML DOM inspection functions to get the actual pointer coordinates
+     * @type {Point}
+     */
+    protected _viewportPoint?: Point;
+    /**
+     * Holds the informations we cache during an event lifespan
+     * This data is needed many times during an event and we want to avoid to recalculate it
+     * multuple times.
+     */
+    protected _targetInfo: FullTargetsInfoWithContainer | undefined;
+    static ownDefaults: TOptions<CanvasOptions>;
+    static getDefaults(): Record<string, any>;
+    /**
+     * @deprecated
+     * 没有upper canvas，只有一个canvas
+     */
+    get upperCanvasEl(): HTMLCanvasElement;
+    /**
+     * @deprecated
+     * 没有upper canvas，只有一个canvas
+     */
+    get contextTop(): CanvasRenderingContext2D;
+    /**
+     * @deprecated
+     * 没有container，只有一个裸canvas，所以直接返回这个canvas的父元素
+     */
+    get wrapperEl(): ParentNode | null;
+    _activeObject?: FabricObject;
+    /**
+     * @private
+     * @param {FabricObject} obj Object that was added
+     */
+    _onObjectAdded(obj: FabricObject): void;
+    /**
+     * @private
+     * @param {FabricObject} obj Object that was removed
+     */
+    _onObjectRemoved(obj: FabricObject): void;
+    _onStackOrderChanged(): void;
+    /**
+     * Divides objects in two groups, one to render immediately
+     * and one to render as activeGroup.
+     * @return {Array} objects to render immediately and pushes the other in the activeGroup.
+     */
+    _chooseObjectsToRender(): FabricObject[];
+    /**
+     * Renders both the top canvas and the secondary container canvas.
+     */
+    renderAll(): void;
+    /**
+     * text selection is rendered by the active text instance during the rendering cycle
+     */
+    renderTopLayer(): void;
+    /**
+     * Method to render only the top canvas.
+     * Also used to render the group selection box.
+     * Does not render text selection.
+     */
+    renderTop(): void;
+    /**
+     * takes an event and determines if selection key has been pressed
+     * @private
+     * @param {TPointerEvent} e Event object
+     */
+    _isSelectionKeyPressed(e: TPointerEvent): boolean;
+    /**
+     * @private
+     * @param {TPointerEvent} e Event object
+     * @param {FabricObject} target
+     */
+    _shouldClearSelection(e: TPointerEvent, target?: FabricObject): target is undefined;
+    /**
+     * Set the cursor type of the canvas element
+     * @param {String} value Cursor type of the canvas element.
+     * @see http://www.w3.org/TR/css3-ui/#cursor
+     */
+    setCursor(value: CSSStyleDeclaration['cursor']): void;
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx to draw the selection on
+     */
+    protected _drawSelection(): void;
+    /**
+     * @deprecated
+     * 没有upper canvas，只有一个canvas
+     * Returns context of top canvas where interactions are drawn
+     * @returns {CanvasRenderingContext2D}
+     */
+    getTopContext(): CanvasRenderingContext2D;
+    /**
+     * @deprecated
+     * 没有upper canvas，只有一个canvas
+     * Returns context of canvas where object selection is drawn
+     * @alias
+     * @return {CanvasRenderingContext2D}
+     */
+    getSelectionContext(): CanvasRenderingContext2D;
+    /**
+     * @deprecated
+     * 没有upper canvas，只有一个canvas
+     * Returns &lt;canvas> element on which object selection is drawn
+     * @return {HTMLCanvasElement}
+     */
+    getSelectionElement(): HTMLCanvasElement;
+    /**
+     * Returns currently active object
+     * @return {FabricObject | null} active object
+     */
+    getActiveObject(): FabricObject | undefined;
+    /**
+     * Returns an array with the current selected objects
+     * @return {FabricObject[]} active objects array
+     */
+    getActiveObjects(): FabricObject[];
+    /**
+     * @private
+     * Compares the old activeObject with the current one and fires correct events
+     * @param {FabricObject[]} oldObjects old activeObject
+     * @param {TPointerEvent} e mouse event triggering the selection events
+     */
+    _fireSelectionEvents(oldObjects: FabricObject[], e?: TPointerEvent): void;
+    /**
+     * Sets given object as the only active object on canvas
+     * @param {FabricObject} object Object to set as an active one
+     * @param {TPointerEvent} [e] Event (passed along when firing "object:selected")
+     * @return {Boolean} true if the object has been selected
+     */
+    setActiveObject(object: FabricObject, e?: TPointerEvent): boolean;
+    /**
+     * This is supposed to be equivalent to setActiveObject but without firing
+     * any event. There is commitment to have this stay this way.
+     * This is the functional part of setActiveObject.
+     * @param {Object} object to set as active
+     * @param {Event} [e] Event (passed along when firing "object:selected")
+     * @return {Boolean} true if the object has been selected
+     */
+    _setActiveObject(object: FabricObject, e?: TPointerEvent): boolean;
+    /**
+     * This is supposed to be equivalent to discardActiveObject but without firing
+     * any selection events ( can still fire object transformation events ). There is commitment to have this stay this way.
+     * This is the functional part of discardActiveObject.
+     * @param {Event} [e] Event (passed along when firing "object:deselected")
+     * @param {Object} object the next object to set as active, reason why we are discarding this
+     * @return {Boolean} true if the active object has been discarded
+     */
+    _discardActiveObject(e?: TPointerEvent, object?: FabricObject): this is {
+        _activeObject: undefined;
+    };
+    /**
+     * Discards currently active object and fire events. If the function is called by fabric
+     * as a consequence of a mouse event, the event is passed as a parameter and
+     * sent to the fire function for the custom events. When used as a method the
+     * e param does not have any application.
+     * @param {event} e
+     * @return {Boolean} true if the active object has been discarded
+     */
+    discardActiveObject(e?: TPointerEvent): this is {
+        _activeObject: undefined;
+    };
+    /**
+     * End the current transform.
+     * You don't usually need to call this method unless you are interrupting a user initiated transform
+     * because of some other event ( a press of key combination, or something that block the user UX )
+     * @param {Event} [e] send the mouse event that generate the finalize down, so it can be used in the event
+     */
+    endCurrentTransform(e?: TPointerEvent): void;
+    /**
+     * @private
+     * @param {Event} e send the mouse event that generate the finalize down, so it can be used in the event
+     */
+    _finalizeCurrentTransform(e?: TPointerEvent): void;
+    /**
+     * Sets viewport transformation of this canvas instance
+     * @param {Array} vpt a Canvas 2D API transform matrix
+     */
+    setViewportTransform(vpt: TMat2D): void;
+    /**
+     * Clears all contexts (background, main, top) of an instance
+     */
+    clear(): void;
+    /**
+     * Draws objects' controls (borders/controls)
+     * @param {CanvasRenderingContext2D} ctx Context to render controls on
+     */
+    drawControls(ctx: CanvasRenderingContext2D): void;
+    /**
+     * @private
+     */
+    protected _toObject(instance: FabricObject, methodName: 'toObject' | 'toDatalessObject', propertiesToInclude: string[]): Record<string, any>;
+    /**
+     * Realizes an object's group transformation on it
+     * @private
+     * @param {FabricObject} [instance] the object to transform (gets mutated)
+     * @returns the original values of instance which were changed
+     */
+    private _realizeGroupTransformOnObject;
+}
+
+declare class Canvas extends SelectableCanvas implements CanvasOptions {
+    /**
+     * Contains the id of the touch event that owns the fabric transform
+     * @type Number
+     * @private
+     */
+    mainTouchId?: number;
+    enablePointerEvents: boolean;
+    /**
+     * Holds a reference to a setTimeout timer for event synchronization
+     * @type number
+     * @private
+     */
+    private _willAddMouseDown;
+    /**
+     * Holds a reference to an object on the canvas that is receiving the drag over event.
+     * @type FabricObject
+     * @private
+     */
+    private _draggedoverTarget?;
+    /**
+     * Holds a reference to an object on the canvas from where the drag operation started
+     * @type FabricObject
+     * @private
+     */
+    private _dragSource?;
+    private dragInitInfo;
+    private selectionGrap;
+    private mouseDown;
+    /**
+     * Holds a reference to an object on the canvas that is the current drop target
+     * May differ from {@link _draggedoverTarget}
+     * @todo inspect whether {@link _draggedoverTarget} and {@link _dropTarget} should be merged somehow
+     * @type FabricObject
+     * @private
+     */
+    private _dropTarget;
+    /**
+     * a boolean that keeps track of the click state during a cycle of mouse down/up.
+     * If a mouse move occurs it becomes false.
+     * Is true by default, turns false on mouse move.
+     * Used to determine if a mouseUp is a click
+     */
+    private _isClick;
+    /**
+     * 处理点击相关的逻辑
+     */
+    private clickInfo;
+    private hasFiredDragStart;
+    constructor(el?: string | HTMLCanvasElement, options?: TCanvasOptions);
+    private addGraps;
+    private bindEvents;
+    protected _drawSelection(): void;
+    /**
+     * @private
+     * @param {Event} [e] Event object fired on wheel event
+     */
+    private _onMouseWheel;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    private _onMouseOut;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    private _onContextMenu;
+    /**
+     * Return a the id of an event.
+     * returns either the pointerId or the identifier or 0 for the mouse event
+     * @private
+     * @param {Event} evt Event object
+     */
+    getPointerId(evt: TouchEvent | PointerEvent): number;
+    /**
+     * Determines if an event has the id of the event that is considered main
+     * @private
+     * @param {evt} event Event object
+     */
+    _isMainEvent(evt: TPointerEvent): boolean;
+    private handleDragMove;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousemove
+     */
+    private _onMouseMove;
+    /**
+     * @private
+     */
+    _onResize(): void;
+    /**
+     * Decides whether the canvas should be redrawn in mouseup and mousedown events.
+     * @private
+     * @param {Object} target
+     */
+    _shouldRender(target: FabricObject | undefined): boolean | undefined;
+    private handleTripleClick;
+    private handleDbClick;
+    private handleClick;
+    private handlePotentialClick;
+    private handleDragStart;
+    /**
+     * Method that defines the actions when mouse is clicked on canvas.
+     * The method inits the currentTransform parameters and renders all the
+     * canvas so the current image can be placed on the top canvas and the rest
+     * in on the container one.
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    private _onMouseDown;
+    private handleDragEnd;
+    private _onMouseUpOutside;
+    /**
+     * Method that defines the actions when mouse is released on canvas.
+     * The method resets the currentTransform parameters, store the image corner
+     * position in the image object and render the canvas on top.
+     * @private
+     * @param {Event} e Event object fired on mouseup
+     */
+    private _onMouseUp;
+    _basicEventHandler<T extends keyof (CanvasEvents | ObjectEvents)>(eventType: T, options: (CanvasEvents & ObjectEvents)[T]): (CanvasEvents & ObjectEvents)[T];
+    /**
+     * @private
+     * Handle event firing for target and subtargets
+     * @param {TPointerEvent} e event from mouse
+     * @param {TPointerEventNames} eventType
+     */
+    _handleEvent<T extends TPointerEventNames>(e: FederatedPointerEvent, eventType: T, extraData?: TEventsExtraData[T]): void;
+    /**
+     * reset cache form common information needed during event processing
+     * @private
+     */
+    _resetTransformEventData(): void;
+    /**
+     * Cache common information needed during event processing
+     * @private
+     * @param {Event} e Event object fired on event
+     */
+    _cacheTransformEventData(e: TPointerEvent): void;
+    /**
+     * Method that defines the actions when mouse is hovering the canvas.
+     * The currentTransform parameter will define whether the user is rotating/scaling/translating
+     * an image or neither of them (only hovering). A group selection is also possible and would cancel
+     * all any other type of action.
+     * In case of an image transformation only the top canvas will be rendered.
+     * @private
+     * @param {Event} e Event object fired on mousemove
+     */
+    __onMouseMove(e: FederatedPointerEvent): void;
+    /**
+     * Manage the mouseout, mouseover events for the fabric object on the canvas
+     * @param {Fabric.Object} target the target where the target from the mousemove event
+     * @param {Event} e Event object fired on mousemove
+     * @private
+     */
+    private _fireOverOutEvents;
+    /**
+     * Manage the dragEnter, dragLeave events for the fabric objects on the canvas
+     * @param {Fabric.Object} target the target where the target from the onDrag event
+     * @param {Object} data Event object fired on dragover
+     * @private
+     */
+    _fireEnterLeaveEvents(e: FederatedPointerEvent, target: FabricObject | undefined, data: DragEventData): void;
+    /**
+     * @private
+     * @param {Event} e Event fired on mousemove
+     */
+    _transformObject(e: FederatedPointerEvent): void;
+    /**
+     * @private
+     */
+    _performTransformAction(e: FederatedPointerEvent, transform: Transform, pointer: Point): void;
+    /**
+     * Sets the cursor depending on where the canvas is being hovered.
+     * Note: very buggy in Opera
+     * @param {Event} e Event object
+     * @param {Object} target Object that the mouse is hovering, if so.
+     */
+    _setCursorFromEvent(evt: FederatedPointerEvent, target?: FabricObject): void;
+    /**
+     * ## Handles multiple selection
+     * - toggles `target` selection (selects/deselects `target` if it isn't/is selected respectively)
+     * - sets the active object in case it is not set or in case there is a single active object left under active selection.
+     * ---
+     * - If the active object is the active selection we add/remove `target` from it
+     * - If not, add the active object and `target` to the active selection and make it the active object.
+     * @TODO rewrite this after find target is refactored
+     * @private
+     * @param {TPointerEvent} e Event object
+     * @param {FabricObject} target target of event to select/deselect
+     * @returns true if grouping occurred
+     */
+    protected handleMultiSelection(e: TPointerEvent, target?: FabricObject): boolean;
+    private newCollectObjects;
+    /**
+     * ## Handles selection
+     * - selects objects that are contained in (and possibly intersecting) the selection bounding box
+     * - sets the active object
+     * ---
+     * runs on mouse up after a mouse move
+     */
+    protected handleSelection(e: TPointerEvent): boolean;
 }
 
 declare const CENTER = "center";
@@ -859,6 +1582,7 @@ declare const SKEWING = "skewing";
 declare const RESIZING = "resizing";
 declare const MODIFY_POLY = "modifyPoly";
 declare const MODIFY_PATH = "modifyPath";
+declare const MODIFIED = "modified";
 declare const NORMAL = "normal";
 
 interface GroupEvents extends ObjectEvents, CollectionEvents {
@@ -1298,6 +2022,9 @@ declare const saveObjectTransform: (target: InnerObject) => {
     top: number;
 };
 
+type ModifierKey = 'altKey' | 'shiftKey' | 'ctrlKey' | 'metaKey';
+type TOptionalModifierKey = ModifierKey | null | undefined;
+type TPointerEventNames = WithBeforeSuffix<'down'> | WithBeforeSuffix<'move'> | WithBeforeSuffix<'up'> | 'click' | 'dblclick' | 'tripleclick' | 'wheel';
 interface StaticCanvasEvents extends CollectionEvents {
     'canvas:cleared': never;
     'before:render': {
@@ -1313,9 +2040,117 @@ interface StaticCanvasEvents extends CollectionEvents {
         target: Group;
     };
 }
-interface CanvasEvents extends StaticCanvasEvents {
+type BeforeSuffix<T extends string> = `${T}:before`;
+type WithBeforeSuffix<T extends string> = T | BeforeSuffix<T>;
+interface InEvent {
+    previousTarget?: FabricObject;
+}
+interface OutEvent {
+    nextTarget?: FabricObject;
+}
+interface TPointerEventInfo<E extends TPointerEvent = TPointerEvent> extends TEvent<E> {
+    target?: FabricObject;
+    subTargets?: FabricObject[];
+    transform?: Transform | null;
+    scenePoint: Point;
+    viewportPoint: Point;
+}
+type TPointerEvents<Prefix extends string> = Record<`${Prefix}${WithBeforeSuffix<'down'> | WithBeforeSuffix<'move'> | 'click' | 'dblclick' | 'tripleclick'}`, TPointerEventInfo> & Record<`${Prefix}down`, TPointerEventInfo & {
+    /**
+     * Indicates if the target or current target where already selected
+     * before the cycle of mouse down -> mouse up started
+     */
+    alreadySelected: boolean;
+}> & Record<`${Prefix}${WithBeforeSuffix<'up'>}`, TPointerEventInfo & {
+    isClick: boolean;
+}> & Record<`${Prefix}wheel`, TPointerEventInfo<WheelEvent>> & Record<`${Prefix}over`, TPointerEventInfo & InEvent> & Record<`${Prefix}out`, TPointerEventInfo & OutEvent> & Record<'pinch', TPointerEventInfo & {
+    scale: number;
+}> & Record<'rotate', TPointerEventInfo & {
+    rotation: number;
+}>;
+interface DragEventData extends TEvent<DragEvent> {
+    target?: FabricObject;
+    subTargets?: FabricObject[];
+    dragSource?: FabricObject;
+    canDrop?: boolean;
+    didDrop?: boolean;
+    dropTarget?: FabricObject;
+}
+interface DnDEvents {
+    dragstart: TPointerEventInfo;
+    dragend: TPointerEventInfo;
+}
+interface CanvasDnDEvents extends DnDEvents {
 }
-interface ObjectEvents {
+type CanvasPointerEvents = TPointerEvents<'mouse:'>;
+interface MiscEvents {
+    'contextmenu:before': SimpleEventHandler<Event>;
+    contextmenu: SimpleEventHandler<Event>;
+}
+interface ModifyPathEvent {
+    commandIndex: number;
+    pointIndex: number;
+}
+type ObjectModificationEvents = {
+    [MOVING]: BasicTransformEvent;
+    [SCALING]: BasicTransformEvent;
+    [ROTATING]: BasicTransformEvent;
+    [SKEWING]: BasicTransformEvent;
+    [RESIZING]: BasicTransformEvent;
+    [MODIFY_POLY]: BasicTransformEvent;
+    [MODIFY_PATH]: BasicTransformEvent & ModifyPathEvent;
+    [MODIFIED]: ModifiedEvent;
+};
+type CanvasModificationEvents = {
+    'before:transform': TEvent & {
+        transform: Transform;
+    };
+    'object:moving': BasicTransformEvent & {
+        target: FabricObject;
+    };
+    'object:scaling': BasicTransformEvent & {
+        target: FabricObject;
+    };
+    'object:rotating': BasicTransformEvent & {
+        target: FabricObject;
+    };
+    'object:skewing': BasicTransformEvent & {
+        target: FabricObject;
+    };
+    'object:resizing': BasicTransformEvent & {
+        target: FabricObject;
+    };
+    'object:modifyPoly': BasicTransformEvent & {
+        target: FabricObject;
+    };
+    'object:modifyPath': BasicTransformEvent & {
+        target: FabricObject;
+    } & ModifyPathEvent;
+    'object:modified': ModifiedEvent;
+};
+interface CanvasSelectionEvents {
+    'selection:created': Partial<TEvent> & {
+        selected: FabricObject[];
+    };
+    'selection:updated': Partial<TEvent> & {
+        selected: FabricObject[];
+        deselected: FabricObject[];
+    };
+    'before:selection:cleared': Partial<TEvent> & {
+        deselected: FabricObject[];
+    };
+    'selection:cleared': Partial<TEvent> & {
+        deselected: FabricObject[];
+    };
+}
+interface CanvasEvents extends StaticCanvasEvents, CanvasPointerEvents, CanvasDnDEvents, MiscEvents, CanvasModificationEvents, CanvasSelectionEvents {
+}
+interface SimpleEventHandler<T extends Event = TPointerEvent> extends TEvent<T> {
+    target?: FabricObject;
+    subTargets: FabricObject[];
+}
+type ObjectPointerEvents = TPointerEvents<'mouse'>;
+interface ObjectEvents extends ObjectPointerEvents, DnDEvents, MiscEvents, ObjectModificationEvents {
     selected: Partial<TEvent> & {
         target: FabricObject;
     };
@@ -1386,6 +2221,13 @@ interface BasicTransformEvent<E extends Event = TPointerEvent> extends TEvent<E>
     transform: Transform;
     pointer: Point;
 }
+interface BasicTransformEvent<E extends Event = TPointerEvent> extends TEvent<E> {
+    transform: Transform;
+    pointer: Point;
+}
+type TEventsExtraData = Record<PropertyKey, Record<PropertyKey, never>> & Record<'down', {
+    alreadySelected: boolean;
+}>;
 
 declare module 'pixi.js' {
     interface Graphics {
@@ -1426,6 +2268,7 @@ declare class ObjectGeometry<EventSpec extends ObjectEvents = ObjectEvents> exte
     angle: TDegree;
     strokeWidth: number;
     strokeUniform: boolean;
+    protected hitArea: Rectangle;
     constructor();
     protected clearPixiContent(): void;
     getCurGraphics(): Graphics;
@@ -1496,6 +2339,7 @@ declare class ObjectGeometry<EventSpec extends ObjectEvents = ObjectEvents> exte
     calcOwnMatrix(): TMat2D;
     calcTransformMatrix(skipGroup?: boolean): TMat2D;
     getBoundingRect(): TBBox;
+    set(key: string | Record<string, any>, value?: any): this;
 }
 
 declare class InnerObject<Props extends TOptions<ObjectProps> = Partial<ObjectProps>, SProps extends SerializedObjectProps = SerializedObjectProps, EventSpec extends ObjectEvents = ObjectEvents> extends ObjectGeometry<EventSpec> {
@@ -3597,5 +4441,5 @@ declare namespace index {
   };
 }
 
-export { Circle, Ellipse, FabricImage, FabricObject, FabricText, FakeCanvasRenderingContext2D, Group, FabricImage as Image, Line, Path, Point, Polygon, Polyline, Rect, StaticCanvas, FabricText as Text, Triangle, circleDefaultValues, ellipseDefaultValues, groupDefaultValues, polylineDefaultValues, rectDefaultValues, triangleDefaultValues, index as util };
+export { Canvas, Circle, Ellipse, FabricImage, FabricObject, FabricText, FakeCanvasRenderingContext2D, Group, FabricImage as Image, Line, Path, Point, Polygon, Polyline, Rect, StaticCanvas, FabricText as Text, Triangle, circleDefaultValues, ellipseDefaultValues, groupDefaultValues, polylineDefaultValues, rectDefaultValues, triangleDefaultValues, index as util };
 export type { CircleProps, EllipseProps, GroupEvents, GroupOwnProps, GroupProps, IPathBBox, PathProps, RectProps, SerializedCircleProps, SerializedEllipseProps, SerializedGroupProps, SerializedLineProps, SerializedPathProps, SerializedPolylineProps, SerializedRectProps };