Updated types on npm

Author: tentone

build/Main.d.ts

@@ -0,0 +1,26 @@
+export { MapView } from './MapView';
+export { LODControl } from './lod/LODControl';
+export { LODRadial } from './lod/LODRadial';
+export { LODFrustum } from './lod/LODFrustum';
+export { LODRaycast } from './lod/LODRaycast';
+export { BingMapsProvider } from './providers/BingMapsProvider';
+export { GoogleMapsProvider } from './providers/GoogleMapsProvider';
+export { HereMapsProvider } from './providers/HereMapsProvider';
+export { MapBoxProvider } from './providers/MapBoxProvider';
+export { MapProvider } from './providers/MapProvider';
+export { MapTilerProvider } from './providers/MapTilerProvider';
+export { OpenMapTilesProvider } from './providers/OpenMapTilesProvider';
+export { OpenStreetMapsProvider } from './providers/OpenStreetMapsProvider';
+export { DebugProvider } from './providers/DebugProvider';
+export { HeightDebugProvider } from './providers/HeightDebugProvider';
+export { MapNodeGeometry } from './geometries/MapNodeGeometry';
+export { MapNodeHeightGeometry } from './geometries/MapNodeHeightGeometry';
+export { MapSphereNodeGeometry } from './geometries/MapSphereNodeGeometry';
+export { MapHeightNode } from './nodes/MapHeightNode';
+export { MapNode } from './nodes/MapNode';
+export { MapPlaneNode } from './nodes/MapPlaneNode';
+export { MapSphereNode } from './nodes/MapSphereNode';
+export { MapHeightNodeShader } from './nodes/MapHeightNodeShader';
+export { UnitsUtils } from './utils/UnitsUtils';
+export { CancelablePromise } from './utils/CancelablePromise';
+export { XHRUtils } from './utils/XHRUtils';

build/MapView.d.ts

@@ -0,0 +1,24 @@
+import { BufferGeometry, Camera, Group, Material, Mesh, Raycaster, Scene, WebGLRenderer } from 'three';
+import { MapNode } from './nodes/MapNode';
+import { MapProvider } from './providers/MapProvider';
+import { LODControl } from './lod/LODControl';
+export declare class MapView extends Mesh {
+    static PLANAR: number;
+    static SPHERICAL: number;
+    static HEIGHT: number;
+    static HEIGHT_SHADER: number;
+    static MARTINI: number;
+    static mapModes: Map<number, any>;
+    lod: LODControl;
+    provider: MapProvider;
+    heightProvider: MapProvider;
+    root: MapNode;
+    constructor(root?: (number | MapNode), provider?: MapProvider, heightProvider?: MapProvider);
+    onBeforeRender: (renderer: WebGLRenderer, scene: Scene, camera: Camera, geometry: BufferGeometry, material: Material, group: Group) => void;
+    setRoot(root: (MapNode | number)): void;
+    setProvider(provider: MapProvider): void;
+    setHeightProvider(heightProvider: MapProvider): void;
+    clear(): any;
+    getMetaData(): void;
+    raycast(raycaster: Raycaster, intersects: any[]): boolean;
+}

build/geometries/MapNodeGeometry.d.ts

@@ -0,0 +1,6 @@
+import { BufferGeometry } from 'three';
+export declare class MapNodeGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, widthSegments?: number, heightSegments?: number, skirt?: boolean, skirtDepth?: number);
+    static buildPlane(width: number, height: number, widthSegments: number, heightSegments: number, indices: number[], vertices: number[], normals: number[], uvs: number[]): void;
+    static buildSkirt(width: number, height: number, widthSegments: number, heightSegments: number, skirtDepth: number, indices: number[], vertices: number[], normals: number[], uvs: number[]): void;
+}

build/geometries/MapNodeHeightGeometry.d.ts

@@ -0,0 +1,5 @@
+import { BufferGeometry } from 'three';
+export declare class MapNodeHeightGeometry extends BufferGeometry {
+    constructor(width?: number, height?: number, widthSegments?: number, heightSegments?: number, skirt?: boolean, skirtDepth?: number, imageData?: ImageData, calculateNormals?: boolean);
+    computeNormals(widthSegments: number, heightSegments: number): void;
+}

build/geometries/MapSphereNodeGeometry.d.ts

