@aibee/owlly 1.0.25 → 1.0.29

package/lib/owlly/element/gif-kit/GifImage.d.ts

@@ -0,0 +1,23 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+import { GifFrame } from './GifFrame';
+import { GifVersion } from './GifVersion';
+export interface GifImage {
+    colorResolution: number;
+    sortFlag: boolean;
+    bgColorIndex: number;
+    pixelAspectRatio: number;
+    frames: GifFrame[];
+    isLoop: boolean;
+    frameIndex1: number;
+    frameIndex2: number;
+    version: GifVersion;
+    width: number;
+    height: number;
+    globalColorTable: Uint8Array;
+    loopCount: number;
+}

package/lib/owlly/element/gif-kit/GifImage.js

@@ -0,0 +1,7 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */

package/lib/owlly/element/gif-kit/GifParser.d.ts

@@ -0,0 +1,17 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+import { GifImage } from './GifImage';
+import { GifFrame } from './GifFrame';
+export declare class GifParser {
+    static readHeader(gif: GifImage, data: DataView): number;
+    static readBlock(gif: GifImage, data: DataView, offset: number): number;
+    static readImageBlock(frame: GifFrame, data: DataView, offset: number): number;
+    static readApplicationExtensionBlock(gif: GifImage, data: DataView, offset: number): number;
+    static readCommentExtensionBlock(data: DataView, offset: number): number;
+    static readGraphicControlExtensionBlock(frame: GifFrame, data: DataView, offset: number): number;
+    static readPlainTextExtensionBlock(data: DataView, offset: number): number;
+}

package/lib/owlly/element/gif-kit/GifParser.js

