nhanh-pure-function 3.0.6-beta.2 → 3.0.6-beta.4

package/dist/Animate/index.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 进度
+ * @param {(schedule)=>void} callback callback( 进度百分比 )
+ * @param {Number} TIME 总时长
+ * @returns {Function} 停止函数
+ */
+export declare function _Animate_Schedule(callback: (schedule: number) => void, TIME?: number): () => boolean;
+/**
+ * 创建指定范围的振荡器，在最小值和最大值之间循环变化
+ * @param initialMin - 振荡器初始最小值
+ * @param initialMax - 振荡器初始最大值
+ * @param initialSteps - 从最小值到最大值所需的动画步数
+ * @param callback - 每帧更新时的回调函数，接收当前振荡值
+ * @param precision - 数值精度（保留小数位数，默认2位）
+ * @returns 振荡器控制对象，包含播放/暂停/参数更新等方法
+ */
+export declare function _Animate_CreateOscillator(initialMin: number, initialMax: number, initialSteps: number, callback: (value: number) => void, precision?: number): {
+    /** 启动/继续动画 */
+    play(target?: number): void;
+    /** 暂停动画 */
+    pause(): void;
+    /** 获取当前值 */
+    getCurrent: () => number;
+    /** 是否正在运行 */
+    isPlaying: () => boolean;
+    /** 更新参数（不中断动画） */
+    updateParams: (newMin: number, newMax: number, newSteps: number) => boolean;
+    /** 获取当前参数 */
+    getParams: () => {
+        min: number;
+        max: number;
+        steps: number;
+        precision: number;
+        stepSize: number;
+    };
+};
+/**
+ * 动画过渡数值变化
+ * @param startValue - 起始值
+ * @param targetValue - 目标值
+ * @param stepCount - 动画步数
+ * @param callback - 每帧回调函数
+ * @param precision - 数值精度（默认2位小数）
+ */
+export declare function _Animate_NumericTransition(startValue: number, targetValue: number, stepCount: number, callback: (currentValue: number) => void, precision?: number): void;

package/dist/Blob/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 将不同格式的数据转换为图像 URL
+ * 此函数支持多种类型的数据输入，包括字符串（Base64/Data URL）、ArrayBuffer、Uint8Array和File，
+ * 并尝试将这些数据转换为指定MIME类型的图像URL
+ *
+ * @param data - 输入数据，可以是字符串（Base64/Data URL）、ArrayBuffer、Uint8Array或File实例
+ * @param mimeType - 期望的图像MIME类型，默认为'image/png'
+ * @returns 成功时返回图像的URL，失败时返回null
+ */
+export declare function _Blob_ConvertDataToImageUrl(data: string | ArrayBuffer | Uint8Array | File, mimeType?: string): string | void | null;

package/dist/Browser/index.d.ts

@@ -0,0 +1,77 @@
+import { PaperType, WindowTarget } from '../Constant';
+/**
+ * 获取帧率
+ * @param {(fps , frameTime)=>void} callback callback( 帧率 , 每帧时间 )
+ * @param {Number} referenceNode 参考节点数量
+ */
+export declare function _Browser_GetFrameRate(callback: (fps: number, frameTime: number) => void, referenceNode?: number): void;
+/**
+ * 复制到剪贴板
+ * @param {string} text
+ */
+export declare function _Browser_CopyToClipboard(text: string): Promise<void>;
+/**
+ * 管理通过键值对打开的窗口
+ */
+export declare class _Browser_KeyedWindowManager {
+    private static keys;
+    /** 请使用静态方法 */
+    private constructor();
+    /** 添加已有窗口 */
+    static add(key: string, win: Window): void;
+    /**
+     * 根据键打开或聚焦窗口
+     * @param key 窗口的唯一键
+     * @param url 要打开的URL
+     * @param target 窗口的目标
+     * @param windowFeatures 新窗口的特性
+     * @returns 返回已打开或新打开的窗口
+     */
+    static open(key: string, url?: string | URL, target?: WindowTarget, windowFeatures?: string): Window | undefined;
+    /**
+     * 检查指定键的窗口是否打开
+     * @param key 窗口的唯一键
+     * @returns 如果窗口打开则返回true，否则返回false
+     */
+    static isOpen(key: string): boolean;
+    /**
+     * 获取与指定键关联的窗口
+     * @param key 窗口的唯一键
+     * @returns 返回对应的窗口，如果窗口已关闭则返回undefined
+     */
+    static getWindow(key: string): Window | undefined;
+    /**
+     * 关闭与指定键关联的窗口
+     * @param key 窗口的唯一键
+     */
+    static close(key: string): void;
+    /**
+     * 关闭所有打开的窗口并清空Map
+     */
+    static closeAll(): void;
+}
+/**
+ * 计算纸张内容可用宽高及边距（考虑设备DPI）
+ * 确保：contentWidth + 2*paddingPx = 纸张宽度像素
+ * @param type 纸张类型
+ * @param padding 边距（毫米）
+ * @returns {
+ *   contentWidth: number;  // 内容可用宽度(px)
+ *   contentHeight: number; // 内容可用高度(px)
+ *   paddingPx: number;     // 边距(px) - 单边值
+ *   paperWidthPx: number;  // 纸张总宽度(px)
+ *   paperHeightPx: number; // 纸张总高度(px)
+ * }
+ */
+export declare function _Browser_CalculatePrintableArea(type: PaperType, padding: number): {
+    /** 内容宽度（像素） */
+    contentWidth: number;
+    /** 内容高度（像素） */
+    contentHeight: number;
+    /** 边距（像素） */
+    paddingPx: number;
+    /** 纸张宽度（像素） */
+    paperWidthPx: number;
+    /** 纸张高度（像素） */
+    paperHeightPx: number;
+};

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 {};