nhanh-pure-function 3.0.5 → 3.0.6-beta.10

package/dist/Canvas/LayerGroup/index.d.ts

@@ -0,0 +1,30 @@
+import { default as _Canvas } from '..';
+import { OverlayType } from '../OverlayGroup';
+import { default as Layer } from './layer';
+import { EventHandler, default as EventController } from '../public/eventController';
+type ConstructorOption = ConstructorParameters<typeof EventController>[0];
+export default class LayerGroup extends EventController {
+    /** 图层群组 */
+    layers: Map<string, Layer>;
+    constructor(option: ConstructorOption);
+    /** 地图的事件触发不需要传递 */
+    defaultContextmenu: EventHandler<"contextmenu">;
+    defaultClick: EventHandler<"click">;
+    defaultDoubleClick: EventHandler<"doubleClick">;
+    defaultHover: EventHandler<"hover">;
+    defaultDragg: EventHandler<"dragg">;
+    defaultDown: EventHandler<"down">;
+    setMainCanvas(mainCanvas?: _Canvas): void;
+    setNotifyReload(notifyReload?: () => void): void;
+    /** 获取图层 */
+    getLayer(name: string): Layer | undefined;
+    /** 添加图层 */
+    addLayer(layers: Layer | Layer[]): void;
+    /** 删除图层 */
+    removeLayer(layers: Layer | Layer[]): void;
+    /** 清空图层 */
+    clearLayers(): void;
+    /** 收集图层的 canvas */
+    fetchCanvas(): [number, HTMLCanvasElement, [[number, number], OverlayType][]][];
+}
+export {};

package/dist/Canvas/LayerGroup/layer.d.ts

@@ -0,0 +1,44 @@
+import { default as _Canvas } from '..';
+import { default as OverlayGroup, OverlayType } from '../OverlayGroup';
+import { default as EventController } from '../public/eventController';
+type ConstructorOption = ConstructorParameters<typeof EventController>[0];
+/**
+ * 图层事件触发机制说明：
+ *
+ * 注意事项：
+ * 图层级事件监听依赖其内部覆盖物的事件触发，仅当满足以下条件时触发：
+ *    事件发生在该图层包含的覆盖物上
+ *    该覆盖物已触发对应类型的事件
+ *
+ * 原因是：
+ *    若存在位于不同 图层 的两个覆盖物，点击位置上是 zIndex 较小的图层中的覆盖物时，
+ *    事件触发对象就应该是该 图层 中的 覆盖物，这时就不应该再触发其他 图层 的事件了；
+ */
+export default class Layer extends EventController {
+    /** 层级 */
+    zIndex: number;
+    protected canvas: HTMLCanvasElement;
+    protected ctx: CanvasRenderingContext2D;
+    /** 是否需要重新绘制 */
+    private isReload;
+    groups: Map<string, OverlayGroup>;
+    constructor(option: ConstructorOption);
+    setMainCanvas(mainCanvas?: _Canvas): void;
+    setNotifyReload(notifyReload?: () => void): void;
+    setGroupNotifyReload(group: OverlayGroup): void;
+    /** 获取覆盖物组 */
+    getGroup(name: string): OverlayGroup | undefined;
+    /** 添加覆盖物组 */
+    addGroup(groups: OverlayGroup | OverlayGroup[]): void;
+    /** 移除覆盖物组 */
+    removeGroup(groups: OverlayGroup | OverlayGroup[]): void;
+    /** 清空覆盖物 */
+    clearGroup(): void;
+    /** 设置图层的 zIndex 值 */
+    setzIndex(zIndex: number): void;
+    /** 本次绘制的覆盖物 */
+    private currentDrawOverlays;
+    /** 获取画布 */
+    getCanvas(): [number, HTMLCanvasElement, [[number, number], OverlayType][]] | undefined;
+}
+export {};

package/dist/Canvas/OverlayGroup/arc.d.ts

