fabric 6.2.0 → 6.3.0

package/dist-extensions/src/canvas/Canvas.d.ts

@@ -0,0 +1,339 @@
+import type { CanvasEvents, DragEventData, ObjectEvents, TPointerEvent, TPointerEventNames, Transform } from '../EventTypeDefs';
+import { Point } from '../Point';
+import type { FabricObject } from '../shapes/Object/FabricObject';
+import type { CanvasOptions, TCanvasOptions } from './CanvasOptions';
+import { SelectableCanvas } from './SelectableCanvas';
+import { TextEditingManager } from './TextEditingManager';
+type TSyntheticEventContext = {
+    mouse: {
+        e: TPointerEvent;
+    };
+    drag: DragEventData;
+};
+export 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?;
+    /**
+     * 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;
+    private _isClick;
+    textEditingManager: TextEditingManager;
+    constructor(el?: string | HTMLCanvasElement, options?: TCanvasOptions);
+    /**
+     * return an event prefix pointer or mouse.
+     * @private
+     */
+    private _getEventPrefix;
+    addOrRemove(functor: any, _eventjsFunctor: 'add' | 'remove'): void;
+    /**
+     * Removes all event listeners
+     */
+    removeListeners(): 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 mouseenter
+     */
+    private _onMouseEnter;
+    /**
+     * supports native like text dragging
+     * @private
+     * @param {DragEvent} e
+     */
+    private _onDragStart;
+    /**
+     * First we clear top context where the effects are being rendered.
+     * Then we render the effects.
+     * Doing so will render the correct effect for all cases including an overlap between `source` and `target`.
+     * @private
+     */
+    private _renderDragEffects;
+    /**
+     * supports native like text dragging
+     * https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/Drag_operations#finishing_a_drag
+     * @private
+     * @param {DragEvent} e
+     */
+    private _onDragEnd;
+    /**
+     * fire `drag` event on canvas and drag source
+     * @private
+     * @param {DragEvent} e
+     */
+    private _onDragProgress;
+    /**
+     * As opposed to {@link findTarget} we want the top most object to be returned w/o the active object cutting in line.
+     * Override at will
+     */
+    protected findDragTargets(e: DragEvent): {
+        target: FabricObject<Partial<import("../..").FabricObjectProps>, import("../..").SerializedObjectProps, ObjectEvents> | undefined;
+        targets: FabricObject<Partial<import("../..").FabricObjectProps>, import("../..").SerializedObjectProps, ObjectEvents>[];
+    };
+    /**
+     * prevent default to allow drop event to be fired
+     * https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/Drag_operations#specifying_drop_targets
+     * @private
+     * @param {DragEvent} [e] Event object fired on Event.js shake
+     */
+    private _onDragOver;
+    /**
+     * fire `dragleave` on `dragover` targets
+     * @private
+     * @param {Event} [e] Event object fired on Event.js shake
+     */
+    private _onDragEnter;
+    /**
+     * fire `dragleave` on `dragover` targets
+     * @private
+     * @param {Event} [e] Event object fired on Event.js shake
+     */
+    private _onDragLeave;
+    /**
+     * `drop:before` is a an event that allows you to schedule logic
+     * before the `drop` event. Prefer `drop` event always, but if you need
+     * to run some drop-disabling logic on an event, since there is no way
+     * to handle event handlers ordering, use `drop:before`
+     * @private
+     * @param {Event} e
+     */
+    private _onDrop;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    private _onContextMenu;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    private _onDoubleClick;
+    /**
+     * 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
+     * @param {Event} e Event object fired on mousedown
+     */
+    _onTouchStart(e: TouchEvent): void;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    _onMouseDown(e: TPointerEvent): void;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    _onTouchEnd(e: TouchEvent): void;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mouseup
+     */
+    _onMouseUp(e: TPointerEvent): void;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousemove
+     */
+    _onMouseMove(e: TPointerEvent): void;
+    /**
+     * @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;
+    /**
+     * 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
+     */
+    __onMouseUp(e: TPointerEvent): void;
+    _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: TPointerEvent, eventType: T): void;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousedown
+     */
+    _onMouseDownInDrawingMode(e: TPointerEvent): void;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mousemove
+     */
+    _onMouseMoveInDrawingMode(e: TPointerEvent): void;
+    /**
+     * @private
+     * @param {Event} e Event object fired on mouseup
+     */
+    _onMouseUpInDrawingMode(e: TPointerEvent): void;
+    /**
+     * 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
+     */
+    __onMouseDown(e: TPointerEvent): 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: TPointerEvent): 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
+     */
+    _fireOverOutEvents(e: TPointerEvent, target?: FabricObject): void;
+    /**
+     * 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(target: FabricObject | undefined, data: DragEventData): void;
+    /**
+     * Manage the synthetic in/out events for the fabric objects on the canvas
+     * @param {Fabric.Object} target the target where the target from the supported events
+     * @param {Object} data Event object fired
+     * @param {Object} config configuration for the function to work
+     * @param {String} config.targetName property on the canvas where the old target is stored
+     * @param {String} [config.canvasEvtOut] name of the event to fire at canvas level for out
+     * @param {String} config.evtOut name of the event to fire for out
+     * @param {String} [config.canvasEvtIn] name of the event to fire at canvas level for in
+     * @param {String} config.evtIn name of the event to fire for in
+     * @private
+     */
+    fireSyntheticInOutEvents<T extends keyof TSyntheticEventContext>(type: T, { target, oldTarget, fireCanvas, e, ...data }: TSyntheticEventContext[T] & {
+        target?: FabricObject;
+        oldTarget?: FabricObject;
+        fireCanvas?: boolean;
+    }): void;
+    /**
+     * Method that defines actions when an Event Mouse Wheel
+     * @param {Event} e Event object fired on mouseup
+     */
+    __onMouseWheel(e: TPointerEvent): void;
+    /**
+     * @private
+     * @param {Event} e Event fired on mousemove
+     */
+    _transformObject(e: TPointerEvent): void;
+    /**
+     * @private
+     */
+    _performTransformAction(e: TPointerEvent, 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(e: TPointerEvent, 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.
+     * @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;
+    /**
+     * ## 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;
+    /**
+     * @override clear {@link textEditingManager}
+     */
+    clear(): void;
+    /**
+     * @override clear {@link textEditingManager}
+     */
+    destroy(): void;
+}
+export {};
+//# sourceMappingURL=Canvas.d.ts.map

package/dist-extensions/src/canvas/Canvas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Canvas.d.ts","sourceRoot":"","sources":["../../../src/canvas/Canvas.ts"],"names":[],"mappings":"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"}

package/dist-extensions/src/canvas/CanvasOptions.d.ts

@@ -0,0 +1,229 @@
+import type { ModifierKey, TOptionalModifierKey } from '../EventTypeDefs';
+import type { TOptions } from '../typedefs';
+import type { StaticCanvasOptions } from './StaticCanvasOptions';
+export 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
+     * @default
+     * @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
+     * @default
+     */
+    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
+     * @default
+     */
+    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
+     * @default
+     */
+    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
+     * @default
+     */
+    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
+     * @default
+     */
+    altActionKey: TOptionalModifierKey;
+}
+export interface CanvasSelectionOptions {
+    /**
+     * Indicates whether group selection should be enabled
+     * @type Boolean
+     * @default
+     */
+    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[]
+     * @default
+     */
+    selectionKey: TOptionalModifierKey | ModifierKey[];
+    /**
+     * Indicates which key enable alternative selection
+     * in case of target overlapping with active object
+     * 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
+     * @default
+     */
+    altSelectionKey: TOptionalModifierKey;
+    /**
+     * Color of selection
+     * @type String
+     * @default
+     */
+    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
+     * @default
+     */
+    selectionBorderColor: string;
+    /**
+     * Width of a line used in object/group selection
+     * @type Number
+     * @default
+     */
+    selectionLineWidth: number;
+    /**
+     * Select only shapes that are fully contained in the dragged selection rectangle.
+     * @type Boolean
+     * @default
+     */
+    selectionFullyContained: boolean;
+}
+export 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'];
+}
+export interface TargetFindOptions {
+    /**
+     * When true, object detection happens on per-pixel basis rather than on per-bounding-box
+     * @type Boolean
+     * @default
+     */
+    perPixelTargetFind: boolean;
+    /**
+     * Number of pixels around target pixel to tolerate (consider active) during object detection
+     * @type Number
+     * @default
+     */
+    targetFindTolerance: number;
+    /**
+     * 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
+     * @default
+     */
+    skipTargetFind: boolean;
+}
+export interface CanvasEventsOptions {
+    /**
+     * Indicates if the right click on canvas can output the context menu or not
+     * @type Boolean
+     * @since 1.6.5
+     * @default
+     */
+    stopContextMenu: boolean;
+    /**
+     * Indicates if the canvas can fire right click events
+     * @type Boolean
+     * @since 1.6.5
+     * @default
+     */
+    fireRightClick: boolean;
+    /**
+     * Indicates if the canvas can fire middle click events
+     * @type Boolean
+     * @since 1.7.8
+     * @default
+     */
+    fireMiddleClick: boolean;
+    /**
+     * When the option is enabled, PointerEvent is used instead of TPointerEvent.
+     * @type Boolean
+     * @default
+     */
+    enablePointerEvents: boolean;
+}
+export interface CanvasOptions extends StaticCanvasOptions, CanvasTransformOptions, CanvasSelectionOptions, CanvasCursorOptions, TargetFindOptions, CanvasEventsOptions {
+    /**
+     * Default element class that's given to wrapper (div) element of canvas
+     * @type String
+     * @default
+     * @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
+     */
+    preserveObjectStacking: boolean;
+}
+export type TCanvasOptions = TOptions<CanvasOptions>;
+export declare const canvasDefaults: TOptions<CanvasOptions>;
+//# sourceMappingURL=CanvasOptions.d.ts.map

