zrender

zrender

Version 6.1.0
Published 1 month ago
4.3 MB
1 dependency
BSD-3-Clause license

Install

npm i zrender

yarn add zrender

pnpm add zrender

Overview

A lightweight graphic library providing 2d draw for Apache ECharts

Index

Variables

variable version

const version: string;

Functions

function dispose

dispose: (zr: ZRender) => void;

function disposeAll

disposeAll: () => void;

function getElementSSRData

getElementSSRData: (el: Element) => ElementSSRData;

function getInstance

getInstance: (id: number) => ZRender;

function init

init: (dom?: HTMLElement | null, opts?: ZRenderInitOpt) => ZRender;

function parseSVG

parseSVG: (
    xml: string | Document | SVGElement,
    opt: SVGParserOption
) => SVGParserResult;

function registerPainter

registerPainter: (name: string, Ctor: PainterBaseCtor) => void;

function registerSSRDataGetter

registerSSRDataGetter: <T>(getter: ElementSSRDataGetter<T>) => void;

function setPlatformAPI

setPlatformAPI: (newPlatformApis: Partial<Platform>) => void;

function showDebugDirtyRect

showDebugDirtyRect: (zr: ZRenderType, opts?: Opts) => void;

Classes

class Arc

class Arc extends Path<ArcProps> {}

constructor

constructor(opts?: ArcProps);

property shape

shape: ArcShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: ArcShape) => void;

method getDefaultShape

getDefaultShape: () => ArcShape;

method getDefaultStyle

getDefaultStyle: () => { stroke: string; fill: string };

class ArcShape

class ArcShape {}

property clockwise

clockwise?: boolean;

property cx

cx: number;

property cy

cy: number;

property endAngle

endAngle: number;

property r

r: number;

property startAngle

startAngle: number;

class BezierCurve

class BezierCurve extends Path<BezierCurveProps> {}

constructor

constructor(opts?: BezierCurveProps);

property shape

shape: BezierCurveShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: BezierCurveShape) => void;

method getDefaultShape

getDefaultShape: () => BezierCurveShape;

method getDefaultStyle

getDefaultStyle: () => { stroke: string; fill: string };

method pointAt

pointAt: (t: number) => number[];

method tangentAt

tangentAt: (t: number) => number[];

class BezierCurveShape

class BezierCurveShape {}

property cpx1

cpx1: number;

property cpx2

cpx2?: number;

property cpy1

cpy1: number;

property cpy2

cpy2?: number;

property percent

percent: number;

property x1

x1: number;

property x2

x2: number;

property y1

y1: number;

property y2

y2: number;

class BoundingRect

class BoundingRect {}

constructor

constructor(x: number, y: number, width: number, height: number);

property height

height: number;

property width

width: number;

property x

x: number;

property y

y: number;

method applyTransform

static applyTransform: (
    target: RectLike,
    source: RectLike,
    m: matrix.MatrixArray
) => void;

method calculateTransform

static calculateTransform: (
    out: matrix.MatrixArray | NullUndefined,
    a: RectLike,
    b: RectLike
) => matrix.MatrixArray;

method clone

clone: () => BoundingRect;

method contain

static contain: (rect: RectLike, x: number, y: number) => boolean;

method copy

static copy: <TTarget extends RectLike>(
    target: TTarget,
    source: RectLike
) => TTarget;

method create

static create: (rect?: RectLike | NullUndefined) => BoundingRect;

method intersect

static intersect: (
    a: RectLike,
    b: RectLike,
    mtv?: PointLike,
    opt?: BoundingRectIntersectOpt
) => boolean;

method isFinite

isFinite: () => boolean;

method isZero

isZero: () => boolean;

method plain

plain: () => RectLike;

method set

static set: <TTarget extends RectLike>(
    target: TTarget,
    x: number,
    y: number,
    width: number,
    height: number
) => TTarget;

method union

union: (other: BoundingRect) => void;

class Circle

class Circle extends Path<CircleProps> {}

constructor

constructor(opts?: CircleProps);

property shape

shape: CircleShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: CircleShape) => void;

method getDefaultShape

getDefaultShape: () => CircleShape;

class CircleShape

class CircleShape {}

property cx

cx: number;

property cy

cy: number;

property r

r: number;

class CompoundPath

class CompoundPath extends Path {}

property shape

shape: CompoundPathShape;

property type

type: string;

method afterBrush

afterBrush: () => void;

method beforeBrush

beforeBrush: () => void;

method buildPath

buildPath: (
    ctx: PathProxy | CanvasRenderingContext2D,
    shape: CompoundPathShape
) => void;

method getBoundingRect

getBoundingRect: () => import('../core/BoundingRect').default;

class Displayable

class Displayable<
    Props extends DisplayableProps = DisplayableProps
> extends Element<Props> {}

constructor

constructor(props?: DisplayableProps);

property culling

culling: boolean;

property cursor

cursor: string;

property dirtyRectTolerance

dirtyRectTolerance: number;

property ignoreCoarsePointer

ignoreCoarsePointer?: boolean;

property incremental

incremental: IncrementalIdCompat;

property initDefaultProps

protected static initDefaultProps: void;

property invisible

invisible: boolean;

property notClear

notClear?: boolean;

property rectHover

rectHover: boolean;

property style

style: Dictionary<any>;

property useHoverLayer

useHoverLayer?: boolean;

property z

z: number;

property z2

z2: number;

property zlevel

zlevel: number;

method afterBrush

afterBrush: () => void;

method animateStyle

animateStyle: (loop: boolean) => Animator<this['style']>;

method attrKV

attrKV: (key: DisplayableKey, value: DisplayablePropertyType) => void;

method beforeBrush

beforeBrush: (param: BeforeBrushParam) => void;

method contain

contain: (x: number, y: number) => boolean;

method createStyle

createStyle: (obj?: Props['style']) => Props['style'];

method dirty

dirty: () => void;

method dirtyStyle

dirtyStyle: (notRedraw?: boolean) => void;

method getAnimationStyleProps

getAnimationStyleProps: () => MapToType<DisplayableProps, boolean>;

method getPaintRect

getPaintRect: () => BoundingRect;

method getPrevPaintRect

getPrevPaintRect: () => BoundingRect;

method innerAfterBrush

innerAfterBrush: () => void;

method innerBeforeBrush

innerBeforeBrush: () => void;

method isStyleObject

isStyleObject: (obj: Props['style']) => any;

method rectContain

rectContain: (x: number, y: number) => boolean;

method setPrevPaintRect

setPrevPaintRect: (paintRect: BoundingRect) => void;

method setStyle

setStyle: {
    (obj: Props['style']): this;
    <T extends keyof Props['style']>(obj: T, value: Props['style'][T]): this;
};

method shouldBePainted

shouldBePainted: (
    viewWidth: number,
    viewHeight: number,
    considerClipPath: boolean,
    considerAncestors: boolean
) => boolean;

method styleChanged

styleChanged: () => boolean;

method styleUpdated

styleUpdated: () => void;

method traverse

traverse: <Context>(
    cb: (this: Context, el: this) => void,
    context?: Context
) => void;

method updateDuringAnimation

updateDuringAnimation: (targetKey: string) => void;

method useStyle

useStyle: (obj: Props['style']) => void;

class Droplet

class Droplet extends Path<DropletProps> {}

constructor