@@ -0,0 +1,98 @@
+import { default as Overlay } from './public/overlay';
+import { OverlayType } from './index';
+import { EventHandler } from '../public/eventController';
+import { ArcStyleType, PolygonStyleType } from '../common.type';
+type ConstructorOption = ConstructorParameters<typeof Overlay<ArcStyleType, [number, number]>>[0] & {
+    /** 是否填充 */
+    isFill?: boolean;
+    /** 是否闭合 */
+    isClosed?: boolean;
+    /** 闭合时是否经过中心点 */
+    isClosedThroughCenter?: boolean;
+    /** 圆弧的半径。必须为正值。 */
+    radiusValue?: number;
+    /** 圆弧的半径。必须为正值。 */
+    radiusPosition?: number;
+    /** 圆弧的起始点，从 x 轴方向开始计算，以弧度为单位。 */
+    startAngle: number;
+    /** 圆弧的终点，从 x 轴方向开始计算，以弧度为单位。 */
+    endAngle: number;
+    /** 如果为 true，逆时针绘制圆弧，反之，顺时针绘制。默认为 false（顺时针）。 */
+    counterclockwise?: boolean;
+    /** 是否可显示控制点 */
+    isHandlePointsVisible?: boolean;
+};
+export default class Arc extends Overlay<ArcStyleType, [number, number]> {
+    private _isFill;
+    /** 是否填充 */
+    get isFill(): boolean;
+    set isFill(isFill: boolean);
+    protected _isClosed: boolean;
+    /** 是否闭合 */
+    get isClosed(): boolean;
+    set isClosed(isClosed: boolean);
+    private _isClosedThroughCenter;
+    /** 闭合时是否经过中心点 */
+    get isClosedThroughCenter(): boolean;
+    set isClosedThroughCenter(isClosedThroughCenter: boolean);
+    private _radiusValue;
+    /** 圆弧的半径。必须为正值。 */
+    get radiusValue(): number;
+    set radiusValue(radius: number);
+    private _radiusPosition;
+    /** 圆弧的半径。必须为正值。 */
+    get radiusPosition(): number;
+    set radiusPosition(radius: number);
+    private _startAngle;
+    /** 圆弧的起始点，从 x 轴方向开始计算，以弧度为单位。 */
+    get startAngle(): number;
+    set startAngle(startAngle: number);
+    private _endAngle;
+    /** 圆弧的终点，从 x 轴方向开始计算，以弧度为单位。 */
+    get endAngle(): number;
+    set endAngle(endAngle: number);
+    private _counterclockwise;
+    /** 如果为 true，逆时针绘制圆弧，反之，顺时针绘制。默认为 false（顺时针）。 */
+    get counterclockwise(): boolean;
+    set counterclockwise(counterclockwise: boolean);
+    /** 当前是否渲染了控制点 */
+    private isShowHandlePoint;
+    /** 是否可显示控制点 */
+    private _isHandlePointsVisible;
+    /** 是否可显示控制点 */
+    get isHandlePointsVisible(): boolean;
+    set isHandlePointsVisible(value: boolean);
+    /** 偏移量 */
+    get offset(): {
+        x: number;
+        y: number;
+    };
+    set offset(offset: {
+        x: number;
+        y: number;
+    });
+    constructor(option: ConstructorOption);
+    /** 默认点击事件 点击后切换控制点显示状态 */
+    defaultClick: EventHandler<"click">;
+    /** 处理拖动状态变化 */
+    defaultDragg: EventHandler<"dragg">;
+    protected updateValueScope(): void;
+    isPointInPath(x: number, y: number): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    isPointInAnywhere(x: number, y: number): boolean;
+    get cursorStyle(): string | undefined;
+    protected setOverlayStyles(ctx?: CanvasRenderingContext2D): PolygonStyleType;
+    protected get computedValueScopeStyles(): PolygonStyleType;
+    /** 控制点 */
+    private handlePoints;
+    /** 控制点数组 */
+    private get handlePointsArr();
+    /** 更新控制点 */
+    private updateHandlePoints;
+    protected updateBaseData(): void;
+    /** 绘制辅助虚线 */
+    private drawGuideLine;
+    draw(ctx: CanvasRenderingContext2D): void;
+    getDraw(): [(ctx: CanvasRenderingContext2D) => void, OverlayType] | void;
+}
+export {};

package/dist/Canvas/OverlayGroup/arcTo.d.ts

