@loaders.gl/textures 3.1.0-alpha.5 → 3.1.0-beta.5

package/src/lib/parsers/parse-pvr.ts

@@ -2,10 +2,10 @@ import {TextureLevel} from '../../types';
 /* eslint-disable camelcase */
 // Forked from PicoGL: https://github.com/tsherif/picogl.js/blob/master/examples/utils/utils.js
 // Copyright (c) 2017 Tarek Sherif, The MIT License (MIT)
-import {GL} from '../gl-constants';
+import {GL_EXTENSIONS_CONSTANTS} from '../gl-extensions';
 import {extractMipmapImages} from '../utils/extract-mipmap-images';
 
-const PVR_CONSTANTS = {
+const PVR_CONSTANTS: Record<string, number> = {
   MAGIC_NUMBER: 0x03525650,
   MAGIC_NUMBER_EXTRA: 0x50565203,
   HEADER_LENGTH: 13,
@@ -19,37 +19,79 @@ const PVR_CONSTANTS = {
   METADATA_SIZE_INDEX: 12
 };
 
-const PVR_PIXEL_FORMATS = {
-  0: [GL.COMPRESSED_RGB_PVRTC_2BPPV1_IMG],
-  1: [GL.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG],
-  2: [GL.COMPRESSED_RGB_PVRTC_4BPPV1_IMG],
-  3: [GL.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG],
-  6: [GL.COMPRESSED_RGB_ETC1_WEBGL],
-  7: [GL.COMPRESSED_RGB_S3TC_DXT1_EXT],
-  9: [GL.COMPRESSED_RGBA_S3TC_DXT3_EXT],
-  11: [GL.COMPRESSED_RGBA_S3TC_DXT5_EXT],
-  22: [GL.COMPRESSED_RGB8_ETC2],
-  23: [GL.COMPRESSED_RGBA8_ETC2_EAC],
-  24: [GL.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2],
-  25: [GL.COMPRESSED_R11_EAC],
-  26: [GL.COMPRESSED_RG11_EAC],
-  27: [GL.COMPRESSED_RGBA_ASTC_4X4_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR],
-  28: [GL.COMPRESSED_RGBA_ASTC_5X4_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR],
-  29: [GL.COMPRESSED_RGBA_ASTC_5X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR],
-  30: [GL.COMPRESSED_RGBA_ASTC_6X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR],
-  31: [GL.COMPRESSED_RGBA_ASTC_6X6_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR],
-  32: [GL.COMPRESSED_RGBA_ASTC_8X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR],
-  33: [GL.COMPRESSED_RGBA_ASTC_8X6_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR],
-  34: [GL.COMPRESSED_RGBA_ASTC_8X8_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR],
-  35: [GL.COMPRESSED_RGBA_ASTC_10X5_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR],
-  36: [GL.COMPRESSED_RGBA_ASTC_10X6_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR],
-  37: [GL.COMPRESSED_RGBA_ASTC_10X8_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR],
-  38: [GL.COMPRESSED_RGBA_ASTC_10X10_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR],
-  39: [GL.COMPRESSED_RGBA_ASTC_12X10_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR],
-  40: [GL.COMPRESSED_RGBA_ASTC_12X12_KHR, GL.COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR]
+const PVR_PIXEL_FORMATS: Record<number, number[]> = {
+  0: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG],
+  1: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG],
+  2: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG],
+  3: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG],
+  6: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL],
+  7: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT],
+  9: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT],
+  11: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT],
+  22: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2],
+  23: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC],
+  24: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2],
+  25: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC],
+  26: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC],
+  27: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR
+  ],
+  28: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X4_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR
+  ],
+  29: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X5_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR
+  ],
+  30: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X5_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR
+  ],
+  31: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X6_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR
+  ],
+  32: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X5_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR
+  ],
+  33: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X6_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR
+  ],
+  34: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X8_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR
+  ],
+  35: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X5_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR
+  ],
+  36: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X6_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR
+  ],
+  37: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X8_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR
+  ],
+  38: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X10_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR
+  ],
+  39: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X10_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR
+  ],
+  40: [
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X12_KHR,
+    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR
+  ]
 };
 
