@loaders.gl/tiles 3.4.0-alpha.4 → 3.4.0

package/src/tileset/tileset-3d.ts

@@ -3,58 +3,18 @@
 // This file is derived from the Cesium code base under Apache 2 license
 // See LICENSE.md and https://github.com/AnalyticalGraphicsInc/cesium/blob/master/LICENSE.md
 
-/*
-
-  The Tileset loading and rendering flow is as below,
-  A rendered (i.e. deck.gl `Tile3DLayer`) triggers `tileset.update()` after a `tileset` is loaded
-  `tileset` starts traversing the tile tree and update `requestTiles` (tiles of which content need
-  to be fetched) and `selectedTiles` (tiles ready for rendering under the current viewport).
-  `Tile3DLayer` will update rendering based on `selectedTiles`.
-  `Tile3DLayer` also listens to `onTileLoad` callback and trigger another round of `update and then traversal`
-  when new tiles are loaded.
-
-  As I3S tileset have stored `tileHeader` file (metadata) and tile content files (geometry, texture, ...) separately.
-  During each traversal, it issues `tilHeader` requests if that `tileHeader` is not yet fetched,
-  after the tile header is fulfilled, it will resume the traversal starting from the tile just fetched (not root).
-
-  Tile3DLayer
-       |
-   await load(tileset)
-       |
-   tileset.update()
-       |                async load tileHeader
-   tileset.traverse() -------------------------- Queued
-       |        resume traversal after fetched  |
-       |----------------------------------------|
-       |
-       |                     async load tile content
-  tilset.requestedTiles  ----------------------------- RequestScheduler
-                                                              |
-  tilset.selectedTiles (ready for rendering)                  |
-       |         Listen to                                    |
-    Tile3DLayer ----------- onTileLoad  ----------------------|
-       |                         |   notify new tile is available
-    updateLayers                 |
-                        tileset.update // trigger another round of update
-*/
-
 import {Matrix4, Vector3} from '@math.gl/core';
 import {Ellipsoid} from '@math.gl/geospatial';
 import {Stats} from '@probe.gl/stats';