@@ -0,0 +1,51 @@
+import { default as Overlay } from './public/overlay';
+import { OverlayType } from './index';
+import { EventHandler } from '../public/eventController';
+import { ArcToStyleType } from '../common.type';
+type ConstructorOption = ConstructorParameters<typeof Overlay<ArcToStyleType, [number, number][]>>[0] & {
+    /** 是否可显示控制点 */
+    isHandlePointsVisible?: boolean;
+    /** 圆弧的半径。必须为正值。 */
+    radiusValue?: number;
+    /** 圆弧的半径。必须为正值。 */
+    radiusPosition?: number;
+};
+export default class ArcTo extends Overlay<ArcToStyleType, [number, number][]> {
+    /** 控制点 */
+    private handlePoints?;
+    /** 控制点数组 */
+    private get handlePointsArr();
+    /** 当前是否渲染了控制点 */
+    private isShowHandlePoint;
+    /** 是否可显示控制点 */
+    private _isHandlePointsVisible;
+    /** 是否可显示控制点 */
+    get isHandlePointsVisible(): boolean;
+    set isHandlePointsVisible(value: boolean);
+    private _radiusValue;
+    /** 圆弧的半径。必须为正值。 */
+    get radiusValue(): number;
+    set radiusValue(radius: number);
+    private _radiusPosition;
+    /** 圆弧的半径。必须为正值。 */
+    get radiusPosition(): number;
+    set radiusPosition(radius: number);
+    constructor(option: ConstructorOption);
+    /** 默认点击事件 点击后切换控制点显示状态 */
+    defaultClick: EventHandler<"click">;
+    /** 处理拖动状态变化 */
+    defaultDragg: EventHandler<"dragg">;
+    protected updateValueScope(): void;
+    isPointInPath(x: number, y: number): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    isPointInAnywhere(x: number, y: number): boolean;
+    get cursorStyle(): string;
+    protected setOverlayStyles(ctx?: CanvasRenderingContext2D): ArcToStyleType;
+    protected get computedValueScopeStyles(): ArcToStyleType;
+    /** 更新控制点 */
+    private updateHandlePoints;
+    protected updateBaseData(): void;
+    draw(ctx: CanvasRenderingContext2D): void;
+    getDraw(): [(ctx: CanvasRenderingContext2D) => void, OverlayType] | void;
+}
+export {};

package/dist/Canvas/OverlayGroup/bezierCurve.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Canvas/OverlayGroup/custom.d.ts

@@ -0,0 +1,24 @@
+import { default as Overlay } from './public/overlay';
+import { OverlayType } from './index';
+type ConstructorOption<T> = ConstructorParameters<typeof Overlay<T, [number, number][]>>[0] & {
+    /** 绘制函数 */
+    draw: (ctx: CanvasRenderingContext2D) => void;
+};
+export default class Custom<T> extends Overlay<T, [number, number][]> {
+    constructor(option: ConstructorOption<T>);
+    protected updateValueScope(): void;
+    isPointInPath(x: number, y: number): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    protected updateBaseData(): void;
+    private convertValuesToPositions;
+    private convertPositionsToValues;
+    private updateDataProperties;
+    protected setOverlayStyles(ctx?: CanvasRenderingContext2D): any;
+    protected get computedValueScopeStyles(): {};
+    private _draw?;
+    /** 传入的自定义绘制函数 */
+    get draw(): (ctx: CanvasRenderingContext2D) => void;
+    set draw(draw: (ctx: CanvasRenderingContext2D) => void);
+    getDraw(): [(ctx: CanvasRenderingContext2D) => void, OverlayType] | void;
+}
+export {};

package/dist/Canvas/OverlayGroup/ellipse.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Canvas/OverlayGroup/index.d.ts

