fabric 5.3.0 → 6.0.0-beta3

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

@@ -0,0 +1,84 @@
+import { TClassProperties } from '../typedefs';
+import { FabricObject } from './Object/FabricObject';
+import type { FabricObjectProps, SerializedObjectProps, TProps } from './Object/types';
+import type { ObjectEvents } from '../EventTypeDefs';
+export declare const ellipseDefaultValues: UniqueEllipseProps;
+interface UniqueEllipseProps {
+    rx: number;
+    ry: number;
+}
+export interface SerializedEllipseProps extends SerializedObjectProps, UniqueEllipseProps {
+}
+export interface EllipseProps extends FabricObjectProps, UniqueEllipseProps {
+}
+export declare class Ellipse<Props extends TProps<EllipseProps> = Partial<EllipseProps>, SProps extends SerializedEllipseProps = SerializedEllipseProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricObject<Props, SProps, EventSpec> implements EllipseProps {
+    /**
+     * Horizontal radius
+     * @type Number
+     * @default
+     */
+    rx: number;
+    /**
+     * Vertical radius
+     * @type Number
+     * @default
+     */
+    ry: number;
+    static cacheProperties: string[];
+    static ownDefaults: Record<string, any>;
+    static getDefaults(): {
+        [x: string]: any;
+    };
+    /**
+     * @private
+     * @param {String} key
+     * @param {*} value
+     * @return {Ellipse} thisArg
+     */
+    _set(key: string, value: any): this;
+    /**
+     * Returns horizontal radius of an object (according to how an object is scaled)
+     * @return {Number}
+     */
+    getRx(): number;
+    /**
+     * Returns Vertical radius of an object (according to how an object is scaled)
+     * @return {Number}
+     */
+    getRy(): number;
+    /**
+     * Returns object representation of an instance
+     * @param {Array} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {Object} object representation of an instance
+     */
+    toObject<T extends Omit<Props & TClassProperties<this>, keyof SProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SProps;
+    /**
+     * Returns svg representation of an instance
+     * @return {Array} an array of strings with the specific svg representation
+     * of the instance
+     */
+    _toSVG(): (string | number)[];
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx context to render on
+     */
+    _render(ctx: CanvasRenderingContext2D): void;
+    /**
+     * List of attribute names to account for when parsing SVG element (used by {@link Ellipse.fromElement})
+     * @static
+     * @memberOf Ellipse
+     * @see http://www.w3.org/TR/SVG/shapes.html#EllipseElement
+     */
+    static ATTRIBUTE_NAMES: string[];
+    /**
+     * Returns {@link Ellipse} instance from an SVG element
+     * @static
+     * @memberOf Ellipse
+     * @param {SVGElement} element Element to parse
+     * @param {Function} [callback] Options callback invoked after parsing is finished
+     * @return {Ellipse}
+     */
+    static fromElement(element: SVGElement, callback: (ellipse: Ellipse) => void): void;
+}
+export {};
+//# sourceMappingURL=Ellipse.d.ts.map

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