@@ -0,0 +1,4 @@
+import { BufferGeometry } from 'three';
+export declare class MapSphereNodeGeometry extends BufferGeometry {
+    constructor(radius: number, widthSegments: number, heightSegments: number, phiStart: number, phiLength: number, thetaStart: number, thetaLength: number);
+}

build/lod/LODControl.d.ts

@@ -0,0 +1,5 @@
+import { MapView } from '../MapView';
+import { Camera, WebGLRenderer, Object3D } from 'three';
+export interface LODControl {
+    updateLOD(view: MapView, camera: Camera, renderer: WebGLRenderer, scene: Object3D): void;
+}

build/lod/LODFrustum.d.ts

@@ -0,0 +1,10 @@
+import { LODRadial } from './LODRadial';
+import { Camera, Object3D, WebGLRenderer } from 'three';
+import { MapView } from '../MapView';
+export declare class LODFrustum extends LODRadial {
+    subdivideDistance: number;
+    simplifyDistance: number;
+    testCenter: boolean;
+    pointOnly: boolean;
+    updateLOD(view: MapView, camera: Camera, renderer: WebGLRenderer, scene: Object3D): void;
+}

build/lod/LODRadial.d.ts

@@ -0,0 +1,8 @@
+import { LODControl } from './LODControl';
+import { Camera, Object3D, WebGLRenderer } from 'three';
+import { MapView } from '../MapView';
+export declare class LODRadial implements LODControl {
+    subdivideDistance: number;
+    simplifyDistance: number;
+    updateLOD(view: MapView, camera: Camera, renderer: WebGLRenderer, scene: Object3D): void;
+}

build/lod/LODRaycast.d.ts

@@ -0,0 +1,13 @@
+import { LODControl } from './LODControl';
+import { Camera, Object3D, Raycaster, Vector2, WebGLRenderer } from 'three';
+import { MapView } from '../MapView';
+export declare class LODRaycast implements LODControl {
+    subdivisionRays: number;
+    thresholdUp: number;
+    thresholdDown: number;
+    raycaster: Raycaster;
+    mouse: Vector2;
+    powerDistance: boolean;
+    scaleDistance: boolean;
+    updateLOD(view: MapView, camera: Camera, renderer: WebGLRenderer, scene: Object3D): void;
+}

build/nodes/MapHeightNode.d.ts

@@ -0,0 +1,20 @@
+import { Material, BufferGeometry, Vector3, Raycaster, Intersection } from 'three';
+import { MapNode } from './MapNode';
+import { MapView } from '../MapView';
+export declare class MapHeightNode extends MapNode {
+    heightLoaded: boolean;
+    textureLoaded: boolean;
+    static tileSize: number;
+    geometrySize: number;
+    geometryNormals: boolean;
+    static geometry: BufferGeometry;
+    static baseGeometry: BufferGeometry;
+    static baseScale: Vector3;
+    constructor(parentNode?: MapHeightNode, mapView?: MapView, location?: number, level?: number, x?: number, y?: number, geometry?: BufferGeometry, material?: Material);
+    initialize(): void;
+    loadTexture(): void;
+    nodeReady(): void;
+    createChildNodes(): void;
+    loadHeightGeometry(): Promise<any>;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}

build/nodes/MapHeightNodeShader.d.ts

@@ -0,0 +1,15 @@
+import { BufferGeometry, Intersection, Material, Raycaster, Texture, Vector3 } from 'three';
+import { MapHeightNode } from './MapHeightNode';
+import { MapView } from '../MapView';
+export declare class MapHeightNodeShader extends MapHeightNode {
+    constructor(parentNode?: MapHeightNode, mapView?: MapView, location?: number, level?: number, x?: number, y?: number);
+    static emptyTexture: Texture;
+    static geometrySize: number;
+    static geometry: BufferGeometry;
+    static baseGeometry: BufferGeometry;
+    static baseScale: Vector3;
+    static prepareMaterial(material: Material): Material;
+    loadTexture(): void;
+    loadHeightGeometry(): Promise<any>;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}

build/nodes/MapMartiniHeightNode.d.ts