-const PVR_SIZE_FUNCTIONS = {
+const PVR_SIZE_FUNCTIONS: Record<number, (width: number, height: number) => number> = {
   0: pvrtc2bppSize,
   1: pvrtc2bppSize,
   2: pvrtc4bppSize,
@@ -126,7 +168,7 @@ export function parsePVR(data: ArrayBuffer): TextureLevel[] {
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_pvrtc/
-function pvrtc2bppSize(width, height) {
+function pvrtc2bppSize(width: number, height: number): number {
   width = Math.max(width, 16);
   height = Math.max(height, 8);
 
@@ -134,7 +176,7 @@ function pvrtc2bppSize(width, height) {
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_pvrtc/
-function pvrtc4bppSize(width, height) {
+function pvrtc4bppSize(width: number, height: number): number {
   width = Math.max(width, 8);
   height = Math.max(height, 8);
 
@@ -151,7 +193,7 @@ function pvrtc4bppSize(width, height) {
 // COMPRESSED_SRGB8_ETC2
 // COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
 // COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
-function dxtEtcSmallSize(width, height) {
+function dxtEtcSmallSize(width: number, height: number): number {
   return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 8;
 }
 
@@ -166,71 +208,71 @@ function dxtEtcSmallSize(width, height) {
 // COMPRESSED_RGBA8_ETC2_EAC
 // COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
 // COMPRESSED_RGBA_ASTC_4x4_KHR
-function dxtEtcAstcBigSize(width, height) {
+function dxtEtcAstcBigSize(width: number, height: number): number {
   return Math.floor((width + 3) / 4) * Math.floor((height + 3) / 4) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc5x4Size(width, height) {
+function atc5x4Size(width: number, height: number): number {
   return Math.floor((width + 4) / 5) * Math.floor((height + 3) / 4) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc5x5Size(width, height) {
+function atc5x5Size(width: number, height: number): number {
   return Math.floor((width + 4) / 5) * Math.floor((height + 4) / 5) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc6x5Size(width, height) {
+function atc6x5Size(width: number, height: number): number {
   return Math.floor((width + 5) / 6) * Math.floor((height + 4) / 5) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc6x6Size(width, height) {
+function atc6x6Size(width: number, height: number): number {
   return Math.floor((width + 5) / 6) * Math.floor((height + 5) / 6) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc8x5Size(width, height) {
+function atc8x5Size(width: number, height: number): number {
   return Math.floor((width + 7) / 8) * Math.floor((height + 4) / 5) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc8x6Size(width, height) {
+function atc8x6Size(width: number, height: number): number {
   return Math.floor((width + 7) / 8) * Math.floor((height + 5) / 6) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc8x8Size(width, height) {
+function atc8x8Size(width: number, height: number): number {
   return Math.floor((width + 7) / 8) * Math.floor((height + 7) / 8) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc10x5Size(width, height) {
+function atc10x5Size(width: number, height: number): number {
   return Math.floor((width + 9) / 10) * Math.floor((height + 4) / 5) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc10x6Size(width, height) {
+function atc10x6Size(width: number, height: number): number {
   return Math.floor((width + 9) / 10) * Math.floor((height + 5) / 6) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc10x8Size(width, height) {
+function atc10x8Size(width: number, height: number): number {
   return Math.floor((width + 9) / 10) * Math.floor((height + 7) / 8) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc10x10Size(width, height) {
+function atc10x10Size(width: number, height: number): number {
   return Math.floor((width + 9) / 10) * Math.floor((height + 9) / 10) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc12x10Size(width, height) {
+function atc12x10Size(width: number, height: number): number {
   return Math.floor((width + 11) / 12) * Math.floor((height + 9) / 10) * 16;
 }
 
 // https://www.khronos.org/registry/webgl/extensions/WEBGL_compressed_texture_astc/
-function atc12x12Size(width, height) {
+function atc12x12Size(width: number, height: number): number {
   return Math.floor((width + 11) / 12) * Math.floor((height + 11) / 12) * 16;
 }

package/src/lib/texture-api/async-deep-map.ts

@@ -1,3 +1,4 @@
+// loaders.gl, MIT license
 /*
 Asynchronously maps a deep structure of values (e.g. objects and arrays of urls).
 
@@ -13,35 +14,41 @@ E.g. a mipmapped cubemap
   ]
 }
 */
+export type Options = Record<string, any>;
+export type Func = (url: string, options: Options) => unknown;
 
-const isObject = (value) => value && typeof value === 'object';
+const isObject = (value: any): boolean => value && typeof value === 'object';
 
 // Loads a deep structure of urls (objects and arrays of urls)
 // Returns an object with six key-value pairs containing the images (or image mip arrays)
 // for each cube face
-export async function asyncDeepMap(tree, func, options = {}) {
+export async function asyncDeepMap(tree: unknown, func: Func, options: Options = {}) {
   return await mapSubtree(tree, func, options);
 }
 
-export async function mapSubtree(object, func, options) {
+export async function mapSubtree(object: unknown, func: Func, options: Options) {
   if (Array.isArray(object)) {
     return await mapArray(object, func, options);
   }
 
   if (isObject(object)) {
-    return await mapObject(object, func, options);
+    return await mapObject(object as object, func, options);
   }
 
   // TODO - ignore non-urls, non-arraybuffers?
-  const url = object;
+  const url = object as string;
   return await func(url, options);
 }
 
 // HELPERS
 
-async function mapObject(object, func, options) {
+async function mapObject(
+  object: Record<string, any>,
+  func: Func,
+  options: Options
+): Promise<Record<string, any>> {
   const promises: Promise<any>[] = [];
-  const values = {};
+  const values: Record<string, any> = {};
 
   for (const key in object) {
     const url = object[key];
@@ -56,7 +63,7 @@ async function mapObject(object, func, options) {
   return values;
 }
 
-async function mapArray(urlArray, func, options = {}) {
+async function mapArray(urlArray: string[], func: Func, options = {}): Promise<any[]> {
   const promises = urlArray.map((url) => mapSubtree(url, func, options));
   return await Promise.all(promises);
 }

package/src/lib/texture-api/deep-load.ts

@@ -1,10 +1,14 @@
+// loaders.gl, MIT license
 import {asyncDeepMap} from './async-deep-map';
 
-export async function deepLoad(urlTree, load, options) {
-  return await asyncDeepMap(urlTree, (url) => shallowLoad(url, load, options));
+export type LoadOptions = Record<string, any>;
+export type Load = (data: ArrayBuffer, options: Record<string, any>) => Promise<any>;
+
+export async function deepLoad(urlTree: unknown, load: Load, options: LoadOptions) {
+  return await asyncDeepMap(urlTree, (url: string) => shallowLoad(url, load, options));
 }
 
-export async function shallowLoad(url, load, options) {
+export async function shallowLoad(url: string, load: Load, options: LoadOptions): Promise<any> {
   // console.error('loading', url);
   const response = await fetch(url, options.fetch);
   const arrayBuffer = await response.arrayBuffer();

package/src/lib/texture-api/generate-url.ts

@@ -1,16 +1,18 @@
-import {resolvePath, assert} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+import {resolvePath} from '@loaders.gl/loader-utils';
+import type {GetUrl, UrlOptions} from './texture-api-types';
 
 // Generate a url by calling getUrl with mix of options, applying options.baseUrl
-export function generateUrl(getUrl, options, urlOptions) {
+export function generateUrl(
+  getUrl: string | GetUrl,
+  options: UrlOptions,
+  urlOptions: Record<string, any>
+): string {
   // Get url
-  let url = getUrl;
-  if (typeof getUrl === 'function') {
-    url = getUrl({...options, ...urlOptions});
-  }
-  assert(typeof url === 'string');
+  let url = typeof getUrl === 'function' ? getUrl({...options, ...urlOptions}) : getUrl;
 
   // Apply options.baseUrl
-  const {baseUrl} = options;
+  const baseUrl = options.baseUrl;
   if (baseUrl) {
     url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
   }

package/src/lib/texture-api/load-image-array.ts

@@ -1,13 +1,19 @@
+// loaders.gl, MIT license
 import {ImageLoader} from '@loaders.gl/images';
+import type {GetUrl} from './texture-api-types';
 import {getImageUrls} from './load-image';
 import {deepLoad} from './deep-load';
 
-export async function loadImageTextureArray(count, getUrl, options = {}) {
+export async function loadImageTextureArray(
+  count: number,
+  getUrl: GetUrl,
+  options = {}
+): Promise<any> {
   const imageUrls = await getImageArrayUrls(count, getUrl, options);
   return await deepLoad(imageUrls, ImageLoader.parse, options);
 }
 
-export async function getImageArrayUrls(count, getUrl, options = {}) {
+export async function getImageArrayUrls(count: number, getUrl: GetUrl, options = {}): Promise<any> {
   const promises: Promise<any>[] = [];
   for (let index = 0; index < count; index++) {
     const promise = getImageUrls(getUrl, options, {index});

package/src/lib/texture-api/load-image-cube.ts

@@ -1,4 +1,6 @@
+// loaders.gl, MIT license
 import {ImageLoader} from '@loaders.gl/images';
+import type {GetUrl, UrlOptions} from './texture-api-types';
 import {getImageUrls} from './load-image';
 import {deepLoad} from './deep-load';
 
@@ -19,11 +21,20 @@ const CUBE_FACES = [
   {face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, direction: 'back', axis: 'z', sign: 'negative'}
 ];
 
+export type ImageCubeTexture = {
+  GL_TEXTURE_CUBE_MAP_POSITIVE_X: any;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_X: any;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Y: any;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: any;
+  GL_TEXTURE_CUBE_MAP_POSITIVE_Z: any;
+  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: any;
+};
+
 // Returns an object with six key-value pairs containing the urls (or url mip arrays)
 // for each cube face
-export async function getImageCubeUrls(getUrl, options) {
+export async function getImageCubeUrls(getUrl: GetUrl, options: UrlOptions) {
   // Calculate URLs
-  const urls = {};
+  const urls: Record<number, string | string[]> = {};
   const promises: Promise<any>[] = [];
 
   let index = 0;
@@ -42,7 +53,10 @@ export async function getImageCubeUrls(getUrl, options) {
 
 // Returns an object with six key-value pairs containing the images (or image mip arrays)
 // for each cube face
-export async function loadImageTextureCube(getUrl, options = {}) {
+export async function loadImageTextureCube(
+  getUrl: GetUrl,
+  options = {}
+): Promise<ImageCubeTexture> {
   const urls = await getImageCubeUrls(getUrl, options);
-  return await deepLoad(urls, ImageLoader.parse, options);
+  return (await deepLoad(urls, ImageLoader.parse, options)) as ImageCubeTexture;
 }

package/src/lib/texture-api/load-image.ts

@@ -1,21 +1,31 @@
 import {assert} from '@loaders.gl/loader-utils';
 import {ImageLoader, getImageSize} from '@loaders.gl/images';
+import type {GetUrl, UrlOptions} from './texture-api-types';
 import {generateUrl} from './generate-url';
 import {deepLoad, shallowLoad} from './deep-load';
 
-export async function loadImageTexture(getUrl, options = {}) {
+export async function loadImageTexture(getUrl: string | GetUrl, options = {}): Promise<any> {
   const imageUrls = await getImageUrls(getUrl, options);
   return await deepLoad(imageUrls, ImageLoader.parse, options);
 }
 
-export async function getImageUrls(getUrl, options, urlOptions = {}) {
+export async function getImageUrls(
+  getUrl: string | GetUrl,
+  options: any,
+  urlOptions: UrlOptions = {}
+): Promise<any> {
   const mipLevels = (options && options.image && options.image.mipLevels) || 0;
   return mipLevels !== 0
     ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions)
     : generateUrl(getUrl, options, urlOptions);
 }
 
-async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions): Promise<string[]> {
+async function getMipmappedImageUrls(
+  getUrl: string | GetUrl,
+  mipLevels: number | 'auto',
+  options: any,
+  urlOptions: UrlOptions
+): Promise<string[]> {
   const urls: string[] = [];
 
   // If no mip levels supplied, we need to load the level 0 image and calculate based on size
@@ -42,6 +52,6 @@ async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions): Pr
 }
 
 // Calculates number of mipmaps based on texture size (log2)
-export function getMipLevels({width, height}) {
-  return 1 + Math.floor(Math.log2(Math.max(width, height)));
+export function getMipLevels(size: {width: number; height: number}): number {
+  return 1 + Math.floor(Math.log2(Math.max(size.width, size.height)));
 }

package/src/lib/texture-api/texture-api-types.ts

@@ -0,0 +1,12 @@
+// loaders.gl, MIT license
+
+export type {ImageType} from '@loaders.gl/images';
+
+export type UrlOptions = {
+  baseUrl?: string;
+  index?: number;
+  face?: number;
+  lod?: number;
+  direction?: string;
+};
+export type GetUrl = (options: UrlOptions) => string;

package/src/lib/utils/extract-mipmap-images.ts

@@ -11,7 +11,7 @@ import {CompressedTextureExtractOptions, TextureLevel} from '../../types';
  * @returns Array of the texture levels
  */
 export function extractMipmapImages(
-  data: Uint8Array | Array<Object>,
+  data: Uint8Array | object[],
   options: CompressedTextureExtractOptions
 ): TextureLevel[] {
   const images = new Array(options.mipMapLevels);
@@ -21,7 +21,9 @@ export function extractMipmapImages(
   let offset = 0;
 
   for (let i = 0; i < options.mipMapLevels; ++i) {
+    // @ts-expect-error
     const levelSize = getLevelSize(options, levelWidth, levelHeight, data, i);
+    // @ts-expect-error
     const levelData = getLevelData(data, i, offset, levelSize);
 
     images[i] = {
@@ -41,7 +43,12 @@ export function extractMipmapImages(
   return images;
 }
 
-function getLevelData(data, index, offset, levelSize) {
+function getLevelData(
+  data: Uint8Array,
+  index: number,
+  offset: number,
+  levelSize: number
+): Uint8Array {
   if (!Array.isArray(data)) {
     return new Uint8Array(data.buffer, data.byteOffset + offset, levelSize);
   }
@@ -49,7 +56,13 @@ function getLevelData(data, index, offset, levelSize) {
   return data[index].levelData;
 }
 
-function getLevelSize(options, levelWidth, levelHeight, data, index) {
+function getLevelSize(
+  options: CompressedTextureExtractOptions,
+  levelWidth: number,
+  levelHeight: number,
+  data: Uint8Array[] | object[],
+  index: number
+): number {
   if (!Array.isArray(data)) {
     return options.sizeFunction(levelWidth, levelHeight);
   }