@@ -0,0 +1,31 @@
+import { default as _Canvas } from '..';
+import { default as EventController } from '../public/eventController';
+import { default as Text } from './text';
+import { default as Point } from './point';
+import { default as Line } from './line';
+import { default as Polygon } from './polygon';
+import { default as Custom } from './custom';
+import { default as Arc } from './arc';
+import { default as ArcTo } from './arcTo';
+type ConstructorOption = ConstructorParameters<typeof EventController>[0];
+export type OverlayType = Text | Point | Line | Arc | ArcTo | Polygon | Custom<any>;
+export default class OverlayGroup extends EventController {
+    /** 覆盖物集合 */
+    overlays: Set<OverlayType>;
+    constructor(option: ConstructorOption);
+    /** 设置主画布 */
+    setMainCanvas(mainCanvas?: _Canvas): void;
+    /** 设置覆盖物重新绘制方法 */
+    setNotifyReload(notifyReload?: () => void): void;
+    /** 添加覆盖物 */
+    addOverlays(overlays: OverlayType[] | OverlayType): void;
+    /** 是否包含覆盖物 */
+    hasOverlay(overlay: OverlayType): boolean;
+    /** 移除覆盖物 */
+    removeOverlays(overlays: OverlayType[] | OverlayType): void;
+    /** 清空覆盖物 */
+    clearOverlays(): void;
+    /** 获取覆盖物的绘制方法 */
+    getOverlaysDrawingMethod(): [number, [(ctx: CanvasRenderingContext2D) => void, OverlayType]][];
+}
+export {};

package/dist/Canvas/OverlayGroup/line.d.ts

@@ -0,0 +1,32 @@
+import { OverlayType } from './index';
+import { default as GeometricBoundary } from './public/geometricBoundary';
+import { LineStyleType } from '../common.type';
+type ConstructorOption = ConstructorParameters<typeof GeometricBoundary<LineStyleType>>[0] & {
+    /** 是否是 两点相连向外延展的无限线 */
+    isInfinite?: boolean;
+};
+export default class Line extends GeometricBoundary<LineStyleType> {
+    private _isInfinite?;
+    /** 是否是 两点相连向外延展的无限线 */
+    get isInfinite(): boolean | undefined;
+    set isInfinite(isInfinite: boolean | undefined);
+    protected isClosed: boolean;
+    protected minNeededHandlePoints: number;
+    constructor(option: ConstructorOption);
+    protected updateValueScope(): void;
+    isPointInPath(x: number, y: number): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    isPointInAnywhere(x: number, y: number): boolean;
+    protected get isWithinRange(): boolean;
+    protected updateBaseData(): void;
+    /** 更新动态点位数据 */
+    protected updateDynamicPosition(): void;
+    protected setOverlayStyles(ctx?: CanvasRenderingContext2D): LineStyleType;
+    protected get computedValueScopeStyles(): LineStyleType;
+    /** 绘制线段 */
+    drawLine(ctx: CanvasRenderingContext2D, position?: [number, number][]): void;
+    /** 绘制无限延伸线段 */
+    drawisInfiniteStraightLine(ctx: CanvasRenderingContext2D): void;
+    getDraw(): [(ctx: CanvasRenderingContext2D) => void, OverlayType] | void;
+}
+export {};

package/dist/Canvas/OverlayGroup/point.d.ts

@@ -0,0 +1,41 @@
+import { default as Overlay } from './public/overlay';
+import { OverlayType } from './index';
+import { EventHandler } from '../public/eventController';
+import { PointStyleType } from '../common.type';
+type ConstructorOption = ConstructorParameters<typeof Overlay<PointStyleType, [number, number]>>[0];
+export default class Point extends Overlay<PointStyleType, [number, number]> {
+    private angle;
+    constructor(option: ConstructorOption);
+    protected updateValueScope(): void;
+    defaultDragg: EventHandler<"dragg">;
+    /** 填充进度 */
+    private fillProgress?;
+    /** 处理悬停状态变化 */
+    defaultHover: EventHandler<"hover">;
+    /** 取消当前动画并重新开始相反方向的动画 */
+    private cancelAndRestartAnimation;
+    /** 开始新的悬停动画 */
+    private startNewHoverAnimation;
+    /** 更新线宽偏移并触发重绘 */
+    private updateLineWidthOffset;
+    isPointInPath(x: number, y: number): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    protected updateBaseData(): void;
+    protected setOverlayStyles(ctx?: CanvasRenderingContext2D): {
+        radius: number;
+        stroke: string;
+        width: number;
+        fill: string;
+    };
+    protected get computedValueScopeStyles(): {
+        point: {
+            radius: number;
+            stroke: string;
+            width: number;
+            fill: string;
+        };
+    };
+    draw(ctx: CanvasRenderingContext2D): void;
+    getDraw(): [(ctx: CanvasRenderingContext2D) => void, OverlayType] | void;
+}
+export {};