constructor(opts?: DropletProps);

property shape

shape: DropletShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: DropletShape) => void;

method getDefaultShape

getDefaultShape: () => DropletShape;

class DropletShape

class DropletShape {}

property cx

cx: number;

property cy

cy: number;

property height

height: number;

property width

width: number;

class Element

class Element<Props extends ElementProps = ElementProps> {}

constructor

constructor(props?: ElementProps);

property anid

anid: string;

property animators

animators: Animator<any>[];

property calculateTextPosition

calculateTextPosition: ElementCalculateTextPosition;

property currentStates

currentStates?: string[];

property draggable

draggable: boolean | 'horizontal' | 'vertical';

property dragging

dragging: boolean;

property extra

extra: Dictionary<unknown>;

property id

id: number;

property ignore

ignore: boolean;

property ignoreClip

ignoreClip: boolean;

property ignoreHostSilent

ignoreHostSilent: boolean;

property initDefaultProps

protected static initDefaultProps: void;

property isGroup

isGroup: boolean;

property name

name: string;

property parent

parent: Group;

property prevStates

prevStates?: string[];

property silent

silent: boolean;

property stateProxy

stateProxy?: (stateName: string, targetStates?: string[]) => ElementState;

property states

states: Dictionary<ElementState>;

property stateTransition

stateTransition: ElementAnimateConfig;

property textConfig

textConfig?: ElementTextConfig;

property textGuideLineConfig

textGuideLineConfig?: ElementTextGuideLineConfig;

property type

type: string;

method addAnimator

addAnimator: (animator: Animator<any>, key: string) => void;

method addSelfToZr

addSelfToZr: (zr: ZRenderType) => void;

method afterUpdate

afterUpdate: () => void;

method animate

animate: (
    key?: string,
    loop?: boolean,
    allowDiscreteAnimation?: boolean
) => Animator<any>;

method animateFrom

animateFrom: (
    target: Props,
    cfg: ElementAnimateConfig,
    animationProps?: MapToType<Props, boolean>
) => void;

method animateTo

animateTo: (
    target: Props,
    cfg?: ElementAnimateConfig,
    animationProps?: MapToType<Props, boolean>
) => void;

method attr

attr: {
    (keyOrObj: Props): this;
    <T extends keyof Props>(keyOrObj: T, value: Props[T]): this;
};

method attrKV

protected attrKV: (key: string, value: unknown) => void;

method beforeUpdate

beforeUpdate: () => void;

method canBeInsideText

protected canBeInsideText: () => boolean;

method clearStates

clearStates: (noAnimation?: boolean) => void;

method dirty

dirty: () => void;

method drift

drift: (dx: number, dy: number, e?: ElementEvent) => void;

method ensureState

ensureState: (name: string) => ElementState;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method getClipPath

getClipPath: () => Path<import('./graphic/Path').PathProps>;

method getInsideTextFill

protected getInsideTextFill: () => string | undefined;

method getInsideTextStroke

protected getInsideTextStroke: (textFill: string) => string | undefined;

method getOutsideFill

protected getOutsideFill: () => string | undefined;

method getOutsideStroke

protected getOutsideStroke: (textFill: string) => string;

method getPaintRect

getPaintRect: () => BoundingRect;

method getState

getState: (name: string) => ElementState;

method getTextContent

getTextContent: () => ZRText;

method getTextGuideLine

getTextGuideLine: () => Polyline;

method hasState

hasState: () => boolean;

method hide

hide: () => void;

method isSilent

isSilent: () => boolean;

method markRedraw

markRedraw: () => void;

method removeClipPath

removeClipPath: () => void;

method removeSelfFromZr

removeSelfFromZr: (zr: ZRenderType) => void;

method removeState

removeState: (state: string) => void;

method removeTextConfig

removeTextConfig: () => void;

method removeTextContent

removeTextContent: () => void;

method removeTextGuideLine

removeTextGuideLine: () => void;

method replaceState

replaceState: (oldState: string, newState: string, forceAdd: boolean) => void;

method saveCurrentToNormalState

saveCurrentToNormalState: (toState: ElementState) => void;

method setClipPath

setClipPath: (clipPath: Path) => void;

method setTextConfig

setTextConfig: (cfg: ElementTextConfig) => void;

method setTextContent

setTextContent: (textEl: ZRText) => void;

method setTextGuideLine

setTextGuideLine: (guideLine: Polyline) => void;

method show

show: () => void;

method stopAnimation

stopAnimation: (scope?: string, forwardToLast?: boolean) => this;

method toggleState

toggleState: (state: string, enable: boolean) => void;

method traverse

traverse: <Context>(
    cb: (this: Context, el: Element<Props>) => void,
    context?: Context
) => void;

method update

update: () => void;

method updateDuringAnimation

updateDuringAnimation: (key: string) => void;

method updateInnerText

updateInnerText: (forceUpdate?: boolean) => void;

method useState

useState: (
    stateName: string,
    keepCurrentStates?: boolean,
    noAnimation?: boolean,
    forceUseHoverLayer?: boolean
) => ElementState;

method useStates

useStates: (
    states: string[],
    noAnimation?: boolean,
    forceUseHoverLayer?: boolean
) => void;

class Ellipse

class Ellipse extends Path<EllipseProps> {}

constructor

constructor(opts?: EllipseProps);

property shape

shape: EllipseShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: EllipseShape) => void;

method getDefaultShape

getDefaultShape: () => EllipseShape;

class EllipseShape

class EllipseShape {}

property cx

cx: number;

property cy

cy: number;

property rx

rx: number;

property ry

ry: number;

class Group

class Group extends Element<GroupProps> {}

constructor

constructor(opts?: GroupProps);

property isGroup

readonly isGroup: boolean;

method add

add: (child: Element) => Group;

method addBefore

addBefore: (child: Element, nextSibling: Element) => this;

method addSelfToZr

addSelfToZr: (zr: ZRenderType) => void;

method childAt

childAt: (idx: number) => Element;

method childCount

childCount: () => number;

method childOfName

childOfName: (name: string) => Element;

method children

children: () => Element<ElementProps>[];

method childrenRef

childrenRef: () => Element<ElementProps>[];

method eachChild

eachChild: <Context>(
    cb: (this: Context, el: Element, index?: number) => void,
    context?: Context
) => this;

method getBoundingRect

getBoundingRect: (includeChildren?: Element[]) => BoundingRect;

method remove

remove: (child: Element) => this;

method removeAll

removeAll: () => this;

method removeSelfFromZr

removeSelfFromZr: (zr: ZRenderType) => void;

method replace

replace: (oldChild: Element, newChild: Element) => this;

method replaceAt

replaceAt: (child: Element, index: number) => this;

method traverse

traverse: <T>(cb: (this: T, el: Element) => boolean | void, context?: T) => this;

class Heart

class Heart extends Path<HeartProps> {}

constructor

constructor(opts?: HeartProps);

property shape

shape: HeartShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: HeartShape) => void;

method getDefaultShape

getDefaultShape: () => HeartShape;

class HeartShape

class HeartShape {}

property cx

cx: number;

property cy

cy: number;

property height

height: number;

property width

width: number;

class Image

class ZRImage extends Displayable<ImageProps> {}

property onload

onload: (image: ImageLike) => void;

property style

style: ImageStyleProps;

method createStyle

createStyle: (obj?: ImageStyleProps) => ImageStyleProps;