@@ -0,0 +1,196 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+import { GifFrame } from './GifFrame';
+import { GifVersion } from './GifVersion';
+export class GifParser {
+    static readHeader(gif, data) {
+        const version = String.fromCharCode(data.getUint8(0), data.getUint8(1), data.getUint8(2), data.getUint8(3), data.getUint8(4), data.getUint8(5));
+        if (version == GifVersion.GIF87a) {
+            gif.version = GifVersion.GIF87a;
+        }
+        else {
+            gif.version = GifVersion.GIF89a;
+        }
+        gif.width = data.getUint16(6, true);
+        gif.height = data.getUint16(8, true);
+        const packed = data.getUint8(10);
+        // Global Color Table Flag(1 bit) Color Resolution(3 bits) Sort Flag(1 bit) Size of Global Color Table(3 bits)
+        const tableFlag = packed & 128;
+        let tableSize;
+        if (tableFlag !== 128) {
+            tableSize = 0;
+        }
+        else {
+            tableSize = 1 << ((packed & 7) + 1);
+        }
+        gif.colorResolution = packed & 112;
+        gif.sortFlag = (packed & 8) === 8;
+        gif.bgColorIndex = data.getUint8(11);
+        gif.pixelAspectRatio = data.getUint8(12);
+        if (tableFlag !== 128) {
+            return 13;
+        }
+        gif.globalColorTable = new Uint8Array(data.buffer, 13, 3 * tableSize);
+        return 13 + 3 * tableSize;
+    }
+    static readBlock(gif, data, offset) {
+        const separator = data.getUint8(offset);
+        if (separator === 0x3b) {
+            return -1;
+        }
+        if (separator === 0x21) {
+            let frame;
+            // Extension block
+            const label = data.getUint8(offset + 1);
+            if (label === 0xf9) {
+                if (gif.frames[gif.frameIndex1] === undefined) {
+                    frame = new GifFrame();
+                    offset = this.readGraphicControlExtensionBlock(frame, data, offset);
+                    gif.frames.push(frame);
+                }
+                else {
+                    frame = gif.frames[gif.frameIndex1];
+                    offset = this.readGraphicControlExtensionBlock(frame, data, offset);
+                }
+                gif.frameIndex1 += 1;
+                return offset;
+            }
+            if (label === 0xfe) {
+                offset = this.readCommentExtensionBlock(data, offset);
+                return offset;
+            }
+            if (label === 0xff) {
+                offset = this.readApplicationExtensionBlock(gif, data, offset);
+                return offset;
+            }
+            if (label === 0x01) {
+                offset = this.readPlainTextExtensionBlock(data, offset);
+                return offset;
+            }
+        }
+        if (separator === 0x2c) {
+            let frame;
+            if (gif.frames[gif.frameIndex2] === undefined) {
+                frame = new GifFrame();
+                offset = this.readImageBlock(frame, data, offset);
+                gif.frames.push(frame);
+            }
+            else {
+                frame = gif.frames[gif.frameIndex2];
+                offset = this.readImageBlock(frame, data, offset);
+            }
+            gif.frameIndex2 += 1;
+            return offset;
+        }
+        return -1;
+    }
+    static readImageBlock(frame, data, offset) {
+        frame.x = data.getUint16(++offset, true);
+        offset += 2;
+        frame.y = data.getUint16(offset, true);
+        offset += 2;
+        frame.width = data.getUint16(offset, true);
+        offset += 2;
+        frame.height = data.getUint16(offset, true);
+        offset += 2;
+        const packed = data.getUint8(offset++);
+        const tableFlag = packed & 128;
+        if (tableFlag === 128) {
+            frame.localTableSize = 1 << ((packed & 7) + 1);
+            frame.localColorTable = new Uint8Array(data.buffer, offset, 3 * frame.localTableSize);
+            offset += 3 * frame.localTableSize;
+        }
+        else {
+            frame.localTableSize = 0;
+        }
+        frame.lzwCode = data.getUint8(offset++);
+        const dataList = new Array();
+        // let datastr = '';
+        let totalSize = 0;
+        while (true) {
+            const blockSize = data.getUint8(offset++);
+            totalSize += blockSize;
+            if (blockSize === 0) {
+                break;
+            }
+            // let s = '';
+            // let position2 = offset;
+            // for (let i = 0; i < blockSize; i++) {
+            //     s += String.fromCharCode(data.getUint8(position2++));
+            // }
+            // datastr = datastr + s;
+            dataList.push(new Uint8Array(data.buffer.slice(offset, offset + blockSize)));
+            offset += blockSize;
+        }
+        // frame.orgpixelData = datastr;
+        const bytes = new Uint8Array(totalSize);
+        bytes.set(dataList[0], 0);
+        let len = dataList[0].byteLength;
+        for (let i = 1, l = dataList.length; i < l; ++i) {
+            bytes.set(dataList[i], len);
+            len += dataList[i].byteLength;
+        }
+        frame.compressedData = bytes;
+        return offset;
+    }
+    static readApplicationExtensionBlock(gif, data, offset) {
+        offset += 2;
+        if (data.getUint8(offset++) !== 0x0b) {
+            throw new Error('faild: _readApplicationExtensionBlock');
+        }
+        const app = String.fromCharCode(data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++), data.getUint8(offset++));
+        if (app === 'NETSCAPE2.0') {
+            gif.isLoop = true;
+            if (data.getUint8(offset++) !== 3) {
+                throw new Error('faild: _readApplicationExtensionBlock (NETSCAPE2.0)');
+            }
+            ++offset;
+            gif.loopCount = data.getUint16(offset, true);
+            offset += 2;
+        }
+        while (true) {
+            const blockSize = data.getUint8(offset++);
+            if (blockSize === 0) {
+                break;
+            }
+            offset += blockSize;
+        }
+        return offset;
+    }
+    static readCommentExtensionBlock(data, offset) {
+        // skip
+        offset += 2;
+        while (true) {
+            const blockSize = data.getUint8(offset++);
+            if (blockSize === 0) {
+                break;
+            }
+            offset += blockSize;
+        }
+        return offset;
+    }
+    static readGraphicControlExtensionBlock(frame, data, offset) {
+        const packed = data.getUint8(offset + 3);
+        frame.transparentFlag = (packed & 1) === 1;
+        frame.delayCentiSeconds = data.getUint16(offset + 4, true);
+        frame.transparentColorIndex = data.getUint8(offset + 6);
+        return offset + 8;
+    }
+    static readPlainTextExtensionBlock(data, offset) {
+        // skip
+        offset += 2;
+        while (true) {
+            const blockSize = data.getUint8(offset++);
+            if (blockSize === 0) {
+                break;
+            }
+            offset += blockSize;
+        }
+        return offset;
+    }
+}