package/dist/Canvas/OverlayGroup/polygon.d.ts

@@ -0,0 +1,47 @@
+import { OverlayType } from './index';
+import { default as GeometricBoundary } from './public/geometricBoundary';
+import { PolygonStyleType } from '../common.type';
+type ConstructorOption = ConstructorParameters<typeof GeometricBoundary<PolygonStyleType>>[0] & {
+    /** 是否为矩形 */
+    isRect?: boolean;
+    /** 矩形圆角半径 */
+    borderRadius?: number | number[];
+    /** 矩形圆角半径类型.  默认为 "position" */
+    borderRadiusType?: "position" | "value";
+};
+export default class Polygon extends GeometricBoundary<PolygonStyleType> {
+    private _isRect;
+    /** 是否为矩形 */
+    get isRect(): boolean;
+    set isRect(isRect: boolean);
+    /** 动态矩形圆角半径 */
+    private dynamicBorderRadius?;
+    private _borderRadius?;
+    /** 矩形圆角半径 */
+    get borderRadius(): number | number[] | undefined;
+    set borderRadius(borderRadius: number | number[] | undefined);
+    private _borderRadiusType;
+    /** 矩形圆角半径类型.  默认为 "position" */
+    get borderRadiusType(): "position" | "value";
+    set borderRadiusType(borderRadiusType: "position" | "value");
+    protected isClosed: boolean;
+    protected minNeededHandlePoints: number;
+    constructor(option: ConstructorOption);
+    protected updateValueScope(): void;
+    isPointInPath(x: number, y: number): boolean;
+    isPointInStroke(x: number, y: number): boolean;
+    isPointInAnywhere(x: number, y: number): boolean;
+    /** 更新动态圆角半径 */
+    private updateDynamicRadius;
+    private handleSingleRadius;
+    /** 更新基础数据 */
+    protected updateBaseData(): void;
+    protected setOverlayStyles(ctx?: CanvasRenderingContext2D): PolygonStyleType;
+    protected get computedValueScopeStyles(): PolygonStyleType;
+    /** 绘制矩形 */
+    drawRect(ctx: CanvasRenderingContext2D): void;
+    /** 绘制多边形 */
+    drawPolygon(ctx: CanvasRenderingContext2D): void;
+    getDraw(): [(ctx: CanvasRenderingContext2D) => void, OverlayType] | void;
+}
+export {};

package/dist/Canvas/OverlayGroup/public/geometricBoundary.d.ts