@@ -0,0 +1,408 @@
+import type { CollectionEvents, ObjectEvents } from '../EventTypeDefs';
+import { Point } from '../Point';
+import type { TClassProperties, TSVGReviver } from '../typedefs';
+import { FabricObject } from './Object/FabricObject';
+import { FabricObjectProps, SerializedObjectProps, TProps } from './Object/types';
+export type LayoutContextType = 'initialization' | 'object_modified' | 'added' | 'removed' | 'layout_change' | 'imperative';
+export type LayoutContext = {
+    type: LayoutContextType;
+    /**
+     * array of objects starting from the object that triggered the call to the current one
+     */
+    path?: Group[];
+    [key: string]: any;
+};
+export type GroupEvents = ObjectEvents & CollectionEvents & {
+    layout: {
+        context: LayoutContext;
+        result: LayoutResult;
+        diff: Point;
+    };
+};
+export type LayoutStrategy = 'fit-content' | 'fit-content-lazy' | 'fixed' | 'clip-path';
+/**
+ * positioning and layout data **relative** to instance's parent
+ */
+export type LayoutResult = {
+    /**
+     * new centerX as measured by the containing plane (same as `left` with `originX` set to `center`)
+     */
+    centerX: number;
+    /**
+     * new centerY as measured by the containing plane (same as `top` with `originY` set to `center`)
+     */
+    centerY: number;
+    /**
+     * correctionX to translate objects by, measured as `centerX`
+     */
+    correctionX?: number;
+    /**
+     * correctionY to translate objects by, measured as `centerY`
+     */
+    correctionY?: number;
+    width: number;
+    height: number;
+};
+export interface GroupOwnProps {
+    layout: LayoutStrategy;
+    subTargetCheck: boolean;
+    interactive: boolean;
+}
+export interface SerializedGroupProps extends SerializedObjectProps, GroupOwnProps {
+    objects: SerializedObjectProps[];
+}
+export interface GroupProps extends FabricObjectProps, GroupOwnProps {
+}
+export declare const groupDefaultValues: {
+    layout: string;
+    strokeWidth: number;
+    subTargetCheck: boolean;
+    interactive: boolean;
+};
+declare const Group_base: {
+    new (...args: any[]): {
+        _objects: import("../EventTypeDefs").BaseFabricObject[];
+        _onObjectAdded(object: import("../EventTypeDefs").BaseFabricObject): void;
+        _onObjectRemoved(object: import("../EventTypeDefs").BaseFabricObject): void;
+        _onStackOrderChanged(object: import("../EventTypeDefs").BaseFabricObject): void;
+        add(...objects: import("../EventTypeDefs").BaseFabricObject[]): number;
+        insertAt(index: number, ...objects: import("../EventTypeDefs").BaseFabricObject[]): number;
+        remove(...objects: import("../EventTypeDefs").BaseFabricObject[]): import("../EventTypeDefs").BaseFabricObject[];
+        forEachObject(callback: (object: import("../EventTypeDefs").BaseFabricObject, index: number, array: import("../EventTypeDefs").BaseFabricObject[]) => any): void;
+        getObjects(...types: string[]): import("../EventTypeDefs").BaseFabricObject[];
+        item(index: number): import("../EventTypeDefs").BaseFabricObject;
+        isEmpty(): boolean;
+        size(): number;
+        contains(object: import("../EventTypeDefs").BaseFabricObject, deep?: boolean | undefined): boolean;
+        complexity(): number;
+        sendObjectToBack(object: import("../EventTypeDefs").BaseFabricObject): boolean;
+        bringObjectToFront(object: import("../EventTypeDefs").BaseFabricObject): boolean;
+        sendObjectBackwards(object: import("../EventTypeDefs").BaseFabricObject, intersecting?: boolean | undefined): boolean;
+        bringObjectForward(object: import("../EventTypeDefs").BaseFabricObject, intersecting?: boolean | undefined): boolean;
+        moveObjectTo(object: import("../EventTypeDefs").BaseFabricObject, index: number): boolean;
+        findNewLowerIndex(object: import("../EventTypeDefs").BaseFabricObject, idx: number, intersecting?: boolean | undefined): number;
+        findNewUpperIndex(object: import("../EventTypeDefs").BaseFabricObject, idx: number, intersecting?: boolean | undefined): number;
+        collectObjects({ left, top, width, height }: import("../typedefs").TBBox, { includeIntersecting }?: {
+            includeIntersecting?: boolean | undefined;
+        }): import("./Object/InteractiveObject").InteractiveFabricObject<Partial<FabricObjectProps>, SerializedObjectProps, ObjectEvents>[];
+    };
+} & {
+    new (options?: GroupProps): FabricObject<GroupProps, SerializedGroupProps, GroupEvents>;
+    ownDefaults: Record<string, any>;
+    getDefaults(): Record<string, any>;
+    stateProperties: string[];
+    cacheProperties: string[];
+    _fromObject<S extends import("./Object/Object").FabricObject<Partial<import("./Object/types/ObjectProps").ObjectProps>, SerializedObjectProps, ObjectEvents>>(object: Record<string, unknown>, { extraParam, ...options }?: {
+        extraParam?: string | undefined;
+        signal?: AbortSignal | undefined;
+    }): Promise<S>;
+    fromObject<T extends TProps<SerializedObjectProps>>(object: T, options?: {
+        signal?: AbortSignal | undefined;
+    } | undefined): Promise<import("./Object/Object").FabricObject<Partial<import("./Object/types/ObjectProps").ObjectProps>, SerializedObjectProps, ObjectEvents>>;
+};
+/**
+ * @fires object:added
+ * @fires object:removed
+ * @fires layout once layout completes
+ */
+export declare class Group extends Group_base {
+    /**
+     * Specifies the **layout strategy** for instance
+     * Used by `getLayoutStrategyResult` to calculate layout
+     * `fit-content`, `fit-content-lazy`, `fixed`, `clip-path` are supported out of the box
+     * @default
+     */
+    layout: LayoutStrategy;
+    /**
+     * Used to optimize performance
+     * set to `false` if you don't need contained objects to be targets of events
+     * @default
+     * @type boolean
+     */
+    subTargetCheck: boolean;
+    /**
+     * Used to allow targeting of object inside groups.
+     * set to true if you want to select an object inside a group.\
+     * **REQUIRES** `subTargetCheck` set to true
+     * @default
+     * @type boolean
+     */
+    interactive: boolean;
+    /**
+     * Used internally to optimize performance
+     * Once an object is selected, instance is rendered without the selected object.
+     * This way instance is cached only once for the entire interaction with the selected object.
+     * @private
+     */
+    protected _activeObjects: FabricObject[];
+    static stateProperties: string[];
+    static ownDefaults: Record<string, any>;
+    private __objectSelectionTracker;
+    private __objectSelectionDisposer;
+    private _firstLayoutDone;
+    static getDefaults(): Record<string, any>;
+    /**
+     * Constructor
+     *
+     * @param {FabricObject[]} [objects] instance objects
+     * @param {Object} [options] Options object
+     * @param {boolean} [objectsRelativeToGroup] true if objects exist in group coordinate plane
+     */
+    constructor(objects?: FabricObject[], options?: Partial<GroupProps>, objectsRelativeToGroup?: boolean);
+    /**
+     * Checks if object can enter group and logs relevant warnings
+     * @private
+     * @param {FabricObject} object
+     * @returns
+     */
+    canEnterGroup(object: FabricObject): boolean;
+    /**
+     * Override this method to enhance performance (for groups with a lot of objects).
+     * If Overriding, be sure not pass illegal objects to group - it will break your app.
+     * @private
+     */
+    protected _filterObjectsBeforeEnteringGroup(objects: FabricObject[]): FabricObject<Partial<FabricObjectProps>, SerializedObjectProps, ObjectEvents>[];
+    /**
+     * Add objects
+     * @param {...FabricObject[]} objects
+     */
+    add(...objects: FabricObject[]): number;
+    /**
+     * Inserts an object into collection at specified index
+     * @param {FabricObject[]} objects Object to insert
+     * @param {Number} index Index to insert object at
+     */
+    insertAt(index: number, ...objects: FabricObject[]): number;
+    /**
+     * Remove objects
+     * @param {...FabricObject[]} objects
+     * @returns {FabricObject[]} removed objects
+     */
+    remove(...objects: FabricObject[]): import("../EventTypeDefs").BaseFabricObject[];
+    _onObjectAdded(object: FabricObject): void;
+    _onRelativeObjectAdded(object: FabricObject): void;
+    /**
+     * @private
+     * @param {FabricObject} object
+     * @param {boolean} [removeParentTransform] true if object should exit group without applying group's transform to it
+     */
+    _onObjectRemoved(object: FabricObject, removeParentTransform?: boolean): void;
+    /**
+     * @private
+     * @param {'added'|'removed'} type
+     * @param {FabricObject[]} targets
+     */
+    _onAfterObjectsChange(type: 'added' | 'removed', targets: FabricObject[]): void;
+    _onStackOrderChanged(): void;
+    /**
+     * @private
+     * @param {string} key
+     * @param {*} value
+     */
+    _set(key: string, value: any): this;
+    /**
+     * @private
+     */
+    _shouldSetNestedCoords(): boolean;
+    /**
+     * Remove all objects
+     * @returns {FabricObject[]} removed objects
+     */
+    removeAll(): import("../EventTypeDefs").BaseFabricObject[];
+    /**
+     * invalidates layout on object modified
+     * @private
+     */
+    __objectMonitor(ev: ObjectEvents['modified']): void;
+    /**
+     * keeps track of the selected objects
+     * @private
+     */
+    __objectSelectionMonitor<T extends boolean>(selected: T, { target: object }: ObjectEvents[T extends true ? 'selected' : 'deselected']): void;
+    /**
+     * @private
+     * @param {boolean} watch
+     * @param {FabricObject} object
+     */
+    _watchObject(watch: boolean, object: FabricObject): void;
+    /**
+     * @private
+     * @param {FabricObject} object
+     * @param {boolean} [removeParentTransform] true if object is in canvas coordinate plane
+     * @returns {boolean} true if object entered group
+     */
+    enterGroup(object: FabricObject, removeParentTransform?: boolean): boolean;
+    /**
+     * @private
+     * @param {FabricObject} object
+     * @param {boolean} [removeParentTransform] true if object is in canvas coordinate plane
+     */
+    _enterGroup(object: FabricObject, removeParentTransform?: boolean): void;
+    /**
+     * @private
+     * @param {FabricObject} object
+     * @param {boolean} [removeParentTransform] true if object should exit group without applying group's transform to it
+     */
+    exitGroup(object: FabricObject, removeParentTransform?: boolean): void;
+    /**
+     * @private
+     * @param {FabricObject} object
+     * @param {boolean} [removeParentTransform] true if object should exit group without applying group's transform to it
+     */
+    _exitGroup(object: FabricObject, removeParentTransform?: boolean): void;
+    /**
+     * Decide if the object should cache or not. Create its own cache level
+     * needsItsOwnCache should be used when the object drawing method requires
+     * a cache step. None of the fabric classes requires it.
+     * Generally you do not cache objects in groups because the group is already cached.
+     * @return {Boolean}
+     */
+    shouldCache(): boolean;
+    /**
+     * Check if this object or a child object will cast a shadow
+     * @return {Boolean}
+     */
+    willDrawShadow(): boolean;
+    /**
+     * Check if instance or its group are caching, recursively up
+     * @return {Boolean}
+     */
+    isOnACache(): boolean;
+    /**
+     * Execute the drawing operation for an object on a specified context
+     * @param {CanvasRenderingContext2D} ctx Context to render on
+     */
+    drawObject(ctx: CanvasRenderingContext2D): void;
+    /**
+     * @override
+     * @return {Boolean}
+     */
+    setCoords(): void;
+    /**
+     * Renders instance on a given context
+     * @param {CanvasRenderingContext2D} ctx context to render instance on
+     */
+    render(ctx: CanvasRenderingContext2D): void;
+    /**
+     * @public
+     * @param {Partial<LayoutResult> & { layout?: string }} [context] pass values to use for layout calculations
+     */
+    triggerLayout<T extends this['layout']>(context?: Partial<LayoutResult> & {
+        layout?: T;
+    }): void;
+    /**
+     * @private
+     * @param {FabricObject} object
+     * @param {Point} diff
+     */
+    _adjustObjectPosition(object: FabricObject, diff: Point): void;
+    /**
+     * initial layout logic:
+     * calculate bbox of objects (if necessary) and translate it according to options received from the constructor (left, top, width, height)
+     * so it is placed in the center of the bbox received from the constructor
+     *
+     * @private
+     * @param {LayoutContext} context
+     */
+    _applyLayoutStrategy(context: LayoutContext): void;
+    /**
+     * Override this method to customize layout.
+     * If you need to run logic once layout completes use `onLayout`
+     * @public
+     * @param {string} layoutDirective
+     * @param {FabricObject[]} objects
+     * @param {LayoutContext} context
+     * @returns {LayoutResult | undefined}
+     */
+    getLayoutStrategyResult<T extends this['layout']>(layoutDirective: T, objects: FabricObject[], context: LayoutContext): any;
+    /**
+     * Override this method to customize layout.
+     * A wrapper around {@link Group#getObjectsBoundingBox}
+     * @public
+     * @param {string} layoutDirective
+     * @param {FabricObject[]} objects
+     * @param {LayoutContext} context
+     * @returns {LayoutResult | undefined}
+     */
+    prepareBoundingBox<T extends this['layout']>(layoutDirective: T, objects: FabricObject[], context: LayoutContext): any;
+    /**
+     * Calculates center taking into account originX, originY while not being sure that width/height are initialized
+     * @public
+     * @param {string} layoutDirective
+     * @param {FabricObject[]} objects
+     * @param {LayoutContext} context
+     * @returns {LayoutResult | undefined}
+     */
+    prepareInitialBoundingBox<T extends this['layout']>(layoutDirective: T, objects: FabricObject[], context: LayoutContext): {
+        centerX: number;
+        centerY: number;
+        correctionX: number;
+        correctionY: number;
+        width: number;
+        height: number;
+    } | undefined;
+    /**
+     * Calculate the bbox of objects relative to instance's containing plane
+     * @public
+     * @param {FabricObject[]} objects
+     * @returns {LayoutResult | null} bounding box
+     */
+    getObjectsBoundingBox(objects: FabricObject[], ignoreOffset?: boolean): LayoutResult | null;
+    /**
+     * Hook that is called once layout has completed.
+     * Provided for layout customization, override if necessary.
+     * Complements `getLayoutStrategyResult`, which is called at the beginning of layout.
+     * @public
+     * @param {LayoutContext} context layout context
+     * @param {LayoutResult} result layout result
+     */
+    onLayout(context: LayoutContext, result: LayoutResult): void;
+    /**
+     *
+     * @private
+     * @param {'toObject'|'toDatalessObject'} [method]
+     * @param {string[]} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @returns {FabricObject[]} serialized objects
+     */
+    __serializeObjects(method: 'toObject' | 'toDatalessObject', propertiesToInclude?: string[]): any[];
+    /**
+     * Returns object representation of an instance
+     * @param {string[]} [propertiesToInclude] Any properties that you might want to additionally include in the output
+     * @return {Object} object representation of an instance
+     */
+    toObject<T extends Omit<GroupProps & TClassProperties<this>, keyof SerializedGroupProps>, K extends keyof T = never>(propertiesToInclude?: K[]): Pick<T, K> & SerializedGroupProps;
+    toString(): string;
+    dispose(): void;
+    /**
+     * @private
+     */
+    _createSVGBgRect(reviver?: TSVGReviver): string;
+    /**
+     * Returns svg representation of an instance
+     * @param {TSVGReviver} [reviver] Method for further parsing of svg representation.
+     * @return {String} svg representation of an instance
+     */
+    _toSVG(reviver?: TSVGReviver): string[];
+    /**
+     * Returns styles-string for svg-export, specific version for group
+     * @return {String}
+     */
+    getSvgStyles(): string;
+    /**
+     * Returns svg clipPath representation of an instance
+     * @param {Function} [reviver] Method for further parsing of svg representation.
+     * @return {String} svg representation of an instance
+     */
+    toClipPathSVG(reviver?: TSVGReviver): string;
+    /**
+     * @todo support loading from svg
+     * @private
+     * @static
+     * @memberOf Group
+     * @param {Object} object Object to create a group from
+     * @returns {Promise<Group>}
+     */
+    static fromObject<T extends TProps<SerializedGroupProps>>({ objects, ...options }: T): Promise<Group>;
+}
+export {};
+//# sourceMappingURL=Group.d.ts.map