package/lib/owlly/element/gif-kit/GifPresenter.d.ts

@@ -0,0 +1,20 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+export declare class GifPresenter {
+    /**
+     * Convert Gif to Blob.
+     *
+     * @return {Blob} BLOB
+     */
+    static writeToBlob(bytes: Uint8Array[]): Blob;
+    /**
+     * Convert Gif to Data-URL string.
+     *
+     * @return {string} Data-URL string
+     */
+    static writeToDataUrl(bytes: Uint8Array[]): string;
+}

package/lib/owlly/element/gif-kit/GifPresenter.js

@@ -0,0 +1,43 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+// @ts-ignore
+// import { isBrowser, isWebWorker } from "browser-or-node";
+export class GifPresenter {
+    /**
+     * Convert Gif to Blob.
+     *
+     * @return {Blob} BLOB
+     */
+    static writeToBlob(bytes) {
+        // if (isBrowser || isWebWorker || typeof Blob === "function") {
+        if (typeof Blob === "function") {
+            return new Blob(bytes, { type: "image/gif" });
+        }
+        throw new Error("writeToBlob is browser-only function");
+    }
+    /**
+     * Convert Gif to Data-URL string.
+     *
+     * @return {string} Data-URL string
+     */
+    static writeToDataUrl(bytes) {
+        // if (isBrowser || isWebWorker) {
+        let str = "";
+        bytes.forEach((buffer) => {
+            const codes = [];
+            for (let i = 0, l = buffer.byteLength; i < l; ++i) {
+                codes.push(buffer[i]);
+            }
+            str += String.fromCharCode.apply(null, codes);
+        });
+        return "data:image/gif;base64," + btoa(str);
+        //     }
+        //     const bytes2 = bytes.toString();
+        //    return "data:image/gif;base64," + Buffer.from(bytes2).toString("base64");
+    }
+}

package/lib/owlly/element/gif-kit/GifVersion.d.ts

@@ -0,0 +1,10 @@
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+export declare enum GifVersion {
+    GIF89a = "GIF89a",
+    GIF87a = "GIF87a"
+}

package/lib/owlly/element/gif-kit/GifVersion.js

@@ -0,0 +1,12 @@
+/* eslint-disable */
+/*!
+ gifken
+ Copyright (c) 2013 aaharu
+ This software is released under the MIT License.
+ https://raw.github.com/aaharu/gifken/master/LICENSE
+ */
+export var GifVersion;
+(function (GifVersion) {
+    GifVersion["GIF89a"] = "GIF89a";
+    GifVersion["GIF87a"] = "GIF87a";
+})(GifVersion || (GifVersion = {}));

package/lib/owlly/element/gltf-mesh-element.d.ts

@@ -0,0 +1,31 @@
+import { NS_THREE } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { View } from '../view/view';
+declare class GLTFMeshElement extends Element {
+    private initialized;
+    private loaded;
+    private needUpdate;
+    private meshes;
+    private meshMaterials;
+    private group;
+    private reloadTimes;
+    private options;
+    private eventListeners;
+    constructor(modelUrl: string, optionalParams?: {
+        fillColor?: NS_THREE.Color | string | number;
+        transparent?: boolean;
+        depthTest?: boolean;
+        renderOrder?: number;
+    }, meshoptDecoder?: any);
+    /**
+   * 读取Mesh模型
+   * @param url NS_THREE.Mesh模型地址
+   */
+    load(url: string, index?: number, meshoptDecoder?: any): void;
+    private setOptions;
+    setSacle(scale: number): void;
+    setOnCurrentViewChanged(func: (view: View) => void): void;
+    update(): ElementFrameContext;
+    dispose(): void;
+}
+export { GLTFMeshElement };

package/lib/owlly/element/gltf-mesh-element.js