@@ -0,0 +1,70 @@
+import { default as Overlay } from './overlay';
+import { default as Point } from '../point';
+import { EventHandler } from '../../public/eventController';
+type PointLocation = [number, number];
+type ConstructorOption<T> = ConstructorParameters<typeof Overlay<T, PointLocation[]>>[0] & {
+    /** 是否可显示控制点 */
+    isHandlePointsVisible?: boolean;
+    /** 是否可以创建新的 控制点 */
+    canCreateOrDeleteHandlePoint?: boolean;
+};
+export default abstract class GeometricBoundary<T> extends Overlay<T, PointLocation[]> {
+    /** 控制点 */
+    protected handlePoints: Point[];
+    /** 当前是否渲染了控制点 */
+    protected isShowHandlePoint: boolean;
+    /** 是否可显示控制点 */
+    private _isHandlePointsVisible;
+    /** 是否可显示控制点 */
+    get isHandlePointsVisible(): boolean;
+    set isHandlePointsVisible(value: boolean);
+    /** 是否闭合 */
+    protected abstract isClosed: boolean;
+    /** 是否可以创建新的 控制点 */
+    canCreateOrDeleteHandlePoint: boolean;
+    /** 最少需要的 控制点 数量 */
+    protected abstract minNeededHandlePoints: number;
+    /** 锁定是否可创建句柄点 */
+    private lockedCanCreateOrDeleteHandlePoint;
+    /** 偏移量 */
+    get offset(): {
+        x: number;
+        y: number;
+    };
+    set offset(offset: {
+        x: number;
+        y: number;
+    });
+    constructor(option: ConstructorOption<T>);
+    /** 默认点击事件 点击后切换控制点显示状态 */
+    defaultClick: EventHandler<"click">;
+    /** 默认点击事件 点击后 创建/删除 控制点 */
+    defaultDoubleClick: EventHandler<"doubleClick">;
+    /** 尝试在指定位置创建新控制点 */
+    private tryCreateNewHandlePoint;
+    /** 尝试删除指定位置的控制点 */
+    private tryDeleteHandlePoint;
+    /** 获取扩展后的动态位置 */
+    private getExtendedDynamicPositions;
+    /** 获取相邻的索引 */
+    private getAdjacentIndices;
+    /** 创建新的控制点 */
+    private createNewHandlePoint;
+    /** 插入点 */
+    private insertHandlePoint;
+    /** 删除点 */
+    private deleteHandlePoint;
+    /** 锁定点创建 */
+    private lockHandlePointCreationTemporarily;
+    /** 解锁点创建 */
+    private resetHandlePointLock;
+    /** 是否可以删除点 */
+    private get canDeleteHandlePoint();
+    /** 处理拖动状态变化 */
+    defaultDragg: EventHandler<"dragg">;
+    /** 更新控制点 */
+    protected updateHandlePoints(): void;
+    /** 更新控制点位置 */
+    protected updateHandlePointsPosition(): void;
+}
+export {};

package/dist/Canvas/OverlayGroup/public/overlay.d.ts

