fabric 5.3.0 → 6.0.0-beta3

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

@@ -0,0 +1,140 @@
+import { XY, Point } from '../Point';
+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 polylineDefaultValues: Partial<TClassProperties<Polyline>>;
+export interface SerializedPolylineProps extends SerializedObjectProps {
+    points: XY[];
+}
+export declare class Polyline<Props extends TProps<FabricObjectProps> = Partial<FabricObjectProps>, SProps extends SerializedPolylineProps = SerializedPolylineProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricObject<Props, SProps, EventSpec> {
+    /**
+     * Points array
+     * @type Array
+     * @default
+     */
+    points: XY[];
+    /**
+     * 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;
+    static ownDefaults: Record<string, any>;
+    static getDefaults(): {
+        [x: string]: any;
+    };
+    /**
+     * A list of properties that if changed trigger a recalculation of dimensions
+     * @todo check if you really need to recalculate for all cases
+     */
+    static layoutProperties: (keyof Polyline)[];
+    fromSVG: boolean;
+    pathOffset: Point;
+    strokeOffset: Point;
+    static cacheProperties: string[];
+    /**
+     * 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?: XY[], options?: Props);
+    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<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[];
+    /**
+     * @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<T extends TProps<SerializedPolylineProps>>(object: T): Promise<Polyline<Partial<FabricObjectProps>, SerializedPolylineProps, ObjectEvents>>;
+}
+//# sourceMappingURL=Polyline.d.ts.map

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

@@ -0,0 +1,76 @@
+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 rectDefaultValues: Partial<TClassProperties<Rect>>;
+interface UniqueRectProps {
+    rx: number;
+    ry: number;
+}
+export interface SerializedRectProps extends SerializedObjectProps, UniqueRectProps {
+}
+export interface RectProps extends FabricObjectProps, UniqueRectProps {
+}
+export declare class Rect<Props extends TProps<RectProps> = Partial<RectProps>, SProps extends SerializedRectProps = SerializedRectProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricObject<Props, SProps, EventSpec> implements RectProps {
+    /**
+     * Horizontal border radius
+     * @type Number
+     * @default
+     */
+    rx: number;
+    /**
+     * Vertical border radius
+     * @type Number
+     * @default
+     */
+    ry: number;
+    static cacheProperties: string[];
+    static ownDefaults: Record<string, any>;
+    static getDefaults(): Record<string, any>;
+    /**
+     * Constructor
+     * @param {Object} [options] Options object
+     * @return {Object} thisArg
+     */
+    constructor(options: Props);
+    /**
+     * 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<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[];
+    /**
+     * 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 {};
+//# sourceMappingURL=Rect.d.ts.map

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

@@ -0,0 +1,119 @@
+import type { ObjectEvents } from '../../EventTypeDefs';
+import type { FabricObjectProps, SerializedObjectProps, TProps } from '../Object/types';
+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<Props extends TProps<FabricObjectProps> = Partial<FabricObjectProps>, SProps extends SerializedObjectProps = SerializedObjectProps, EventSpec extends ObjectEvents = ObjectEvents> extends FabricObject<Props, SProps, EventSpec> {
+    abstract styles: TextStyle;
+    protected abstract _textLines: string[][];
+    protected _forceClearCache: boolean;
+    static _styleProperties: readonly ["fontSize", "fontWeight", "fontFamily", "fontStyle", "underline", "overline", "linethrough", "stroke", "strokeWidth", "fill", "deltaY", "textBackgroundColor"];
+    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