method getAnimationStyleProps

getAnimationStyleProps: () => MapToType<ImageProps, boolean>;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method getHeight

getHeight: () => number;

method getWidth

getWidth: () => number;

class IncrementalDisplayable

class IncrementalDisplayable extends Displayble {}

property incremental

incremental: number;

property notClear

notClear: boolean;

method addDisplayable

addDisplayable: (displayable: Displayble, notPersistent?: boolean) => void;

method addDisplayables

addDisplayables: (displayables: Displayble[], notPersistent?: boolean) => void;

method clearDisplaybles

clearDisplaybles: () => void;

method clearTemporalDisplayables

clearTemporalDisplayables: () => void;

method contain

contain: (x: number, y: number) => boolean;

method eachPendingDisplayable

eachPendingDisplayable: (cb: (displayable: Displayble) => void) => void;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method getCursor

getCursor: () => number;

method getDisplayables

getDisplayables: () => Displayble[];

method getTemporalDisplayables

getTemporalDisplayables: () => Displayble[];

method innerAfterBrush

innerAfterBrush: () => void;

method traverse

traverse: <T>(cb: (this: T, el: this) => void, context: T) => void;

method update

update: () => void;

method useStyle

useStyle: () => void;

class Isogon

class Isogon extends Path<IsogonProps> {}

constructor

constructor(opts?: IsogonProps);

property shape

shape: IsogonShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: IsogonShape) => void;

method getDefaultShape

getDefaultShape: () => IsogonShape;

class IsogonShape

class IsogonShape {}

property n

n: number;

property r

r: number;

property x

x: number;

property y

y: number;

class Line

class Line extends Path<LineProps> {}

constructor

constructor(opts?: LineProps);

property shape

shape: LineShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: LineShape) => void;

method getDefaultShape

getDefaultShape: () => LineShape;

method getDefaultStyle

getDefaultStyle: () => { stroke: string; fill: string };

method pointAt

pointAt: (p: number) => VectorArray;

class LinearGradient

class LinearGradient extends Gradient {}

constructor

constructor(
    x: number,
    y: number,
    x2: number,
    y2: number,
    colorStops?: GradientColorStop[],
    globalCoord?: boolean
);

property type

type: string;

property x

x: number;

property x2

x2: number;

property y

y: number;

property y2

y2: number;

class LineShape

class LineShape {}

property percent

percent: number;

property x1

x1: number;

property x2

x2: number;

property y1

y1: number;

property y2

y2: number;

class OrientedBoundingRect

class OrientedBoundingRect {}

constructor

constructor(rect?: BoundingRect, transform?: MatrixArray);

method fromBoundingRect

fromBoundingRect: (rect: BoundingRect, transform?: MatrixArray) => void;

method intersect

intersect: (
    other: OrientedBoundingRect,
    mtv?: PointLike,
    opt?: BoundingRectIntersectOpt
) => boolean;

class Path

class Path<Props extends PathProps = PathProps> extends Displayable<Props> {}

constructor

constructor(opts?: PathProps);

property autoBatch

autoBatch: boolean;

property initDefaultProps

protected static initDefaultProps: void;

property path

path: PathProxy;

property segmentIgnoreThreshold

segmentIgnoreThreshold: number;

property shape

shape: Dictionary<any>;

property strokeContainThreshold

strokeContainThreshold: number;

property style

style: PathStyleProps;

property subPixelOptimize

subPixelOptimize: boolean;

method animateShape

animateShape: (loop: boolean) => Animator<this['shape']>;

method attrKV

attrKV: (key: PathKey, value: PathPropertyType) => void;

method buildPath

buildPath: (
    ctx: PathProxy | CanvasRenderingContext2D,
    shapeCfg: Dictionary<any>,
    inBatch?: boolean
) => void;

method canBeInsideText

protected canBeInsideText: () => boolean;

method contain

contain: (x: number, y: number) => boolean;

method createPathProxy

createPathProxy: () => void;

method createStyle

createStyle: (obj?: Props['style']) => Props['style'];

method dirty

dirty: () => void;

method dirtyShape

dirtyShape: () => void;

method extend

static extend: <Shape extends Dictionary<any>>(defaultProps: {
    type?: string;
    shape?: Shape;
    style?: PathStyleProps;
    beforeBrush?: Displayable['beforeBrush'];
    afterBrush?: Displayable['afterBrush'];
    getBoundingRect?: Displayable['getBoundingRect'];
    calculateTextPosition?: Element['calculateTextPosition'];
    buildPath(
        this: Path,
        ctx: CanvasRenderingContext2D | PathProxy,
        shape: Shape,
        inBatch?: boolean
    ): void;
    init?(this: Path, opts: PathProps): void;
}) => new (opts?: PathProps & { shape: Shape }) => Path;

method getAnimationStyleProps

getAnimationStyleProps: () => MapToType<PathProps, boolean>;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method getDecalElement

getDecalElement: () => Path<PathProps>;

method getDefaultShape

protected getDefaultShape: () => {};

method getDefaultStyle

protected getDefaultStyle: () => Props['style'];

method getInsideTextFill

protected getInsideTextFill: () => '#333' | '#ccc' | '#eee';

method getInsideTextStroke

protected getInsideTextStroke: (textFill?: string) => string;

method getUpdatedPathProxy

getUpdatedPathProxy: (inBatch?: boolean) => PathProxy;

method hasFill

hasFill: () => boolean;

method hasStroke

hasStroke: () => boolean;

method isZeroArea

isZeroArea: () => boolean;

method pathUpdated

pathUpdated: () => void;

method setShape

setShape: {
    (obj: Props['shape']): this;
    <T extends keyof Props['shape']>(obj: T, value: Props['shape'][T]): this;
};

method shapeChanged

shapeChanged: () => boolean;

method update

update: () => void;

method updateDuringAnimation

updateDuringAnimation: (targetKey: string) => void;

class Pattern

class Pattern {}

constructor

constructor(image: string | ImageLike, repeat: ImagePatternRepeat);

property image

image: string | ImageLike;

property repeat

repeat: ImagePatternRepeat;

property rotation

rotation: number;

property scaleX

scaleX: number;

property scaleY

scaleY: number;

property svgElement

svgElement: string | SVGElement;

property type

type: string;

property x

x: number;

property y

y: number;

class Point

class Point {}

constructor

constructor(x?: number, y?: number);

property x

x: number;

property y

y: number;

method add

static add: (out: PointLike, p0: PointLike, p1: PointLike) => void;

method clone

clone: () => Point;

method copy

static copy: (p: PointLike, p2: PointLike) => void;

method distance

distance: (other: PointLike) => number;

method distanceSquare

distanceSquare: (other: Point) => number;

method dot

static dot: (p0: PointLike, p1: PointLike) => number;

method equal

equal: (other: PointLike) => boolean;

method fromArray

fromArray: (input: number[]) => void;

method len

static len: (p: PointLike) => number;

method lenSquare

static lenSquare: (p: PointLike) => number;

method lerp

static lerp: (out: PointLike, p0: PointLike, p1: PointLike, t: number) => void;

method negate

negate: () => this;

method normalize

normalize: () => this;

method scale

static scale: (out: PointLike, p0: PointLike, scalar: number) => void;

method scaleAndAdd