@@ -0,0 +1,176 @@
+import { default as _Canvas } from '../..';
+import { OverlayType } from '../index';
+import { EventHandler, default as EventController } from '../../public/eventController';
+import { _Type_DeepPartial } from '../../..';
+import { BaseLineStyle, PointStyleType } from '../../common.type';
+type ConstructorOption<T, V> = ConstructorParameters<typeof EventController>[0] & {
+    /** 样式 */
+    style?: _Type_DeepPartial<T> | string;
+    /** 层级 */
+    zIndex?: number;
+    /** 坐标轴上的点位 */
+    position?: V;
+    /** 动态点位 */
+    dynamicPosition?: V;
+    /** 坐标轴上的值 */
+    value?: V;
+    /** 偏移 */
+    offset?: {
+        x: number;
+        y: number;
+    };
+    /** 鼠标移入时是否重新绘制 */
+    redrawOnIsHoverChange?: boolean;
+};
+export default abstract class Overlay<T, V extends [number, number] | [number, number][]> extends EventController {
+    static ctx: CanvasRenderingContext2D;
+    private _style?;
+    /** 样式 */
+    get style(): Overlay<T, V>["_style"] | undefined;
+    set style(style: Overlay<T, V>["_style"] | undefined);
+    private _position?;
+    /** 坐标轴上的点位 */
+    get position(): V | undefined;
+    set position(position: V | undefined);
+    private _value?;
+    /** 坐标轴上的值 */
+    get value(): V | undefined;
+    set value(value: V | undefined);
+    private _zIndex;
+    /** 层级 */
+    get zIndex(): number;
+    set zIndex(zIndex: number);
+    private _dynamicPosition?;
+    /** 动态点位 */
+    get dynamicPosition(): V | undefined;
+    private set dynamicPosition(value);
+    private _offset;
+    /** 偏移量 */
+    get offset(): {
+        x: number;
+        y: number;
+    };
+    set offset(offset: {
+        x: number;
+        y: number;
+    });
+    /** 最终的动态位置（含：偏移） */
+    get finalDynamicPosition(): V;
+    /** 绘制路径 */
+    path?: Path2D;
+    constructor(option: ConstructorOption<T, V>);
+    /** 内部使用的属性映射表，请勿修改 */
+    private readonly publicToPrivateKeyMap;
+    /** 请勿在实体对象中调用此方法，此方法仅用于类内部无副作用更新 （请勿使用！） */
+    internalUpdate(option: {
+        offset?: {
+            x: number;
+            y: number;
+        };
+        position?: V;
+        value?: V;
+        dynamicPosition?: V;
+        zIndex?: number;
+        style?: _Type_DeepPartial<T> | string;
+    }, updateValueScope?: boolean): void;
+    /** 鼠标移入时是否重新绘制 */
+    redrawOnIsHoverChange: boolean;
+    /** 默认 hover  事件 */
+    defaultHover: EventHandler<"hover">;
+    setMainCanvas(mainCanvas?: _Canvas): void;
+    setNotifyReload(notifyReload?: () => void): void;
+    /** 值范围 */
+    private _valueScope?;
+    /** 值范围 */
+    get valueScope(): {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    } | undefined;
+    private set valueScope(value);
+    /** 更新值范围 */
+    protected abstract updateValueScope(): void;
+    /** 初始化值范围 */
+    protected initValueScope(): void;
+    /** 计算 valueScope 所需要的样式 */
+    protected abstract get computedValueScopeStyles(): {
+        stroke?: BaseLineStyle;
+        point?: PointStyleType;
+    };
+    /** 描边半径值 */
+    private styleRadius;
+    /** 计算样式半径值 */
+    protected calculateStyleRadiusValue(uselastFact?: boolean): {
+        radius: number;
+        value: number;
+    } | undefined;
+    /** 额外偏移 */
+    private offsetValue;
+    /** 计算偏移 */
+    protected calculateOffsetValue(uselastFact?: boolean): void;
+    /** 固定的额外范围 */
+    private fixedExtraScope;
+    /** 初始化设置固定的额外范围 */
+    protected setFixedExtraScope(init: true): void;
+    /** 设置固定的额外范围 */
+    protected setFixedExtraScope(fixedExtraScope?: {
+        topV: number;
+        bottomV: number;
+        leftV: number;
+        rightV: number;
+    }): void;
+    /** 额外范围 */
+    private extraScope;
+    /** 初始化设置额外范围 */
+    protected setExtraScope(init: true): void;
+    /** 更新额外范围 */
+    protected setExtraScope(): void;
+    /** 设置新的额外范围 */
+    protected setExtraScope(extraScope?: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    }): void;
+    /** 判断是否在可视范围内 */
+    protected get isWithinRange(): boolean;
+    /** 判断是否需要渲染 */
+    protected get isNeedRender(): boolean;
+    /** 计算偏移量 */
+    protected calculateOffset(offsetX: number, offsetY: number): {
+        x: {
+            value: number;
+            position: number;
+            dynamicPosition: number;
+        };
+        y: {
+            value: number;
+            position: number;
+            dynamicPosition: number;
+        };
+    };
+    /** 处理一维数组的坐标数据 */
+    protected handleValuePosition(type: "array1D"): boolean;
+    /** 处理二维数组的坐标数据 */
+    protected handleValuePosition(type: "array2D", minLen: number): boolean;
+    /** 更新基础数据 */
+    protected abstract updateBaseData(): void;
+    /** 判断当前路径中是否包含指定点 */
+    abstract isPointInPath(x: number, y: number): boolean;
+    /** 检测某点是否在路径的描边所在的区域内 */
+    abstract isPointInStroke(x: number, y: number): boolean;
+    /** 检测某点是否在当前覆盖物中 */
+    isPointInAnywhere(x: number, y: number): boolean;
+    /** 设置透明度 */
+    setGlobalAlpha(ctx: CanvasRenderingContext2D): void;
+    /** 绘制线基础样式 */
+    protected setBaseLineStyle(ctx: CanvasRenderingContext2D, style: BaseLineStyle): BaseLineStyle;
+    /** 设置画布样式 */
+    protected abstract setOverlayStyles(ctx?: CanvasRenderingContext2D): T;
+    /** 光标样式 */
+    get cursorStyle(): string | undefined;
+    /** 获取绘制函数 */
+    abstract getDraw(): [(ctx: CanvasRenderingContext2D) => void, OverlayType] | void;
+}
+export {};