@loaders.gl/3d-tiles 4.0.0-alpha.6 → 4.0.0-alpha.7

package/dist/tiles-3d-loader.d.ts

@@ -1,4 +1,18 @@
-import type { LoaderWithParser } from '@loaders.gl/loader-utils';
+import type { LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
+import type { DracoLoaderOptions } from '@loaders.gl/draco';
+import type { ImageLoaderOptions } from '@loaders.gl/images';
+export type Tiles3DLoaderOptions = LoaderOptions & DracoLoaderOptions & ImageLoaderOptions & {
+    '3d-tiles'?: {
+        /** Whether to parse any embedded glTF binaries (or extract memory for independent glTF parsing) */
+        loadGLTF?: boolean;
+        /** If renderer doesn't support quantized positions, loader can decode them on CPU */
+        decodeQuantizedPositions?: boolean;
+        /** Whether this is a tileset or a tile */
+        isTileset?: boolean | 'auto';
+        /** Controls which axis is "up" in glTF files */
+        assetGltfUpAxis?: 'x' | 'y' | 'z' | null;
+    };
+};
 /**
  * Loader for 3D Tiles
  */

package/dist/tiles-3d-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tiles-3d-loader.d.ts","sourceRoot":"","sources":["../src/tiles-3d-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAO/D;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,gBAiB3B,CAAC"}
+{"version":3,"file":"tiles-3d-loader.d.ts","sourceRoot":"","sources":["../src/tiles-3d-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAgB,MAAM,0BAA0B,CAAC;AAE7F,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAC1D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAQ3D,MAAM,MAAM,oBAAoB,GAAG,aAAa,GAE9C,kBAAkB,GAClB,kBAAkB,GAAG;IACnB,UAAU,CAAC,EAAE;QACX,mGAAmG;QACnG,QAAQ,CAAC,EAAE,OAAO,CAAC;QACnB,qFAAqF;QACrF,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,0CAA0C;QAC1C,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;QAC7B,gDAAgD;QAChD,eAAe,CAAC,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,CAAC;KAC1C,CAAC;CACH,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,gBAiB3B,CAAC"}

package/dist/tiles-3d-loader.js

@@ -27,47 +27,49 @@ exports.Tiles3DLoader = {
         }
     }
 };