static scaleAndAdd: (
    out: PointLike,
    p0: PointLike,
    p1: PointLike,
    scalar: number
) => void;

method set

static set: (p: PointLike, x: number, y: number) => void;

method sub

static sub: (out: PointLike, p0: PointLike, p1: PointLike) => void;

method toArray

toArray: (out: number[]) => number[];

method transform

transform: (m: MatrixArray) => this;

class Polygon

class Polygon extends Path<PolygonProps> {}

constructor

constructor(opts?: PolygonProps);

property shape

shape: PolygonShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: PolygonShape) => void;

method getDefaultShape

getDefaultShape: () => PolygonShape;

class PolygonShape

class PolygonShape {}

property points

points: VectorArray[];

property smooth

smooth?: number;

property smoothConstraint

smoothConstraint?: VectorArray[];

class Polyline

class Polyline extends Path<PolylineProps> {}

constructor

constructor(opts?: PolylineProps);

property shape

shape: PolylineShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: PolylineShape) => void;

method getDefaultShape

getDefaultShape: () => PolylineShape;

method getDefaultStyle

getDefaultStyle: () => { stroke: string; fill: string };

class PolylineShape

class PolylineShape {}

property percent

percent?: number;

property points

points: VectorArray[];

property smooth

smooth?: number;

property smoothConstraint

smoothConstraint?: VectorArray[];

class RadialGradient

class RadialGradient extends Gradient {}

constructor

constructor(
    x: number,
    y: number,
    r: number,
    colorStops?: GradientColorStop[],
    globalCoord?: boolean
);

property r

r: number;

property type

type: string;

property x

x: number;

property y

y: number;

class Rect

class Rect extends Path<RectProps> {}

constructor

constructor(opts?: RectProps);

property shape

shape: RectShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: RectShape) => void;

method getDefaultShape

getDefaultShape: () => RectShape;

method isZeroArea

isZeroArea: () => boolean;

class RectShape

class RectShape {}

property height

height: number;

property r

r?: number | number[];

property width

width: number;

property x

x: number;

property y

y: number;

class Ring

class Ring extends Path<RingProps> {}

constructor

constructor(opts?: RingProps);

property shape

shape: RingShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: RingShape) => void;

method getDefaultShape

getDefaultShape: () => RingShape;

class RingShape

class RingShape {}

property cx

cx: number;

property cy

cy: number;

property r

r: number;

property r0

r0: number;

class Rose

class Rose extends Path<RoseProps> {}

constructor

constructor(opts?: RoseProps);

property shape

shape: RoseShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: RoseShape) => void;

method getDefaultShape

getDefaultShape: () => RoseShape;

method getDefaultStyle

getDefaultStyle: () => { stroke: string; fill: string };

class RoseShape

class RoseShape {}

property cx

cx: number;

property cy

cy: number;

property k

k: number;

property n

n: number;

property r

r: number[];

class Sector

class Sector extends Path<SectorProps> {}

constructor

constructor(opts?: SectorProps);

property shape

shape: SectorShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: SectorShape) => void;

method getDefaultShape

getDefaultShape: () => SectorShape;

method isZeroArea

isZeroArea: () => boolean;

class SectorShape

class SectorShape {}

property clockwise

clockwise: boolean;

property cornerRadius

cornerRadius: number | number[];

property cx

cx: number;

property cy

cy: number;

property endAngle

endAngle: number;

property r

r: number;

property r0

r0: number;

property startAngle

startAngle: number;

class Star

class Star extends Path<StarProps> {}

constructor

constructor(opts?: StarProps);

property shape

shape: StarShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: StarShape) => void;

method getDefaultShape

getDefaultShape: () => StarShape;

class StarShape

class StarShape {}

property cx

cx: number;

property cy

cy: number;

property n

n: number;

property r

r: number;

property r0

r0: number;

class Text

class ZRText extends Displayable<TextProps> implements GroupLike {}

constructor

constructor(opts?: TextProps);

property innerTransformable

innerTransformable: Transformable;

property isTruncated

isTruncated: boolean;

property overlap

overlap: 'hidden' | 'show' | 'blur';

property style

style: TextStyleProps;

property type

type: string;

method addSelfToZr

addSelfToZr: (zr: ZRenderType) => void;

method childrenRef

childrenRef: () => (ZRImage | Rect | TSpan)[];

method getAnimationStyleProps

getAnimationStyleProps: () => MapToType<TextProps, boolean>;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method getComputedTransform

getComputedTransform: () => MatrixArray;

method getLocalTransform

getLocalTransform: (m?: MatrixArray) => MatrixArray;

method makeFont

static makeFont: (style: TextStylePropsPart) => string;

method removeSelfFromZr

removeSelfFromZr: (zr: ZRenderType) => void;

method setDefaultTextStyle

setDefaultTextStyle: (defaultTextStyle: DefaultTextStyle) => void;

method setTextContent

setTextContent: (textContent: never) => void;

method update

update: () => void;

method updateTransform

updateTransform: () => void;

class Trochoid

class Trochoid extends Path<TrochoidProps> {}

constructor

constructor(opts?: TrochoidProps);

property shape

shape: TrochoidShape;

method buildPath

buildPath: (ctx: CanvasRenderingContext2D, shape: TrochoidShape) => void;

method getDefaultShape

getDefaultShape: () => TrochoidShape;

method getDefaultStyle

getDefaultStyle: () => { stroke: string; fill: string };

class TrochoidShape

class TrochoidShape {}

property cx

cx: number;

property cy

cy: number;

property d

d: number;

property location

location: string;

property r

r: number;

property r0

r0: number;

class TSpan

class TSpan extends Displayable<TSpanProps> {}

property initDefaultProps

protected static initDefaultProps: void;

property style

style: TSpanStyleProps;

method createStyle

createStyle: (obj?: TSpanStyleProps) => TSpanStyleProps;

method getBoundingRect

getBoundingRect: () => BoundingRect;

method hasFill

hasFill: () => boolean;

method hasStroke

hasStroke: () => boolean;

method setBoundingRect

setBoundingRect: (rect: BoundingRect) => void;

Interfaces

interface ArcProps

interface ArcProps extends PathProps {}

property shape

shape?: Partial<ArcShape>;

interface BezierCurveProps

interface BezierCurveProps extends PathProps {}

property shape

shape?: Partial<BezierCurveShape>;

interface CircleProps

interface CircleProps extends PathProps {}

property shape

shape?: Partial<CircleShape>;

interface CompoundPathShape

interface CompoundPathShape {}

property paths

paths: Path[];

interface Displayable

interface Displayable<Props extends DisplayableProps = DisplayableProps> {}

property stateProxy

stateProxy: (stateName: string) => DisplayableState;

property states

states: Dictionary<DisplayableState>;

method animate

animate: {
    (key?: '', loop?: boolean): Animator<this>;
    (key: 'style', loop?: boolean): Animator<this['style']>;
};

method ensureState

ensureState: (stateName: string) => DisplayableState;

method getState

getState: (stateName: string) => DisplayableState;

interface DisplayableProps

interface DisplayableProps extends ElementProps {}

property batch

batch?: boolean;

property culling

culling?: boolean;

property cursor

cursor?: string;

property ignoreCoarsePointer

ignoreCoarsePointer?: boolean;

property incremental

incremental?: Displayable['incremental'];

property invisible

invisible?: boolean;

property progressive

progressive?: boolean;