package/dist-extensions/src/canvas/CanvasOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasOptions.d.ts","sourceRoot":"","sources":["../../../src/canvas/CanvasOptions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAEjE,MAAM,WAAW,sBAAsB;IACrC;;;;;;OAMG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;;;;;;;;;OAWG;IACH,WAAW,EAAE,oBAAoB,CAAC;IAElC;;;;;;OAMG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;;;;;OAMG;IACH,gBAAgB,EAAE,OAAO,CAAC;IAE1B;;;;;;;;OAQG;IACH,WAAW,EAAE,oBAAoB,CAAC;IAElC;;;;;;;;OAQG;IACH,YAAY,EAAE,oBAAoB,CAAC;CACpC;AAED,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,SAAS,EAAE,OAAO,CAAC;IAEnB;;;;;;;;;OASG;IACH,YAAY,EAAE,oBAAoB,GAAG,WAAW,EAAE,CAAC;IAEnD;;;;;;;;;;;OAWG;IACH,eAAe,EAAE,oBAAoB,CAAC;IAEtC;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAE7B;;;;OAIG;IACH,oBAAoB,EAAE,MAAM,CAAC;IAE7B;;;;OAIG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAE3B;;;;OAIG;IACH,uBAAuB,EAAE,OAAO,CAAC;CAClC;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,WAAW,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAE3C;;;;OAIG;IACH,UAAU,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAE1C;;;;OAIG;IACH,aAAa,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAE7C;;;;OAIG;IACH,iBAAiB,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;IAEjD;;;;;OAKG;IACH,gBAAgB,EAAE,mBAAmB,CAAC,QAAQ,CAAC,CAAC;CACjD;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,kBAAkB,EAAE,OAAO,CAAC;IAE5B;;;;OAIG;IACH,mBAAmB,EAAE,MAAM,CAAC;IAE5B;;;;;;;;OAQG;IACH,cAAc,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;;;;OAKG;IACH,cAAc,EAAE,OAAO,CAAC;IAExB;;;;;OAKG;IACH,eAAe,EAAE,OAAO,CAAC;IAEzB;;;;OAIG;IACH,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,aACf,SAAQ,mBAAmB,EACzB,sBAAsB,EACtB,sBAAsB,EACtB,mBAAmB,EACnB,iBAAiB,EACjB,mBAAmB;IACrB;;;;;OAKG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;;OAKG;IACH,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;AAErD,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,aAAa,CAkClD,CAAC"}