@@ -0,0 +1,33 @@
+import { Material, MeshPhongMaterial, Texture } from 'three';
+import { MapNodeGeometry } from '../geometries/MapNodeGeometry';
+import { MapView } from '../MapView';
+import { MapHeightNode } from './MapHeightNode';
+export declare class MapMartiniHeightNode extends MapHeightNode {
+    static geometrySize: number;
+    static emptyTexture: Texture;
+    static geometry: MapNodeGeometry;
+    elevationDecoder: any;
+    static tileSize: number;
+    exageration: number;
+    meshMaxError: number | Function;
+    material: MeshPhongMaterial;
+    constructor(parentNode?: MapHeightNode, mapView?: MapView, location?: number, level?: number, x?: number, y?: number, { elevationDecoder, meshMaxError, exageration }?: {
+        elevationDecoder?: any;
+        meshMaxError?: number;
+        exageration?: number;
+    });
+    static prepareMaterial(material: Material, level: number, exageration?: number): any;
+    static getTerrain(imageData: Uint8ClampedArray, tileSize: number, elevation: any): Float32Array;
+    static getMeshAttributes(vertices: number[], terrain: Float32Array, tileSize: number, bounds: number[], exageration: number): {
+        position: {
+            value: Float32Array;
+            size: number;
+        };
+        uv: {
+            value: Float32Array;
+            size: number;
+        };
+    };
+    onHeightImage(image: HTMLImageElement): Promise<void>;
+    loadHeightGeometry(): Promise<any>;
+}

build/nodes/MapNode.d.ts

@@ -0,0 +1,32 @@
+import { Material, Mesh, Vector3, BufferGeometry, Object3D } from 'three';
+import { MapView } from '../MapView';
+export declare abstract class MapNode extends Mesh {
+    mapView: MapView;
+    parentNode: MapNode;
+    location: number;
+    level: number;
+    x: number;
+    y: number;
+    nodesLoaded: number;
+    subdivided: boolean;
+    childrenCache: Object3D[];
+    cacheChild: boolean;
+    isMesh: boolean;
+    static baseGeometry: BufferGeometry;
+    static baseScale: Vector3;
+    static childrens: number;
+    static root: number;
+    static topLeft: number;
+    static topRight: number;
+    static bottomLeft: number;
+    static bottomRight: number;
+    constructor(parentNode?: MapNode, mapView?: MapView, location?: number, level?: number, x?: number, y?: number, geometry?: BufferGeometry, material?: Material);
+    initialize(): void;
+    createChildNodes(): void;
+    subdivide(): void;
+    simplify(): void;
+    loadTexture(): void;
+    nodeReady(): void;
+    getNeighborsDirection(direction: number): MapNode[];
+    getNeighbors(): MapNode[];
+}

build/nodes/MapPlaneNode.d.ts

@@ -0,0 +1,11 @@
+import { BufferGeometry, Intersection, Raycaster, Vector3 } from 'three';
+import { MapNode } from './MapNode';
+export declare class MapPlaneNode extends MapNode {
+    constructor(parentNode?: any, mapView?: any, location?: number, level?: number, x?: number, y?: number);
+    static geometry: BufferGeometry;
+    static baseGeometry: BufferGeometry;
+    static baseScale: Vector3;
+    initialize(): void;
+    createChildNodes(): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}

build/nodes/MapSphereNode.d.ts

@@ -0,0 +1,16 @@
+import { BufferGeometry, Vector3, Raycaster, Intersection } from 'three';
+import { MapNode } from './MapNode';
+import { MapSphereNodeGeometry } from '../geometries/MapSphereNodeGeometry';
+export declare class MapSphereNode extends MapNode {
+    static baseGeometry: BufferGeometry;
+    static baseScale: Vector3;
+    static segments: number;
+    constructor(parentNode?: any, mapView?: any, location?: number, level?: number, x?: number, y?: number);
+    initialize(): void;
+    static createGeometry(zoom: number, x: number, y: number): MapSphereNodeGeometry;
+    applyScaleNode(): void;
+    updateMatrix(): void;
+    updateMatrixWorld(force?: boolean): void;
+    createChildNodes(): void;
+    raycast(raycaster: Raycaster, intersects: Intersection[]): void;
+}

build/nodes/Martini.d.ts