package/dist/src/shapes/IText/DraggableTextDelegate.d.ts

@@ -0,0 +1,78 @@
+import { DragEventData, DropEventData, TPointerEvent } from '../../EventTypeDefs';
+import type { IText } from './IText';
+/**
+ * #### Dragging IText/Textbox Lifecycle
+ * - {@link start} is called from `mousedown` {@link IText#_mouseDownHandler} and determines if dragging should start by testing {@link isPointerOverSelection}
+ * - if true `mousedown` {@link IText#_mouseDownHandler} is blocked to keep selection
+ * - if the pointer moves, canvas fires numerous mousemove {@link Canvas#_onMouseMove} that we make sure **aren't** prevented ({@link IText#shouldStartDragging}) in order for the window to start a drag session
+ * - once/if the session starts canvas calls {@link onDragStart} on the active object to determine if dragging should occur
+ * - canvas fires relevant drag events that are handled by the handlers defined in this scope
+ * - {@link end} is called from `mouseup` {@link IText#mouseUpHandler}, blocking IText default click behavior
+ * - in case the drag session didn't occur, {@link end} handles a click, since logic to do so was blocked during `mousedown`
+ */
+export declare class DraggableTextDelegate {
+    readonly target: IText;
+    private __mouseDownInPlace;
+    private __dragStartFired;
+    private __isDraggingOver;
+    private __dragStartSelection?;
+    private __dragImageDisposer?;
+    private _dispose?;
+    constructor(target: IText);
+    isPointerOverSelection(e: TPointerEvent): boolean;
+    /**
+     * @public override this method to disable dragging and default to mousedown logic
+     */
+    start(e: TPointerEvent): boolean;
+    /**
+     * @public override this method to disable dragging without discarding selection
+     */
+    isActive(): boolean;
+    /**
+     * Ends interaction and sets cursor in case of a click
+     * @returns true if was active
+     */
+    end(e: TPointerEvent): boolean;
+    getDragStartSelection(): {
+        selectionStart: number;
+        selectionEnd: number;
+    } | undefined;
+    /**
+     * Override to customize the drag image
+     * https://developer.mozilla.org/en-US/docs/Web/API/DataTransfer/setDragImage
+     */
+    setDragImage(e: DragEvent, { selectionStart, selectionEnd, }: {
+        selectionStart: number;
+        selectionEnd: number;
+    }): void;
+    /**
+     * @returns {boolean} determines whether {@link target} should/shouldn't become a drag source
+     */
+    onDragStart(e: DragEvent): boolean;
+    /**
+     * use {@link targetCanDrop} to respect overriding
+     * @returns {boolean} determines whether {@link target} should/shouldn't become a drop target
+     */
+    canDrop(e: DragEvent): boolean;
+    /**
+     * in order to respect overriding {@link IText#canDrop} we call that instead of calling {@link canDrop} directly
+     */
+    protected targetCanDrop(e: DragEvent): boolean;
+    dragEnterHandler({ e }: DragEventData): void;
+    dragOverHandler(ev: DragEventData): void;
+    dragLeaveHandler(): void;
+    /**
+     * Override the `text/plain | application/fabric` types of {@link DragEvent#dataTransfer}
+     * in order to change the drop value or to customize styling respectively, by listening to the `drop:before` event
+     * https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/Drag_operations#performing_a_drop
+     */
+    dropHandler(ev: DropEventData): void;
+    /**
+     * fired only on the drag source after drop (if occurred)
+     * handle changes to the drag source in case of a drop on another object or a cancellation
+     * https://developer.mozilla.org/en-US/docs/Web/API/HTML_Drag_and_Drop_API/Drag_operations#finishing_a_drag
+     */
+    dragEndHandler({ e }: DragEventData): void;
+    dispose(): void;
+}
+//# sourceMappingURL=DraggableTextDelegate.d.ts.map