property rectHover

rectHover?: boolean;

property style

style?: Dictionary<any>;

property z

z?: number;

property z2

z2?: number;

property zlevel

zlevel?: number;

interface DropletProps

interface DropletProps extends PathProps {}

property shape

shape?: Partial<DropletShape>;

interface Element

interface Element<Props extends ElementProps = ElementProps>
    extends Transformable,
        Eventful<
            {
                [key in ElementEventName]: (e: ElementEvent) => void | boolean;
            } & {
                [key in string]: (...args: any) => void | boolean;
            }
        >,
        ElementEventHandlerProps {}

interface ElementAnimateConfig

interface ElementAnimateConfig {}

property aborted

aborted?: Function;

property additive

additive?: boolean;

property delay

delay?: number;

property done

done?: Function;

property duration

duration?: number;

property during

during?: (percent: number) => void;

property easing

easing?: AnimationEasing;

property force

force?: boolean;

property scope

scope?: string;

property setToFinal

setToFinal?: boolean;

interface ElementEvent

interface ElementEvent {}

property cancelBubble

cancelBubble: boolean;

property event

event: ZRRawEvent;

property gestureEvent

gestureEvent: string;

property offsetX

offsetX: number;

property offsetY

offsetY: number;

property pinchScale

pinchScale: number;

property pinchX

pinchX: number;

property pinchY

pinchY: number;

property stop

stop: (this: ElementEvent) => void;

property target

target: Element;

property topTarget

topTarget: Element;

property type

type: ElementEventName;

property wheelDelta

wheelDelta: number;

property which

which: number;

property zrByTouch

zrByTouch: boolean;

interface ElementProps

interface ElementProps
    extends Partial<ElementEventHandlerProps>,
        Partial<Pick<Transformable, TransformProp>> {}

property anid

anid?: string;

property clipPath

clipPath?: Path;

property draggable

draggable?: boolean | 'horizontal' | 'vertical';

property drift

drift?: Element['drift'];

property extra

extra?: Dictionary<unknown>;

property globalScaleRatio

globalScaleRatio?: number;

property ignore

ignore?: boolean;

property ignoreClip

ignoreClip?: boolean;

property ignoreHostSilent

ignoreHostSilent?: boolean;

property isGroup

isGroup?: boolean;

property name

name?: string;

property silent

silent?: boolean;

property textConfig

textConfig?: ElementTextConfig;

property textContent

textContent?: ZRText;

interface ElementTextConfig

interface ElementTextConfig {}

property autoOverflowArea

autoOverflowArea?: boolean;

property distance

distance?: number;

property inside

inside?: boolean;

property insideFill

insideFill?: string;

property insideStroke

insideStroke?: string;

property layoutRect

layoutRect?: RectLike;

property local

local?: boolean;

property offset

offset?: number[];

property origin

origin?: (number | string)[] | 'center';

property outsideFill

outsideFill?: string;

property outsideStroke

outsideStroke?: string;

property position

position?: BuiltinTextPosition | (number | string)[];

property rotation

rotation?: number;

interface ElementTextGuideLineConfig

interface ElementTextGuideLineConfig {}

property anchor

anchor?: Point;

property candidates

candidates?: ('left' | 'top' | 'right' | 'bottom')[];

property showAbove

showAbove?: boolean;

interface EllipseProps

interface EllipseProps extends PathProps {}

property shape

shape?: Partial<EllipseShape>;

interface GroupProps

interface GroupProps extends ElementProps {}

interface HeartProps

interface HeartProps extends PathProps {}

property shape

shape?: Partial<HeartShape>;

interface ImagePatternObject

interface ImagePatternObject extends PatternObjectBase {}

property image

image: ImageLike | string;

property imageHeight

imageHeight?: number;

property imageWidth

imageWidth?: number;

property repeat

repeat?: ImagePatternRepeat;

interface ImageProps

interface ImageProps extends DisplayableProps {}

property onload

onload?: (image: ImageLike) => void;

property style

style?: ImageStyleProps;

interface ImageStyleProps

interface ImageStyleProps extends CommonStyleProps {}

property height

height?: number;

property image

image?: string | ImageLike;

property sHeight

sHeight?: number;

property sWidth

sWidth?: number;

property sx

sx?: number;

property sy

sy?: number;

property width

width?: number;

property x

x?: number;

property y

y?: number;

interface IsogonProps

interface IsogonProps extends PathProps {}

property shape

shape?: Partial<IsogonShape>;

interface LinearGradientObject

interface LinearGradientObject extends GradientObject {}

property type

type: 'linear';

property x

x: number;

property x2

x2: number;

property y

y: number;

property y2

y2: number;

interface LineProps

interface LineProps extends PathProps {}

property shape

shape?: Partial<LineShape>;

interface Path

interface Path<Props extends PathProps = PathProps> {}

property stateProxy

stateProxy: (stateName: string) => PathState;

property states

states: Dictionary<PathState>;

method animate

animate: {
    (key?: '', loop?: boolean): Animator<this>;
    (key: 'style', loop?: boolean): Animator<this['style']>;
    (key: 'shape', loop?: boolean): Animator<this['shape']>;
};

method ensureState

ensureState: (stateName: string) => PathState;

method getState

getState: (stateName: string) => PathState;

interface PathProps

interface PathProps extends DisplayableProps {}

property autoBatch

autoBatch?: boolean;

property buildPath

buildPath?: (
    ctx: PathProxy | CanvasRenderingContext2D,
    shapeCfg: Dictionary<any>,
    inBatch?: boolean
) => void;

property segmentIgnoreThreshold

segmentIgnoreThreshold?: number;

property shape

shape?: Dictionary<any>;

property strokeContainThreshold

strokeContainThreshold?: number;

property style

style?: PathStyleProps;

property subPixelOptimize

subPixelOptimize?: boolean;

interface PathStyleProps

interface PathStyleProps extends CommonStyleProps {}

property decal

decal?: PatternObject;

property fill

fill?: string | PatternObject | LinearGradientObject | RadialGradientObject;

property fillOpacity

fillOpacity?: number;

property lineCap

lineCap?: CanvasLineCap;

property lineDash

lineDash?: false | number[] | 'solid' | 'dashed' | 'dotted';

property lineDashOffset

lineDashOffset?: number;

property lineJoin

lineJoin?: CanvasLineJoin;

property lineWidth

lineWidth?: number;

property miterLimit

miterLimit?: number;

property stroke

stroke?: string | PatternObject | LinearGradientObject | RadialGradientObject;

property strokeFirst

strokeFirst?: boolean;

property strokeNoScale

strokeNoScale?: boolean;

property strokeOpacity

strokeOpacity?: number;

property strokePercent

strokePercent?: number;

interface PatternObjectBase

interface PatternObjectBase {}

property id

id?: number;

property rotation

rotation?: number;

property scaleX

scaleX?: number;

property scaleY

scaleY?: number;

property type

type?: 'pattern';

property x

x?: number;

property y

y?: number;

interface PointLike

interface PointLike {}

property x

x: number;

property y

y: number;

interface PolygonProps

interface PolygonProps extends PathProps {}

property shape

shape?: Partial<PolygonShape>;

interface PolylineProps

interface PolylineProps extends PathProps {}

property shape

shape?: Partial<PolylineShape>;

interface RadialGradientObject

interface RadialGradientObject extends GradientObject {}

