style: fix unused variable lint errors.

src/main.ts

@@ -20,5 +20,5 @@
 import {setupDefaultViewer} from 'neuroglancer/ui/default_viewer_setup';
 
 window.addEventListener('DOMContentLoaded', () => {
-  const viewer = setupDefaultViewer();
+  setupDefaultViewer();
 });

src/neuroglancer/chunk_manager/generic_file_source.ts

@@ -19,7 +19,7 @@
  * Provides a simple way to request a file on the backend with priority integration.
  */
 
-import {Chunk, ChunkManager, ChunkSourceBase, RECOMPUTE_CHUNK_PRIORITIES_LAST} from 'neuroglancer/chunk_manager/backend';
+import {Chunk, ChunkManager, ChunkSourceBase} from 'neuroglancer/chunk_manager/backend';
 import {ChunkPriorityTier, ChunkState} from 'neuroglancer/chunk_manager/base';
 import {CANCELED, CancellationToken, makeCancelablePromise} from 'neuroglancer/util/cancellation';
 import {openHttpRequest, sendHttpRequest} from 'neuroglancer/util/http_request';

src/neuroglancer/datasource/brainmaps/api_frontend.ts

@@ -19,7 +19,7 @@
  * This implements the authentication API based on neuroglancer/util/google_auth2.
  */
 
-import {getToken, implementation, Token} from 'neuroglancer/datasource/brainmaps/api_implementation';
+import {getToken, implementation} from 'neuroglancer/datasource/brainmaps/api_implementation';
 import {StatusMessage} from 'neuroglancer/status';
 import {CancellationTokenSource} from 'neuroglancer/util/cancellation';
 import {authenticateGoogleOAuth2} from 'neuroglancer/util/google_oauth2';

src/neuroglancer/datasource/brainmaps/backend.ts

@@ -17,7 +17,7 @@
 import 'neuroglancer/datasource/brainmaps/api_backend';
 
 import {registerChunkSource} from 'neuroglancer/chunk_manager/backend';
-import {makeRequest, HttpCall, ChangeSpecPayload, ChangeStackAwarePayload, MeshFragmentPayload, SkeletonPayload, SubvolumePayload} from 'neuroglancer/datasource/brainmaps/api';
+import {makeRequest, HttpCall, ChangeStackAwarePayload, MeshFragmentPayload, SkeletonPayload, SubvolumePayload} from 'neuroglancer/datasource/brainmaps/api';
 import {ChangeSpec, MeshSourceParameters, SkeletonSourceParameters, VolumeChunkEncoding, VolumeSourceParameters} from 'neuroglancer/datasource/brainmaps/base';
 import {decodeJsonManifestChunk, decodeTriangleVertexPositionsAndIndices, FragmentChunk, ManifestChunk, ParameterizedMeshSource} from 'neuroglancer/mesh/backend';
 import {decodeSkeletonVertexPositionsAndIndices, ParameterizedSkeletonSource, SkeletonChunk} from 'neuroglancer/skeleton/backend';
@@ -29,7 +29,6 @@ import {CancellationToken} from 'neuroglancer/util/cancellation';
 import {Endianness} from 'neuroglancer/util/endian';
 import {vec3Key} from 'neuroglancer/util/geom';
 import {verifyObject, verifyObjectProperty, verifyStringArray} from 'neuroglancer/util/json';
