@aibee/owlly 1.0.26 → 1.0.29

package/lib/owlly/overlay/canvas-overlay.js

@@ -0,0 +1,510 @@
+import { Externals } from '../stage/externals';
+import { Overlay } from './overlay';
+import { Owlly2D } from '../owlly-2d';
+import { Events } from '../utils/events';
+// import { BasicTools } from '../utils';
+class ShapeGroup {
+    constructor(shape, rawShape, baseZoom, zIndices = []) {
+        this.shape = shape;
+        this.rawShape = rawShape;
+        this.baseZoom = baseZoom;
+        this.zIndices = zIndices;
+        this.points = [];
+        this.lineJointsStyle = 'joints';
+        this.vertexOptions = {
+            radius: 0,
+            fill: '#fff',
+            shadowColor: '#000',
+            shadowBlur: 3,
+            shadowOffset: { x: 1, y: 2 },
+            shadowOpacity: 0.3,
+            shadowEnabled: false,
+        };
+    }
+}
+var MouseState;
+(function (MouseState) {
+    MouseState[MouseState["IDLE"] = 0] = "IDLE";
+    MouseState[MouseState["DOWN"] = 1] = "DOWN";
+    MouseState[MouseState["MOVE"] = 2] = "MOVE";
+})(MouseState || (MouseState = {}));
+/**
+ * POI覆盖层, 可以展示POI图标与文字, 存在图标时以图标中心为中心, 否则为文字中心
+ * @example
+ * ```typescript
+ * const poiOverlay = new PoiOverlay();
+ * // 任意View
+ * view.addOverlay(poiOverlay);
+ * ```
+ */
+class CanvasOverlay extends Overlay {
+    init(parent, container = new HTMLElement()) {
+        const { THREE } = Externals.getInstance();
+        this.container = container;
+        this.parent = parent;
+        this.owlly2D = Owlly2D.getInstance(container);
+        this.layer = this.owlly2D.addLayer();
+        this.shapes = [];
+        this.renderThisFrame = true;
+        this.layer.zIndex(0);
+        this.enabled = true;
+        this.mouseState = MouseState.IDLE;
+        this.mousePositionBuffer = new THREE.Vector2();
+        this.listeners = {
+            pointerDown: (e) => { this.onPointerDown(e); },
+            pointerUp: (e) => { this.onPointerUp(e); },
+            touchStart: (e) => { this.onTouchStart(e); },
+            touchEnd: (e) => { this.onTouchEnd(e); },
+            nodePointerDown: (e) => { this.onNodePointerDown(e); },
+            nodePointerUp: () => { this.onNodePointerUp(); },
+        };
+        this.container.addEventListener('pointerdown', this.listeners.pointerDown, true);
+        this.container.addEventListener('pointerup', this.listeners.pointerUp, true);
+        this.container.addEventListener('touchstart', this.listeners.touchStart, true);
+        this.container.addEventListener('touchend', this.listeners.touchEnd, true);
+    }
+    /**
+     * 打开交互
+     */
+    openInteraction() {
+        this.owlly2D.openInteraction();
+    }
+    /**
+     * 关闭交互
+     */
+    closeInteraction() {
+        this.owlly2D.closeInteraction();
+    }
+    update() {
+        if (this.renderThisFrame) {
+            this.renderThisFrame = false;
+            return true;
+        }
+        return false;
+    }
+    render() {
+        if (!this.enabled)
+            return;
+        if (this.parent.camera) {
+            const { camera } = this.parent;
+            const { clientHeight, clientWidth } = this.container;
+            const widthHalf = clientWidth / 2;
+            const heightHalf = clientHeight / 2;
+            this.shapes.forEach(({ shape, rawShape, zIndices, points, vertexOptions, lineJointsStyle, }) => {
+                this.updateShapeDataToKonvaShape(shape, rawShape, camera, widthHalf, heightHalf, points, vertexOptions, zIndices, lineJointsStyle);
+            });
+        }
+        this.layer.draw();
+    }
+    setRenderOrder(order) {
+        this.layer.zIndex(order);
+    }
+    dispose() {
+        this.shapes.forEach((s) => {
+            const konvaObject = s.shape;
+            konvaObject.destroy();
+            if (s.shape.children.length === 0) {
+                s.shape.destroy();
+                s.points.forEach((p) => {
+                    p.off('mousedown touchdown');
+                    p.destroy();
+                });
+            }
+            if (s && s.shape)
+                delete s.shape; // eslint-disable-line
+        });
+        this.renderThisFrame = true;
+        this.container.removeEventListener('pointerdown', this.listeners.pointerDown, true);
+        this.container.removeEventListener('pointerup', this.listeners.pointerUp, true);
+        this.container.removeEventListener('touchstart', this.listeners.touchStart, true);
+        this.container.removeEventListener('touchend', this.listeners.touchEnd, true);
+        this.layer.destroy();
+    }
+    onPointerDown(e) {
+        this.owlly2D.stage._mousedown(e); // eslint-disable-line no-underscore-dangle
+    }
+    onPointerUp(e) {
+        const { THREE } = Externals.getInstance();
+        this.owlly2D.stage._mouseup(e); // eslint-disable-line no-underscore-dangle
+        const { clientX, clientY } = e;
+        const { left: rectX, top: rectY } = this.container.getBoundingClientRect();
+        const x = clientX - rectX;
+        const y = clientY - rectY;
+        const distance = new THREE.Vector2(x, y).distanceToSquared(this.mousePositionBuffer);
+        this.emit(Events.CANVAS_VERTEX_UP, this.eventTarget, e.button);
+        if (this.mouseState === MouseState.DOWN && distance < 100) {
+            this.emit(Events.CANVAS_VERTEX_CLICKED, this.eventTarget, e.button);
+        }
+        this.mouseState = MouseState.IDLE;
+    }
+    onTouchStart(e) {
+        this.owlly2D.stage._touchstart(e); // eslint-disable-line no-underscore-dangle
+    }
+    onTouchEnd(e) {
+        const { THREE } = Externals.getInstance();
+        this.owlly2D.stage._touchend(e); // eslint-disable-line no-underscore-dangle
+        const { clientX, clientY } = e.changedTouches[0];
+        // const { clientWidth, clientHeight } = this.container;
+        const { left: rectX, top: rectY } = this.container.getBoundingClientRect();
+        const x = clientX - rectX;
+        const y = clientY - rectY;
+        const distance = new THREE.Vector2(x, y).distanceToSquared(this.mousePositionBuffer);
+        this.emit(Events.CANVAS_VERTEX_UP, this.eventTarget, 0);
+        if (this.mouseState === MouseState.DOWN && distance < 100) {
+            this.emit(Events.CANVAS_VERTEX_CLICKED, this.eventTarget, 0);
+        }
+        this.mouseState = MouseState.IDLE;
+    }
+    onNodePointerDown(e) {
+        // console.log('node pointer down', e);
+        if (this.mouseState !== MouseState.IDLE)
+            return;
+        let index = -1;
+        const target = this.shapes.find((shape) => {
+            const i = shape.points.indexOf((e.currentTarget));
+            if (i >= 0)
+                index = i;
+            return i >= 0;
+        });
+        if (!target)
+            return;
+        this.mouseState = MouseState.DOWN;
+        const { clientX, clientY } = e.evt instanceof MouseEvent ? e.evt : e.evt.touches[0];
+        // const { clientWidth, clientHeight } = this.container;
+        const { left: rectX, top: rectY } = this.container.getBoundingClientRect();
+        const x = clientX - rectX;
+        const y = clientY - rectY;
+        this.mousePositionBuffer.set(x, y);
+        this.eventTarget = target;
+        this.emit(Events.CANVAS_VERTEX_DOWN, target, index, e.evt instanceof MouseEvent ? e.evt.button : 0);
+    }
+    onNodePointerUp() {
+        // do nothing
+    }
+    /**
+     * 清空画布
+     */
+    clearShapes() {
+        this.shapes.forEach((shape) => {
+            shape.shape.destroy();
+            shape.points.forEach((point) => {
+                point.destroy();
+            });
+            delete shape.shape; // eslint-disable-line
+        });
+        this.shapes = [];
+        this.renderThisFrame = true;
+    }
+    /**
+     * 删除Shape
+     * @param shape Shape
+     */
+    removeShape(shape) {
+        if (!shape)
+            return;
+        for (let i = 0; i < this.shapes.length; i++) {
+            if (this.shapes[i].rawShape === shape || this.shapes[i].shape === shape) {
+                const konvaObject = this.shapes[i].shape;
+                konvaObject.destroy();
+                const shapeToRemove = this.shapes[i];
+                if (this.shapes[i].shape.children.length === 0) {
+                    this.shapes[i].shape.destroy();
+                    this.shapes[i].points.forEach((p) => {
+                        p.off('mousedown touchdown');
+                        p.destroy();
+                    });
+                    this.shapes.splice(i, 1);
+                }
+                if (shapeToRemove === this.shapes[i] && this.shapes[i].shape)
+                    delete this.shapes[i].shape; // eslint-disable-line
+                this.renderThisFrame = true;
+            }
+        }
+    }
+    /**
+     * 更新Shape
+     * @param shape Shape
+     */
+    updateShape(shape, zIndices = []) {
+        if (!shape)
+            return null;
+        const { Konva } = Externals.getInstance();
+        for (let i = 0; i < this.shapes.length; i++) {
+            if (this.shapes[i].rawShape === shape || this.shapes[i].shape === shape) {
+                const konvaObject = this.shapes[i].shape;
+                this.shapes[i].zIndices = zIndices;
+                if (konvaObject instanceof Konva.Shape) {
+                    const newShape = this.transformShapeDataToKonvaShape(this.shapes[i].rawShape.getData());
+                    if (newShape) {
+                        konvaObject.setAttrs(newShape.attrs);
+                    }
+                    this.shapes[i].points.forEach((p) => { p.setAttrs(this.shapes[i].vertexOptions); });
+                }
+                this.renderThisFrame = true;
+                return this.shapes[i].shape;
+            }
+        }
+        return null;
+    }
+    setVertexConfig(shape, config) {
+        if (!shape)
+            return null;
+        for (let i = 0; i < this.shapes.length; i++) {
+            if (this.shapes[i].rawShape === shape || this.shapes[i].shape === shape) {
+                const newConfig = Object.assign(this.shapes[i].vertexOptions, config);
+                this.shapes[i].points.forEach((p) => {
+                    p.setAttrs(newConfig);
+                });
+                this.renderThisFrame = true;
+                return this.shapes[i].shape;
+            }
+        }
+        return null;
+    }
+    /**
+     * 将shapeData转换为Konva.Path对象
+     * @param shapeData ShapeData
+     */
+    transformShapeDataToKonvaShape(shapeData) {
+        const { shapeType } = shapeData;
+        const { Konva } = Externals.getInstance();
+        if (shapeType === 'point') {
+            const circle = new Konva.Circle({
+                radius: shapeData.radius,
+                id: shapeData.id,
+                x: shapeData.x,
+                y: shapeData.y,
+                stroke: shapeData.stroke,
+                strokeWidth: shapeData.strokeWidth,
+                fill: shapeData.fill,
+            });
+            return circle;
+        }
+        if (shapeType === 'line') {
+            const path = new Konva.Path({
+                id: shapeData.id,
+                x: shapeData.x,
+                y: shapeData.y,
+                data: `${shapeData.path.toUpperCase()}`,
+                stroke: shapeData.stroke,
+                strokeWidth: shapeData.strokeWidth,
+                lineJoin: 'round',
+                lineCap: 'round',
+            });
+            return path;
+        }
+        if (shapeType === 'shape') {
+            const path = new Konva.Path({
+                id: shapeData.id,
+                x: shapeData.x,
+                y: shapeData.y,
+                data: `${shapeData.path.toUpperCase()}z`,
+                stroke: shapeData.stroke,
+                strokeWidth: shapeData.strokeWidth,
+                fill: shapeData.fill,
+                lineJoin: 'round',
+                lineCap: 'round',
+            });
+            return path;
+        }
+        return null;
+    }
+    // private sideOfVecToCamera(camera: Camera, vec: Vector3, norm: Vector3): number {
+    //   return vec.clone().sub(camera.position).dot(norm);
+    // }
+    updateShapeDataToKonvaShape(shape, rawShape, camera, halfW, halfH, points, pointOptions, zIndices = [], lineJointsStyle = 'joints') {
+        const { THREE, Konva } = Externals.getInstance();
+        const shapeData = rawShape.getData();
+        const { shapeType } = shapeData;
+        const frustum = new THREE.Frustum();
+        frustum.setFromProjectionMatrix(new THREE.Matrix4().multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse));
+        if (shapeType === 'point') {
+            const circle = shape;
+            const v = new THREE.Vector3(shapeData.x, shapeData.y, shapeData.zIndex);
+            const coordinate2 = v.project(camera);
+            const x = (coordinate2.x + 1) * halfW;
+            const y = (1 - coordinate2.y) * halfH;
+            circle.x(x);
+            circle.y(y);
+        }
+        else if (camera instanceof THREE.OrthographicCamera) {
+            const path = shape;
+            const pathSteps = rawShape.getSteps();
+            const globalZ = shapeData.zIndex;
+            let data = pathSteps.map((s, i) => {
+                let z = globalZ;
+                if (i < zIndices.length)
+                    z = zIndices[i];
+                const coords = s.coords.map(([x, y]) => {
+                    const v = new THREE.Vector3(x, y, z);
+                    const coordinate2 = v.project(camera);
+                    const sx = (coordinate2.x + 1) * halfW;
+                    const sy = (1 - coordinate2.y) * halfH;
+                    return `${sx},${sy}`;
+                }).join(',');
+                return `${s.command}${coords}`;
+            }).join('').toUpperCase();
+            if (shapeType === 'shape')
+                data += 'z';
+            path.data(data);
+        }
+        else {
+            const path = shape;
+            const pathSteps = rawShape.getSteps();
+            const globalZ = shapeData.zIndex;
+            const lookAtVec = new THREE.Vector3(0, 0, -1);
+            lookAtVec.applyQuaternion(camera.quaternion);
+            let prevVecVisible = false;
+            let currentVecVisible = false;
+            const prevVec = new THREE.Vector3();
+            let data = pathSteps.map((s, i) => {
+                let z = globalZ;
+                if (i < zIndices.length)
+                    z = zIndices[i];
+                const [x, y] = s.coords[s.coords.length - 1];
+                const v = new THREE.Vector3(x, y, z);
+                let addOn = '';
+                currentVecVisible = frustum.containsPoint(v);
+                if (i > 0) {
+                    const line = new THREE.Line3(prevVec.clone(), v.clone());
+                    const lVisible = prevVecVisible && currentVecVisible;
+                    if (!lVisible) {
+                        const intersections = frustum.planes.map((p) => {
+                            const intersects = p.intersectLine(line, new THREE.Vector3());
+                            if (!intersects)
+                                return null;
+                            const valid = !frustum.planes.filter((pl) => pl !== p).some((pl) => (pl.distanceToPoint(intersects) < 0));
+                            return valid ? intersects : null;
+                        }).filter((p) => p);
+                        if (intersections.length) {
+                            intersections.sort((a, b) => (a.distanceToSquared(prevVec) - b.distanceToSquared(prevVec)));
+                            addOn = intersections.map((vec, j) => {
+                                const coord = vec.project(camera);
+                                const sign = coord.z > 1 ? -1 : 1;
+                                const sx = (coord.x + 1) * halfW * sign;
+                                const sy = (1 - coord.y) * halfH * sign;
+                                if (j === 0)
+                                    return `${prevVecVisible ? 'l' : 'm'}${sx},${sy}`;
+                                return `l${sx},${sy}`;
+                            }).join('');
+                        }
+                    }
+                }
+                prevVec.copy(v);
+                const coordinate2 = v.project(camera);
+                const sign = coordinate2.z > 1 ? -1 : 1;
+                const sx = (coordinate2.x + 1) * halfW * sign;
+                const sy = (1 - coordinate2.y) * halfH * sign;
+                const pointVisible = lineJointsStyle === 'joints' || (lineJointsStyle === 'endpoints' && (i === 0 || i === zIndices.length - 1));
+                if (i < points.length) {
+                    const point = points[i];
+                    point.x(sx);
+                    point.y(sy);
+                    point.visible(pointVisible && currentVecVisible && path.visible());
+                    point.setAttrs(pointOptions);
+                }
+                else {
+                    const point = new Konva.Circle({
+                        radius: 0,
+                        x: sx,
+                        y: sy,
+                        stroke: 'transparent',
+                        strokeWidth: 0,
+                    });
+                    point.visible(pointVisible && currentVecVisible && path.visible());
+                    point.setAttrs(pointOptions);
+                    point.on('mousedown touchdown', this.listeners.nodePointerDown);
+                    this.layer.add(point);
+                    points.push(point);
+                }
+                prevVecVisible = currentVecVisible;
+                return `${addOn}${currentVecVisible ? 'l' : 'm'}${sx},${sy}`;
+            }).join('').toUpperCase();
+            while (points.length > pathSteps.length) {
+                const point = points.pop();
+                point.off('mousedown touchdown');
+                point.destroy();
+            }
+            if (shapeType === 'shape')
+                data += 'z';
+            path.data(data);
+        }
+    }
+    addShape(shapes, baseZoom = { x: 1, y: 1 }, zIndices = []) {
+        const ret = [];
+        const shapeList = Array.isArray(shapes) ? shapes : [shapes];
+        const zIndicesList = (zIndices.length && Array.isArray(zIndices[0]) ? zIndices : [zIndices]);
+        shapeList.forEach((shape, i) => {
+            const shapeData = shape.getData();
+            const konvaShape = this.transformShapeDataToKonvaShape(shapeData);
+            if (konvaShape !== null) {
+                ret.push(konvaShape);
+                this.layer.add(konvaShape);
+                const shapeGroup = new ShapeGroup(konvaShape, shape, baseZoom, zIndicesList[i]);
+                shapeGroup.points.forEach((p) => { p.setAttrs(shapeGroup.vertexOptions); });
+                this.shapes.push(shapeGroup);
+            }
+        });
+        this.renderThisFrame = true;
+        if (Array.isArray(shapes)) {
+            return ret;
+        }
+        if (ret.length > 0) {
+            return ret[0];
+        }
+        return null;
+    }
+    getShapeGroup(shape) {
+        return this.shapes.find((s) => s.rawShape === shape || s.shape === shape);
+    }
+    forceRender() {
+        this.renderThisFrame = true;
+    }
+    /**
+     * 计算路径距离中点
+     * @param shape 目标图形
+     */
+    getMiddlePoint(shape) {
+        const shapeGroup = this.getShapeGroup(shape);
+        if (!shapeGroup)
+            return null;
+        const steps = shapeGroup.rawShape.getSteps();
+        const { zIndices } = shapeGroup;
+        const { THREE } = Externals.getInstance();
+        if (!steps.length)
+            return null;
+        const distArray = [0];
+        let dist = 0;
+        const prevPoint = new THREE.Vector3(steps[0].coords[steps[0].coords.length - 1][0], steps[0].coords[steps[0].coords.length - 1][1], zIndices.length > 0 ? zIndices[0] : 0);
+        const currentPoint = new THREE.Vector3();
+        const result = new THREE.Vector3().copy(prevPoint);
+        for (let i = 1; i < steps.length; i += 1) {
+            const [x, y] = steps[i].coords[steps[i].coords.length - 1];
+            const z = zIndices[i];
+            currentPoint.set(x, y, z);
+            const d = currentPoint.distanceTo(prevPoint);
+            dist += d;
+            distArray.push(dist);
+            prevPoint.copy(currentPoint);
+        }
+        const distHalf = dist / 2;
+        let middleIndex = 0;
+        while (middleIndex + 1 < distArray.length && distArray[middleIndex + 1] < distHalf)
+            middleIndex += 1;
+        result.set(steps[middleIndex].coords[steps[middleIndex].coords.length - 1][0], steps[middleIndex].coords[steps[middleIndex].coords.length - 1][1], zIndices.length > middleIndex ? zIndices[middleIndex] : 0);
+        if (middleIndex + 1 < distArray.length) {
+            const segmentLength = distArray[middleIndex + 1] - distArray[middleIndex];
+            const ratio = (distHalf - distArray[middleIndex]) / segmentLength;
+            const furtherPoint = new THREE.Vector3(steps[middleIndex + 1].coords[steps[middleIndex + 1].coords.length - 1][0], steps[middleIndex + 1].coords[steps[middleIndex + 1].coords.length - 1][1], zIndices.length > middleIndex + 1 ? zIndices[middleIndex + 1] : 0);
+            result.add(furtherPoint.sub(result).multiplyScalar(ratio));
+        }
+        return result;
+    }
+    setEnabled(value) {
+        this.enabled = value;
+    }
+    resize(containerWidth, containerHeight) {
+        this.owlly2D.resize(containerWidth, containerHeight);
+    }
+}
+export { CanvasOverlay, ShapeGroup };