@@ -0,0 +1,136 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader';
+import { Externals } from '../stage/externals';
+import { Element, ElementFrameContext } from './element';
+import { BasicTools } from '../utils/basic-tools';
+import { Events } from '../utils/events';
+class GLTFMeshElement extends Element {
+    constructor(modelUrl, optionalParams, meshoptDecoder) {
+        super();
+        this.reloadTimes = 1;
+        const { THREE } = Externals.getInstance();
+        this.options = optionalParams || {};
+        this.meshes = [];
+        this.meshMaterials = [];
+        this.group = new THREE.Group();
+        this.add(this.group);
+        // const material = options.material || new THREE.MeshBasicMaterial({
+        //   color: options.fillColor ? options.fillColor : 0x00ff00,
+        //   transparent: options.transparent !== undefined ? options.transparent : false,
+        //   opacity: options.opacity !== undefined ? options.opacity : 1,
+        //   side: DoubleSide,
+        //   depthWrite: true,
+        // });
+        // const plainVertices: number[] = [];
+        // vertices.forEach((vertex) => { plainVertices.push(vertex.x, vertex.y, vertex.z); });
+        // const vertexBuffer = new Float32Array(plainVertices);
+        // const bufferGeometry = new BufferGeometry();
+        // bufferGeometry.setAttribute('position', new BufferAttribute(vertexBuffer, 3));
+        // bufferGeometry.setIndex(triangles);
+        // const mesh = new THREE.Mesh(bufferGeometry, material);
+        // mesh.renderOrder = 1000;
+        // this.group.add(mesh);
+        if (modelUrl)
+            this.load(modelUrl, 0, meshoptDecoder);
+        this.initialized = false;
+        this.loaded = false;
+    }
+    /**
+   * 读取Mesh模型
+   * @param url NS_THREE.Mesh模型地址
+   */
+    load(url, index = 0, meshoptDecoder) {
+        this.initialized = false;
+        this.loaded = false;
+        const loader = new GLTFLoader();
+        if (meshoptDecoder) {
+            loader.setMeshoptDecoder(meshoptDecoder);
+        }
+        const { THREE } = Externals.getInstance();
+        loader.load(url, (gltf) => {
+            // this.modelNode = gltf.scene;
+            this.add(gltf.scene);
+            this.group.add(gltf.scene);
+            this.loaded = true;
+            this.initialized = true;
+            this.needUpdate = true;
+            gltf.scene.traverse((obj) => {
+                if (obj instanceof THREE.Mesh) {
+                    this.meshes.push(obj);
+                    this.meshMaterials.push(obj.material);
+                }
+            });
+            this.setOptions(this.options);
+            // if (useBVH) {
+            //   this.bvh = BVHTree.createBVHTree(gltf.scene);
+            // } else {
+            //   this.raycaster = new Raycaster();
+            // }
+            // const box = new Box3().setFromObject(gltf.scene);
+            // const { max, min } = box;
+            // this.boundingBoxMesh.geometry = new BoxBufferGeometry(max.x - min.x, max.y - min.y, max.z - min.z);
+            // this.boundingBoxMesh.position.copy(max.clone().add(min.clone()).multiplyScalar(0.5));
+            this.emit(Events.ELEMENT_LOADED, this);
+        }, undefined, (error) => {
+            const nextIndex = index + 1;
+            if (nextIndex > this.reloadTimes) {
+                this.emit(Events.ELEMENT_LOADED_ERROR, this, error);
+            }
+            else {
+                this.load(url, nextIndex, meshoptDecoder);
+            }
+        });
+    }
+    setOptions(options) {
+        const { THREE } = Externals.getInstance();
+        this.meshes.forEach((m) => {
+            if (options.renderOrder) {
+                m.renderOrder = options.renderOrder;
+            }
+        });
+        this.meshMaterials.forEach((m) => {
+            m.depthTest = !!options.depthTest;
+            m.transparent = !!options.transparent;
+            if (options.fillColor) {
+                m.color = new THREE.Color(options.fillColor);
+            }
+        });
+        this.options = Object.assign(Object.assign({}, options), this.options);
+    }
+    setSacle(scale) {
+        this.meshes.forEach((m) => {
+            m.geometry.scale(scale, scale, scale);
+        });
+        this.needUpdate = true;
+    }
+    setOnCurrentViewChanged(func) {
+        // if (this.eventListeners && this.eventListeners.onCurrentViewChanged) {
+        //   EventHub.off(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+        // }
+        this.eventListeners = {
+            onCurrentViewChanged: func,
+        };
+        // EventHub.on(OwllyEvents.RENDERING_VIEW_CHANGED, this.eventListeners.onCurrentViewChanged);
+    }
+    // renderingViewChanged(view: View): void {
+    //   if (this.eventListeners && this.eventListeners.onCurrentViewChanged) {
+    //     this.eventListeners.onCurrentViewChanged(view);
+    //   }
+    // }
+    update() {
+        const frameContext = new ElementFrameContext(this);
+        if (!this.initialized && this.loaded) {
+            this.initialized = true;
+            frameContext.needUpdate = true;
+        }
+        if (this.initialized && !this.parent) {
+            frameContext.shouldPlaceElement = true;
+        }
+        return frameContext;
+    }
+    dispose() {
+        super.dispose();
+        BasicTools.dispose(this, true);
+    }
+}
+export { GLTFMeshElement };

