WMS tile seam corrections

dist/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const NO_DATA_VALUE_INTERNAL = -1100101;

dist/src/controls/compass.d.ts

@@ -0,0 +1,15 @@
+import { Corners } from '../generalTypes.d.ts';
+interface Private {
+}
+export default class Compass {
+    _: Private;
+    p: any;
+    name: string;
+    corner: Corners;
+    constructor(parent: any, name: string);
+    getControl: () => string;
+    attachEvents: () => void;
+    onUpdate: () => void;
+    setDirection: () => void;
+}
+export {};

dist/src/controls/coordinates.d.ts

@@ -0,0 +1,19 @@
+import { Corners } from '../generalTypes.d.ts';
+interface Private {
+}
+interface Params {
+    existingDivId?: string;
+}
+export default class Coordinates {
+    _: Private;
+    p: any;
+    name: string;
+    params: Params;
+    corner: Corners;
+    constructor(parent: any, name: string, params?: object);
+    getControl: () => string;
+    attachEvents: () => void;
+    onUpdate: () => void;
+    private updateMouseCoords;
+}
+export {};

dist/src/controls/exaggerate.d.ts

@@ -0,0 +1,18 @@
+import { Corners } from '../generalTypes.d.ts';
+interface Private {
+}
+export default class Exaggerate {
+    _: Private;
+    id: string;
+    p: any;
+    name: string;
+    corner: Corners;
+    exaggeration: number;
+    constructor(parent: any, name: string);
+    getControl: () => string;
+    attachEvents: () => void;
+    private getInactiveContent;
+    private getActiveContent;
+    setExaggeration: (multiplier: number) => void;
+}
+export {};

dist/src/controls/home.d.ts

@@ -0,0 +1,13 @@
+import { Corners } from '../generalTypes';
+interface Private {
+}
+export default class Home {
+    _: Private;
+    p: any;
+    name: string;
+    corner: Corners;
+    constructor(parent: any, name: string);
+    getControl: () => string;
+    attachEvents: () => void;
+}
+export {};

dist/src/controls/index.d.ts

@@ -0,0 +1,29 @@
+import { Corners } from '../generalTypes';
+export default class Controls {
+    p: any;
+    controlContainer: HTMLElement;
+    corners: {
+        TopLeft: HTMLElement;
+        TopRight: HTMLElement;
+        BottomLeft: HTMLElement;
+        BottomRight: HTMLElement;
+    };
+    activeControls: any;
+    compass: any;
+    coordinates: any;
+    home: any;
+    layers: any;
+    exaggerate: any;
+    observe: any;
+    walk: any;
+    link: any;
+    constructor(parent: any);
+    addControl: (name: string, control: any, params?: object, corner?: Corners) => any;
+    removeControl: (name: any) => void;
+    _onUpdateEvent: () => void;
+    _onMove: (lng: any, lat: any, height: any) => void;
+    _onMouseMove: (lng: any, lat: any, height: any) => void;
+    _onMouseOut: (e?: any) => void;
+    _onFirstPersonUpdate: () => void;
+    _onOrbitalUpdate: (e?: any) => void;
+}

dist/src/controls/layers.d.ts

@@ -0,0 +1,17 @@
+import { Corners } from '../generalTypes.d.ts';
+interface Private {
+}
+export default class Layers {
+    _: Private;
+    id: string;
+    p: any;
+    name: string;
+    corner: Corners;
+    constructor(parent: any, name: string);
+    getControl: () => string;
+    attachEvents: () => void;
+    private getInactiveContent;
+    private getActiveContent;
+    private attachEventsInternal;
+}
+export {};

dist/src/controls/link.d.ts

@@ -0,0 +1,29 @@
+import { Corners } from '../generalTypes';
+import { Object3D } from 'three';
+interface Private {
+    linkPanned: boolean;
+    linkPannedTimeout: any;
+    targetPoint?: Object3D;
+}
+export default class Link {
+    _: Private;
+    p: any;
+    name: string;
+    params: any;
+    corner: Corners;
+    return: any;
+    constructor(parent: any, name: string, params?: object);
+    getControl: () => string;
+    attachEvents: () => void;
+    getReturn: () => any;
+    onMove: (lng: any, lat: any, height: any) => void;
+    onMouseMove: (lng: any, lat: any, height: any) => void;
+    onMouseOut: () => void;
+    onFirstPersonUpdate: () => void;
+    onOrbitalUpdate: () => void;
+    setLink: (latlng?: any, style?: any, spriteId?: string) => void;
+    linkMove: (lng: number, lat: number) => void;
+    linkMouseMove: (lng: number, lat: number) => void;
+    linkMouseOut: () => void;
+}
+export {};

dist/src/controls/observe.d.ts