package/lib/owlly/overlay/css-2d-overlay.d.ts

@@ -0,0 +1,14 @@
+import { Overlay } from './overlay';
+import { View } from '../view/view';
+declare class CSS2DOverlay extends Overlay {
+    private container;
+    private parent;
+    private renderer;
+    init(parent: View, container?: HTMLElement): void;
+    resize(containerWidth: number, containerHeight: number): void;
+    setRenderOrder(order: number): void;
+    update(): boolean;
+    render(): void;
+    dispose(): void;
+}
+export { CSS2DOverlay };

package/lib/owlly/overlay/css-2d-overlay.js

@@ -0,0 +1,35 @@
+import { CSS2DRenderer } from '../../external/renderers/css-2d-renderer';
+import { Overlay } from './overlay';
+class CSS2DOverlay extends Overlay {
+    init(parent, container = parent.container) {
+        this.container = container;
+        this.parent = parent;
+        const { clientWidth, clientHeight } = this.container;
+        this.renderer = new CSS2DRenderer();
+        this.renderer.setSize(clientWidth, clientHeight);
+        this.renderer.domElement.style.position = 'absolute';
+        this.renderer.domElement.style.top = '0';
+        this.renderer.domElement.style.userSelect = 'none';
+        this.container.appendChild(this.renderer.domElement);
+    }
+    resize(containerWidth, containerHeight) {
+        this.renderer.setSize(containerWidth, containerHeight);
+    }
+    setRenderOrder(order) {
+        this.renderer.domElement.style.setProperty('z-index', `${order}`);
+    }
+    update() {
+        return false;
+    }
+    render() {
+        if (!this.parent.camera)
+            return;
+        this.renderer.render(this.parent.stage.scene, this.parent.camera);
+    }
+    dispose() {
+        this.container.removeChild(this.renderer.domElement);
+        this.renderer = null;
+        this.container = null;
+    }
+}
+export { CSS2DOverlay };

