diff --git a/types/amap-js-api-map3d/amap-js-api-map3d-tests.ts b/types/amap-js-api-map3d/amap-js-api-map3d-tests.ts new file mode 100644 index 0000000000..ec89b74476 --- /dev/null +++ b/types/amap-js-api-map3d/amap-js-api-map3d-tests.ts @@ -0,0 +1,489 @@ +/** + * preset.ts + */ + +declare const map: AMap.Map; +declare const lnglat: AMap.LngLat; +declare const size: AMap.Size; +declare const lnglatTuple: [number, number]; +declare const pixel: AMap.Pixel; +declare const layer: AMap.Layer; +declare const ambientLight: AMap.Lights.AmbientLight; +declare const directionLight: AMap.Lights.DirectionLight; +declare const line: AMap.Object3D.Line; +declare const mesh: AMap.Object3D.Mesh; +declare const object3d: AMap.Object3D; +declare const geometry: AMap.Geometry3D.Mesh; + +/** + * lights.ts + */ + +// $ExpectType AmbientLight +const testAmbientLight = new AMap.Lights.AmbientLight([0.1, 0, 0.1], 1); + +// $ExpectType void +testAmbientLight.setColor([0.1, 1, 0.5]); + +// $ExpectType void +testAmbientLight.setIntensity(1); + +// $ExpectType DirectionLight +const testDirectionLight = new AMap.Lights.DirectionLight([1, 2, 3], [1, 2, 3], 1); + +// $ExpectType void +testDirectionLight.setColor([1, 2, 3]); + +// $ExpectType void +testDirectionLight.setIntensity(1); + +// $ExpectType void +testDirectionLight.setDirection([1, 2, 3]); + +/** + * map3d.ts + */ + +// $ExpectType Object3DResult | null +map.getObject3DByContainerPos(pixel); + +// $ExpectType Object3DResult | null +const containserPos = map.getObject3DByContainerPos(pixel, [layer], true); +if (containserPos) { + // $ExpectType number + containserPos.index; + // $ExpectType Vector3 + containserPos.point; + // $ExpectType number + containserPos.distance; + // $ExpectType Object3D + containserPos.object; +} else { + // $ExpectType null + containserPos; +} + +map.AmbientLight = ambientLight; +map.AmbientLight = undefined; + +map.DirectionLight = directionLight; +map.DirectionLight = undefined; + +/** + * object3d-group.ts + */ + +// $ExpectType Object3DGroup +const testObject3dGroup1 = new AMap.Object3DGroup(); +// $ExpectType Object3DGroup +const testObject3dGroup2 = new AMap.Object3DGroup(); + +// $ExpectType Object3D[] +testObject3dGroup1.children; +// $ExpectType Mesh[] +testObject3dGroup2.children; + +// $ExoectType void +testObject3dGroup1.add(line); +// $ExoectType void +testObject3dGroup1.add(mesh); +// $ExoectType void +testObject3dGroup2.add(mesh); +// $ExpectError +testObject3dGroup2.add(line); + +// $ExoectType void +testObject3dGroup1.remove(line); +// $ExoectType void +testObject3dGroup1.remove(mesh); +// $ExoectType void +testObject3dGroup2.remove(mesh); +// $ExpectError +testObject3dGroup2.remove(line); + +/** + * object3d-Layer.ts + */ + +// $ExpectType Object3DLayer +new AMap.Object3DLayer(); +// $ExpectType Object3DLayer +new AMap.Object3DLayer({}); +// $ExpectType Object3DLayer +const testObject3DLayer = new AMap.Object3DLayer({ + map, + visible: true, + opacity: 0.1, + zIndex: 2, + zooms: [1, 2] +}); + +// $ExpectType void +testObject3DLayer.setMap(null); +// $ExpectType void +testObject3DLayer.setMap(map); + +// $ExpectType Map | null | undefined +testObject3DLayer.getMap(); + +// $ExpectType void +testObject3DLayer.hide(); + +// $ExpectType void +testObject3DLayer.show(); + +// $ExpectType void +testObject3DLayer.setOpacity(1); + +// $ExpectType number +testObject3DLayer.getOpacity(); + +// $ExpectType void +testObject3DLayer.setzIndex(1); + +// $ExpectType number +testObject3DLayer.getzIndex(); + +// $ExpectType [number, number] +testObject3DLayer.getZooms(); + +// $ExpectType void +testObject3DLayer.add(object3d); + +// $ExpectType void +testObject3DLayer.remove(object3d); + +// $ExpectType void +testObject3DLayer.clear(); + +// $ExpectType void +testObject3DLayer.reDraw(); + +/** + * vector3.ts + */ + +// $ExpectType Vector3 +const testVector = new AMap.Vector3([1, 2, 3]); +// $ExpectType Vector3 +new AMap.Vector3(testVector); + +// $ExpectType [number, number, number] +testVector.elements; + +// $ExpectType void +testVector.set(1, 2, 3); + +// $ExpectType number +testVector.dot(); + +// $ExpectType Vector3 +testVector.clone(); + +// $ExpectType Vector3 +testVector.add(testVector); +// $ExpectType Vector3 +testVector.add([1, 2, 3]); + +// $ExpectType Vector3 +testVector.sub(testVector); +// $ExpectType Vector3 +testVector.sub([1, 2, 3]); + +// $ExpectType Vector3 +testVector.addVectors(testVector, testVector); + +// $ExpectType Vector3 +testVector.subVectors(testVector, testVector); + +// $ExpectType Vector3 +testVector.crossVectors(testVector, testVector); + +// $ExpectType Vector3 +testVector.normalize(); + +// $ExpectType number +testVector.length(); + +/** + * object3d/mesh.ts + */ + +// $ExpectType Mesh +const testMesh = new AMap.Object3D.Mesh(); + +// $ExpectError +testMesh.geometry = geometry; + +// $ExpectType number[] +testMesh.geometry.vertices; +// $ExpectError +testMesh.geometry.vertices = []; +testMesh.geometry.vertices.shift(); + +// $ExpectType number[] +testMesh.geometry.vertexColors; +// $ExpectError +testMesh.geometry.vertexColors = []; +testMesh.geometry.vertexColors.shift(); + +// $ExpectType number[] +testMesh.geometry.vertexUVs; +// $ExpectError +testMesh.geometry.vertexUVs = []; +testMesh.geometry.vertexUVs.shift(); + +// $ExpectType number[] +testMesh.geometry.faces; +// $ExpectError +testMesh.geometry.faces = []; +testMesh.geometry.faces.shift(); + +// $ExpectType number[] +testMesh.geometry.textureIndices; +// $ExpectError +testMesh.geometry.textureIndices = []; +testMesh.geometry.textureIndices.shift(); + +// $ExpectType (string | HTMLCanvasElement)[] +testMesh.textures; + +// $ExpectType boolean +testMesh.needUpdate; + +// $ExpectType boolean +testMesh.transparent; + +// $ExpectType boolean +testMesh.DEPTH_TEST; + +// $ExpectType void +testMesh.reDraw(); + +/** + * object3d/meshAcceptLights.ts + */ + +// $ExpectType MeshAcceptLights +const testMeshAcceptLights = new AMap.Object3D.MeshAcceptLights(); + +// $ExpectError +testMeshAcceptLights.geometry = geometry; + +// $ExpectType number[] +testMeshAcceptLights.geometry.vertices; +// $ExpectError +testMeshAcceptLights.geometry.vertices = []; +testMeshAcceptLights.geometry.vertices.shift(); + +// $ExpectType number[] +testMeshAcceptLights.geometry.vertexColors; +// $ExpectError +testMeshAcceptLights.geometry.vertexColors = []; +testMeshAcceptLights.geometry.vertexColors.shift(); + +// $ExpectType number[] +testMeshAcceptLights.geometry.vertexUVs; +// $ExpectError +testMeshAcceptLights.geometry.vertexUVs = []; +testMeshAcceptLights.geometry.vertexUVs.shift(); + +// $ExpectType number[] +testMeshAcceptLights.geometry.faces; +// $ExpectError +testMeshAcceptLights.geometry.faces = []; +testMeshAcceptLights.geometry.faces.shift(); + +// $ExpectType number[] +testMeshAcceptLights.geometry.textureIndices; +// $ExpectError +testMeshAcceptLights.geometry.textureIndices = []; +testMeshAcceptLights.geometry.textureIndices.shift(); + +// $ExpectType number[] +testMeshAcceptLights.geometry.vertexNormals; +// $ExpectError +testMeshAcceptLights.geometry.vertexNormals = []; +testMeshAcceptLights.geometry.vertexNormals.shift(); + +// $ExpectType (string | HTMLCanvasElement)[] +testMeshAcceptLights.textures; + +// $ExpectType boolean +testMeshAcceptLights.needUpdate; + +// $ExpectType boolean +testMeshAcceptLights.transparent; + +// $ExpectType boolean +testMeshAcceptLights.DEPTH_TEST; + +// $ExpectType void +testMeshAcceptLights.reDraw(); + +/** + * object3d/meshLine.ts + */ + +// $ExpectError +new AMap.Object3D.MeshLine(); +// $ExpectError +new AMap.Object3D.MeshLine({}); +// $ExpectType MeshLine +const testMeshLine = new AMap.Object3D.MeshLine({ + path: [lnglat], + width: 1, + height: 1, + color: 'red' +}); +// $ExpectType MeshLine +new AMap.Object3D.MeshLine({ + path: [lnglat], + color: [0, 0, 1, 1] +}); +// $ExpectType MeshLine +new AMap.Object3D.MeshLine({ + path: [[1, 2]] +}); +// $ExpectType MeshLine +new AMap.Object3D.MeshLine({ + path: [lnglat], + unit: 'meter' +}); +// $ExpectType MeshLine +new AMap.Object3D.MeshLine({ + path: [pixel], + unit: 'px' +}); +// $ExpectError +new AMap.Object3D.MeshLine({ + path: [lnglat], + unit: 'px' +}); +// $ExpectError +new AMap.Object3D.MeshLine({ + path: [pixel], + unit: 'meter' +}); + +// $ExpectType number[] +testMeshLine.geometry.vertices; +// $ExpectError +testMeshLine.geometry.vertices = []; +testMeshLine.geometry.vertices.shift(); + +// $ExpectType number[] +testMeshLine.geometry.vertexUVs; +// $ExpectError +testMeshLine.geometry.vertexUVs = []; +testMeshLine.geometry.vertexUVs.shift(); + +// $ExpectType number[] +testMeshLine.geometry.vertexColors; +// $ExpectError +testMeshLine.geometry.vertexColors = []; +testMeshLine.geometry.vertexColors.shift(); + +// $ExpectType number[] +testMeshLine.geometry.vertexColors; +// $ExpectError +testMeshLine.geometry.vertexColors = []; +testMeshLine.geometry.vertexColors.shift(); + +// $ExpectType number[] +testMeshLine.geometry.vertexIndices; +// $ExpectError +testMeshLine.geometry.vertexIndices = []; +testMeshLine.geometry.vertexIndices.shift(); + +// $ExpectType number[] +testMeshLine.geometry.directions; +// $ExpectError +testMeshLine.geometry.directions = []; +testMeshLine.geometry.directions.shift(); + +// $ExpectType number[] +testMeshLine.geometry.textureIndices; +// $ExpectError +testMeshLine.geometry.textureIndices = []; +testMeshLine.geometry.textureIndices.shift(); + +// $ExpectType number +testMeshLine.width; + +// $ExpectType void +testMeshLine.setPath([lnglat]); +// $ExpectType void +testMeshLine.setPath([lnglatTuple]); +// $ExpectType void +testMeshLine.setPath([pixel]); + +// $ExpectType void +testMeshLine.setWidth(10); + +// $ExpectType void +testMeshLine.setHeight(10); + +// $ExpectType void +testMeshLine.setColor('red'); + +/** + * object3d/prism.ts + */ + +// $ExpectError +new AMap.Object3D.Prism(); +// $ExpectError +new AMap.Object3D.Prism({}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [lnglat], + color: 'red' +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [lnglat], + color: 'red', + height: 1, + color2: 'blue' +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [pixel], + color: 'red' +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [lnglat], + color: 'red' +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [[lnglat]], + color: 'red' +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [[pixel]], + color: 'red' +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [[lnglatTuple]], + color: 'red' +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [lnglat], + color: ['red'] +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [lnglat], + color: [1, 1, 1, 1] +}); +// $ExpectType Prism +new AMap.Object3D.Prism({ + path: [lnglat], + color: [[1, 1, 1, 1]] +}); diff --git a/types/amap-js-api-map3d/geometry-3d.d.ts b/types/amap-js-api-map3d/geometry-3d.d.ts new file mode 100644 index 0000000000..edb4fd2a85 --- /dev/null +++ b/types/amap-js-api-map3d/geometry-3d.d.ts @@ -0,0 +1,28 @@ +declare namespace AMap { + abstract class Geometry3D { + readonly vertices: number[]; + readonly vertexUVs: number[]; + readonly vertexColors: number[]; + } + + namespace Geometry3D { + class Mesh extends Geometry3D { + readonly type: 'mesh'; + readonly faces: number[]; + readonly textureIndices: number[]; + } + + class Line extends Geometry3D { + readonly type: 'line'; + readonly segments: number[]; + readonly textureIndices: number[]; + } + + class Points extends Geometry3D { + readonly type: 'points'; + readonly pointSizes: number[]; + readonly pointAreas: number[]; + readonly textureIndices: number[]; + } + } +} diff --git a/types/amap-js-api-map3d/index.d.ts b/types/amap-js-api-map3d/index.d.ts new file mode 100644 index 0000000000..43be45eb13 --- /dev/null +++ b/types/amap-js-api-map3d/index.d.ts @@ -0,0 +1,15 @@ +// Type definitions for non-npm package amap-js-api-map3d 1.4 +// Project: https://lbs.amap.com/api/javascript-api/reference/maps-3d +// Definitions by: breeze9527 +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped +// TypeScript Version: 2.8 + +/// + +/// +/// +/// +/// +/// +/// +/// diff --git a/types/amap-js-api-map3d/lights.d.ts b/types/amap-js-api-map3d/lights.d.ts new file mode 100644 index 0000000000..b637ee79ef --- /dev/null +++ b/types/amap-js-api-map3d/lights.d.ts @@ -0,0 +1,17 @@ +declare namespace AMap { + namespace Lights { + class AmbientLight { + constructor(color: [number, number, number], intensity: number); + setColor(color: [number, number, number]): void; + setIntensity(intensity: number): void; + } + + class DirectionLight { + constructor(direction: [number, number, number], color: [number, number, number], intensity: number); + update(): void; + setDirection(direction: [number, number, number]): void; + setColor(direction: [number, number, number]): void; + setIntensity(intensity: number): void; + } + } +} diff --git a/types/amap-js-api-map3d/map3d.d.ts b/types/amap-js-api-map3d/map3d.d.ts new file mode 100644 index 0000000000..f2345f1a30 --- /dev/null +++ b/types/amap-js-api-map3d/map3d.d.ts @@ -0,0 +1,15 @@ +declare namespace AMap { + namespace Map { + interface Object3DResult { + index: number; + point: Vector3; + distance: number; + object: Object3D; + } + } + interface Map { + AmbientLight?: Lights.AmbientLight; + DirectionLight?: Lights.DirectionLight; + getObject3DByContainerPos(pixel: Pixel, layers?: Layer[], all?: boolean): Map.Object3DResult | null; + } +} diff --git a/types/amap-js-api-map3d/object3d-group.d.ts b/types/amap-js-api-map3d/object3d-group.d.ts new file mode 100644 index 0000000000..4c1f4d90d3 --- /dev/null +++ b/types/amap-js-api-map3d/object3d-group.d.ts @@ -0,0 +1,8 @@ +declare namespace AMap { + class Object3DGroup extends Object3D { + constructor(); + children: C[]; + add(object3d: C): void; + remove(object3d: C): void; + } +} diff --git a/types/amap-js-api-map3d/object3d-layer.d.ts b/types/amap-js-api-map3d/object3d-layer.d.ts new file mode 100644 index 0000000000..de29a0bfd9 --- /dev/null +++ b/types/amap-js-api-map3d/object3d-layer.d.ts @@ -0,0 +1,27 @@ +declare namespace AMap { + namespace Object3DLayer { + interface Options { + map?: Map; + visible?: boolean; + opacity?: number; + zIndex?: number; + zooms?: [number, number]; + } + } + + class Object3DLayer extends Layer { + constructor(options?: Object3DLayer.Options) + add(object3d: Object3D): void; + remove(object3d: Object3D): void; + clear(): void; + reDraw(): void; + + // internal + setOption(options: { + position?: number; + scale?: number; + height?: number; + scene?: number; + }): void; + } +} diff --git a/types/amap-js-api-map3d/object3d.d.ts b/types/amap-js-api-map3d/object3d.d.ts new file mode 100644 index 0000000000..32f63e2378 --- /dev/null +++ b/types/amap-js-api-map3d/object3d.d.ts @@ -0,0 +1,92 @@ +declare namespace AMap { + class Object3D { + readonly geometry: Geometry3D; + transparent: boolean; + DEPTH_TEST: boolean; + textures: Array; + needUpdate: boolean; + reDraw(): void; + + // internal + reset(): void; + } + + namespace Object3D { + class Mesh extends Object3D { + readonly geometry: Geometry3D.Mesh; + } + + class MeshAcceptLights extends Mesh { + readonly geometry: Geometry3D.Mesh & { readonly vertexNormals: number[] }; + } + + namespace Prism { + interface Options { + path: LngLat[] | Pixel[] | Array>; + color: string | number[] | Array; + height?: number; + color2?: string | number[] | Array; + } + } + class Prism extends MeshAcceptLights { + constructor(options: Prism.Options); + } + + // tslint:disable-next-line + class Wall extends Prism { } + + class Line extends Object3D { + readonly geometry: Geometry3D.Line; + } + + namespace ThinLine { + interface Options { + path: Array<[number, number]>; + color: string; + altitude?: number; + dashArray?: number[]; + } + } + class ThinLine extends Line { + constructor(options: ThinLine.Options); + } + + class Points extends Object3D { + readonly geometry: Geometry3D.Points; + borderColor: string; + borderWeight: number; + } + + class RoundPoints extends Points { + merge: boolean; + } + + namespace MeshLine { + type Options = { + width?: number; + height?: number | number[]; + color?: string | number[]; + } & ({ + unit?: 'meter'; + path: Array<[number, number]> | LngLat[]; + } | { + unit: 'px'; + path: Array<[number, number]> | Pixel[]; + }); + } + // inherit from WideLine + class MeshLine extends Object3D { + constructor(options: MeshLine.Options); + readonly geometry: Geometry3D & { + readonly vertexIndices: number[]; + readonly directions: number[]; + readonly textureIndices: number[]; + }; + width: number; + setPath(path: LngLat[] | Pixel[] | Array<[number, number]>): void; + setWidth(width: number): void; + setHeight(height: number | number[]): void; + setColor(color: string): void; + } + } +} diff --git a/types/amap-js-api-map3d/tsconfig.json b/types/amap-js-api-map3d/tsconfig.json new file mode 100644 index 0000000000..e28735d963 --- /dev/null +++ b/types/amap-js-api-map3d/tsconfig.json @@ -0,0 +1,31 @@ +{ + "compilerOptions": { + "module": "commonjs", + "lib": [ + "es6", + "dom" + ], + "noEmit": true, + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "strictFunctionTypes": true, + "baseUrl": "../", + "typeRoots": [ + "../" + ], + "types": [], + "forceConsistentCasingInFileNames": true + }, + "files": [ + "geometry-3d.d.ts", + "index.d.ts", + "lights.d.ts", + "map3d.d.ts", + "object3d-group.d.ts", + "object3d-layer.d.ts", + "object3d.d.ts", + "vector3.d.ts", + "amap-js-api-map3d-tests.ts" + ] +} diff --git a/types/amap-js-api-map3d/tslint.json b/types/amap-js-api-map3d/tslint.json new file mode 100644 index 0000000000..f93cf8562a --- /dev/null +++ b/types/amap-js-api-map3d/tslint.json @@ -0,0 +1,3 @@ +{ + "extends": "dtslint/dt.json" +} diff --git a/types/amap-js-api-map3d/vector3.d.ts b/types/amap-js-api-map3d/vector3.d.ts new file mode 100644 index 0000000000..1cb02fe9b0 --- /dev/null +++ b/types/amap-js-api-map3d/vector3.d.ts @@ -0,0 +1,16 @@ +declare namespace AMap { + class Vector3 { + readonly elements: [number, number, number]; + constructor(elements: [number, number, number] | Vector3); + set(x: number, y: number, z: number): void; + dot(): number; + clone(): Vector3; + add(elements: [number, number, number] | Vector3): this; + sub(elements: [number, number, number] | Vector3): this; + addVectors(a: Vector3, b: Vector3): this; + subVectors(a: Vector3, b: Vector3): this; + crossVectors(a: Vector3, b: Vector3): this; + normalize(): this; + length(): number; + } +}