@aibee/crc-bmap 0.1.2 → 0.1.3

package/lib/src/plugins/index.d.ts

@@ -2,3 +2,4 @@ export * from "./equipment";
 export * from "./navigation";
 export * from './mul-floors';
 export * from './nav-path';
+export * from './select';

package/lib/src/plugins/nav-path/nav-path.d.ts

@@ -1,5 +1,5 @@
 import { EventDispatcher } from "three";
-import { End, PathData, PathDirection, RouteType, Start } from "../../utils";
+import { End2, PathData, PathDirection, RouteType2, Start2 } from "../../utils";
 import { Facility, RoadData2 } from "../../utils/road2";
 interface EventMap {
     "init-road-status": {
@@ -16,7 +16,7 @@ export declare class NavPath extends EventDispatcher<EventMap> {
     initRoadStatus: boolean;
     constructor();
     setRoadData(roadData: RoadData2[], facilities: Facility[]): Promise<void>;
-    getPath(start: Start, end: End, type?: RouteType): Promise<PathData>;
+    getPath(start: Start2, end: End2, type?: RouteType2): Promise<PathData>;
     getDirectionPath(points: [number, number][]): Promise<DirectionPathData[]>;
     dispose(): Promise<void>;
 }

package/lib/src/plugins/navigation/navigation.d.ts

@@ -1,10 +1,16 @@
 import { BMap } from "../../bmap";
 import { Plugin } from "../base";
 import { Path, PathConfig } from "./path";
-import { PathData, RoadData } from "../../utils";
+import { PathData2, TweenUtil } from "../../utils";
 import { Floor, Poi2, PoiOptions2 } from "../../elements";
-import { Group as TweenGroup } from "@tweenjs/tween.js";
+import { PathDirection } from "../../utils/path";
+import { Tween } from "@tweenjs/tween.js";
 export type Point = [number, number];
+export interface NavigationProcessInfo {
+    distance: number;
+    dir: PathDirection;
+    nextDirDistance: number;
+}
 interface EventMap {
     "fetch-road-status": {
         status: boolean;
@@ -13,42 +19,55 @@ interface EventMap {
         pathIndex: number;
     };
     "path-animation-end": {};
-    "fetch-road-data": {
-        roadInfo: RoadData[];
+    "render-path": {
+        path: Path;
     };
+    "navigation-info": NavigationProcessInfo;
 }
 export interface NavigationConfig {
     path?: Partial<PathConfig>;
-    speed: number;
     cheapMaximumDistance: number;
     startPoi: Partial<PoiOptions2>;
     needStartPoi: boolean;
     offsetY: number;
+    directionEmitThreshold: number;
+    disablePathAnimation: boolean;
 }
 export declare class Navigation extends Plugin<EventMap> {
     path: Path | null;
     fetchRoadStatus: boolean;
-    paths: PathData;
+    paths: PathData2;
+    curPathIndex: number;
+    curFloorPath: PathData2[0] | null;
+    translatePath: PathData2[0]["points"] | null;
+    currentPathPosition: [number, number] | null;
     options: NavigationConfig;
-    pathTween: TweenGroup;
+    pathTween: Tween<any> | null;
     startPoi: Poi2 | null;
     movedDistance: number;
     pathStart: [number, number];
+    tweenUtil: TweenUtil;
     animationPathOptions: {
         cPathIndex: number;
     };
     cPath: Point[];
-    constructor(bmap: BMap, project: string, options?: Partial<NavigationConfig>);
+    constructor(bmap: BMap, project?: string | Partial<NavigationConfig>, options?: Partial<NavigationConfig>);
+    get curFloorPathLength(): number;
+    get curFloorPathPoints(): [number, number][];
     registryEvent(): void;
+    pauseAnimation(): void;
+    continueAnimation(): void;
     unRegistryEvent(): void;
     onUpdate: () => void;
     clearPath(): void;
+    private setCurFloorPath;
+    setCurPathIndex(index: number): void;
     onSwitchFloor: ({ data: { curFloor } }: {
         data: {
             curFloor: Floor;
         };
     }) => void;
-    addPath(paths: PathData): void;
+    addPath(paths: PathData2, routeIndex?: number): void;
     translatePoints(points: Point[]): Point[];
     renderPath(points: Point[]): void;
     catmullRomCurve3(points: Point[]): [number, number][];
@@ -60,12 +79,23 @@ export declare class Navigation extends Plugin<EventMap> {
     animationTo(point: {
         floor: string;
         pos: [number, number];
-    }, speed?: number): Promise<unknown>;
+    }, speed: number): Promise<unknown>;
     getPathDirection(): number | null;
     changeCameraToPathUp(duration?: number): Promise<unknown>;
     initNavigationCamera(): Promise<void>;
     translateCameraToStartPoi(duration?: number): Promise<unknown>;
     initCameraZoom(duration?: number): Promise<unknown>;
+    toPositionBySpeed(position: [number, number], speed: number): Promise<unknown>;
+    adsorb(position: [number, number]): {
+        distance: number;
+        closestPoint: [number, number];
+    } | null;
+    getRemainDistance(): number;
+    getNextDirDistance(): {
+        dir: PathDirection;
+        distance: number;
+    } | null;
+    private emitNavigationInfo;
     dispose(): void;
 }
 export {};

package/lib/src/plugins/navigation/path.d.ts

@@ -15,7 +15,6 @@ export declare class Path extends Object3D {
     texture: Texture | null;
     config: PathConfig;
     points: [number, number][];
-    pathDistance: number;
     basicRepeat: number;
     prevCameraZoom: number;
     constructor(navigation: Navigation, config?: Partial<PathConfig>);
@@ -28,7 +27,7 @@ export declare class Path extends Object3D {
     loadTexture(url: string): Promise<Texture>;
     transformPoints(points: [number, number][]): number[];
     updatePoints(points: [number, number][]): void;
-    movePath(distance: number): void;
+    movePath(ratio: number): void;
     create(points: [number, number][]): Promise<Mesh<any, any, import("three").Object3DEventMap>>;
     dispose(): void;
 }

package/lib/src/plugins/position/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sensor';
+export * from './position';

package/lib/src/plugins/position/position.d.ts

@@ -0,0 +1,11 @@
+import { Sensor, SensorOptions } from "./sensor";
+export interface PdrPositionOptions {
+    sensor?: Partial<SensorOptions>;
+}
+export declare class PdrPosition {
+    sensor: Sensor;
+    constructor(options?: PdrPositionOptions);
+    checkSensor(): Promise<{
+        deviceOrientation: boolean;
+    }>;
+}

package/lib/src/plugins/position/sensor.d.ts

@@ -0,0 +1,59 @@
+import { Timer } from "../../utils";
+import { EventDispatcher } from "three";
+interface SensorEventMap {
+    "start": {};
+    "stop": {};
+    "sensor-data": {
+        data: SensorData[];
+    };
+}
+interface DeviceMotionData {
+    type: "deviceMotion";
+    timestamp: number;
+    res: [number, number, number];
+}
+interface AccelerationData {
+    type: "accelerometer";
+    timestamp: number;
+    res: [number, number, number];
+}
+interface GpsData {
+    type: "gps";
+    timestamp: number;
+    res: [number, number, number];
+}
+interface CompassData {
+    type: "compass";
+    timestamp: number;
+    res: number;
+}
+type SensorData = DeviceMotionData | AccelerationData | GpsData | CompassData;
+export interface SensorOptions {
+    time: number;
+    elements: ("compass" | "deviceMotion" | "acceleration" | "gps")[];
+}
+export declare class Sensor extends EventDispatcher<SensorEventMap> {
+    options: SensorOptions;
+    gpsTimer: null | number;
+    data: SensorData[];
+    timer: Timer;
+    dispatchTimer: number | null;
+    constructor(options?: Partial<SensorOptions>);
+    start(): void;
+    addDeviceMotion: import("lodash").DebouncedFunc<(data: DeviceMotionData) => void>;
+    addAcceleration: import("lodash").DebouncedFunc<(data: AccelerationData) => void>;
+    deviceOrientationAbsHandler: (e: DeviceOrientationEvent) => void;
+    /**
+     * 获取 compass 和 deviceMotion
+     */
+    listenDeviceOrientation(): void;
+    handleAcceleration: (e: DeviceMotionEvent) => void;
+    listenAcceleration(): void;
+    listenGps(): void;
+    checkSensor(): Promise<{
+        deviceOrientation: boolean;
+    }>;
+    checkDeviceOrientation(): Promise<boolean>;
+    stop(): void;
+}
+export {};

package/lib/src/plugins/select/box-selection.d.ts

@@ -0,0 +1,39 @@
+import { Context } from "../../context/context";
+import { BaseSvg, Graphic } from "../../elements";
+import { Frustum, Vector3 } from "three";
+interface BoxSelectionEventMap {
+    "selected": {
+        list: Graphic[];
+    };
+}
+export declare class BoxSelection extends BaseSvg<BoxSelectionEventMap> {
+    startPoint?: Vector3;
+    endPoint?: Vector3;
+    rect: SVGElement;
+    frustum: Frustum;
+    constructor(context: Context);
+    setEnable(enable: boolean): void;
+    onPointerDown: (e: PointerEvent) => void;
+    onPointerMove: (e: PointerEvent) => void;
+    onPointerUp: (e: PointerEvent) => void;
+    onUpdate: () => void;
+    registryEvent(): void;
+    unRegistryEvent(): void;
+    doSelect(): void;
+    searchMapInFrustum(leftTop: {
+        x: number;
+        y: number;
+    }, rightBottom: {
+        x: number;
+        y: number;
+    }): Graphic[];
+    searchChildInFrustum(object: Graphic, leftTop: {
+        x: number;
+        y: number;
+    }, rightBottom: {
+        x: number;
+        y: number;
+    }): boolean;
+    dispose(): void;
+}
+export {};

package/lib/src/plugins/select/index.d.ts

@@ -0,0 +1 @@
+export * from './select';

package/lib/src/plugins/select/select.d.ts

@@ -0,0 +1,47 @@
+import { Graphic, Poi, Poi2 } from "../../elements";
+import { BMap } from "../../bmap";
+import { Plugin } from "../base";
+import { BoxSelection } from "./box-selection";
+export interface BMapSelectOptions {
+    boxSelection: boolean;
+    elements: ("graphic" | "poi")[];
+}
+interface SelectionEventMap {
+    "select": {
+        graphics: Graphic[];
+        pois: (Poi | Poi2)[];
+        isMultipleSelect: boolean;
+    };
+}
+export declare class BMapSelect extends Plugin<SelectionEventMap> {
+    options: BMapSelectOptions;
+    _list: Set<Graphic>;
+    _poiList: Set<Poi | Poi2>;
+    boxSelection: BoxSelection;
+    prevPanStatus?: boolean;
+    prevRotateStatus?: boolean;
+    downPoint: {
+        x: number;
+        y: number;
+    } | null;
+    isMultipleSelect: boolean;
+    constructor(bmap: BMap, options?: Partial<BMapSelectOptions>);
+    get list(): Set<Graphic>;
+    enableBoxSelection(): void;
+    disableBoxSelection(): void;
+    onPointerDown: (e: PointerEvent) => void;
+    onPointerUp: (e: PointerEvent) => void;
+    onPointerOut: (e: PointerEvent) => void;
+    onKeyDown: (e: KeyboardEvent) => void;
+    onKeyUp: (e: KeyboardEvent) => void;
+    onBoxSelected: ({ list }: {
+        list: Graphic[];
+    }) => void;
+    selectEnd(): void;
+    registryEvent(): void;
+    unRegistryEvent(): void;
+    clear(): void;
+    remove(graphic: Graphic): void;
+    dispose(): void;
+}
+export {};

package/lib/src/utils/create.d.ts

@@ -1,2 +1,3 @@
-import { BufferGeometry, Line, LineBasicMaterial, Vector3 } from "three";
+import { BoxGeometry, BufferGeometry, Line, LineBasicMaterial, Mesh, Vector3 } from "three";
 export declare function createThreeLine(points: Vector3[], color?: number): Line<BufferGeometry<import("three").NormalBufferAttributes>, LineBasicMaterial>;
+export declare function createThreeBox(pos: Vector3, color?: number): Mesh<BoxGeometry, LineBasicMaterial, import("three").Object3DEventMap>;

package/lib/src/utils/index.d.ts

@@ -21,3 +21,4 @@ export * from './webworker';
 export * from './string';
 export * from './create';
 export * from './translate';
+export * from './tween';

package/lib/src/utils/os.d.ts

@@ -1 +1,4 @@
 export declare const isMac: boolean;
+export declare const UA: string;
+export declare const isIphone: boolean;
+export declare const isAndroid: boolean;

package/lib/src/utils/path.d.ts

@@ -62,3 +62,5 @@ export declare function getDirectPath(points: [number, number][]): {
     distance: number;
     points: [number, number][];
 }[];
+export declare function getDistanceByPathPos(path: [number, number][], pos: [number, number]): number;
+export declare function getPosByPathDistance(path: [number, number][], distance: number): [number, number] | null;

package/lib/src/utils/tween.d.ts

@@ -0,0 +1,16 @@
+import { Tween, Group } from '@tweenjs/tween.js';
+export declare class TweenUtil {
+    pauseTween: boolean;
+    tweenStore: Set<Tween<any>>;
+    group: Group;
+    constructor();
+    update(): void;
+    pause(): void;
+    continue(): void;
+    remove(tween: Tween<any>): void;
+    getAll(): Tween<{
+        [x: string]: any;
+    }>[];
+    clear(): void;
+    dispose(): void;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aibee/crc-bmap",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "",
   "main": "lib/bmap.min.js",
   "module": "lib/bmap.esm.js",