package/lib/owlly/overlay/css-3d-overlay.d.ts

@@ -0,0 +1,16 @@
+import { NS_THREE } from '../stage/externals';
+import { CSS3DRenderer } from '../../external/renderers/css-3d-renderer';
+import { Overlay } from './overlay';
+import { View } from '../view/view';
+declare class CSS3DOverlay extends Overlay {
+    private container;
+    private parent;
+    renderer: CSS3DRenderer | null;
+    init(parent: View, container?: HTMLElement): void;
+    resize(containerWidth: number, containerHeight: number): void;
+    setRenderOrder(order: number): void;
+    update(): boolean;
+    render(scene: NS_THREE.Scene): void;
+    dispose(): void;
+}
+export { CSS3DOverlay };

package/lib/owlly/overlay/css-3d-overlay.js

@@ -0,0 +1,36 @@
+import { CSS3DRenderer } from '../../external/renderers/css-3d-renderer';
+import { Overlay } from './overlay';
+class CSS3DOverlay extends Overlay {
+    init(parent, container = new HTMLElement()) {
+        this.container = container;
+        this.parent = parent;
+        const { clientWidth, clientHeight } = this.container;
+        this.renderer = new CSS3DRenderer();
+        this.renderer.setSize(clientWidth, clientHeight);
+        this.renderer.domElement.style.position = 'absolute';
+        this.renderer.domElement.style.top = '0';
+        this.renderer.domElement.style.left = '0';
+        this.renderer.domElement.style.userSelect = 'none';
+        // this.renderer.domElement.style.pointerEvents = 'none';
+        this.container.appendChild(this.renderer.domElement);
+    }
+    resize(containerWidth, containerHeight) {
+        this.renderer.setSize(containerWidth, containerHeight);
+    }
+    setRenderOrder(order) {
+        this.renderer.domElement.style.setProperty('z-index', `${order}`);
+    }
+    update() {
+        return false;
+    }
+    render(scene) {
+        if (!this.parent.camera)
+            return;
+        this.renderer.render(scene, this.parent.camera);
+    }
+    dispose() {
+        this.container.removeChild(this.renderer.domElement);
+        this.renderer = null;
+    }
+}
+export { CSS3DOverlay };

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

@@ -0,0 +1,6 @@
+export * from './overlay';
+export * from './path-overlay2';
+export * from './css-2d-overlay';
+export * from './poi-overlay';
+export * from './canvas-overlay';
+export * from './poi-overlay-3d';

package/lib/owlly/overlay/index.js

@@ -0,0 +1,11 @@
+// #if WEB_ONLY
+export * from './overlay';
+// #endif
+// export * from './path-overlay';
+export * from './path-overlay2';
+// export * from './label-overlay';
+export * from './css-2d-overlay';
+// export * from './css-3d-overlay';
+export * from './poi-overlay';
+export * from './canvas-overlay';
+export * from './poi-overlay-3d';