fabric 5.3.0-browser → 6.0.0-beta1

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

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

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

@@ -0,0 +1,7 @@
+import { TClassProperties } from '../typedefs';
+import { Polyline } from './Polyline';
+export declare class Polygon extends Polyline {
+    protected isOpen(): boolean;
+}
+export declare const polygonDefaultValues: Partial<TClassProperties<Polygon>>;
+//# sourceMappingURL=Polygon.d.ts.map

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

@@ -0,0 +1,130 @@
+import { IPoint, Point } from '../Point';
+import { TClassProperties } from '../typedefs';
+import { FabricObject } from './Object/FabricObject';
+export declare class Polyline extends FabricObject {
+    /**
+     * Points array
+     * @type Array
+     * @default
+     */
+    points: IPoint[];
+    /**
+     * WARNING: Feature in progress
+     * Calculate the exact bounding box taking in account strokeWidth on acute angles
+     * this will be turned to true by default on fabric 6.0
+     * maybe will be left in as an optimization since calculations may be slow
+     * @deprecated
+     * @type Boolean
+     * @default false
+     */
+    exactBoundingBox: boolean;
+    private initialized;
+    /**
+     * A list of properties that if changed trigger a recalculation of dimensions
+     * @todo check if you really need to recalculate for all cases
+     */
+    strokeBBoxAffectingProperties: (keyof this)[];
+    fromSVG: boolean;
+    pathOffset: Point;
+    strokeOffset: Point;
+    /**
+     * Constructor
+     * @param {Array} points Array of points (where each point is an object with x and y)
+     * @param {Object} [options] Options object
+     * @return {Polyline} thisArg
+     * @example
+     * var poly = new Polyline([
+     *     { x: 10, y: 10 },
+     *     { x: 50, y: 30 },
+     *     { x: 40, y: 70 },
+     *     { x: 60, y: 50 },
+     *     { x: 100, y: 150 },
+     *     { x: 40, y: 100 }
+     *   ], {
+     *   stroke: 'red',
+     *   left: 100,
+     *   top: 100
+     * });
+     */
+    constructor(points?: IPoint[], { left, top, ...options }?: any);
+    protected isOpen(): boolean;
+    private _projectStrokeOnPoints;
+    /**
+     * Calculate the polygon bounding box
+     * @private
+     */
+    _calcDimensions(): {
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        pathOffset: Point;
+        strokeOffset: Point;
+    };
+    setDimensions(): void;
+    setBoundingBox(adjustPosition?: boolean): void;
+    /**
+     * @override stroke is taken in account in size
+     */
+    _getNonTransformedDimensions(): Point;
+    /**
+     * @override stroke and skewing are taken into account when projecting stroke on points,
+     * therefore we don't want the default calculation to account for skewing as well
+     *
+     * @private
+     */
+    _getTransformedDimensions(options?: any): Point;
+    /**
+     * Recalculates dimensions when changing skew and scale
+     * @private
+     */
+    _set(key: string, value: any): this;
+    /**
+     * 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(propertiesToInclude?: string[]): object;
+    /**
+     * Returns svg representation of an instance
+     * @return {Array} an array of strings with the specific svg representation
+     * of the instance
+     */
+    _toSVG(): string[];
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx Context to render on
+     */
+    _render(ctx: CanvasRenderingContext2D): void;
+    /**
+     * Returns complexity of an instance
+     * @return {Number} complexity of this instance
+     */
+    complexity(): number;
+    /**
+     * List of attribute names to account for when parsing SVG element (used by {@link Polyline.fromElement})
+     * @static
+     * @memberOf Polyline
+     * @see: http://www.w3.org/TR/SVG/shapes.html#PolylineElement
+     */
+    static ATTRIBUTE_NAMES: string[];
+    /**
+     * Returns Polyline instance from an SVG element
+     * @static
+     * @memberOf Polyline
+     * @param {SVGElement} element Element to parser
+     * @param {Function} callback callback function invoked after parsing
+     * @param {Object} [options] Options object
+     */
+    static fromElement(element: SVGElement, callback: (poly: Polyline | null) => any, options?: any): any;
+    /**
+     * Returns Polyline instance from an object representation
+     * @static
+     * @memberOf Polyline
+     * @param {Object} object Object to create an instance from
+     * @returns {Promise<Polyline>}
+     */
+    static fromObject(object: Record<string, unknown>): Promise<import("./Object/Object").FabricObject<import("../EventTypeDefs").ObjectEvents>>;
+}
+export declare const polylineDefaultValues: Partial<TClassProperties<Polyline>>;
+//# sourceMappingURL=Polyline.d.ts.map

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

@@ -0,0 +1,62 @@
+import { TClassProperties } from '../typedefs';
+import { FabricObject } from './Object/FabricObject';
+export declare class Rect extends FabricObject {
+    /**
+     * Horizontal border radius
+     * @type Number
+     * @default
+     */
+    rx: number;
+    /**
+     * Vertical border radius
+     * @type Number
+     * @default
+     */
+    ry: number;
+    /**
+     * Constructor
+     * @param {Object} [options] Options object
+     * @return {Object} thisArg
+     */
+    constructor(options: Record<string, unknown>);
+    /**
+     * Initializes rx/ry attributes
+     * @private
+     */
+    _initRxRy(): void;
+    /**
+     * @private
+     * @param {CanvasRenderingContext2D} ctx Context to render on
+     */
+    _render(ctx: CanvasRenderingContext2D): void;
+    /**
+     * 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(propertiesToInclude?: string[]): Record<string, any>;
+    /**
+     * Returns svg representation of an instance
+     * @return {Array} an array of strings with the specific svg representation
+     * of the instance
+     */
+    _toSVG(): string[];
+    /**
+     * List of attribute names to account for when parsing SVG element (used by `Rect.fromElement`)
+     * @static
+     * @memberOf Rect
+     * @see: http://www.w3.org/TR/SVG/shapes.html#RectElement
+     */
+    static ATTRIBUTE_NAMES: string[];
+    /**
+     * Returns {@link Rect} instance from an SVG element
+     * @static
+     * @memberOf Rect
+     * @param {SVGElement} element Element to parse
+     * @param {Function} callback callback function invoked after parsing
+     * @param {Object} [options] Options object
+     */
+    static fromElement(element: SVGElement, callback: (rect: Rect | null) => void, options?: {}): void;
+}
+export declare const rectDefaultValues: Partial<TClassProperties<Rect>>;
+//# sourceMappingURL=Rect.d.ts.map