-import {
-  RequestScheduler,
-  assert,
-  path,
-  LoaderWithParser,
-  LoaderOptions
-} from '@loaders.gl/loader-utils';
+import {RequestScheduler, path, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
 import {TilesetCache} from './tileset-cache';
 import {calculateTransformProps} from './helpers/transform-utils';
 import {FrameState, getFrameState, limitSelectedTiles} from './helpers/frame-state';
 import {getZoomFromBoundingVolume, getZoomFromExtent, getZoomFromFullExtent} from './helpers/zoom';
+
+import type {GeospatialViewport, Viewport} from '../types';
 import {Tile3D} from './tile-3d';
 import {TILESET_TYPE} from '../constants';
-import {GeospatialViewport, Viewport} from '../types';
 
 import {TilesetTraverser} from './tileset-traverser';
 
@@ -62,6 +22,27 @@ import {TilesetTraverser} from './tileset-traverser';
 import {Tileset3DTraverser} from './format-3d-tiles/tileset-3d-traverser';
 import {I3STilesetTraverser} from './format-i3s/i3s-tileset-traverser';
 
+export type TilesetJSON = any;
+
+/*
+export type TilesetJSON = {
+    loader;
+    // could be  3d tiles, i3s
+    type: 'I3S' | '3DTILES';
+    /** The url to the top level tileset JSON file. *
+    url: string;
+    basePath?: string;
+    // Geometric error when the tree is not rendered at all
+    lodMetricType: string;
+    lodMetricValue: number;
+    root: {
+      refine: string;
+      [key: string]: unknown;
+    },
+    [key: string]: unknown;
+};
+*/
+
 export type Tileset3DProps = {
   // loading
   throttleRequests?: boolean;
@@ -98,83 +79,63 @@ export type Tileset3DProps = {
 type Props = {
   description: string;
   ellipsoid: object;
+  /** A 4x4 transformation matrix this transforms the entire tileset. */
   modelMatrix: Matrix4;
+  /** Set to false to disable network request throttling */
   throttleRequests: boolean;
+  /** Number of simultaneous requsts, if throttleRequests is true */
+  maxRequests: number;
   maximumMemoryUsage: number;
+  /** Maximum number limit of tiles selected for show. 0 means no limit */
   maximumTilesSelected: number;
+  /** Delay time before the tileset traversal. It prevents traversal requests spam.*/
   debounceTime: number;
-  onTileLoad: (tile: Tile3D) => any;
-  onTileUnload: (tile: Tile3D) => any;
-  onTileError: (tile: Tile3D, message: string, url: string) => any;
+  /** Callback. Indicates this a tile's content was loaded */
+  onTileLoad: (tile: Tile3D) => void;
+  /** Callback. Indicates this a tile's content was unloaded (cache full) */
+  onTileUnload: (tile: Tile3D) => void;
+  /** Callback. Indicates this a tile's content failed to load */
+  onTileError: (tile: Tile3D, message: string, url: string) => void;
+  /** Callback. Allows post-process selectedTiles right after traversal. */
   onTraversalComplete: (selectedTiles: Tile3D[]) => Tile3D[];
+  /** The maximum screen space error used to drive level of detail refinement. */
   maximumScreenSpaceError: number;
-  viewportTraversersMap: any;
+  viewportTraversersMap: Record<string, any> | null;
   attributions: string[];
-  maxRequests: number;
   loadTiles: boolean;
   loadOptions: LoaderOptions;
   updateTransforms: boolean;
+  /** View distance scale modifier */
   viewDistanceScale: number;
   basePath: string;
+  /** Optional async tile content loader */
   contentLoader?: (tile: Tile3D) => Promise<void>;
-  i3s: {[key: string]: any};
+  /** @todo I3S specific knowledge should be moved to I3S module */
+  i3s: Record<string, any>;
 };
 
 const DEFAULT_PROPS: Props = {
   description: '',
-
   ellipsoid: Ellipsoid.WGS84,
-  // A 4x4 transformation matrix this transforms the entire tileset.
   modelMatrix: new Matrix4(),
-
-  // Set to false to disable network request throttling
   throttleRequests: true,
-
-  // Number of simultaneous requsts, if throttleRequests is true
   maxRequests: 64,
-
   maximumMemoryUsage: 32,
-  /** Maximum number limit of tiles selected for show. 0 means no limit */
   maximumTilesSelected: 0,
-  /** Delay time before the tileset traversal. It prevents traversal requests spam.*/
   debounceTime: 0,
-
-  /**
-   * Callback. Indicates this a tile's content was loaded
-   * @param tile {TileHeader}
-   */
   onTileLoad: () => {},
-  /**
-   * Callback. Indicates this a tile's content was unloaded
-   * @param tile {TileHeader}
-   */
   onTileUnload: () => {},
   onTileError: () => {},
-  /**
-   * Callback. Allows post-process selectedTiles right after traversal.
-   * @param selectedTiles {TileHeader[]}
-   * @returns TileHeader[] - output array of tiles to return to deck.gl
-   */
   onTraversalComplete: (selectedTiles: Tile3D[]) => selectedTiles,
-
-  // Optional async tile content loader
   contentLoader: undefined,
-
-  // View distance scale modifier
   viewDistanceScale: 1.0,
-
-  // The maximum screen space error used to drive level of detail refinement.
   maximumScreenSpaceError: 8,
-
   loadTiles: true,
   updateTransforms: true,
   viewportTraversersMap: null,
-
   loadOptions: {fetch: {}},
-
   attributions: [],
   basePath: '',
-
   i3s: {}
 };
 
@@ -190,13 +151,46 @@ const TILES_LOAD_FAILED = 'Failed Tile Loads';
 const POINTS_COUNT = 'Points/Vertices';
 const TILES_GPU_MEMORY = 'Tile Memory Use';
 
+/**
+ * The Tileset loading and rendering flow is as below,
+ * A rendered (i.e. deck.gl `Tile3DLayer`) triggers `tileset.update()` after a `tileset` is loaded
+ * `tileset` starts traversing the tile tree and update `requestTiles` (tiles of which content need
+ * to be fetched) and `selectedTiles` (tiles ready for rendering under the current viewport).
+ * `Tile3DLayer` will update rendering based on `selectedTiles`.
+ * `Tile3DLayer` also listens to `onTileLoad` callback and trigger another round of `update and then traversal`
+ * when new tiles are loaded.
+
+ * As I3S tileset have stored `tileHeader` file (metadata) and tile content files (geometry, texture, ...) separately.
+ * During each traversal, it issues `tilHeader` requests if that `tileHeader` is not yet fetched,
+ * after the tile header is fulfilled, it will resume the traversal starting from the tile just fetched (not root).
+
+ * Tile3DLayer
+ *      |
+ *  await load(tileset)
+ *      |
+ *  tileset.update()
+ *      |                async load tileHeader
+ *  tileset.traverse() -------------------------- Queued
+ *      |        resume traversal after fetched  |
+ *      |----------------------------------------|
+ *      |
+ *      |                     async load tile content
+ * tilset.requestedTiles  ----------------------------- RequestScheduler
+ *                                                             |
+ * tilset.selectedTiles (ready for rendering)                  |
+ *      |         Listen to                                    |
+ *   Tile3DLayer ----------- onTileLoad  ----------------------|
+ *      |                         |   notify new tile is available
+ *   updateLayers                 |
+ *                       tileset.update // trigger another round of update
+*/
 export class Tileset3D {
   // props: Tileset3DProps;
   options: Props;
-  loadOptions: {[key: string]: any};
+  loadOptions: LoaderOptions;
 
   type: string;
-  tileset: {[key: string]: any};
+  tileset: TilesetJSON;
   loader: LoaderWithParser;
   url: string;
   basePath: string;
@@ -205,60 +199,71 @@ export class Tileset3D {
   lodMetricType: string;
   lodMetricValue: number;
   refine: string;
-  root: Tile3D | null;
-  roots: {[key: string]: Tile3D};
-  asset: {[key: string]: any};
+  root: Tile3D | null = null;
+  roots: Record<string, Tile3D> = {};
+  /** @todo any->unknown */
+  asset: Record<string, any> = {};
 
-  description: string;
+  // Metadata for the entire tileset
+  description: string = '';
   properties: any;
-  extras: any;
-  attributions: any;
-  credits: any;
+
+  extras: any = null;
+  attributions: any = {};
+  credits: any = {};
 
   stats: Stats;
 
   /** flags that contain information about data types in nested tiles */
   contentFormats = {draco: false, meshopt: false, dds: false, ktx2: false};
 
-  traverseCounter: number;
-  geometricError: number;
-  selectedTiles: Tile3D[];
-  private updatePromise: Promise<number> | null = null;
-  tilesetInitializationPromise: Promise<void>;
+  // view props
+  cartographicCenter: Vector3 | null = null;
+  cartesianCenter: Vector3 | null = null;
+  zoom: number = 1;
+  boundingVolume: any = null;
 
-  cartographicCenter: Vector3 | null;
-  cartesianCenter: Vector3 | null;
-  zoom: number;
-  boundingVolume: any;
+  /** Updated based on the camera position and direction */
+  dynamicScreenSpaceErrorComputedDensity: number = 0.0;
 
   // METRICS
-  // The maximum amount of GPU memory (in MB) that may be used to cache tiles.
-  // Tiles not in view are unloaded to enforce private
-  // The total amount of GPU memory in bytes used by the tileset.
-  gpuMemoryUsageInBytes: any;
-  dynamicScreenSpaceErrorComputedDensity: any;
 
-  // TRAVERSAL
-  _traverser: TilesetTraverser;
-  private _cache: TilesetCache;
-  _requestScheduler: RequestScheduler;
+  /**
+   * The maximum amount of GPU memory (in MB) that may be used to cache tiles
+   * Tiles not in view are unloaded to enforce private
+   */
+  maximumMemoryUsage: number = 32;
 
-  _frameNumber: number;
-  private _queryParamsString: string;
-  private _queryParams: any;
-  private _extensionsUsed: any;
-  private _tiles: {[id: string]: Tile3D};
+  /** The total amount of GPU memory in bytes used by the tileset. */
+  gpuMemoryUsageInBytes: number = 0;
 
-  // counter for tracking tiles requests
-  private _pendingCount: any;
+  /** Update tracker. increase in each update cycle. */
+  _frameNumber: number = 0;
+  private _queryParams: Record<string, string> = {};
+  private _extensionsUsed: string[] = [];
+  private _tiles: Record<string, Tile3D> = {};
 
-  // HOLD TRAVERSAL RESULTS
-  private lastUpdatedVieports: Viewport[] | Viewport | null;
-  private _requestedTiles: any;
-  private _emptyTiles: any;
-  private frameStateData: any;
+  /** counter for tracking tiles requests */
+  private _pendingCount: number = 0;
 
-  maximumMemoryUsage: number;
+  /** Hold traversal results */
+  selectedTiles: Tile3D[] = [];
+
+  // TRAVERSAL
+  traverseCounter: number = 0;
+  geometricError: number = 0;
+  private lastUpdatedVieports: Viewport[] | Viewport | null = null;
+  private _requestedTiles: Tile3D[] = [];
+  private _emptyTiles: Tile3D[] = [];
+  private frameStateData: any = {};
+
+  _traverser: TilesetTraverser;
+  _cache = new TilesetCache();
+  _requestScheduler: RequestScheduler;
+
+  // Promise tracking
+  private updatePromise: Promise<number> | null = null;
+  tilesetInitializationPromise: Promise<void>;
 
   /**
    * Create a new Tileset3D
@@ -266,83 +271,40 @@ export class Tileset3D {
    * @param props
    */
   // eslint-disable-next-line max-statements
-  constructor(json: any, options?: Tileset3DProps) {
-    assert(json);
-
+  constructor(tileset: TilesetJSON, options?: Tileset3DProps) {
     // PUBLIC MEMBERS
     this.options = {...DEFAULT_PROPS, ...options};
     // raw data
-    this.tileset = json;
-    this.loader = json.loader;
+    this.tileset = tileset;
+    this.loader = tileset.loader;
     // could be  3d tiles, i3s
-    this.type = json.type;
+    this.type = tileset.type;
     // The url to a tileset JSON file.
-    this.url = json.url;
-    this.basePath = json.basePath || path.dirname(this.url);
+    this.url = tileset.url;
+    this.basePath = tileset.basePath || path.dirname(this.url);
     this.modelMatrix = this.options.modelMatrix;
     this.ellipsoid = this.options.ellipsoid;
 
     // Geometric error when the tree is not rendered at all
-    this.lodMetricType = json.lodMetricType;
-    this.lodMetricValue = json.lodMetricValue;
-    this.refine = json.root.refine;
+    this.lodMetricType = tileset.lodMetricType;
+    this.lodMetricValue = tileset.lodMetricValue;
+    this.refine = tileset.root.refine;
 
     this.loadOptions = this.options.loadOptions || {};
 
-    this.root = null;
-    this.roots = {};
-    // view props
-    this.cartographicCenter = null;
-    this.cartesianCenter = null;
-    this.zoom = 1;
-    this.boundingVolume = null;
-
     // TRAVERSAL
-    this.traverseCounter = 0;
-    this.geometricError = 0;
     this._traverser = this._initializeTraverser();
-    this._cache = new TilesetCache();
     this._requestScheduler = new RequestScheduler({
       throttleRequests: this.options.throttleRequests,
       maxRequests: this.options.maxRequests
     });
-    // update tracker
-    // increase in each update cycle
-    this._frameNumber = 0;
-
-    // counter for tracking tiles requests
-    this._pendingCount = 0;
-
-    // HOLD TRAVERSAL RESULTS
-    this._tiles = {};
-    this.selectedTiles = [];
-    this._emptyTiles = [];
-    this._requestedTiles = [];
-    this.frameStateData = {};
-    this.lastUpdatedVieports = null;
-
-    this._queryParams = {};
-    this._queryParamsString = '';
 
     // METRICS
-    // The maximum amount of GPU memory (in MB) that may be used to cache tiles.
-    // Tiles not in view are unloaded to enforce this.
-    this.maximumMemoryUsage = this.options.maximumMemoryUsage || 32;
     // The total amount of GPU memory in bytes used by the tileset.
-    this.gpuMemoryUsageInBytes = 0;
     this.stats = new Stats({id: this.url});
     this._initializeStats();
 
-    // EXTRACTED FROM TILESET
-    this._extensionsUsed = undefined;
-    this.dynamicScreenSpaceErrorComputedDensity = 0.0; // Updated based on the camera position and direction
-    // Metadata for the entire tileset
-    this.extras = null;
-    this.asset = {};
-    this.credits = {};
-    this.description = this.options.description || '';
-
-    this.tilesetInitializationPromise = this._initializeTileSet(json);
+    this.tilesetInitializationPromise = this._initializeTileSet(tileset);
   }
 
   /** Release resources */
@@ -365,10 +327,8 @@ export class Tileset3D {
   }
 
   get queryParams(): string {
-    if (!this._queryParamsString) {
-      this._queryParamsString = getQueryParamString(this._queryParams);
-    }
-    return this._queryParamsString;
+    const search = new URLSearchParams(this._queryParams).toString();
+    return search ? `?${search}` : '';
   }
 
   setProps(props: Tileset3DProps): void {
@@ -389,12 +349,12 @@ export class Tileset3D {
     if (isDataUrl) {
       return tilePath;
     }
-    return `${tilePath}${this.queryParams}`;
+    return `${tilePath}${tilePath.includes('?') ? '&' : '?'}${this.queryParams}`;
   }
 
   // TODO CESIUM specific
   hasExtension(extensionName: string): boolean {
-    return Boolean(this._extensionsUsed && this._extensionsUsed.indexOf(extensionName) > -1);
+    return Boolean(this._extensionsUsed.indexOf(extensionName) > -1);
   }
 
   /**
@@ -559,7 +519,7 @@ export class Tileset3D {
     this._updateStats();
   }
 
-  _tilesChanged(oldSelectedTiles, selectedTiles) {
+  _tilesChanged(oldSelectedTiles: Tile3D[], selectedTiles: Tile3D[]): boolean {
     if (oldSelectedTiles.length !== selectedTiles.length) {
       return true;
     }
@@ -570,7 +530,7 @@ export class Tileset3D {
     return changed;
   }
 
-  _loadTiles() {
+  _loadTiles(): void {
     // Sort requests by priority before making any requests.
     // This makes it less likely this requests will be cancelled after being issued.
     // requestedTiles.sort((a, b) => a._priority - b._priority);
@@ -582,12 +542,12 @@ export class Tileset3D {
     }
   }
 
-  _unloadTiles() {
+  _unloadTiles(): void {
     // unload tiles from cache when hit maximumMemoryUsage
     this._cache.unloadTiles(this, (tileset, tile) => tileset._unloadTile(tile));
   }
 
-  _updateStats() {
+  _updateStats(): void {
     let tilesRenderable = 0;
     let pointsRenderable = 0;
     for (const tile of this.selectedTiles) {
@@ -607,7 +567,7 @@ export class Tileset3D {
     this.stats.get(POINTS_COUNT).count = pointsRenderable;
   }
 
-  async _initializeTileSet(tilesetJson) {
+  async _initializeTileSet(tilesetJson: TilesetJSON): Promise<void> {
     if (this.type === TILESET_TYPE.I3S) {
       this.calculateViewPropsI3S();
       tilesetJson.root = await tilesetJson.root;
@@ -630,7 +590,7 @@ export class Tileset3D {
    * For I3S there is extent (<1.8 version) or fullExtent (>=1.8 version) to calculate view props
    * @returns
    */
-  private calculateViewPropsI3S() {
+  private calculateViewPropsI3S(): void {
     // for I3S 1.8 try to calculate with fullExtent
     const fullExtent = this.tileset.fullExtent;
     if (fullExtent) {
@@ -674,7 +634,6 @@ export class Tileset3D {
    */
   private calculateViewPropsTiles3D() {
     const root = this.root as Tile3D;
-    assert(root);
     const {center} = root.boundingVolume;
     // TODO - handle all cases
     if (!center) {
@@ -710,7 +669,7 @@ export class Tileset3D {
 
   // Installs the main tileset JSON file or a tileset JSON file referenced from a tile.
   // eslint-disable-next-line max-statements
-  _initializeTileHeaders(tilesetJson, parentTileHeader) {
+  _initializeTileHeaders(tilesetJson: TilesetJSON, parentTileHeader?: any) {
     // A tileset JSON file referenced from a tile may exist in a different directory than the root tileset.
     // Get the basePath relative to the external tileset.
     const rootTile = new Tile3D(this, tilesetJson.root, parentTileHeader); // resource
@@ -733,6 +692,17 @@ export class Tileset3D {
         const children = tile.header.children || [];
         for (const childHeader of children) {
           const childTile = new Tile3D(this, childHeader, tile);
+
+          // Special handling for Google
+          // A session key must be used for all tile requests
+          if (childTile.contentUrl?.includes('?session=')) {
+            const url = new URL(childTile.contentUrl);
+            const session = url.searchParams.get('session');
+            if (session) {
+              this._queryParams.session = session;
+            }
+          }
+
           tile.children.push(childTile);
           childTile.depth = tile.depth + 1;
           stack.push(childTile);
@@ -743,7 +713,7 @@ export class Tileset3D {
     return rootTile;
   }
 
-  _initializeTraverser() {
+  _initializeTraverser(): TilesetTraverser {
     let TraverserClass;
     const type = this.type;
     switch (type) {
@@ -763,24 +733,24 @@ export class Tileset3D {
     });
   }
 
-  _destroyTileHeaders(parentTile) {
+  _destroyTileHeaders(parentTile: Tile3D): void {
     this._destroySubtree(parentTile);
   }
 
-  async _loadTile(tile) {
+  async _loadTile(tile: Tile3D): Promise<void> {
     let loaded;
     try {
       this._onStartTileLoading();
       loaded = await tile.loadContent();
-    } catch (error) {
-      this._onTileLoadError(tile, error);
+    } catch (error: unknown) {
+      this._onTileLoadError(tile, error instanceof Error ? error : new Error('load failed'));
     } finally {
       this._onEndTileLoading();
       this._onTileLoad(tile, loaded);
     }
   }
 
-  _onTileLoadError(tile, error) {
+  _onTileLoadError(tile: Tile3D, error: Error): void {
     this.stats.get(TILES_LOAD_FAILED).incrementCount();
 
     const message = error.message || error.toString();
@@ -790,7 +760,7 @@ export class Tileset3D {
     this.options.onTileError(tile, message, url);
   }
 
-  _onTileLoad(tile, loaded) {
+  _onTileLoad(tile: Tile3D, loaded: boolean): void {
     if (!loaded) {
       return;
     }
@@ -854,7 +824,7 @@ export class Tileset3D {
     this.stats.get(TILES_LOADING).decrementCount();
   }
 
-  _addTileToCache(tile) {
+  _addTileToCache(tile: Tile3D) {
     this._cache.add(this, tile, (tileset) => tileset._updateCacheStats(tile));
   }
 
@@ -863,12 +833,12 @@ export class Tileset3D {
     this.stats.get(TILES_IN_MEMORY).incrementCount();
 
     // Good enough? Just use the raw binary ArrayBuffer's byte length.
-    this.gpuMemoryUsageInBytes += tile.content.byteLength || 0;
+    this.gpuMemoryUsageInBytes += tile.gpuMemoryUsageInBytes || 0;
     this.stats.get(TILES_GPU_MEMORY).count = this.gpuMemoryUsageInBytes;
   }
 
   _unloadTile(tile) {
-    this.gpuMemoryUsageInBytes -= (tile.content && tile.content.byteLength) || 0;
+    this.gpuMemoryUsageInBytes -= tile.gpuMemoryUsageInBytes || 0;
 
     this.stats.get(TILES_IN_MEMORY).decrementCount();
     this.stats.get(TILES_UNLOADED).incrementCount();
@@ -922,6 +892,12 @@ export class Tileset3D {
   }
 
   _initializeTiles3DTileset(tilesetJson) {
+    if (tilesetJson.queryString) {
+      const searchParams = new URLSearchParams(tilesetJson.queryString);
+      const queryParams = Object.fromEntries(searchParams.entries());
+      this._queryParams = {...this._queryParams, ...queryParams};
+    }
+
     this.asset = tilesetJson.asset;
     if (!this.asset) {
       throw new Error('Tileset must have an asset property.');
@@ -945,29 +921,15 @@ export class Tileset3D {
     // Gets the tileset's properties dictionary object, which contains metadata about per-feature properties.
     this.properties = tilesetJson.properties;
     this.geometricError = tilesetJson.geometricError;
-    this._extensionsUsed = tilesetJson.extensionsUsed;
+    this._extensionsUsed = tilesetJson.extensionsUsed || [];
     // Returns the extras property at the top of the tileset JSON (application specific metadata).
     this.extras = tilesetJson.extras;
   }
 
   _initializeI3STileset() {
+    // @ts-expect-error
     if (this.loadOptions.i3s && 'token' in this.loadOptions.i3s) {
-      this._queryParams.token = this.loadOptions.i3s.token;
+      this._queryParams.token = this.loadOptions.i3s.token as string;
     }
   }
 }
-
-function getQueryParamString(queryParams): string {
-  const queryParamStrings: string[] = [];
-  for (const key of Object.keys(queryParams)) {
-    queryParamStrings.push(`${key}=${queryParams[key]}`);
-  }
-  switch (queryParamStrings.length) {
-    case 0:
-      return '';
-    case 1:
-      return `?${queryParamStrings[0]}`;
-    default:
-      return `?${queryParamStrings.join('&')}`;
-  }
-}