@@ -0,0 +1,23 @@
+import { Corners } from '../generalTypes.d.ts';
+interface Private {
+}
+export default class Observe {
+    _: Private;
+    p: any;
+    name: string;
+    id: string;
+    helpDiv: HTMLElement;
+    corner: Corners;
+    constructor(parent: any, name: string);
+    getControl: () => string;
+    private getInactiveContent;
+    private getActiveContent;
+    attachEvents: () => void;
+    private setCamera;
+    private leaveObserver;
+    private getObserverValues;
+    private keydownObserverSettings;
+    private toggleFOVOverlay;
+    private updateFOVOverlayBounds;
+}
+export {};

dist/src/controls/walk.d.ts

@@ -0,0 +1,16 @@
+import { Corners } from '../generalTypes.d.ts';
+interface Private {
+}
+export default class Walk {
+    _: Private;
+    p: any;
+    name: string;
+    helpDiv: HTMLElement;
+    corner: Corners;
+    constructor(parent: any, name: string);
+    getControl: () => string;
+    attachEvents: () => void;
+    private setCamera;
+    private leaveWalking;
+}
+export {};

dist/src/core/cameras.d.ts

@@ -0,0 +1,58 @@
+import { Vector2, Vector3 } from 'three';
+interface Private {
+    keepNear: boolean;
+    crosshair: HTMLElement;
+}
+interface Orbit {
+    camera: any;
+    controls: any;
+    near: number;
+    far: number;
+}
+interface FirstPerson {
+    camera: any;
+    controls: any;
+    lockControls: boolean;
+    height: 3;
+}
+export default class Camera {
+    _: Private;
+    container: HTMLElement;
+    sceneContainer: HTMLElement;
+    camera: any;
+    controls: any;
+    orbit: Orbit;
+    firstPerson: FirstPerson;
+    isFirstPerson: boolean;
+    isShift: boolean;
+    moveForward?: boolean;
+    moveBackward?: boolean;
+    moveLeft?: boolean;
+    moveRight?: boolean;
+    canJump?: boolean;
+    prevTime?: number;
+    velocity?: Vector3;
+    constructor(container: HTMLElement, sceneContainer: HTMLElement, scene: any, projection: any);
+    reset(): void;
+    _init(scene: any, projection: any): void;
+    swap(lockControls: any, skipLock: any): void;
+    private inToFirstPerson;
+    private outFromFirstPerson;
+    private toggleCrosshair;
+    private requestPointerLocking;
+    setupEvents(): void;
+    onKeyDown: (event: KeyboardEvent) => void;
+    onKeyUp: (event: KeyboardEvent) => void;
+    updateSize: () => void;
+    setNearFarPlane: (farther: any, near: any, far: any, keepNear: any) => void;
+    setFirstPersonHeight: (height: any) => void;
+    getFirstPersonFocalLength: () => number;
+    setFirstPersonFocalLength: (focalLength: any) => void;
+    getFirstPersonFOV: () => number;
+    setFirstPersonFOV: (fov: any) => void;
+    getFirstPersonAspect: () => number;
+    setFirstPersonAspect: (aspect: any) => void;
+    setCameraAzimuthElevation: (az: any, el: any, cameraIsFirstPerson: any) => void;
+    update: () => Vector2;
+}
+export {};

dist/src/core/renderer.d.ts

@@ -0,0 +1,8 @@
+export default class Renderer {
+    renderer: any;
+    container: HTMLElement;
+    constructor(container: HTMLElement);
+    _init(): void;
+    updateSize: () => void;
+    remove(): void;
+}

dist/src/core/shaders.d.ts

@@ -0,0 +1,7 @@
+import { ShaderMaterial } from 'three';
+declare const Shaders: {
+    simplePoint: () => ShaderMaterial;
+    multiTexture: (textures: any, fadeIn?: boolean) => ShaderMaterial;
+    atmosphere: (color?: string) => ShaderMaterial;
+};
+export default Shaders;

dist/src/layers/clamped.d.ts

@@ -0,0 +1,10 @@
+import { XYZ } from '../generalTypes.d.ts';
+export default class ClampedLayerer {
+    p: any;
+    constructor(parent: any);
+    add: (layerObj: any, callback?: Function) => void;
+    toggle: (name: string, on?: boolean) => boolean;
+    setOpacity: (name: string, opacity: number) => boolean;
+    remove: (name: string) => boolean;
+    getClampedTexture: (i: number, xyz: XYZ) => any;
+}

dist/src/layers/index.d.ts

