nhanh-pure-function 3.0.4 → 3.0.6-beta.1

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2024 ADMINnhanh
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2024 ADMINnhanh
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,19 +1,19 @@
-# nhanh-pure-function
-
-纯函数工具库，提供了一些常用的纯函数工具，帮助您在 JavaScript/TypeScript 项目中更高效地处理数据。
-
-## 安装
-
-您可以通过 npm 安装该库：
-
-```bash
-npm install nhanh-pure-function
-```
-
-## 功能介绍
-
-`nhanh-pure-function` 库旨在提供一系列纯函数，这些函数在处理数据时不会产生副作用，确保函数的输入和输出之间的映射关系是确定的。这使得代码更易于测试、维护和复用。
-
-## 许可证
-
+# nhanh-pure-function
+
+纯函数工具库，提供了一些常用的纯函数工具，帮助您在 JavaScript/TypeScript 项目中更高效地处理数据。
+
+## 安装
+
+您可以通过 npm 安装该库：
+
+```bash
+npm install nhanh-pure-function
+```
+
+## 功能介绍
+
+`nhanh-pure-function` 库旨在提供一系列纯函数，这些函数在处理数据时不会产生副作用，确保函数的输入和输出之间的映射关系是确定的。这使得代码更易于测试、维护和复用。
+
+## 许可证
+
 [MIT](https://opensource.org/licenses/MIT)

package/dist/Browser/index.d.ts

@@ -51,7 +51,7 @@ export declare class _Browser_KeyedWindowManager {
     static closeAll(): void;
 }
 /**
- * 计算内容可用宽高及边距（考虑设备DPI）
+ * 计算纸张内容可用宽高及边距（考虑设备DPI）
  * 确保：contentWidth + 2*paddingPx = 纸张宽度像素
  * @param type 纸张类型
  * @param padding 边距（毫米）

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,97 @@
+import { default as Overlay } from './public/overlay';
+import { OverlayType } from './index';
+import { EventHandler } from '../public/eventController';
+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,50 @@
+import { default as Overlay } from './public/overlay';
+import { OverlayType } from './index';
+import { EventHandler } from '../public/eventController';
+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,31 @@
+import { OverlayType } from './index';
+import { default as GeometricBoundary } from './public/geometricBoundary';
+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,40 @@
+import { default as Overlay } from './public/overlay';
+import { OverlayType } from './index';
+import { EventHandler } from '../public/eventController';
+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,46 @@
+import { OverlayType } from './index';
+import { default as GeometricBoundary } from './public/geometricBoundary';
+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 {};