package/dist-extensions/src/canvas/DOMManagers/CanvasDOMManager.d.ts

@@ -0,0 +1,29 @@
+import type { TSize } from '../../typedefs';
+import type { CSSDimensions } from './util';
+import type { CanvasItem } from './StaticCanvasDOMManager';
+import { StaticCanvasDOMManager } from './StaticCanvasDOMManager';
+export declare class CanvasDOMManager extends StaticCanvasDOMManager {
+    upper: CanvasItem;
+    container: HTMLDivElement;
+    constructor(arg0?: string | HTMLCanvasElement, { allowTouchScrolling, containerClass, }?: {
+        allowTouchScrolling?: boolean;
+        /**
+         * @deprecated here only for backward compatibility
+         */
+        containerClass?: string;
+    });
+    protected createUpperCanvas(): HTMLCanvasElement;
+    protected createContainerElement(): HTMLDivElement;
+    /**
+     * @private
+     * @param {HTMLCanvasElement} element canvas element to apply styles on
+     */
+    protected applyCanvasStyle(element: HTMLCanvasElement, { allowTouchScrolling: allow }: {
+        allowTouchScrolling: boolean;
+    }): void;
+    setDimensions(size: TSize, retinaScaling: number): void;
+    setCSSDimensions(size: Partial<CSSDimensions>): void;
+    cleanupDOM(size: TSize): void;
+    dispose(): void;
+}
+//# sourceMappingURL=CanvasDOMManager.d.ts.map

