fabric 5.3.0 → 6.0.0-beta3

package/dist/src/controls/Control.d.ts

@@ -0,0 +1,228 @@
+import { ControlActionHandler, TPointerEvent, TransformActionHandler } from '../EventTypeDefs';
+import { Point } from '../Point';
+import type { InteractiveFabricObject } from '../shapes/Object/InteractiveObject';
+import { TDegree, TMat2D } from '../typedefs';
+import { ControlRenderingStyleOverride } from './controlRendering';
+export declare class Control {
+    /**
+     * keep track of control visibility.
+     * mainly for backward compatibility.
+     * if you do not want to see a control, you can remove it
+     * from the control set.
+     * @type {Boolean}
+     * @default true
+     */
+    visible: boolean;
+    /**
+     * Name of the action that the control will likely execute.
+     * This is optional. FabricJS uses to identify what the user is doing for some
+     * extra optimizations. If you are writing a custom control and you want to know
+     * somewhere else in the code what is going on, you can use this string here.
+     * you can also provide a custom getActionName if your control run multiple actions
+     * depending on some external state.
+     * default to scale since is the most common, used on 4 corners by default
+     * @type {String}
+     * @default 'scale'
+     */
+    actionName: string;
+    /**
+     * Drawing angle of the control.
+     * NOT used for now, but name marked as needed for internal logic
+     * example: to reuse the same drawing function for different rotated controls
+     * @type {Number}
+     * @default 0
+     */
+    angle: number;
+    /**
+     * Relative position of the control. X
+     * 0,0 is the center of the Object, while -0.5 (left) or 0.5 (right) are the extremities
+     * of the bounding box.
+     * @type {Number}
+     * @default 0
+     */
+    x: number;
+    /**
+     * Relative position of the control. Y
+     * 0,0 is the center of the Object, while -0.5 (top) or 0.5 (bottom) are the extremities
+     * of the bounding box.
+     * @type {Number}
+     * @default 0
+     */
+    y: number;
+    /**
+     * Horizontal offset of the control from the defined position. In pixels
+     * Positive offset moves the control to the right, negative to the left.
+     * It used when you want to have position of control that does not scale with
+     * the bounding box. Example: rotation control is placed at x:0, y: 0.5 on
+     * the boundind box, with an offset of 30 pixels vertically. Those 30 pixels will
+     * stay 30 pixels no matter how the object is big. Another example is having 2
+     * controls in the corner, that stay in the same position when the object scale.
+     * of the bounding box.
+     * @type {Number}
+     * @default 0
+     */
+    offsetX: number;
+    /**
+     * Vertical offset of the control from the defined position. In pixels
+     * Positive offset moves the control to the bottom, negative to the top.
+     * @type {Number}
+     * @default 0
+     */
+    offsetY: number;
+    /**
+     * Sets the length of the control. If null, defaults to object's cornerSize.
+     * Expects both sizeX and sizeY to be set when set.
+     * @type {?Number}
+     * @default null
+     */
+    sizeX: number | null;
+    /**
+     * Sets the height of the control. If null, defaults to object's cornerSize.
+     * Expects both sizeX and sizeY to be set when set.
+     * @type {?Number}
+     * @default null
+     */
+    sizeY: number | null;
+    /**
+     * Sets the length of the touch area of the control. If null, defaults to object's touchCornerSize.
+     * Expects both touchSizeX and touchSizeY to be set when set.
+     * @type {?Number}
+     * @default null
+     */
+    touchSizeX: number | null;
+    /**
+     * Sets the height of the touch area of the control. If null, defaults to object's touchCornerSize.
+     * Expects both touchSizeX and touchSizeY to be set when set.
+     * @type {?Number}
+     * @default null
+     */
+    touchSizeY: number | null;
+    /**
+     * Css cursor style to display when the control is hovered.
+     * if the method `cursorStyleHandler` is provided, this property is ignored.
+     * @type {String}
+     * @default 'crosshair'
+     */
+    cursorStyle: string;
+    /**
+     * If controls has an offsetY or offsetX, draw a line that connects
+     * the control to the bounding box
+     * @type {Boolean}
+     * @default false
+     */
+    withConnection: boolean;
+    constructor(options: Partial<Control>);
+    /**
+     * The control actionHandler, provide one to handle action ( control being moved )
+     * @param {Event} eventData the native mouse event
+     * @param {Transform} transformData properties of the current transform
+     * @param {Number} x x position of the cursor
+     * @param {Number} y y position of the cursor
+     * @return {Boolean} true if the action/event modified the object
+     */
+    actionHandler: TransformActionHandler;
+    /**
+     * The control handler for mouse down, provide one to handle mouse down on control
+     * @param {Event} eventData the native mouse event
+     * @param {Transform} transformData properties of the current transform
+     * @param {Number} x x position of the cursor
+     * @param {Number} y y position of the cursor
+     * @return {Boolean} true if the action/event modified the object
+     */
+    mouseDownHandler?: ControlActionHandler;
+    /**
+     * The control mouseUpHandler, provide one to handle an effect on mouse up.
+     * @param {Event} eventData the native mouse event
+     * @param {Transform} transformData properties of the current transform
+     * @param {Number} x x position of the cursor
+     * @param {Number} y y position of the cursor
+     * @return {Boolean} true if the action/event modified the object
+     */
+    mouseUpHandler?: ControlActionHandler;
+    /**
+     * Returns control actionHandler
+     * @param {Event} eventData the native mouse event
+     * @param {FabricObject} fabricObject on which the control is displayed
+     * @param {Control} control control for which the action handler is being asked
+     * @return {Function} the action handler
+     */
+    getActionHandler(eventData: TPointerEvent, fabricObject: InteractiveFabricObject, control: Control): TransformActionHandler | undefined;
+    /**
+     * Returns control mouseDown handler
+     * @param {Event} eventData the native mouse event
+     * @param {FabricObject} fabricObject on which the control is displayed
+     * @param {Control} control control for which the action handler is being asked
+     * @return {Function} the action handler
+     */
+    getMouseDownHandler(eventData: TPointerEvent, fabricObject: InteractiveFabricObject, control: Control): ControlActionHandler | undefined;
+    /**
+     * Returns control mouseUp handler.
+     * During actions the fabricObject or the control can be of different obj
+     * @param {Event} eventData the native mouse event
+     * @param {FabricObject} fabricObject on which the control is displayed
+     * @param {Control} control control for which the action handler is being asked
+     * @return {Function} the action handler
+     */
+    getMouseUpHandler(eventData: TPointerEvent, fabricObject: InteractiveFabricObject, control: Control): ControlActionHandler | undefined;
+    /**
+     * Returns control cursorStyle for css using cursorStyle. If you need a more elaborate
+     * function you can pass one in the constructor
+     * the cursorStyle property
+     * @param {Event} eventData the native mouse event
+     * @param {Control} control the current control ( likely this)
+     * @param {FabricObject} object on which the control is displayed
+     * @return {String}
+     */
+    cursorStyleHandler(eventData: TPointerEvent, control: Control, fabricObject: InteractiveFabricObject): string;
+    /**
+     * Returns the action name. The basic implementation just return the actionName property.
+     * @param {Event} eventData the native mouse event
+     * @param {Control} control the current control ( likely this)
+     * @param {FabricObject} object on which the control is displayed
+     * @return {String}
+     */
+    getActionName(eventData: TPointerEvent, control: Control, fabricObject: InteractiveFabricObject): string;
+    /**
+     * Returns controls visibility
+     * @param {FabricObject} object on which the control is displayed
+     * @param {String} controlKey key where the control is memorized on the
+     * @return {Boolean}
+     */
+    getVisibility(fabricObject: InteractiveFabricObject, controlKey: string): boolean;
+    /**
+     * Sets controls visibility
+     * @param {Boolean} visibility for the object
+     * @return {Void}
+     */
+    setVisibility(visibility: boolean, name: string, fabricObject: InteractiveFabricObject): void;
+    positionHandler(dim: Point, finalMatrix: TMat2D, fabricObject: InteractiveFabricObject, currentControl: Control): Point;
+    /**
+     * Returns the coords for this control based on object values.
+     * @param {Number} objectAngle angle from the fabric object holding the control
+     * @param {Number} objectCornerSize cornerSize from the fabric object holding the control (or touchCornerSize if
+     *   isTouch is true)
+     * @param {Number} centerX x coordinate where the control center should be
+     * @param {Number} centerY y coordinate where the control center should be
+     * @param {boolean} isTouch true if touch corner, false if normal corner
+     */
+    calcCornerCoords(objectAngle: TDegree, objectCornerSize: number, centerX: number, centerY: number, isTouch: boolean): {
+        tl: Point;
+        tr: Point;
+        bl: Point;
+        br: Point;
+    };
+    /**
+     * Render function for the control.
+     * When this function runs the context is unscaled. unrotate. Just retina scaled.
+     * all the functions will have to translate to the point left,top before starting Drawing
+     * if they want to draw a control where the position is detected.
+     * left and top are the result of the positionHandler function
+     * @param {RenderingContext2D} ctx the context where the control will be drawn
+     * @param {Number} left position of the canvas where we are about to render the control.
+     * @param {Number} top position of the canvas where we are about to render the control.
+     * @param {Object} styleOverride
+     * @param {FabricObject} fabricObject the object where the control is about to be rendered
+     */
+    render(ctx: CanvasRenderingContext2D, left: number, top: number, styleOverride: ControlRenderingStyleOverride | undefined, fabricObject: InteractiveFabricObject): void;
+}
+//# sourceMappingURL=Control.d.ts.map