package/lib/owlly/element/index.d.ts

@@ -0,0 +1,20 @@
+export * from './map-kit';
+export * from './element';
+export * from './placeable-2d';
+export * from './mesh-line-2d';
+export * from './ring-element';
+export * from './bottom-nav-element';
+export * from './floor-model';
+export * from './panorama';
+export * from './panorama-group';
+export * from './svg-floor-model';
+export * from './svg-floors';
+export * from './camera';
+export * from './path';
+export * from './path-group';
+export * from './gltf-mesh-element';
+export * from './mesh-element';
+export * from './polygon-mesh';
+export * from './sphere-mesh';
+export * from './dom-label-2d';
+export * from './video-element';

package/lib/owlly/element/index.js

@@ -0,0 +1,24 @@
+export * from './map-kit';
+export * from './element';
+export * from './placeable-2d';
+export * from './mesh-line-2d';
+export * from './ring-element';
+export * from './bottom-nav-element';
+// #if WEB_ONLY
+export * from './floor-model';
+export * from './panorama';
+export * from './panorama-group';
+export * from './svg-floor-model';
+export * from './svg-floors';
+export * from './camera';
+export * from './path';
+export * from './path-group';
+export * from './gltf-mesh-element';
+export * from './mesh-element';
+export * from './polygon-mesh';
+export * from './sphere-mesh';
+// export * from './dom-3d-element';
+// export * from './dom-2d-element';
+export * from './dom-label-2d';
+export * from './video-element';
+// #endif

package/lib/owlly/element/map-kit/shape.d.ts