property r

r: number;

property type

type: 'radial';

property x

x: number;

property y

y: number;

interface RectProps

interface RectProps extends PathProps {}

property shape

shape?: Partial<RectShape>;

interface RingProps

interface RingProps extends PathProps {}

property shape

shape?: Partial<RingShape>;

interface RoseProps

interface RoseProps extends PathProps {}

property shape

shape?: Partial<RoseShape>;

interface SectorProps

interface SectorProps extends PathProps {}

property shape

shape?: Partial<SectorShape>;

interface StarProps

interface StarProps extends PathProps {}

property shape

shape?: Partial<StarShape>;

interface SVGPatternObject

interface SVGPatternObject extends PatternObjectBase {}

property svgElement

svgElement?: SVGVNode;

property svgHeight

svgHeight?: number;

property svgWidth

svgWidth?: number;

interface Text

interface ZRText {}

property stateProxy

stateProxy: (stateName: string) => TextState;

property states

states: Dictionary<TextState>;

method animate

animate: {
    (key?: '', loop?: boolean): Animator<this>;
    (key: 'style', loop?: boolean): Animator<this['style']>;
};

method ensureState

ensureState: (stateName: string) => TextState;

method getState

getState: (stateName: string) => TextState;

interface TextProps

interface TextProps extends DisplayableProps {}

property culling

culling?: boolean;

property cursor

cursor?: string;

property style

style?: TextStyleProps;

property z

z?: number;

property z2

z2?: number;

property zlevel

zlevel?: number;

interface TextStyleProps

interface TextStyleProps extends TextStylePropsPart {}

property ellipsis

ellipsis?: string;

property lineOverflow

lineOverflow?: 'truncate';

property overflow

overflow?: 'break' | 'breakAll' | 'truncate' | 'none';

property placeholder

placeholder?: string;

property rich

rich?: Dictionary<TextStylePropsPart>;

property text

text?: string;

property truncateMinChar

truncateMinChar?: number;

property width

width?: number;

property x

x?: number;

property y

y?: number;

interface TextStylePropsPart

interface TextStylePropsPart {}

property align

align?: TextAlign;

property backgroundColor

backgroundColor?:
    | string
    | {
          image: ImageLike | string;
      };

property borderColor

borderColor?: string;

property borderDash

borderDash?: false | number[];

property borderDashOffset

borderDashOffset?: number;

property borderRadius

borderRadius?: number | number[];

property borderWidth

borderWidth?: number;

property fill

fill?: string;

property fillOpacity

fillOpacity?: number;

property font

font?: string;

property fontFamily

fontFamily?: string;

property fontSize

fontSize?: number | string;

property fontStyle

fontStyle?: FontStyle;

property fontWeight

fontWeight?: FontWeight;

property height

height?: number;

property lineDash

lineDash?: false | number[];

property lineDashOffset

lineDashOffset?: number;

property lineHeight

lineHeight?: number;

property lineWidth

lineWidth?: number;

property margin

margin?: number | number[];

property opacity

opacity?: number;

property padding

padding?: number | number[];

property shadowBlur

shadowBlur?: number;

property shadowColor

shadowColor?: string;

property shadowOffsetX

shadowOffsetX?: number;

property shadowOffsetY

shadowOffsetY?: number;

property stroke

stroke?: string;

property strokeNoScale

strokeNoScale?: boolean;

property strokeOpacity

strokeOpacity?: number;

property tag

tag?: string;

property text

text?: string;

property textFont

textFont?: string;

property textShadowBlur

textShadowBlur?: number;

property textShadowColor

textShadowColor?: string;

property textShadowOffsetX

textShadowOffsetX?: number;

property textShadowOffsetY

textShadowOffsetY?: number;

property verticalAlign

verticalAlign?: TextVerticalAlign;

property width

width?: number | string;

interface TrochoidProps

interface TrochoidProps extends PathProps {}

property shape

shape?: Partial<TrochoidShape>;

interface TSpanProps

interface TSpanProps extends DisplayableProps {}

property style

style?: TSpanStyleProps;

interface TSpanStyleProps

interface TSpanStyleProps extends PathStyleProps {}

property font

font?: string;

property fontFamily

fontFamily?: string;

property fontSize

fontSize?: number;

property fontStyle

fontStyle?: FontStyle;

property fontWeight

fontWeight?: FontWeight;

property text

text?: string;

property textAlign

textAlign?: CanvasTextAlign;

property textBaseline

textBaseline?: CanvasTextBaseline;

property x

x?: number;

property y

y?: number;

interface ZRenderInitOpt

interface ZRenderInitOpt {}

property devicePixelRatio

devicePixelRatio?: number;

property height

height?: number | string;

property pointerSize

pointerSize?: number;

property renderer

renderer?: string;

property ssr

ssr?: boolean;

property useCoarsePointer

useCoarsePointer?: 'auto' | boolean;

property useDirtyRect

useDirtyRect?: boolean;

property width

width?: number | string;

interface ZRenderType

interface ZRenderType extends ZRender {}

Type Aliases

type ElementEventCallback

type ElementEventCallback<Ctx, Impl> = (
    this: CbThis<Ctx, Impl>,
    e: ElementEvent
) => boolean | void;

type ElementSSRData

type ElementSSRData = zrUtil.HashMap<unknown>;

type ElementSSRDataGetter

type ElementSSRDataGetter<T> = (el: Element) => zrUtil.HashMap<T>;

type ImageState

type ImageState = Pick<ImageProps, DisplayableStatePropNames> & ElementCommonState;

type PathState

type PathState = Pick<PathProps, PathStatePropNames> & {
    hoverLayer?: ElementCommonState['hoverLayer'];
};

type PathStatePropNames

type PathStatePropNames = DisplayableStatePropNames | 'shape';

type PatternObject

type PatternObject = ImagePatternObject | SVGPatternObject;

type RectLike

type RectLike = {
    x: number;
    y: number;
    width: number;
    height: number;
};

type TextState

type TextState = Pick<TextProps, DisplayableStatePropNames> & ElementCommonState;

type TSpanState

type TSpanState = Pick<TSpanProps, DisplayableStatePropNames>;

Namespaces

namespace color

module 'lib/tool/color.d.ts' {}

variable fastMapToColor

const fastMapToColor: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

variable mapToColor