@@ -0,0 +1,34 @@
+import Tile3dLayerer from './tile3d';
+import TileLayerer from './tile';
+import ClampedLayerer from './clamped';
+import VectorLayerer from './vector';
+interface Private {
+    layerers: {
+        tile3d: Tile3dLayerer;
+        tile: TileLayerer;
+        clamped: ClampedLayerer;
+        vector: VectorLayerer;
+    };
+}
+export default class Layers {
+    _: Private;
+    p: any;
+    baseStyle: any;
+    tile3d: any;
+    tile: any;
+    clamped: any;
+    vector: any;
+    all: any;
+    constructor(parent: any);
+    _reset(): void;
+    addLayer: (type: string, layerObj: any, callback?: Function, sI?: number) => void;
+    removeLayer: (name: string) => boolean;
+    toggleLayer: (name: string, on?: boolean) => boolean;
+    setLayerOpacity: (name: string, opacity: number) => boolean;
+    findHighestMaxZoom: () => number;
+    findLowestMinZoom: () => number;
+    private getFeatureStyleProp;
+    getLayerByName: (layerName: string) => any;
+    getFeatureStyle: (layer: any, feature: any, isStrokeless?: boolean) => any;
+}
+export {};

dist/src/layers/tile.d.ts

@@ -0,0 +1,8 @@
+export default class TileLayerer {
+    p: any;
+    constructor(parent: any);
+    add: (layerObj: any) => void;
+    toggle: (name: string, on?: boolean) => boolean;
+    setOpacity: (name: string, opacity: number) => boolean;
+    remove: (name: string) => boolean;
+}

dist/src/layers/tile3d.d.ts

@@ -0,0 +1,10 @@
+export default class Tile3dLayerer {
+    p: any;
+    constructor(parent: any);
+    add: (layerObj: any) => void;
+    toggle: (name: string, on?: boolean) => boolean;
+    setOpacity: (name: string, opacity: number) => boolean;
+    remove: (name: string) => boolean;
+    private generateTile3ds;
+    private localizeTile3ds;
+}

dist/src/layers/vector.d.ts

@@ -0,0 +1,11 @@
+export default class VectorLayerer {
+    p: any;
+    baseStyle: any;
+    constructor(parent: any);
+    add: (layerObj: any, callback?: Function) => void;
+    toggle: (name: string, on?: boolean) => boolean;
+    setOpacity: (name: string, opacity: number) => boolean;
+    remove: (name: string) => boolean;
+    private generateVectors;
+    private geomTo;
+}

dist/src/parsers/rgba.d.ts

@@ -0,0 +1,3 @@
+import '../secondary/PNG/zlib';
+import '../secondary/PNG/png';
+export default function RGBAParser(tilePath: string, layerObj?: any, xyz?: any, tileResolution?: number, numberOfVertices?: number): Promise<number[]>;

dist/src/secondary/OrbitControls.d.ts

@@ -0,0 +1,5 @@
+declare function OrbitControls(object: any, domElement: any): void;
+declare namespace OrbitControls {
+    var prototype: any;
+}
+export default OrbitControls;

dist/src/secondary/PointerLockControls.d.ts

@@ -0,0 +1 @@
+export default function PointerLockControls(camera: any): void;

dist/src/secondary/loadingScreen.d.ts

@@ -0,0 +1,7 @@
+import './loadingScreen.scss';
+export default class Controls {
+    p: any;
+    loadingContainer: HTMLElement;
+    constructor(parent: any);
+    end: (name: any) => void;
+}

dist/src/secondary/sprites.d.ts

@@ -0,0 +1,8 @@
+import { Sprite } from 'three';
+declare const Sprites: {
+    spriteMaterials: {};
+    makeMarkerSprite: (parameters: any, id: any, forceNewMaterial?: boolean) => Sprite;
+    makeMarkerMaterial: (parameters: any, id: any, forceNewMaterial?: boolean) => any;
+    makeTextSprite: (message: any, parameters: any) => Sprite;
+};
+export default Sprites;

dist/src/utils/index.d.ts

@@ -0,0 +1,22 @@
+import { XY, XYZ } from '../generalTypes';
+declare const Utils: {
+    getIn: (obj: any, keyArray: string[], notSetValue?: any) => any;
+    mod: (n: number, m: number) => number;
+    findHighestMaxZoom: (tileLayers: any) => number;
+    findLowestMinZoom: (tileLayers: any) => number;
+    isInExtent: (xyz: XYZ, bb: any, projection: any) => boolean;
+    clone: (obj: any) => any;
+    capitalizeFirstLetter: (string: string) => string;
+    getExtension: (string: string) => string;
+    getRadiansPerPixel: (zoom: number) => number;
+    lastTileContains: any[];
+    tileContains: (xyz: any, z: number, useLast?: boolean) => any;
+    tileIsContained(xyzContainer: any, xyzContained: any, useLast?: boolean): boolean;
+    arrayAverage(array: any, key: string): number;
+    hexToRGB(hex: string): any;
+    rotatePoint(pt: any, center: any, angle: any): XY;
+    rotateAroundArbAxis(object: any, axis: any, radians: any, noPremultiply?: boolean): void;
+    getParamString(params: any, baseUrl: string, isUppercase?: boolean): string;
+    isArray(object: any): boolean;
+};
+export default Utils;