@@ -0,0 +1,131 @@
+/**
+ * 图形结构描述体
+ */
+interface ShapeData {
+    /** 图形ID */
+    id: string;
+    /** 图形位置X坐标 */
+    x: number;
+    /** 图形位置Y坐标 */
+    y: number;
+    /** 图形半径 */
+    radius: number;
+    /** 图形位置Z起始高度 */
+    zIndex: number;
+    /** @ignore 图形几何中心 */
+    centroid: [number, number];
+    /** 图形在三维空间(Z轴)高度 */
+    height: number;
+    /** 图形类型, 分别有: shape(闭合图形), line(线段集), point(点) */
+    shapeType: 'point' | 'line' | 'shape';
+    /**
+     * 图形路径, 路径描述采取以下规范:
+     * 采取类path的指令式描述, 指令结构为 `<command><position>,<position>[,<position>]...`, path为指令的连续组合.
+     * 其中, command分为三种, 每种command后跟随数对x, y坐标:
+     *   - m: 移动, 结构为 `m<x>,<y>`, 移动至x, y坐标
+     *   - l: 直线, 结构为 `l<x>,<y>`, 从当前所在位置连线到x, y坐标
+     *   - c: 二次贝塞尔曲线, 结构为 `c<cp0x>,<cp0y>,<cp1x>,<cp1y>,<x>,<y>`, 从当前所在位置连线到x, y, 并通过控制点cp0, cp1生成曲线
+     */
+    path: string;
+    /**
+     * 缺口索引描述, 针对shape与line,可以配置缺口.
+     * 结构为`<from i0>,<to i1>,<from i2>, <to i3>, ...`
+     * 每两个索引成为一组, 该组所对应的path指令将不会被绘制.
+     */
+    hollows: string;
+    /** 填充颜色, 接受HEX, 默认 #FFFFFF */
+    fill: string;
+    /** 描边颜色, 接受HEX, 默认 #444444 */
+    stroke: string;
+    /** 描边宽度, 接受整数, 默认 1 */
+    strokeWidth: number;
+    /** @ignore 整体透明度, 范围为 [0 - 1] */
+    opacity: number;
+    /** 填充透明度, 范围为 [0 - 1] */
+    fillOpacity: number;
+    /** 透明度, 范围为 [0 - 1] */
+    strokeOpacity: number;
+    /** @ignore 缩放, 数组元素分别对应X, Y, Z轴缩放 */
+    scale: [number, number, number];
+    /** @ignore 旋转, 数组元素描述一个四元数 */
+    rotation: [number, number, number, number];
+    /** @ignore 天花板是否可见 */
+    ceilingVisible: boolean;
+    /** 节点标签 from id/name, [ground, impassable, store] */
+    tag: string;
+    /** 父级名称 from group, [ground, impassable, store] */
+    parentName: string;
+    /** 3D侧面颜色 */
+    sideColor?: string;
+    /** 3D侧面透明度 */
+    sideOpacity?: number;
+}
+/**
+ * PathCommand
+ * @ignore
+ */
+declare enum PathCommand {
+    MOVE = "m",
+    LINE = "l",
+    CURVE = "c"
+}
+/**
+ * PathStep
+ * @ignore
+ */
+interface PathStep {
+    command: PathCommand;
+    coords: [number, number][];
+}
+declare class ShapeUtils {
+    static GenerateStepsFromPath(path: string): PathStep[];
+    static GeneratePathFromSteps(steps: PathStep[]): string;
+    static ParseHollows(hollowString: string): [number, number][];
+    static UnparseHollows(hollows: [number, number][]): string;
+    static PolyonOfPathStep(pathSteps: PathStep[]): [number, number][][];
+    static PolygonOfShape(shape: Shape): [number, number][][];
+}
+/**
+ * 图形, 用作地图图形描述
+ * @noInheritDoc
+ */
+declare class Shape {
+    private data;
+    private steps;
+    private hollows;
+    autoCalculateCentroid: boolean;
+    /**
+     * @param data 基于ShapeData结构的描述.
+     * @param autoCalculateCentroid 自动计算图形的视觉中心.
+     * @example
+     * ```typescript
+     * // 将svg解析为Shape对象数组
+     * const shapes = await SvgUtils.parseSVG(
+     *   <svg url>,
+     *   [0.02, 0, 0, 0, 0, -0.02, 0, 0, 0, 0, 0, 0, -40, 40, 0, 1], // 对齐矩阵
+     * );
+     * // 也可以直接传入配置生成shape
+     * const shape = new Shape({ path: 'm0,0l1,0l1,1l0,1' }); // 正方形
+     * // 或
+     * shape.updateData({ fill: '#ff0000' });
+     * ```
+     */
+    constructor(data?: object, autoCalculateCentroid?: boolean);
+    /**
+     * 更新图形数据
+     * @param data 基于ShapeData结构的描述
+     */
+    updateData(data: object, autoCalculateCentroid?: boolean): void;
+    updatePathFromSelfSteps(): void;
+    /**
+     * 获得图形数据
+     */
+    getData(): ShapeData;
+    /** @ignore */
+    getHollows(): [number, number][];
+    /** @ignore */
+    getSteps(): PathStep[];
+    /** 获得图形类型 */
+    getShapeType(): 'point' | 'line' | 'shape';
+}
+export { ShapeData, Shape, PathStep, PathCommand, ShapeUtils, };