package/dist/src/shapes/Text/StyledText.d.ts

@@ -0,0 +1,118 @@
+import { ObjectEvents } from '../../EventTypeDefs';
+import { FabricObject } from '../Object/FabricObject';
+export type TextStyleDeclaration = Record<string, any>;
+export type TextStyle = {
+    [line: number | string]: {
+        [char: number | string]: TextStyleDeclaration;
+    };
+};
+export declare abstract class StyledText<EventSpec extends ObjectEvents> extends FabricObject<EventSpec> {
+    abstract styles: TextStyle;
+    protected abstract _textLines: string[][];
+    protected abstract _forceClearCache: boolean;
+    protected abstract _styleProperties: string[];
+    abstract get2DCursorLocation(selectionStart: number, skipWrapping?: boolean): {
+        charIndex: number;
+        lineIndex: number;
+    };
+    /**
+     * Returns true if object has no styling or no styling in a line
+     * @param {Number} lineIndex , lineIndex is on wrapped lines.
+     * @return {Boolean}
+     */
+    isEmptyStyles(lineIndex?: number): boolean;
+    /**
+     * Returns true if object has a style property or has it ina specified line
+     * This function is used to detect if a text will use a particular property or not.
+     * @param {String} property to check for
+     * @param {Number} lineIndex to check the style on
+     * @return {Boolean}
+     */
+    styleHas(property: string, lineIndex?: number): boolean;
+    /**
+     * Check if characters in a text have a value for a property
+     * whose value matches the textbox's value for that property.  If so,
+     * the character-level property is deleted.  If the character
+     * has no other properties, then it is also deleted.  Finally,
+     * if the line containing that character has no other characters
+     * then it also is deleted.
+     *
+     * @param {string} property The property to compare between characters and text.
+     */
+    cleanStyle(property: string): false | undefined;
+    /**
+     * Remove a style property or properties from all individual character styles
+     * in a text object.  Deletes the character style object if it contains no other style
+     * props.  Deletes a line style object if it contains no other character styles.
+     *
+     * @param {String} props The property to remove from character styles.
+     */
+    removeStyle(property: string): void;
+    private _extendStyles;
+    /**
+     * Gets style of a current selection/cursor (at the start position)
+     * @param {Number} startIndex Start index to get styles at
+     * @param {Number} endIndex End index to get styles at, if not specified startIndex + 1
+     * @param {Boolean} [complete] get full style or not
+     * @return {Array} styles an array with one, zero or more Style objects
+     */
+    getSelectionStyles(startIndex: number, endIndex?: number, complete?: boolean): TextStyleDeclaration[];
+    /**
+     * Gets style of a current selection/cursor position
+     * @param {Number} position  to get styles at
+     * @param {Boolean} [complete] full style if true
+     * @return {Object} style Style object at a specified index
+     * @private
+     */
+    getStyleAtPosition(position: number, complete?: boolean): TextStyleDeclaration;
+    /**
+     * Sets style of a current selection, if no selection exist, do not set anything.
+     * @param {Object} styles Styles object
+     * @param {Number} startIndex Start index to get styles at
+     * @param {Number} [endIndex] End index to get styles at, if not specified startIndex + 1
+     */
+    setSelectionStyles(styles: object, startIndex: number, endIndex?: number): void;
+    /**
+     * get the reference, not a clone, of the style object for a given character
+     * @param {Number} lineIndex
+     * @param {Number} charIndex
+     * @return {Object} style object
+     */
+    _getStyleDeclaration(lineIndex: number, charIndex: number): TextStyleDeclaration | null;
+    /**
+     * return a new object that contains all the style property for a character
+     * the object returned is newly created
+     * @param {Number} lineIndex of the line where the character is
+     * @param {Number} charIndex position of the character on the line
+     * @return {Object} style object
+     */
+    getCompleteStyleDeclaration(lineIndex: number, charIndex: number): TextStyleDeclaration;
+    /**
+     * @param {Number} lineIndex
+     * @param {Number} charIndex
+     * @param {Object} style
+     * @private
+     */
+    protected _setStyleDeclaration(lineIndex: number, charIndex: number, style: object): void;
+    /**
+     *
+     * @param {Number} lineIndex
+     * @param {Number} charIndex
+     * @private
+     */
+    protected _deleteStyleDeclaration(lineIndex: number, charIndex: number): void;
+    /**
+     * @param {Number} lineIndex
+     * @return {Boolean} if the line exists or not
+     * @private
+     */
+    protected _getLineStyle(lineIndex: number): boolean;
+    /**
+     * Set the line style to an empty object so that is initialized
+     * @param {Number} lineIndex
+     * @private
+     */
+    protected _setLineStyle(lineIndex: number): void;
+    protected _deleteLineStyle(lineIndex: number): void;
+}
+//# sourceMappingURL=StyledText.d.ts.map