-function getBaseUri(tileset) {
-    return loader_utils_1.path.dirname(tileset.url);
-}
-async function parseTile(arrayBuffer, options, context) {
-    const tile = {
-        content: {
-            featureIds: null
-        }
-    };
-    const byteOffset = 0;
-    await (0, parse_3d_tile_1.parse3DTile)(arrayBuffer, byteOffset, options, context, tile.content);
-    return tile.content;
+/** Parses a tileset or tile */
+async function parse(data, options = {}, context) {
+    // auto detect file type
+    const loaderOptions = options['3d-tiles'] || {};
+    let isTileset;
+    if (loaderOptions.isTileset === 'auto') {
+        isTileset = context?.url && context.url.indexOf('.json') !== -1;
+    }
+    else {
+        isTileset = loaderOptions.isTileset;
+    }
+    return (await isTileset)
+        ? parseTileset(data, options, context)
+        : parseTile(data, options, context);
 }
+/** Parse a tileset */
 async function parseTileset(data, options, context) {
     const tilesetJson = JSON.parse(new TextDecoder().decode(data));
     // eslint-disable-next-line no-use-before-define
-    tilesetJson.loader = options.loader || exports.Tiles3DLoader;
-    tilesetJson.url = context.url;
+    tilesetJson.loader = options?.loader || exports.Tiles3DLoader;
+    tilesetJson.url = context?.url || '';
+    tilesetJson.queryString = context?.queryString || '';
     // base path that non-absolute paths in tileset are relative to.
     tilesetJson.basePath = getBaseUri(tilesetJson);
-    tilesetJson.root = await (0, parse_3d_tile_header_1.normalizeTileHeaders)(tilesetJson, options);
+    // TODO - check option types in normalizeTileHeaders
+    tilesetJson.root = await (0, parse_3d_tile_header_1.normalizeTileHeaders)(tilesetJson, options || {});
     tilesetJson.type = tiles_1.TILESET_TYPE.TILES3D;
     tilesetJson.lodMetricType = tiles_1.LOD_METRIC_TYPE.GEOMETRIC_ERROR;
     tilesetJson.lodMetricValue = tilesetJson.root?.lodMetricValue || 0;
     return tilesetJson;
 }
-async function parse(data, options, context) {
-    // auto detect file type
-    const loaderOptions = options['3d-tiles'] || {};
-    let isTileset;
-    if (loaderOptions.isTileset === 'auto') {
-        isTileset = context.url && context.url.indexOf('.json') !== -1;
-    }
-    else {
-        isTileset = loaderOptions.isTileset;
-    }
-    if (isTileset) {
-        data = await parseTileset(data, options, context);
-    }
-    else {
-        data = await parseTile(data, options, context);
-    }
-    return data;
+/** Parse a tile */
+async function parseTile(arrayBuffer, options, context) {
+    const tile = {
+        content: {
+            featureIds: null
+        }
+    };
+    const byteOffset = 0;
+    await (0, parse_3d_tile_1.parse3DTile)(arrayBuffer, byteOffset, options, context, tile.content);
+    return tile.content;
+}
+/** Get base name */
+function getBaseUri(tileset) {
+    return loader_utils_1.path.dirname(tileset.url);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/3d-tiles",
-  "version": "4.0.0-alpha.6",
+  "version": "4.0.0-alpha.7",
   "description": "3D Tiles, an open standard for streaming massive heterogeneous 3D geospatial datasets.",
   "license": "MIT",
   "publishConfig": {
@@ -34,17 +34,17 @@
     "build-bundle": "esbuild src/bundle.ts --bundle --outfile=dist/dist.min.js"
   },
   "dependencies": {
-    "@loaders.gl/draco": "4.0.0-alpha.6",
-    "@loaders.gl/gltf": "4.0.0-alpha.6",
-    "@loaders.gl/loader-utils": "4.0.0-alpha.6",
-    "@loaders.gl/math": "4.0.0-alpha.6",
-    "@loaders.gl/tiles": "4.0.0-alpha.6",
+    "@loaders.gl/draco": "4.0.0-alpha.7",
+    "@loaders.gl/gltf": "4.0.0-alpha.7",
+    "@loaders.gl/loader-utils": "4.0.0-alpha.7",
+    "@loaders.gl/math": "4.0.0-alpha.7",
+    "@loaders.gl/tiles": "4.0.0-alpha.7",
     "@math.gl/core": "^3.5.1",
     "@math.gl/geospatial": "^3.5.1",
     "long": "^5.2.1"
   },
   "peerDependencies": {
-    "@loaders.gl/core": "4.0.0-alpha.5"
+    "@loaders.gl/core": "4.0.0-alpha.6"
   },
-  "gitHead": "acc1985050dfaa0f1f0c066f8da5bce7454a046c"
+  "gitHead": "afb59c4d8e5d8ebb9c28f111cb0c96c5527d0ffd"
 }

package/src/lib/parsers/helpers/parse-3d-tile-gltf-view.ts

@@ -7,7 +7,7 @@
 // - Do we add an option to control this?
 // - Also, should we have hard dependency on gltf module or use injection or auto-discovery for gltf parser?
 
-import {GLTFLoader} from '@loaders.gl/gltf';
+import {GLTFLoader, postProcessGLTF, _getMemoryUsageGLTF} from '@loaders.gl/gltf';
 import {sliceArrayBuffer} from '@loaders.gl/loader-utils';
 
 export const GLTF_FORMAT = {
@@ -66,7 +66,9 @@ export async function extractGLTF(tile, gltfFormat, options, context) {
     }
     if (tile.gltfArrayBuffer) {
       // TODO - Should handle byteOffset... However, not used now...
-      tile.gltf = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      const gltfWithBuffers = await parse(tile.gltfArrayBuffer, GLTFLoader, options, context);
+      tile.gltf = postProcessGLTF(gltfWithBuffers);
+      tile.gpuMemoryUsageInBytes = _getMemoryUsageGLTF(tile.gltf);
       delete tile.gltfArrayBuffer;
       delete tile.gltfByteOffset;
       delete tile.gltfByteLength;

package/src/lib/parsers/helpers/parse-3d-tile-subtree.ts

@@ -75,7 +75,7 @@ export default async function parse3DTilesSubtree(
 /**
  * Get url for bitstream downloading
  * @param bitstreamRelativeUri
- * @param baseUri
+ * @param basePath
  * @returns
  */
 function resolveBufferUri(bitstreamRelativeUri: string, basePath: string): string {

package/src/lib/parsers/parse-3d-tile-composite.ts

@@ -4,17 +4,28 @@
 // Reference code:
 // https://github.com/AnalyticalGraphicsInc/cesium/blob/master/Source/Scene/Composite3DTileContent.js#L182
 
+import type {LoaderContext} from '@loaders.gl/loader-utils';
+import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
 import {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';
 
+/** Resolve circulate dependency by passing in parsing function as argument */
+type Parse3DTile = (
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext,
+  subtile
+) => Promise<number>;
+
 // eslint-disable-next-line max-params
 export async function parseComposite3DTile(
   tile,
-  arrayBuffer,
-  byteOffset,
-  options,
-  context,
-  parse3DTile
-) {
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext,
+  parse3DTile: Parse3DTile
+): Promise<number> {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
 
   const view = new DataView(arrayBuffer);

package/src/lib/parsers/parse-3d-tile-gltf.ts

@@ -1,6 +1,13 @@
-import {GLTFLoader} from '@loaders.gl/gltf';
+import type {LoaderContext} from '@loaders.gl/loader-utils';
+import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+import {_getMemoryUsageGLTF, GLTFLoader, postProcessGLTF} from '@loaders.gl/gltf';
 
-export async function parseGltf3DTile(tile, arrayBuffer, options, context) {
+export async function parseGltf3DTile(
+  tile,
+  arrayBuffer: ArrayBuffer,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext
+): Promise<void> {
   // Set flags
   // glTF models need to be rotated from Y to Z up
   // https://github.com/AnalyticalGraphicsInc/3d-tiles/tree/master/specification#y-up-to-z-up
@@ -12,5 +19,7 @@ export async function parseGltf3DTile(tile, arrayBuffer, options, context) {
       : 'Y';
 
   const {parse} = context;
-  tile.gltf = await parse(arrayBuffer, GLTFLoader, options, context);
+  const gltfWithBuffers = await parse(arrayBuffer, GLTFLoader, options, context);
+  tile.gltf = postProcessGLTF(gltfWithBuffers);
+  tile.gpuMemoryUsageInBytes = _getMemoryUsageGLTF(tile.gltf);
 }

package/src/lib/parsers/parse-3d-tile-header.ts

@@ -1,3 +1,4 @@
+import type {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
 import type {LoaderOptions} from '@loaders.gl/loader-utils';
 import {Tile3DSubtreeLoader} from '../../tile-3d-subtree-loader';
 import {load} from '@loaders.gl/core';
@@ -13,7 +14,7 @@ function getTileType(tile) {
     return TILE_TYPE.EMPTY;
   }
 
-  const contentUrl = tile.contentUrl;
+  const contentUrl = tile.contentUrl.split('?')[0]; // Discard query string
   const fileExtension = contentUrl.split('.').pop();
   switch (fileExtension) {
     case 'pnts':
@@ -128,7 +129,7 @@ export async function normalizeImplicitTileHeaders(
   tile: Tile3D,
   tileset: Tileset3D,
   implicitTilingExtension: ImplicitTilingExtension,
-  options: LoaderOptions
+  options: Tiles3DLoaderOptions
 ) {
   const basePath = tileset.basePath;
   const {

package/src/lib/parsers/parse-3d-tile-instanced-model.ts

@@ -10,14 +10,28 @@ import Tile3DBatchTable from '../classes/tile-3d-batch-table';
 import {parse3DTileHeaderSync} from './helpers/parse-3d-tile-header';
 import {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/parse-3d-tile-tables';
 import {parse3DTileGLTFViewSync, extractGLTF} from './helpers/parse-3d-tile-gltf-view';
-
-export async function parseInstancedModel3DTile(tile, arrayBuffer, byteOffset, options, context) {
+import {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+import {LoaderContext} from '@loaders.gl/loader-utils';
+
+export async function parseInstancedModel3DTile(
+  tile,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext
+): Promise<number> {
   byteOffset = parseInstancedModel(tile, arrayBuffer, byteOffset, options, context);
   await extractGLTF(tile, tile.gltfFormat, options, context);
   return byteOffset;
 }
 
-function parseInstancedModel(tile, arrayBuffer, byteOffset, options, context) {
+function parseInstancedModel(
+  tile,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext
+): number {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
   if (tile.version !== 1) {
     throw new Error(`Instanced 3D Model version ${tile.version} is not supported`);

package/src/lib/parsers/parse-3d-tile-point-cloud.ts

@@ -12,8 +12,16 @@ import {parse3DTileTablesHeaderSync, parse3DTileTablesSync} from './helpers/pars
 import {normalize3DTileColorAttribute} from './helpers/normalize-3d-tile-colors';
 import {normalize3DTileNormalAttribute} from './helpers/normalize-3d-tile-normals';
 import {normalize3DTilePositionAttribute} from './helpers/normalize-3d-tile-positions';
-
-export async function parsePointCloud3DTile(tile, arrayBuffer, byteOffset, options, context) {
+import {Tiles3DLoaderOptions} from '../../tiles-3d-loader';
+import {LoaderContext} from '@loaders.gl/loader-utils';
+
+export async function parsePointCloud3DTile(
+  tile,
+  arrayBuffer: ArrayBuffer,
+  byteOffset: number,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext
+): Promise<number> {
   byteOffset = parse3DTileHeaderSync(tile, arrayBuffer, byteOffset);
   byteOffset = parse3DTileTablesHeaderSync(tile, arrayBuffer, byteOffset);
   byteOffset = parse3DTileTablesSync(tile, arrayBuffer, byteOffset, options);
@@ -24,13 +32,14 @@ export async function parsePointCloud3DTile(tile, arrayBuffer, byteOffset, optio
   await parseDraco(tile, featureTable, batchTable, options, context);
 
   parsePositions(tile, featureTable, options);
+  // @ts-expect-error TODO - do we need to assert on the batch table?
   parseColors(tile, featureTable, batchTable);
   parseNormals(tile, featureTable);
 
   return byteOffset;
 }
 
-function initializeTile(tile) {
+function initializeTile(tile): void {
   // Initialize point cloud tile defaults
   tile.attributes = {
     positions: null,
@@ -44,7 +53,10 @@ function initializeTile(tile) {
   tile.isOctEncoded16P = false;
 }
 
-function parsePointCloudTables(tile) {
+function parsePointCloudTables(tile): {
+  featureTable: Tile3DFeatureTable;
+  batchTable: Tile3DBatchTable | null;
+} {
   const featureTable = new Tile3DFeatureTable(tile.featureTableJson, tile.featureTableBinary);
 
   const pointsLength = featureTable.getGlobalProperty('POINTS_LENGTH');
@@ -64,7 +76,11 @@ function parsePointCloudTables(tile) {
   return {featureTable, batchTable};
 }
 
-function parsePositions(tile, featureTable, options) {
+function parsePositions(
+  tile,
+  featureTable: Tile3DFeatureTable,
+  options: Tiles3DLoaderOptions
+): void {
   if (!tile.attributes.positions) {
     if (featureTable.hasProperty('POSITION')) {
       tile.attributes.positions = featureTable.getPropertyArray('POSITION', GL.FLOAT, 3);
@@ -101,7 +117,7 @@ function parsePositions(tile, featureTable, options) {
   }
 }
 
-function parseColors(tile, featureTable, batchTable) {
+function parseColors(tile, featureTable: Tile3DFeatureTable, batchTable: Tile3DBatchTable): void {
   if (!tile.attributes.colors) {
     let colors = null;
     if (featureTable.hasProperty('RGBA')) {
@@ -122,7 +138,7 @@ function parseColors(tile, featureTable, batchTable) {
   }
 }
 
-function parseNormals(tile, featureTable) {
+function parseNormals(tile, featureTable: Tile3DFeatureTable): void {
   if (!tile.attributes.normals) {
     let normals = null;
     if (featureTable.hasProperty('NORMAL')) {
@@ -136,7 +152,7 @@ function parseNormals(tile, featureTable) {
   }
 }
 
-function parseBatchIds(tile, featureTable) {
+function parseBatchIds(tile, featureTable: Tile3DFeatureTable): Tile3DBatchTable | null {
   let batchTable: Tile3DBatchTable | null = null;
   if (!tile.batchIds && featureTable.hasProperty('BATCH_ID')) {
     tile.batchIds = featureTable.getPropertyArray('BATCH_ID', GL.UNSIGNED_SHORT, 1);
@@ -154,7 +170,13 @@ function parseBatchIds(tile, featureTable) {
 }
 
 // eslint-disable-next-line complexity
-async function parseDraco(tile, featureTable, batchTable, options, context) {
+async function parseDraco(
+  tile,
+  featureTable: Tile3DFeatureTable,
+  batchTable,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext
+) {
   let dracoBuffer;
   let dracoFeatureTableProperties;
   let dracoBatchTableProperties;
@@ -202,7 +224,12 @@ async function parseDraco(tile, featureTable, batchTable, options, context) {
 }
 
 // eslint-disable-next-line complexity, max-statements
-export async function loadDraco(tile, dracoData, options, context) {
+export async function loadDraco(
+  tile,
+  dracoData,
+  options: Tiles3DLoaderOptions,
+  context: LoaderContext
+) {
   const {parse} = context;
   const dracoOptions = {
     ...options,

package/src/tiles-3d-loader.ts

@@ -1,10 +1,30 @@
-import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {LoaderWithParser, LoaderOptions, LoaderContext} from '@loaders.gl/loader-utils';
+// / import type { GLTFLoaderOptions } from '@loaders.gl/gltf';
+import type {DracoLoaderOptions} from '@loaders.gl/draco';
+import type {ImageLoaderOptions} from '@loaders.gl/images';
+
 import {path} from '@loaders.gl/loader-utils';
 import {TILESET_TYPE, LOD_METRIC_TYPE} from '@loaders.gl/tiles';
 import {VERSION} from './lib/utils/version';
 import {parse3DTile} from './lib/parsers/parse-3d-tile';
 import {normalizeTileHeaders} from './lib/parsers/parse-3d-tile-header';
 
+export type Tiles3DLoaderOptions = LoaderOptions &
+  // GLTFLoaderOptions & - TODO not yet exported
+  DracoLoaderOptions &
+  ImageLoaderOptions & {
+    '3d-tiles'?: {
+      /** Whether to parse any embedded glTF binaries (or extract memory for independent glTF parsing) */
+      loadGLTF?: boolean;
+      /** If renderer doesn't support quantized positions, loader can decode them on CPU */
+      decodeQuantizedPositions?: boolean;
+      /** Whether this is a tileset or a tile */
+      isTileset?: boolean | 'auto';
+      /** Controls which axis is "up" in glTF files */
+      assetGltfUpAxis?: 'x' | 'y' | 'z' | null;
+    };
+  };
+
 /**
  * Loader for 3D Tiles
  */
@@ -27,29 +47,39 @@ export const Tiles3DLoader: LoaderWithParser = {
   }
 };
 
-function getBaseUri(tileset) {
-  return path.dirname(tileset.url);
-}
+/** Parses a tileset or tile */
+async function parse(data, options: Tiles3DLoaderOptions = {}, context?: LoaderContext) {
+  // auto detect file type
+  const loaderOptions = options['3d-tiles'] || {};
+  let isTileset;
+  if (loaderOptions.isTileset === 'auto') {
+    isTileset = context?.url && context.url.indexOf('.json') !== -1;
+  } else {
+    isTileset = loaderOptions.isTileset;
+  }
 
-async function parseTile(arrayBuffer, options, context) {
-  const tile = {
-    content: {
-      featureIds: null
-    }
-  };
-  const byteOffset = 0;
-  await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);
-  return tile.content;
+  return (await isTileset)
+    ? parseTileset(data, options, context)
+    : parseTile(data, options, context);
 }
 
-async function parseTileset(data, options, context) {
+/** Parse a tileset */
+async function parseTileset(
+  data: ArrayBuffer,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+) {
   const tilesetJson = JSON.parse(new TextDecoder().decode(data));
+
   // eslint-disable-next-line no-use-before-define
-  tilesetJson.loader = options.loader || Tiles3DLoader;
-  tilesetJson.url = context.url;
+  tilesetJson.loader = options?.loader || Tiles3DLoader;
+  tilesetJson.url = context?.url || '';
+  tilesetJson.queryString = context?.queryString || '';
+
   // base path that non-absolute paths in tileset are relative to.
   tilesetJson.basePath = getBaseUri(tilesetJson);
-  tilesetJson.root = await normalizeTileHeaders(tilesetJson, options);
+  // TODO - check option types in normalizeTileHeaders
+  tilesetJson.root = await normalizeTileHeaders(tilesetJson, options || {});
 
   tilesetJson.type = TILESET_TYPE.TILES3D;
 
@@ -59,21 +89,23 @@ async function parseTileset(data, options, context) {
   return tilesetJson;
 }
 
-async function parse(data, options, context) {
-  // auto detect file type
-  const loaderOptions = options['3d-tiles'] || {};
-  let isTileset;
-  if (loaderOptions.isTileset === 'auto') {
-    isTileset = context.url && context.url.indexOf('.json') !== -1;
-  } else {
-    isTileset = loaderOptions.isTileset;
-  }
-
-  if (isTileset) {
-    data = await parseTileset(data, options, context);
-  } else {
-    data = await parseTile(data, options, context);
-  }
+/** Parse a tile */
+async function parseTile(
+  arrayBuffer: ArrayBuffer,
+  options?: Tiles3DLoaderOptions,
+  context?: LoaderContext
+) {
+  const tile = {
+    content: {
+      featureIds: null
+    }
+  };
+  const byteOffset = 0;
+  await parse3DTile(arrayBuffer, byteOffset, options, context, tile.content);
+  return tile.content;
+}
 
-  return data;
+/** Get base name */
+function getBaseUri(tileset) {
+  return path.dirname(tileset.url);
 }