-import {inflate} from 'pako';
 
 const CHUNK_DECODERS = new Map([
   [
@@ -59,12 +58,11 @@ function applyChangeStack(changeStack: ChangeSpec|undefined, payload: ChangeStac
 }
 
 @registerChunkSource(VolumeSourceParameters)
-class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeSourceParameters> {
+export class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeSourceParameters> {
   chunkDecoder = CHUNK_DECODERS.get(this.parameters.encoding)!;
 
   private applyEncodingParams(payload: SubvolumePayload) {
     let {encoding} = this.parameters;
-    const compression_suffix = `/image_format_options.gzip_compression_level=6`;
     switch (encoding) {
       case VolumeChunkEncoding.RAW:
         payload.subvolume_format = 'RAW';
@@ -148,7 +146,7 @@ function decodeFragmentChunk(chunk: FragmentChunk, response: ArrayBuffer) {
 }
 
 @registerChunkSource(MeshSourceParameters)
-class MeshSource extends ParameterizedMeshSource<MeshSourceParameters> {
+export class MeshSource extends ParameterizedMeshSource<MeshSourceParameters> {
   private manifestDecoder = this.parameters.changeSpec !== undefined ?
       decodeManifestChunkWithSupervoxelIds :
       decodeManifestChunk;

src/neuroglancer/datasource/dvid/backend.ts

@@ -20,10 +20,7 @@ import {ParameterizedVolumeChunkSource, VolumeChunk} from 'neuroglancer/slicevie
 import {ChunkDecoder} from 'neuroglancer/sliceview/backend_chunk_decoders';
 import {decodeCompressedSegmentationChunk} from 'neuroglancer/sliceview/backend_chunk_decoders/compressed_segmentation';
 import {decodeJpegChunk} from 'neuroglancer/sliceview/backend_chunk_decoders/jpeg';
-import {decodeRawChunk} from 'neuroglancer/sliceview/backend_chunk_decoders/raw';
-import {VolumeType} from 'neuroglancer/sliceview/volume/base';
 import {CancellationToken} from 'neuroglancer/util/cancellation';
-import {vec3} from 'neuroglancer/util/geom';
 import {openShardedHttpRequest, sendHttpRequest} from 'neuroglancer/util/http_request';
 import {RPC} from 'neuroglancer/worker_rpc';
 
@@ -32,7 +29,7 @@ const TILE_CHUNK_DECODERS = new Map<TileEncoding, ChunkDecoder>([
 ]);
 
 @registerChunkSource(VolumeChunkSourceParameters)
-class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
+export class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
   constructor(rpc: RPC, options: any) {
     super(rpc, options);
 
@@ -80,7 +77,7 @@ class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSource
 }
 
 @registerChunkSource(TileChunkSourceParameters)
-class TileChunkSource extends ParameterizedVolumeChunkSource<TileChunkSourceParameters> {
+export class TileChunkSource extends ParameterizedVolumeChunkSource<TileChunkSourceParameters> {
   chunkDecoder = TILE_CHUNK_DECODERS.get(this.parameters['encoding'])!;
 
   download(chunk: VolumeChunk, cancellationToken: CancellationToken) {

src/neuroglancer/datasource/dvid/base.ts

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {VolumeType} from 'neuroglancer/sliceview/volume/base';
 
 export enum VolumeChunkEncoding {
   JPEG,

src/neuroglancer/datasource/ndstore/backend.ts

@@ -30,7 +30,7 @@ chunkDecoders.set('jpeg', decodeJpegChunk);
 chunkDecoders.set('raw', decodeRawChunk);
 
 @registerChunkSource(VolumeChunkSourceParameters)
-class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
+export class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
   chunkDecoder = chunkDecoders.get(this.parameters.encoding)!;
 
   download(chunk: VolumeChunk, cancellationToken: CancellationToken) {

src/neuroglancer/datasource/ndstore/frontend.ts

@@ -21,10 +21,9 @@
 
 import {ChunkManager} from 'neuroglancer/chunk_manager/frontend';
 import {CompletionResult, registerDataSourceFactory} from 'neuroglancer/datasource/factory';
-import {VolumeChunkSourceParameters, NDSTORE_URL_PREFIX, LEGACY_URL_PREFIX} from 'neuroglancer/datasource/ndstore/base';
+import {VolumeChunkSourceParameters, NDSTORE_URL_PREFIX} from 'neuroglancer/datasource/ndstore/base';
 import {DataType, VolumeChunkSpecification, VolumeSourceOptions, VolumeType} from 'neuroglancer/sliceview/volume/base';
 import {defineParameterizedVolumeChunkSource, MultiscaleVolumeChunkSource as GenericMultiscaleVolumeChunkSource} from 'neuroglancer/sliceview/volume/frontend';
-import {CancellationToken} from 'neuroglancer/util/cancellation';
 import {applyCompletionOffset, getPrefixMatchesWithDescriptions} from 'neuroglancer/util/completion';
 import {mat4, vec3} from 'neuroglancer/util/geom';
 import {openShardedHttpRequest, sendHttpRequest} from 'neuroglancer/util/http_request';

src/neuroglancer/datasource/nifti/backend.ts

@@ -141,7 +141,7 @@ registerPromiseRPC(
     });
 
 @registerChunkSource(VolumeSourceParameters)
-class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeSourceParameters> {
+export class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeSourceParameters> {
   download(chunk: VolumeChunk, cancellationToken: CancellationToken) {
     chunk.chunkDataSize = this.spec.chunkDataSize;
     return getNiftiFileData(

src/neuroglancer/datasource/precomputed/backend.ts

@@ -32,7 +32,7 @@ chunkDecoders.set(VolumeChunkEncoding.JPEG, decodeJpegChunk);
 chunkDecoders.set(VolumeChunkEncoding.COMPRESSED_SEGMENTATION, decodeCompressedSegmentationChunk);
 
 @registerChunkSource(VolumeChunkSourceParameters)
-class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
+export class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
   chunkDecoder = chunkDecoders.get(this.parameters.encoding)!;
 
   download(chunk: VolumeChunk, cancellationToken: CancellationToken) {
@@ -65,7 +65,7 @@ export function decodeFragmentChunk(chunk: FragmentChunk, response: ArrayBuffer)
 }
 
 @registerChunkSource(MeshSourceParameters)
-class MeshSource extends ParameterizedMeshSource<MeshSourceParameters> {
+export class MeshSource extends ParameterizedMeshSource<MeshSourceParameters> {
   download(chunk: ManifestChunk, cancellationToken: CancellationToken) {
     let {parameters} = this;
     let requestPath = `${parameters.path}/${chunk.objectId}:${parameters.lod}`;

src/neuroglancer/datasource/precomputed/frontend.ts

@@ -77,8 +77,7 @@ export class MultiscaleVolumeChunkSource implements GenericMultiscaleVolumeChunk
   }
 
   constructor(
-      public chunkManager: ChunkManager, public baseUrls: string[], public path: string,
-      private obj: any) {
+      public chunkManager: ChunkManager, public baseUrls: string[], public path: string, obj: any) {
     verifyObject(obj);
     this.dataType = verifyObjectProperty(obj, 'data_type', x => verifyEnumString(x, DataType));
     this.numChannels = verifyObjectProperty(obj, 'num_channels', verifyPositiveInt);

src/neuroglancer/datasource/python/backend.ts

@@ -35,7 +35,7 @@ chunkDecoders.set(VolumeChunkEncoding.JPEG, decodeJpegChunk);
 chunkDecoders.set(VolumeChunkEncoding.RAW, decodeRawChunk);
 
 @registerChunkSource(VolumeChunkSourceParameters)
-class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
+export class VolumeChunkSource extends ParameterizedVolumeChunkSource<VolumeChunkSourceParameters> {
   chunkDecoder = chunkDecoders.get(this.parameters['encoding'])!;
   encoding = VolumeChunkEncoding[this.parameters.encoding].toLowerCase();
 

src/neuroglancer/datasource/render/backend.ts

@@ -24,13 +24,13 @@ import {CancellationToken} from 'neuroglancer/util/cancellation';
 import {Float32ArrayBuilder} from 'neuroglancer/util/float32array_builder';
 import {vec3} from 'neuroglancer/util/geom';
 import {openShardedHttpRequest, sendHttpJsonPostRequest, sendHttpRequest} from 'neuroglancer/util/http_request';
-import {parseArray, verify3dVec, verifyFloat, verifyInt, verifyObject, verifyString} from 'neuroglancer/util/json';
+import {parseArray, verify3dVec, verifyObject, verifyString} from 'neuroglancer/util/json';
 
 let chunkDecoders = new Map<string, ChunkDecoder>();
 chunkDecoders.set('jpg', decodeJpegChunk);
 
 @registerChunkSource(TileChunkSourceParameters)
-class TileChunkSource extends ParameterizedVolumeChunkSource<TileChunkSourceParameters> {
+export class TileChunkSource extends ParameterizedVolumeChunkSource<TileChunkSourceParameters> {
   chunkDecoder = chunkDecoders.get(this.parameters.encoding)!;
 
   download(chunk: VolumeChunk, cancellationToken: CancellationToken) {
@@ -73,16 +73,6 @@ function decodeSectionIDs(response: any) {
   return sectionIDs;
 }
 
-function parseCoordinateTransform(coordsResult: any): vec3[] {
-  let coords = new Array<vec3>();
-
-  parseArray(coordsResult, coordsObj => {
-    verifyObject(coordsObj);
-    coords.push(verify3dVec(coordsObj['world']));
-  });
-  return coords;
-}
-
 function createConversionObject(tileId: string, xcoord: any, ycoord: any) {
   return {'tileId': tileId, 'local': [xcoord, ycoord]};
 }
@@ -160,7 +150,7 @@ function downloadPointMatchChunk(
 }
 
 @registerChunkSource(PointMatchChunkSourceParameters)
-class PointMatchSource extends
+export class PointMatchSource extends
     ParameterizedVectorGraphicsChunkSource<PointMatchChunkSourceParameters> {
   download(chunk: VectorGraphicsChunk, cancellationToken: CancellationToken): Promise<void> {
     let {parameters} = this;

src/neuroglancer/datasource/render/frontend.ts

@@ -23,10 +23,10 @@ import {ChunkManager} from 'neuroglancer/chunk_manager/frontend';
 import {CompletionResult, registerDataSourceFactory} from 'neuroglancer/datasource/factory';
 import {PointMatchChunkSourceParameters, TileChunkSourceParameters} from 'neuroglancer/datasource/render/base';
 import {VectorGraphicsChunkSpecification, VectorGraphicsSourceOptions} from 'neuroglancer/sliceview/vector_graphics/base';
-import {defineParameterizedVectorGraphicsSource, MultiscaleVectorGraphicsChunkSource as GenericMultiscaleVectorGraphicsChunkSource, VectorGraphicsChunkSource} from 'neuroglancer/sliceview/vector_graphics/frontend';
+import {defineParameterizedVectorGraphicsSource, MultiscaleVectorGraphicsChunkSource as GenericMultiscaleVectorGraphicsChunkSource} from 'neuroglancer/sliceview/vector_graphics/frontend';
 import {DataType, VolumeChunkSpecification, VolumeSourceOptions, VolumeType} from 'neuroglancer/sliceview/volume/base';
 import {defineParameterizedVolumeChunkSource, MultiscaleVolumeChunkSource as GenericMultiscaleVolumeChunkSource, VolumeChunkSource} from 'neuroglancer/sliceview/volume/frontend';
-import {applyCompletionOffset, getPrefixMatches, getPrefixMatchesWithDescriptions} from 'neuroglancer/util/completion';
+import {applyCompletionOffset, getPrefixMatchesWithDescriptions} from 'neuroglancer/util/completion';
 import {vec3} from 'neuroglancer/util/geom';
 import {openShardedHttpRequest, sendHttpRequest} from 'neuroglancer/util/http_request';
 import {parseArray, parseQueryStringParameters, verifyFloat, verifyInt, verifyObject, verifyObjectProperty, verifyOptionalInt, verifyOptionalString, verifyString} from 'neuroglancer/util/json';
@@ -449,8 +449,6 @@ export class MultiscaleVectorGraphicsChunkSource implements GenericMultiscaleVec
     this.dims[2] = 1;
   }
   getSources(vectorGraphicsSourceOptions: VectorGraphicsSourceOptions) {
-    let sources: VectorGraphicsChunkSource[][] = [];
-
     let voxelSize = vec3.clone(this.stackInfo.voxelResolution);
 
     let lowerVoxelBound = vec3.create(), upperVoxelBound = vec3.create();

src/neuroglancer/layer.ts

@@ -523,7 +523,7 @@ export class VisibleRenderLayerTracker<RenderLayerType extends VisibilityTracked
   }
 
   private updateVisibleLayers() {
-    let {visibleLayers, newVisibleLayers, renderLayerType, layerAdded, layerRemoved} = this;
+    let {visibleLayers, newVisibleLayers, renderLayerType, layerAdded} = this;
     for (let renderLayer of this.layerManager.readyRenderLayers()) {
       if (renderLayer instanceof renderLayerType) {
         let typedLayer = <RenderLayerType>renderLayer;

src/neuroglancer/layer_dialog.ts

@@ -18,8 +18,7 @@ import {findSourceGroup, getVolume, suggestLayerName, volumeCompleter} from 'neu
 import {LayerListSpecification, ManagedUserLayerWithSpecification} from 'neuroglancer/layer_specification';
 import {Overlay} from 'neuroglancer/overlay';
 import {DataType, VolumeType} from 'neuroglancer/sliceview/volume/base';
-import {MultiscaleVolumeChunkSource} from 'neuroglancer/sliceview/volume/frontend';
-import {CancellationToken, CANCELED, CancellationTokenSource} from 'neuroglancer/util/cancellation';
+import {CancellationToken, CancellationTokenSource} from 'neuroglancer/util/cancellation';
 import {associateLabelWithElement} from 'neuroglancer/widget/associate_label';
 import {AutocompleteTextInput, makeCompletionElementWithDescription} from 'neuroglancer/widget/autocomplete';
 import {makeHiddenSubmitButton} from 'neuroglancer/widget/hidden_submit_button';

src/neuroglancer/mesh/backend.ts

@@ -279,7 +279,7 @@ export class FragmentSource extends ChunkSource {
 };
 
 @registerSharedObject(MESH_LAYER_RPC_ID)
-class MeshLayer extends SegmentationLayerSharedObjectCounterpart {
+export class MeshLayer extends SegmentationLayerSharedObjectCounterpart {
   source: MeshSource;
 
   constructor(rpc: RPC, options: any) {

src/neuroglancer/single_mesh/backend.ts

@@ -227,7 +227,7 @@ export class SingleMeshSource extends ChunkSource {
 }
 
 @registerSharedObject(SINGLE_MESH_LAYER_RPC_ID)
-class SingleMeshLayer extends SharedObjectCounterpart {
+export class SingleMeshLayer extends SharedObjectCounterpart {
   source: SingleMeshSource;
   chunkManager: ChunkManager;
 

src/neuroglancer/single_mesh/frontend.ts

@@ -23,7 +23,7 @@ import {shareVisibility} from 'neuroglancer/shared_visibility_count/frontend';
 import {GET_SINGLE_MESH_INFO_RPC_ID, SINGLE_MESH_CHUNK_KEY, SINGLE_MESH_LAYER_RPC_ID, SINGLE_MESH_SOURCE_RPC_ID, SingleMeshInfo, SingleMeshSourceParameters, VertexAttributeInfo} from 'neuroglancer/single_mesh/base';
 import {TrackableValue} from 'neuroglancer/trackable_value';
 import {DataType} from 'neuroglancer/util/data_type';
-import {mat4, vec2, vec3, vec4} from 'neuroglancer/util/geom';
+import {mat4, vec2, vec3} from 'neuroglancer/util/geom';
 import {parseArray, stableStringify, verifyOptionalString, verifyString} from 'neuroglancer/util/json';
 import {getObjectId} from 'neuroglancer/util/object_id';
 import {Uint64} from 'neuroglancer/util/uint64';
@@ -210,7 +210,7 @@ vLightingFactor = abs(dot(normal, uLightDirection.xyz)) + uLightDirection.w;
     };
     bindTexture(data.vertexTexture);
     bindTexture(data.normalTexture);
-    let {attributeInfo, attributeNames} = this;
+    const {attributeNames} = this;
     data.vertexAttributeTextures.forEach((texture, i) => {
       if (attributeNames[i] !== undefined) {
         bindTexture(texture);
@@ -449,7 +449,7 @@ export class SingleMeshLayer extends PerspectiveViewRenderLayer {
       return;
     }
 
-    let {gl, displayState} = this;
+    let {gl} = this;
     let shaderManager = this.shaderManager!;
     shader.bind();
     shaderManager.beginLayer(gl, shader, renderContext);

src/neuroglancer/skeleton/backend.ts

@@ -56,7 +56,6 @@ export class SkeletonChunk extends Chunk {
     super.serialize(msg, transfers);
     const vertexPositions = this.vertexPositions!;
     const indices = this.indices!;
-    let vertexDataBytes = vertexPositions.byteLength;
     msg['indices'] = indices;
     transfers.push(indices.buffer);
 

src/neuroglancer/skeleton/frontend.ts

@@ -264,8 +264,6 @@ export class SkeletonLayer extends RefCounted {
 
     let {pickIDs} = renderContext;
 
-    const {vertexAttributes} = this;
-
     gl.lineWidth(lineWidth);
 
     forEachSegmentToDraw(displayState, skeletons, (rootObjectId, objectId, skeleton) => {

src/neuroglancer/sliceview/backend.ts

@@ -16,7 +16,7 @@
 
 import {Chunk, ChunkManager, ChunkSource} from 'neuroglancer/chunk_manager/backend';
 import {ChunkPriorityTier} from 'neuroglancer/chunk_manager/base';
-import {RenderLayer as RenderLayerInterface, SLICEVIEW_RENDERLAYER_RPC_ID, SLICEVIEW_RPC_ID, SliceViewBase, SliceViewChunkSource as SliceViewChunkSourceInterface, SliceViewChunkSpecification} from 'neuroglancer/sliceview/base';
+import {RenderLayer as RenderLayerInterface, SLICEVIEW_RPC_ID, SliceViewBase, SliceViewChunkSource as SliceViewChunkSourceInterface, SliceViewChunkSpecification} from 'neuroglancer/sliceview/base';
 import {ChunkLayout} from 'neuroglancer/sliceview/chunk_layout';
 import {vec3, vec3Key} from 'neuroglancer/util/geom';
 import {NullarySignal} from 'neuroglancer/util/signal';

src/neuroglancer/sliceview/base.ts

@@ -14,13 +14,11 @@
  * limitations under the License.
  */
 
-import {ChunkManager} from 'neuroglancer/chunk_manager/frontend';
-import {MeshSource} from 'neuroglancer/mesh/frontend';
 import {ChunkLayout} from 'neuroglancer/sliceview/chunk_layout';
 import {partitionArray} from 'neuroglancer/util/array';
 import {approxEqual} from 'neuroglancer/util/compare';
 import {DATA_TYPE_BYTES, DataType} from 'neuroglancer/util/data_type';
-import {effectiveScalingFactorFromMat4, identityMat4, kAxes, kInfinityVec, kZeroVec, mat4, prod3, rectifyTransformMatrixIfAxisAligned, transformVectorByMat4, vec3, vec4} from 'neuroglancer/util/geom';
+import {effectiveScalingFactorFromMat4, identityMat4, kAxes, kInfinityVec, kZeroVec, mat4, rectifyTransformMatrixIfAxisAligned, transformVectorByMat4, vec3} from 'neuroglancer/util/geom';
 import {SharedObject} from 'neuroglancer/worker_rpc';
 
 export {DATA_TYPE_BYTES, DataType};