const mapToColor: {
    (normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput;
    (normalizedValue: number, colors: string[]): string;
};

function fastLerp

fastLerp: (
    normalizedValue: number,
    colors: number[][],
    out?: number[]
) => number[];

function lerp

lerp: {
    (normalizedValue: number, colors: string[], fullOutput: boolean): LerpFullOutput;
    (normalizedValue: number, colors: string[]): string;
};

function lift

lift: (color: string, level: number) => string;

function liftColor

liftColor: { (color: GradientObject): GradientObject; (color: string): string };

function lum

lum: (color: string, backgroundLum: number) => number;

function modifyAlpha

modifyAlpha: (color: string, alpha?: number) => string;

function modifyHSL

modifyHSL: (
    color: string,
    h?: number | ((h: number) => number),
    s?: string | number | ((s: number) => number),
    l?: string | number | ((l: number) => number)
) => string;

function parse

parse: (colorStr: string, rgbaArr?: number[]) => number[];

function parseCssFloat

parseCssFloat: (val: string | number) => number;

function parseCssInt

parseCssInt: (val: string | number) => number;

function random

random: () => string;

function stringify

stringify: (arrColor: number[], type: string) => string;

function toHex

toHex: (color: string) => string;

namespace matrix

module 'lib/core/matrix.d.ts' {}

function clone

clone: (a: MatrixArray) => MatrixArray;

function copy

copy: (out: MatrixArray, m: MatrixArray) => MatrixArray;

function create

create: () => MatrixArray;

function identity

identity: (out: MatrixArray) => MatrixArray;

function invert

invert: (out: MatrixArray, a: MatrixArray) => MatrixArray | null;

function mul

mul: (out: MatrixArray, m1: MatrixArray, m2: MatrixArray) => MatrixArray;

function rotate

rotate: (
    out: MatrixArray,
    a: MatrixArray,
    rad: number,
    pivot?: VectorArray
) => MatrixArray;

function scale

scale: (out: MatrixArray, a: MatrixArray, v: VectorArray) => MatrixArray;

function translate

translate: (out: MatrixArray, a: MatrixArray, v: VectorArray) => MatrixArray;

type MatrixArray

type MatrixArray = number[];

namespace morph

module 'lib/tool/morphPath.d.ts' {}

function alignBezierCurves

alignBezierCurves: (array1: number[][], array2: number[][]) => number[][][];

function centroid

centroid: (array: number[]) => number[];

function combineMorph

combineMorph: (
    fromList: (CombineMorphingPath | Path)[],
    toPath: Path,
    animationOpts: CombineConfig
) => {
    fromIndividuals: Path<import('../graphic/Path').PathProps>[];
    toIndividuals: Path<import('../graphic/Path').PathProps>[];
    count: number;
};

function defaultDividePath

defaultDividePath: (
    path: Path,
    count: number
) => Path<import('../graphic/Path').PathProps>[];

function isCombineMorphing

isCombineMorphing: (path: Element) => path is CombineMorphingPath;

function isMorphing

isMorphing: (el: Element) => boolean;

function morphPath

morphPath: (
    fromPath: Path,
    toPath: Path,
    animationOpts: ElementAnimateConfig
) => Path;

function separateMorph

separateMorph: (
    fromPath: Path,
    toPathList: Path[],
    animationOpts: SeparateConfig
) => {
    fromIndividuals: Path<import('../graphic/Path').PathProps>[];
    toIndividuals: Path<import('../graphic/Path').PathProps>[];
    count: number;
};

interface CombineConfig

interface CombineConfig extends ElementAnimateConfig {}

property dividePath

dividePath?: DividePath;

property individualDelay

individualDelay?: IndividualDelay;

interface CombineMorphingPath

interface CombineMorphingPath extends Path {}

method childrenRef

childrenRef: () => (CombineMorphingPath | Path)[];

interface DividePath

interface DividePath {}

call signature

(params: DividePathParams): Path[];

interface DividePathParams

interface DividePathParams {}

property count

count: number;

property path

path: Path;

interface IndividualDelay

interface IndividualDelay {}

call signature

(index: number, count: number, fromPath: Path, toPath: Path): number;

interface SeparateConfig

interface SeparateConfig extends ElementAnimateConfig {}

property dividePath

dividePath?: DividePath;

property individualDelay

individualDelay?: IndividualDelay;

namespace path

module 'lib/tool/path.d.ts' {}

function clonePath

clonePath: (
    sourcePath: Path,
    opts?: { bakeTransform?: boolean; toLocal?: boolean }
) => Path<PathProps>;

function createFromString

createFromString: (str: string, opts?: SVGPathOption) => SVGPath;

function extendFromString

extendFromString: (str: string, defaultOpts?: SVGPathOption) => typeof SVGPath;

function mergePath

mergePath: (pathEls: Path[], opts: PathProps) => Path<PathProps>;

namespace util

module 'lib/core/util.d.ts' {}

variable bind

const bind: FunctionBind;

variable EPSILON

const EPSILON: number;

variable RADIAN_TO_DEGREE

const RADIAN_TO_DEGREE: number;

function assert

assert: (condition: any, message?: string) => void;

function assignProps

assignProps: {
    <TSrc extends Dictionary<any>, TCommonKey extends keyof TSrc>(
        tar: NullUndefined,
        src: TSrc,
        props: readonly TCommonKey[]
    ): Pick<TSrc, TCommonKey>;
    <
        TTar extends Dictionary<any>,
        TSrc extends Dictionary<any>,
        TCommonKey extends keyof TSrc & keyof TTar
    >(
        tar: TTar,
        src: TSrc & { [P in TCommonKey]: TTar[P] },
        props: readonly TCommonKey[]
    ): TTar;
};

function clone

clone: <T extends unknown>(source: T) => T;

function concatArray

concatArray: <T, R>(a: ArrayLike<T>, b: ArrayLike<R>) => ArrayLike<T | R>;

function createCanvas

createCanvas: () => HTMLCanvasElement;

function createHashMap

createHashMap: <T, KEY extends string | number = string | number>(
    obj?: HashMap<T, KEY> | { [key in KEY]?: T } | KEY[]
) => HashMap<T, KEY>;

function createObject

createObject: <T>(proto?: object, properties?: T) => T;

function curry

curry: {
    <F extends CurryFunc, T1 extends Parameters<F>[0]>(func: F, a: T1): Curry1<
        F,
        T1
    >;
    <F extends CurryFunc, T1 extends Parameters<F>[0], T2 extends Parameters<F>[1]>(
        func: F,
        a: T1,
        b: T2
    ): Curry2<F, T1, T2>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3
    ): Curry3<F, T1, T2, T3>;
    <
        F extends CurryFunc,
        T1 extends Parameters<F>[0],
        T2 extends Parameters<F>[1],
        T3 extends Parameters<F>[2],
        T4 extends Parameters<F>[3]
    >(
        func: F,
        a: T1,
        b: T2,
        c: T3,
        d: T4
    ): Curry4<F, T1, T2, T3, T4>;
};

function defaults

defaults: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S,
    overlay?: boolean
) => T & S;

function disableUserSelect

disableUserSelect: (dom: HTMLElement) => void;

function each

each: <
    I extends any[] | readonly any[] | Dictionary<any> | ArrayLike<any>,
    Context
>(
    arr: I,
    cb: (
        this: Context,
        value: I extends (infer T)[] | readonly (infer T)[] | ArrayLike<infer T>
            ? T
            : I extends Dictionary<any>
            ? I extends Record<infer K extends string | number | symbol, infer T>
                ? T
                : unknown
            : unknown,
        index?: I extends any[] | readonly any[] | ArrayLike<any>
            ? number
            : keyof I & string,
        arr?: I
    ) => void,
    context?: Context
) => void;

function eqNaN

eqNaN: (value: any) => boolean;

function extend

extend: <T extends Dictionary<any>, S extends Dictionary<any>>(
    target: T,
    source: S
) => T & S;

function filter

filter: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index: number, arr: readonly T[]) => boolean,
    context?: Context
) => T[];

function find

find: <T, Context>(
    arr: readonly T[],
    cb: (this: Context, value: T, index?: number, arr?: readonly T[]) => boolean,
    context?: Context
) => T;

function guid

guid: () => number;

function hasOwn

hasOwn: (own: object, prop: string) => boolean;

function indexOf