package/dist/src/controls/changeWidth.d.ts

@@ -0,0 +1,13 @@
+import { TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Action handler to change object's width
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const changeObjectWidth: TransformActionHandler;
+export declare const changeWidth: TransformActionHandler<import("../EventTypeDefs").Transform>;
+//# sourceMappingURL=changeWidth.d.ts.map

package/dist/src/controls/commonControls.d.ts

@@ -0,0 +1,28 @@
+import { Control } from './Control';
+export declare const createObjectDefaultControls: () => {
+    ml: Control;
+    mr: Control;
+    mb: Control;
+    mt: Control;
+    tl: Control;
+    tr: Control;
+    bl: Control;
+    br: Control;
+    mtr: Control;
+};
+export declare const createResizeControls: () => {
+    mr: Control;
+    ml: Control;
+};
+export declare const createTextboxDefaultControls: () => {
+    mr: Control;
+    ml: Control;
+    mb: Control;
+    mt: Control;
+    tl: Control;
+    tr: Control;
+    bl: Control;
+    br: Control;
+    mtr: Control;
+};
+//# sourceMappingURL=commonControls.d.ts.map

package/dist/src/controls/controlRendering.d.ts

@@ -0,0 +1,29 @@
+import type { InteractiveFabricObject } from '../shapes/Object/InteractiveObject';
+import type { Control } from './Control';
+export type ControlRenderingStyleOverride = Partial<Pick<InteractiveFabricObject, 'cornerStyle' | 'cornerSize' | 'cornerColor' | 'cornerStrokeColor' | 'cornerDashArray' | 'transparentCorners'>>;
+export type ControlRenderer = (ctx: CanvasRenderingContext2D, left: number, top: number, styleOverride: ControlRenderingStyleOverride, fabricObject: InteractiveFabricObject) => void;
+/**
+ * Render a round control, as per fabric features.
+ * This function is written to respect object properties like transparentCorners, cornerSize
+ * cornerColor, cornerStrokeColor
+ * plus the addition of offsetY and offsetX.
+ * @param {CanvasRenderingContext2D} ctx context to render on
+ * @param {Number} left x coordinate where the control center should be
+ * @param {Number} top y coordinate where the control center should be
+ * @param {Object} styleOverride override for FabricObject controls style
+ * @param {FabricObject} fabricObject the fabric object for which we are rendering controls
+ */
+export declare function renderCircleControl(this: Control, ctx: CanvasRenderingContext2D, left: number, top: number, styleOverride: ControlRenderingStyleOverride, fabricObject: InteractiveFabricObject): void;
+/**
+ * Render a square control, as per fabric features.
+ * This function is written to respect object properties like transparentCorners, cornerSize
+ * cornerColor, cornerStrokeColor
+ * plus the addition of offsetY and offsetX.
+ * @param {CanvasRenderingContext2D} ctx context to render on
+ * @param {Number} left x coordinate where the control center should be
+ * @param {Number} top y coordinate where the control center should be
+ * @param {Object} styleOverride override for FabricObject controls style
+ * @param {FabricObject} fabricObject the fabric object for which we are rendering controls
+ */
+export declare function renderSquareControl(this: Control, ctx: CanvasRenderingContext2D, left: number, top: number, styleOverride: ControlRenderingStyleOverride, fabricObject: InteractiveFabricObject): void;
+//# sourceMappingURL=controlRendering.d.ts.map

package/dist/src/controls/drag.d.ts

@@ -0,0 +1,12 @@
+import { TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Action handler
+ * @private
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if the translation occurred
+ */
+export declare const dragHandler: TransformActionHandler;
+//# sourceMappingURL=drag.d.ts.map

package/dist/src/controls/index.d.ts

@@ -0,0 +1,13 @@
+export { changeWidth } from './changeWidth';
+export { renderCircleControl, renderSquareControl } from './controlRendering';
+export * from './commonControls';
+export { dragHandler } from './drag';
+export { createPolyControls } from './polyControl';
+export { rotationStyleHandler, rotationWithSnapping } from './rotate';
+export { scaleCursorStyleHandler, scalingEqually, scalingX, scalingY, } from './scale';
+export { scaleOrSkewActionName, scaleSkewCursorStyleHandler, scalingXOrSkewingY, scalingYOrSkewingX, } from './scaleSkew';
+export { skewCursorStyleHandler, skewHandlerX, skewHandlerY } from './skew';
+export { getLocalPoint } from './util';
+export { wrapWithFireEvent } from './wrapWithFireEvent';
+export { wrapWithFixedAnchor } from './wrapWithFixedAnchor';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/controls/polyControl.d.ts

@@ -0,0 +1,5 @@
+import { Control } from './Control';
+import type { Polyline } from '../shapes/Polyline';
+export declare function createPolyControls(poly: Polyline, options?: Partial<Control>): Record<string, Control>;
+export declare function createPolyControls(numOfControls: number, options?: Partial<Control>): Record<string, Control>;
+//# sourceMappingURL=polyControl.d.ts.map

package/dist/src/controls/rotate.d.ts

@@ -0,0 +1,12 @@
+import { ControlCursorCallback, TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Find the correct style for the control that is used for rotation.
+ * this function is very simple and it just take care of not-allowed or standard cursor
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} a valid css string for the cursor
+ */
+export declare const rotationStyleHandler: ControlCursorCallback;
+export declare const rotationWithSnapping: TransformActionHandler<import("../EventTypeDefs").Transform>;
+//# sourceMappingURL=rotate.d.ts.map

package/dist/src/controls/scale.d.ts

@@ -0,0 +1,47 @@
+import { ControlCursorCallback, TPointerEvent, Transform, TransformActionHandler } from '../EventTypeDefs';
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import { TAxis } from '../typedefs';
+type ScaleTransform = Transform & {
+    gestureScale?: number;
+    signX?: number;
+    signY?: number;
+};
+type ScaleBy = TAxis | 'equally' | '' | undefined;
+/**
+ * Inspect event and fabricObject properties to understand if the scaling action
+ * @param {Event} eventData from the user action
+ * @param {FabricObject} fabricObject the fabric object about to scale
+ * @return {Boolean} true if scale is proportional
+ */
+export declare function scaleIsProportional(eventData: TPointerEvent, fabricObject: FabricObject): boolean;
+/**
+ * Inspect fabricObject to understand if the current scaling action is allowed
+ * @param {FabricObject} fabricObject the fabric object about to scale
+ * @param {String} by 'x' or 'y' or ''
+ * @param {Boolean} scaleProportionally true if we are trying to scale proportionally
+ * @return {Boolean} true if scaling is not allowed at current conditions
+ */
+export declare function scalingIsForbidden(fabricObject: FabricObject, by: ScaleBy, scaleProportionally: boolean): boolean;
+/**
+ * return the correct cursor style for the scale action
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} a valid css string for the cursor
+ */
+export declare const scaleCursorStyleHandler: ControlCursorCallback;
+/**
+ * Generic scaling logic, to scale from corners either equally or freely.
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const scaleObjectFromCorner: TransformActionHandler<ScaleTransform>;
+export declare const scalingEqually: TransformActionHandler<ScaleTransform>;
+export declare const scalingX: TransformActionHandler<ScaleTransform>;
+export declare const scalingY: TransformActionHandler<ScaleTransform>;
+export {};
+//# sourceMappingURL=scale.d.ts.map

package/dist/src/controls/scaleSkew.d.ts

@@ -0,0 +1,39 @@
+import { ControlCallback, ControlCursorCallback, TransformActionHandler } from '../EventTypeDefs';
+import { TAxisKey } from '../typedefs';
+/**
+ * Inspect event, control and fabricObject to return the correct action name
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} an action name
+ */
+export declare const scaleOrSkewActionName: ControlCallback<TAxisKey<'skew' | 'scale'> | ''>;
+/**
+ * Combine skew and scale style handlers to cover fabric standard use case
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} a valid css string for the cursor
+ */
+export declare const scaleSkewCursorStyleHandler: ControlCursorCallback;
+/**
+ * Composed action handler to either scale X or skew Y
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const scalingXOrSkewingY: TransformActionHandler;
+/**
+ * Composed action handler to either scale Y or skew X
+ * Needs to be wrapped with `wrapWithFixedAnchor` to be effective
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const scalingYOrSkewingX: TransformActionHandler;
+//# sourceMappingURL=scaleSkew.d.ts.map

package/dist/src/controls/skew.d.ts

@@ -0,0 +1,33 @@
+import { ControlCursorCallback, Transform, TransformActionHandler } from '../EventTypeDefs';
+export type SkewTransform = Transform & {
+    skewingSide: -1 | 1;
+};
+/**
+ * return the correct cursor style for the skew action
+ * @param {Event} eventData the javascript event that is causing the scale
+ * @param {Control} control the control that is interested in the action
+ * @param {FabricObject} fabricObject the fabric object that is interested in the action
+ * @return {String} a valid css string for the cursor
+ */
+export declare const skewCursorStyleHandler: ControlCursorCallback;
+/**
+ * Wrapped Action handler for skewing on the X axis, takes care of the
+ * skew direction and determines the correct transform origin for the anchor point
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const skewHandlerX: TransformActionHandler;
+/**
+ * Wrapped Action handler for skewing on the Y axis, takes care of the
+ * skew direction and determines the correct transform origin for the anchor point
+ * @param {Event} eventData javascript event that is doing the transform
+ * @param {Object} transform javascript object containing a series of information around the current transform
+ * @param {number} x current mouse x position, canvas normalized
+ * @param {number} y current mouse y position, canvas normalized
+ * @return {Boolean} true if some change happened
+ */
+export declare const skewHandlerY: TransformActionHandler;
+//# sourceMappingURL=skew.d.ts.map

package/dist/src/controls/util.d.ts

@@ -0,0 +1,41 @@
+import { TPointerEvent, Transform, TransformAction, BasicTransformEvent } from '../EventTypeDefs';
+import { Point } from '../Point';
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import { TOriginX, TOriginY } from '../typedefs';
+import type { Control } from './Control';
+export declare const NOT_ALLOWED_CURSOR = "not-allowed";
+/**
+ * @param {Boolean} alreadySelected true if target is already selected
+ * @param {String} corner a string representing the corner ml, mr, tl ...
+ * @param {Event} e Event object
+ * @param {FabricObject} [target] inserted back to help overriding. Unused
+ */
+export declare const getActionFromCorner: (alreadySelected: boolean, corner: string, e: TPointerEvent, target: FabricObject) => string;
+/**
+ * Checks if transform is centered
+ * @param {Object} transform transform data
+ * @return {Boolean} true if transform is centered
+ */
+export declare function isTransformCentered(transform: Transform): boolean;
+export declare function invertOrigin(origin: TOriginX | TOriginY): number;
+export declare const isLocked: (target: FabricObject, lockingKey: 'lockMovementX' | 'lockMovementY' | 'lockRotation' | 'lockScalingX' | 'lockScalingY' | 'lockSkewingX' | 'lockSkewingY' | 'lockScalingFlip') => boolean;
+export declare const commonEventInfo: TransformAction<Transform, BasicTransformEvent>;
+/**
+ * Combine control position and object angle to find the control direction compared
+ * to the object center.
+ * @param {FabricObject} fabricObject the fabric object for which we are rendering controls
+ * @param {Control} control the control class
+ * @return {Number} 0 - 7 a quadrant number
+ */
+export declare function findCornerQuadrant(fabricObject: FabricObject, control: Control): number;
+/**
+ * Transforms a point to the offset from the given origin
+ * @param {Object} transform
+ * @param {String} originX
+ * @param {String} originY
+ * @param {number} x
+ * @param {number} y
+ * @return {Fabric.Point} the normalized point
+ */
+export declare function getLocalPoint({ target, corner }: Transform, originX: TOriginX, originY: TOriginY, x: number, y: number): Point;
+//# sourceMappingURL=util.d.ts.map

package/dist/src/controls/wrapWithFireEvent.d.ts

@@ -0,0 +1,8 @@
+import { TModificationEvents, Transform, TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Wrap an action handler with firing an event if the action is performed
+ * @param {Function} actionHandler the function to wrap
+ * @return {Function} a function with an action handler signature
+ */
+export declare const wrapWithFireEvent: <T extends Transform>(eventName: TModificationEvents, actionHandler: TransformActionHandler<T>) => TransformActionHandler<T>;
+//# sourceMappingURL=wrapWithFireEvent.d.ts.map

package/dist/src/controls/wrapWithFixedAnchor.d.ts

@@ -0,0 +1,9 @@
+import { Transform, TransformActionHandler } from '../EventTypeDefs';
+/**
+ * Wrap an action handler with saving/restoring object position on the transform.
+ * this is the code that permits to objects to keep their position while transforming.
+ * @param {Function} actionHandler the function to wrap
+ * @return {Function} a function with an action handler signature
+ */
+export declare function wrapWithFixedAnchor<T extends Transform>(actionHandler: TransformActionHandler<T>): TransformActionHandler<T>;
+//# sourceMappingURL=wrapWithFixedAnchor.d.ts.map

package/dist/src/env/browser.d.ts

@@ -0,0 +1,3 @@
+import { TFabricEnv } from './types';
+export declare const getEnv: () => TFabricEnv;
+//# sourceMappingURL=browser.d.ts.map

package/dist/src/env/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This file is consumed by fabric.
+ * The `./node` and `./browser` files define the env variable that is used by this module.
+ * The `./node` module sets the env at import time.
+ * The `./browser` module is defined to be the default env and doesn't set the env at all.
+ * This is done in order to support isomorphic usage for browser and node applications
+ * since window and document aren't defined at time of import in SSR, we can't set env so we avoid it by deferring to the default env.
+ */
+import { TFabricEnv } from './types';
+import type { DOMWindow } from 'jsdom';
+export declare const setEnv: (value: TFabricEnv) => void;
+export declare const getEnv: () => TFabricEnv;
+export declare const getDocument: () => Document;
+export declare const getWindow: () => Window | DOMWindow;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/env/node.d.ts

@@ -0,0 +1,5 @@
+import type { Canvas as NodeCanvas } from 'canvas';
+import { TFabricEnv } from './types';
+export declare const getNodeCanvas: (canvasEl: HTMLCanvasElement) => NodeCanvas;
+export declare const getEnv: () => TFabricEnv;
+//# sourceMappingURL=node.d.ts.map

package/dist/src/env/types.d.ts

@@ -0,0 +1,15 @@
+import { GLProbe } from '../filters/GLProbes/GLProbe';
+import type { DOMWindow } from 'jsdom';
+export type TCopyPasteData = {
+    copiedText?: string;
+    copiedStyle?: Record<string, string>;
+};
+export type TFabricEnv = {
+    document: Document;
+    window: Window | DOMWindow;
+    isTouchSupported: boolean;
+    WebGLProbe: GLProbe;
+    dispose(element: Element): void;
+    copyPasteData: TCopyPasteData;
+};
+//# sourceMappingURL=types.d.ts.map