package/dist-extensions/src/canvas/DOMManagers/CanvasDOMManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CanvasDOMManager.d.ts","sourceRoot":"","sources":["../../../../src/canvas/DOMManagers/CanvasDOMManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAM5C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAGlE,qBAAa,gBAAiB,SAAQ,sBAAsB;IAC1D,KAAK,EAAE,UAAU,CAAC;IAClB,SAAS,EAAE,cAAc,CAAC;gBAGxB,IAAI,CAAC,EAAE,MAAM,GAAG,iBAAiB,EACjC,EACE,mBAA2B,EAC3B,cAAmB,GACpB,GAAE;QACD,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B;;WAEG;QACH,cAAc,CAAC,EAAE,MAAM,CAAC;KACpB;IAqBR,SAAS,CAAC,iBAAiB;IAe3B,SAAS,CAAC,sBAAsB;IAUhC;;;OAGG;IACH,SAAS,CAAC,gBAAgB,CACxB,OAAO,EAAE,iBAAiB,EAC1B,EAAE,mBAAmB,EAAE,KAAK,EAAE,EAAE;QAAE,mBAAmB,EAAE,OAAO,CAAA;KAAE;IAWlE,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM;IAMhD,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC,GAAG,IAAI;IAMpD,UAAU,CAAC,IAAI,EAAE,KAAK;IAYtB,OAAO;CAQR"}

package/dist-extensions/src/canvas/DOMManagers/StaticCanvasDOMManager.d.ts