indexOf: <T>(array: T[] | readonly T[] | ArrayLike<T>, value: T) => number;

function inherits

inherits: (clazz: Function, baseClazz: Function) => void;

function isArray

isArray: (value: any) => value is any[];

function isArrayLike

isArrayLike: (data: any) => data is ArrayLike<any>;

function isBuiltInObject

isBuiltInObject: (value: any) => boolean;

function isDom

isDom: (value: any) => value is HTMLElement;

function isFunction

isFunction: (value: any) => value is Function;

function isGradientObject

isGradientObject: (value: any) => value is GradientObject;

function isImagePatternObject

isImagePatternObject: (value: any) => value is ImagePatternObject;

function isNumber

isNumber: (value: any) => value is number;

function isObject

isObject: <T = unknown>(value: T) => value is object & T;

function isPrimitive

isPrimitive: (obj: any) => boolean;

function isRegExp

isRegExp: (value: unknown) => value is RegExp;

function isString

isString: (value: any) => value is string;

function isStringSafe

isStringSafe: (value: any) => value is string;

function isTypedArray

isTypedArray: (value: any) => boolean;

function keys

keys: <T extends object>(obj: T) => (KeyOfDistributive<T> & string)[];

function logError

logError: (...args: any[]) => void;

function map

map: <T, R, Context>(
    arr: readonly T[],
    cb: (this: Context, val: T, index?: number, arr?: readonly T[]) => R,
    context?: Context
) => R[];

function merge

merge: {
    <T extends Dictionary<any>, S extends Dictionary<any>>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T & S;
    <T extends unknown, S extends unknown>(
        target: T,
        source: S,
        overwrite?: boolean
    ): T | S;
};

function mergeAll

mergeAll: (targetAndSources: any[], overwrite?: boolean) => any;

function mixin

mixin: <T, S>(
    target: T | Function,
    source: S | Function,
    override?: boolean
) => void;

function nativeSlice

nativeSlice: (start?: number, end?: number) => any[];

function noop

noop: () => void;

function normalizeCssArray

normalizeCssArray: (val: number | number[]) => number[];

function reduce

reduce: <T, S, Context>(
    arr: readonly T[],
    cb: (
        this: Context,
        previousValue: S,
        currentValue: T,
        currentIndex?: number,
        arr?: readonly T[]
    ) => S,
    memo?: S,
    context?: Context
) => S;

function retrieve

retrieve: <T>(...args: T[]) => T;

function retrieve2

retrieve2: <T, R>(value0: T, value1: R) => T | R;

function retrieve3

retrieve3: <T, R, W>(value0: T, value1: R, value2: W) => T | R | W;

function setAsPrimitive

setAsPrimitive: (obj: any) => void;

function slice

slice: <T>(arr: ArrayLike<T>, start?: number, end?: number) => T[];

function trim

trim: (str: string) => string;

class HashMap

class HashMap<T, KEY extends string | number = string | number> {}

constructor

constructor(obj?: HashMap<T, KEY> | { [key in KEY]?: T } | KEY[]);

property data

data: MapInterface<T, KEY>;

method each

each: <Context>(
    cb: (this: Context, value?: T, key?: KEY) => void,
    context?: Context
) => void;

method get

get: (key: KEY) => T;

method hasKey

hasKey: (key: KEY) => boolean;

method keys

keys: () => KEY[];

method removeKey

removeKey: (key: KEY) => void;

method set

set: (key: KEY, value: T) => T;

type Bind1

type Bind1<F, Ctx> = F extends (this: Ctx, ...args: infer A) => infer R
    ? (...args: A) => R
    : unknown;

type Bind2

type Bind2<F, Ctx, T1> = F extends (this: Ctx, a: T1, ...args: infer A) => infer R
    ? (...args: A) => R
    : unknown;

type Bind3

type Bind3<F, Ctx, T1, T2> = F extends (
    this: Ctx,
    a: T1,
    b: T2,
    ...args: infer A
) => infer R
    ? (...args: A) => R
    : unknown;

type Bind4

type Bind4<F, Ctx, T1, T2, T3> = F extends (
    this: Ctx,
    a: T1,
    b: T2,
    c: T3,
    ...args: infer A
) => infer R
    ? (...args: A) => R
    : unknown;

type Bind5

type Bind5<F, Ctx, T1, T2, T3, T4> = F extends (
    this: Ctx,
    a: T1,
    b: T2,
    c: T3,
    d: T4,
    ...args: infer A
) => infer R
    ? (...args: A) => R
    : unknown;

type Curry1

type Curry1<F, T1> = F extends (a: T1, ...args: infer A) => infer R
    ? (...args: A) => R
    : unknown;

type Curry2

type Curry2<F, T1, T2> = F extends (a: T1, b: T2, ...args: infer A) => infer R
    ? (...args: A) => R
    : unknown;

type Curry3

type Curry3<F, T1, T2, T3> = F extends (
    a: T1,
    b: T2,
    c: T3,
    ...args: infer A
) => infer R
    ? (...args: A) => R
    : unknown;

type Curry4

type Curry4<F, T1, T2, T3, T4> = F extends (
    a: T1,
    b: T2,
    c: T3,
    d: T4,
    ...args: infer A
) => infer R
    ? (...args: A) => R
    : unknown;

namespace vector

module 'lib/core/vector.d.ts' {}

variable dist

const dist: (v1: VectorArray, v2: VectorArray) => number;

variable distSquare

const distSquare: (v1: VectorArray, v2: VectorArray) => number;

variable length

const length: (v: VectorArray) => number;

variable lengthSquare

const lengthSquare: (v: VectorArray) => number;

function add

add: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function applyTransform

applyTransform: <T extends VectorArray>(
    out: T,
    v: VectorArray,
    m: MatrixArray
) => T;

function clone

clone: (v: VectorArray) => VectorArray;

function copy

copy: <T extends VectorArray>(out: T, v: VectorArray) => T;

function create

create: (x?: number, y?: number) => VectorArray;

function distance

distance: (v1: VectorArray, v2: VectorArray) => number;

function distanceSquare

distanceSquare: (v1: VectorArray, v2: VectorArray) => number;

function div

div: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function dot

dot: (v1: VectorArray, v2: VectorArray) => number;

function len

len: (v: VectorArray) => number;

function lenSquare

lenSquare: (v: VectorArray) => number;

function lerp

lerp: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    t: number
) => T;

function max

max: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function min

min: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function mul

mul: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

function negate

negate: <T extends VectorArray>(out: T, v: VectorArray) => T;

function normalize

normalize: <T extends VectorArray>(out: T, v: VectorArray) => T;

function scale

scale: <T extends VectorArray>(out: T, v: VectorArray, s: number) => T;

function scaleAndAdd

scaleAndAdd: <T extends VectorArray>(
    out: T,
    v1: VectorArray,
    v2: VectorArray,
    a: number
) => T;

function set

set: <T extends VectorArray>(out: T, a: number, b: number) => T;

function sub

sub: <T extends VectorArray>(out: T, v1: VectorArray, v2: VectorArray) => T;

type VectorArray

type VectorArray = number[];

Package Files (43)

Dependencies (1)

tslib

Dev Dependencies (19)

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/zrender.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/zrender)

HTML

<a href="https://www.jsdocs.io/package/zrender"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 1 second ago.
Package analyzed in 12731 ms.
Missing or incorrect documentation? Open an issue for this package.