@@ -0,0 +1,22 @@
+export declare class Martini {
+    gridSize: number;
+    numTriangles: number;
+    numParentTriangles: number;
+    indices: Uint32Array;
+    coords: Uint16Array;
+    constructor(gridSize?: number);
+    createTile(terrain: any): Tile;
+}
+declare class Tile {
+    martini: Martini;
+    terrain: Float32Array;
+    errors: Float32Array;
+    constructor(terrain: Float32Array, martini: Martini);
+    update(): void;
+    getMesh(maxError?: number, withSkirts?: boolean): {
+        vertices: any;
+        triangles: any;
+        numVerticesWithoutSkirts: number;
+    };
+}
+export {};

build/providers/BingMapsProvider.d.ts

@@ -0,0 +1,18 @@
+import { MapProvider } from './MapProvider';
+export declare class BingMapsProvider extends MapProvider {
+    maxZoom: number;
+    apiKey: string;
+    type: string;
+    format: string;
+    mapSize: number;
+    subdomain: string;
+    constructor(apiKey?: string, type?: string);
+    static AERIAL: string;
+    static ROAD: string;
+    static AERIAL_LABELS: string;
+    static OBLIQUE: string;
+    static OBLIQUE_LABELS: string;
+    getMetaData(): void;
+    static quadKey(zoom: number, x: number, y: number): string;
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/DebugProvider.d.ts

@@ -0,0 +1,5 @@
+import { MapProvider } from './MapProvider';
+export declare class DebugProvider extends MapProvider {
+    resolution: number;
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/GoogleMapsProvider.d.ts

@@ -0,0 +1,12 @@
+import { MapProvider } from './MapProvider';
+export declare class GoogleMapsProvider extends MapProvider {
+    apiToken: string;
+    sessionToken: string;
+    orientation: number;
+    format: string;
+    mapType: string;
+    overlay: boolean;
+    constructor(apiToken: string);
+    createSession(): void;
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/HeightDebugProvider.d.ts

@@ -0,0 +1,9 @@
+import { MapProvider } from './MapProvider';
+import { Color } from 'three';
+export declare class HeightDebugProvider extends MapProvider {
+    provider: MapProvider;
+    fromColor: Color;
+    toColor: Color;
+    constructor(provider: any);
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/HereMapsProvider.d.ts

@@ -0,0 +1,16 @@
+import { MapProvider } from './MapProvider';
+export declare class HereMapsProvider extends MapProvider {
+    static PATH: string;
+    appId: string;
+    appCode: string;
+    style: string;
+    scheme: string;
+    format: string;
+    size: number;
+    version: string;
+    server: number;
+    constructor(appId: string, appCode: string, style: string, scheme: string, format: string, size: number);
+    nextServer(): void;
+    getMetaData(): void;
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/MapBoxProvider.d.ts

@@ -0,0 +1,16 @@
+import { MapProvider } from './MapProvider';
+export declare class MapBoxProvider extends MapProvider {
+    static ADDRESS: string;
+    static STYLE: number;
+    static MAP_ID: number;
+    apiToken: string;
+    format: string;
+    useHDPI: boolean;
+    mode: number;
+    mapId: string;
+    style: string;
+    version: string;
+    constructor(apiToken?: string, id?: string, mode?: number, format?: string, useHDPI?: boolean, version?: string);
+    getMetaData(): void;
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/MapProvider.d.ts

@@ -0,0 +1,9 @@
+export declare abstract class MapProvider {
+    name: string;
+    minZoom: number;
+    maxZoom: number;
+    bounds: number[];
+    center: number[];
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+    getMetaData(): void;
+}

build/providers/MapTilerProvider.d.ts

@@ -0,0 +1,10 @@
+import { MapProvider } from './MapProvider';
+export declare class MapTilerProvider extends MapProvider {
+    apiKey: string;
+    format: string;
+    category: string;
+    style: string;
+    resolution: number;
+    constructor(apiKey: any, category: any, style: any, format: any);
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/OpenMapTilesProvider.d.ts

@@ -0,0 +1,9 @@
+import { MapProvider } from './MapProvider';
+export declare class OpenMapTilesProvider extends MapProvider {
+    address: string;
+    format: string;
+    theme: string;
+    constructor(address: string, format?: string, theme?: string);
+    getMetaData(): void;
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}

build/providers/OpenStreetMapsProvider.d.ts

@@ -0,0 +1,7 @@
+import { MapProvider } from './MapProvider';
+export declare class OpenStreetMapsProvider extends MapProvider {
+    address: string;
+    format: string;
+    constructor(address?: string);
+    fetchTile(zoom: number, x: number, y: number): Promise<any>;
+}