@@ -0,0 +1,29 @@
+import type { TSize } from '../../typedefs';
+import type { CSSDimensions } from './util';
+export type CanvasItem = {
+    el: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+};
+export declare class StaticCanvasDOMManager {
+    /**
+     * Keeps a copy of the canvas style before setting retina scaling and other potions
+     * in order to return it to original state on dispose
+     * @type string
+     */
+    private _originalCanvasStyle?;
+    lower: CanvasItem;
+    constructor(arg0?: string | HTMLCanvasElement);
+    protected createLowerCanvas(arg0?: HTMLCanvasElement | string): HTMLCanvasElement;
+    cleanupDOM({ width, height }: TSize): void;
+    setDimensions(size: TSize, retinaScaling: number): void;
+    setCSSDimensions(size: Partial<CSSDimensions>): void;
+    /**
+     * Calculates canvas element offset relative to the document
+     */
+    calcOffset(): {
+        left: number;
+        top: number;
+    };
+    dispose(): void;
+}
+//# sourceMappingURL=StaticCanvasDOMManager.d.ts.map

package/dist-extensions/src/canvas/DOMManagers/StaticCanvasDOMManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StaticCanvasDOMManager.d.ts","sourceRoot":"","sources":["../../../../src/canvas/DOMManagers/StaticCanvasDOMManager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,QAAQ,CAAC;AAM5C,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,iBAAiB,CAAC;IACtB,GAAG,EAAE,wBAAwB,CAAC;CAC/B,CAAC;AAEF,qBAAa,sBAAsB;IACjC;;;;OAIG;IACH,OAAO,CAAC,oBAAoB,CAAC,CAAS;IAEtC,KAAK,EAAE,UAAU,CAAC;gBAEN,IAAI,CAAC,EAAE,MAAM,GAAG,iBAAiB;IAK7C,SAAS,CAAC,iBAAiB,CAAC,IAAI,CAAC,EAAE,iBAAiB,GAAG,MAAM;IAkB7D,UAAU,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK;IAYnC,aAAa,CAAC,IAAI,EAAE,KAAK,EAAE,aAAa,EAAE,MAAM;IAKhD,gBAAgB,CAAC,IAAI,EAAE,OAAO,CAAC,aAAa,CAAC;IAI7C;;OAEG;IACH,UAAU;;;;IAIV,OAAO;CAKR"}

package/dist-extensions/src/canvas/DOMManagers/util.d.ts

@@ -0,0 +1,24 @@
+import type { TSize } from '../../typedefs';
+export declare const setCanvasDimensions: (el: HTMLCanvasElement, ctx: CanvasRenderingContext2D, { width, height }: TSize, retinaScaling?: number) => void;
+export declare function allowTouchScrolling(element: HTMLElement, allow: boolean): void;
+export type CSSDimensions = {
+    width: number | string;
+    height: number | string;
+};
+export declare const setCSSDimensions: (el: HTMLElement, { width, height }: Partial<CSSDimensions>) => void;
+/**
+ * Returns offset for a given element
+ * @param {HTMLElement} element Element to get offset for
+ * @return {Object} Object with "left" and "top" properties
+ */
+export declare function getElementOffset(element: HTMLElement): {
+    left: number;
+    top: number;
+};
+/**
+ * Makes element unselectable
+ * @param {HTMLElement} element Element to make unselectable
+ * @return {HTMLElement} Element that was passed in
+ */
+export declare function makeElementUnselectable(element: HTMLElement): HTMLElement;
+//# sourceMappingURL=util.d.ts.map

package/dist-extensions/src/canvas/DOMManagers/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../../src/canvas/DOMManagers/util.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAQ5C,eAAO,MAAM,mBAAmB,OAC1B,iBAAiB,OAChB,wBAAwB,qBACV,KAAK,iCAUzB,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,EAAE,OAAO,QAMvE;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;CACzB,CAAC;AAEF,eAAO,MAAM,gBAAgB,OACvB,WAAW,qBACI,OAAO,CAAC,aAAa,CAAC,SAK1C,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,WAAW;;;EA6BpD;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,WAAW,eAM3D"}