@itwin/frontend-tiles 3.7.0-dev.6 → 3.7.0-dev.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@itwin/frontend-tiles",
-  "version": "3.7.0-dev.6",
+  "version": "3.7.0-dev.7",
   "description": "Experimental alternative technique for visualizing the contents of iModels",
   "main": "lib/cjs/frontend-tiles.js",
   "module": "lib/esm/frontend-tiles.js",
@@ -22,18 +22,18 @@
     "url": "http://www.bentley.com"
   },
   "peerDependencies": {
-    "@itwin/core-bentley": "3.7.0-dev.6",
-    "@itwin/core-common": "3.7.0-dev.6",
-    "@itwin/core-frontend": "3.7.0-dev.6",
-    "@itwin/core-geometry": "3.7.0-dev.6"
+    "@itwin/core-bentley": "3.7.0-dev.7",
+    "@itwin/core-common": "3.7.0-dev.7",
+    "@itwin/core-frontend": "3.7.0-dev.7",
+    "@itwin/core-geometry": "3.7.0-dev.7"
   },
   "devDependencies": {
-    "@itwin/build-tools": "3.7.0-dev.6",
-    "@itwin/core-bentley": "3.7.0-dev.6",
-    "@itwin/core-common": "3.7.0-dev.6",
-    "@itwin/core-frontend": "3.7.0-dev.6",
-    "@itwin/core-geometry": "3.7.0-dev.6",
-    "@itwin/eslint-plugin": "3.7.0-dev.6",
+    "@itwin/build-tools": "3.7.0-dev.7",
+    "@itwin/core-bentley": "3.7.0-dev.7",
+    "@itwin/core-common": "3.7.0-dev.7",
+    "@itwin/core-frontend": "3.7.0-dev.7",
+    "@itwin/core-geometry": "3.7.0-dev.7",
+    "@itwin/eslint-plugin": "3.7.0-dev.7",
     "@types/node": "18.11.5",
     "eslint": "^7.11.0",
     "rimraf": "^3.0.2",

package/src/BatchedSpatialTileTreeRefs.ts

@@ -4,11 +4,13 @@
 *--------------------------------------------------------------------------------------------*/
 
 import {
-  AttachToViewportArgs, IModelConnection, SpatialTileTreeReferences, SpatialViewState, TileTreeReference,
+  AttachToViewportArgs, IModelConnection, SpatialTileTreeReferences, SpatialViewState, TileTreeLoadStatus, TileTreeOwner, TileTreeReference,
 } from "@itwin/core-frontend";
 import { BatchedTileTreeReference } from "./BatchedTileTreeReference";
+import { ComputeSpatialTilesetBaseUrl, createFallbackSpatialTileTreeReferences } from "./FrontendTiles";
 
-class TreeRefs implements SpatialTileTreeReferences {
+// Obtains tiles pre-published by mesh export service.
+class BatchedSpatialTileTreeReferences implements SpatialTileTreeReferences {
   private readonly _treeRef: BatchedTileTreeReference;
 
   public constructor(treeRef: BatchedTileTreeReference) {
@@ -36,8 +38,121 @@ class TreeRefs implements SpatialTileTreeReferences {
   }
 }
 
+// A placeholder used by [[ProxySpatialTileTreeReferences]] until asynchronous loading completes.
+// It provides a TileTreeOwner that never loads a tile tree.
+// This ensures that [ViewState.areAllTileTreesLoaded]($frontend) will not return `true` while we are loading.
+class ProxyTileTreeReference extends TileTreeReference {
+  private readonly _treeOwner: TileTreeOwner;
+
+  public constructor(iModel: IModelConnection) {
+    super();
+    this._treeOwner = {
+      iModel,
+      tileTree: undefined,
+      loadStatus: TileTreeLoadStatus.NotLoaded,
+      load: () => undefined,
+      dispose: () => { },
+      loadTree: async () => Promise.resolve(undefined),
+    };
+  }
+
+  public override get treeOwner() {
+    return this._treeOwner;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  public override get _isLoadingComplete() {
+    return false;
+  }
+}
+
+// Serves as a placeholder while we asynchronously obtain the base URL for a pre-published tileset (or asynchronously determine
+// that no such tileset exists).
+class ProxySpatialTileTreeReferences implements SpatialTileTreeReferences {
+  // Once async loading completes, all methods will be forwarded to this implementation.
+  private _impl?: SpatialTileTreeReferences;
+  private readonly _proxyRef: ProxyTileTreeReference;
+  // Retained if attachToViewport is called while we are still loading; and reset if detachFromViewport is called while loading.
+  private _attachArgs?: AttachToViewportArgs;
+
+  public constructor(view: SpatialViewState, getBaseUrl: Promise<URL | undefined>) {
+    this._proxyRef = new ProxyTileTreeReference(view.iModel);
+    getBaseUrl.then((url: URL | undefined) => {
+      if (url) {
+        const ref = BatchedTileTreeReference.create(view, url);
+        this.setTreeRefs(new BatchedSpatialTileTreeReferences(ref));
+      } else {
+        this.setTreeRefs(createFallbackSpatialTileTreeReferences(view));
+      }
+    }).catch(() => {
+      this.setTreeRefs(createFallbackSpatialTileTreeReferences(view));
+    });
+  }
+
+  private setTreeRefs(refs: SpatialTileTreeReferences): void {
+    this._impl = refs;
+    if (this._attachArgs) {
+      this._impl.attachToViewport(this._attachArgs);
+      this._attachArgs.invalidateSymbologyOverrides();
+      this._attachArgs = undefined;
+    }
+  }
+
+  public update(): void {
+    this._impl?.update();
+  }
+
+  public attachToViewport(args: AttachToViewportArgs): void {
+    if (this._impl)
+      this._impl.attachToViewport(args);
+    else
+      this._attachArgs = args;
+  }
+
+  public detachFromViewport(): void {
+    if (this._impl)
+      this._impl.detachFromViewport();
+    else
+      this._attachArgs = undefined;
+  }
+
+  public setDeactivated(): void { }
+
+  public *[Symbol.iterator](): Iterator<TileTreeReference> {
+    if (this._impl)
+      return this._impl[Symbol.iterator]();
+
+    yield this._proxyRef;
+  }
+}
+
+const iModelToBaseUrl = new Map<IModelConnection, URL | null | Promise<URL | undefined>>();
+
 /** @internal */
-export function createBatchedSpatialTileTreeReferences(view: SpatialViewState, computeBaseUrl: (iModel: IModelConnection) => URL): SpatialTileTreeReferences {
-  const treeRef = BatchedTileTreeReference.create(view, computeBaseUrl(view.iModel));
-  return new TreeRefs(treeRef);
+export function createBatchedSpatialTileTreeReferences(view: SpatialViewState, computeBaseUrl: ComputeSpatialTilesetBaseUrl): SpatialTileTreeReferences {
+  const iModel = view.iModel;
+  let entry = iModelToBaseUrl.get(iModel);
+  if (undefined === entry) {
+    const promise = computeBaseUrl(iModel);
+    iModelToBaseUrl.set(iModel, entry = promise);
+    iModel.onClose.addOnce(() => iModelToBaseUrl.delete(iModel));
+    promise.then((url: URL | undefined) => {
+      if (iModelToBaseUrl.has(iModel))
+        iModelToBaseUrl.set(iModel, url ?? null);
+    }).catch(() => {
+      if (iModelToBaseUrl.has(iModel))
+        iModelToBaseUrl.set(iModel, null);
+    });
+  }
+
+  if (null === entry) {
+    // No tileset exists for this iModel - use default tile generation instead.
+    return createFallbackSpatialTileTreeReferences(view);
+  }
+
+  if (entry instanceof Promise)
+    return new ProxySpatialTileTreeReferences(view, entry);
+
+  const ref = BatchedTileTreeReference.create(view, entry);
+  return new BatchedSpatialTileTreeReferences(ref);
 }

package/src/FrontendTiles.ts

@@ -6,16 +6,25 @@
 import { IModelConnection, SpatialTileTreeReferences, SpatialViewState } from "@itwin/core-frontend";
 import { createBatchedSpatialTileTreeReferences } from "./BatchedSpatialTileTreeRefs";
 
+/** A function that can provide the base URL where a tileset representing all of the spatial models in a given iModel are stored.
+ * The tileset is expected to reside at "baseUrl/tileset.json" and to have been produced by the [mesh export service](https://developer.bentley.com/apis/mesh-export/).
+ * If no such tileset exists for the given iModel, return `undefined`.
+ * @see [[FrontendTilesOptions.computeSpatialTilesetBaseUrl]].
+ * @alpha
+ */
+export type ComputeSpatialTilesetBaseUrl = (iModel: IModelConnection) => Promise<URL | undefined>;
+
 /** Options supplied to [[initializeFrontendTiles]].
  * @alpha
  */
 export interface FrontendTilesOptions {
-  /** Given an iModel, provide the base URL where the tiles are stored representing all of the spatial models in the iModel.
-   * It is expected that baseUrl/tileset.json exists and contains a 3d tileset in which all relative URLs are relative to baseUrl.
-   */
-  computeSpatialTilesetBaseUrl: (iModel: IModelConnection) => URL;
+  /** Provide the base URL for the pre-published tileset for a given iModel. */
+  computeSpatialTilesetBaseUrl: ComputeSpatialTilesetBaseUrl;
 }
 
+/** @internal */
+export const createFallbackSpatialTileTreeReferences = SpatialTileTreeReferences.create;
+
 /** Initialize the frontend-tiles package to obtain tiles for spatial views.
  * @alpha
  */