@loaders.gl/images 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/lib/parsers/parse-to-image-bitmap.js

@@ -1,43 +1,61 @@
-import { isSVG, getBlob } from './svg-utils';
-import parseToImage from './parse-to-image';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const svg_utils_1 = require("./svg-utils");
+const parse_to_image_1 = __importDefault(require("./parse-to-image"));
 const EMPTY_OBJECT = {};
 let imagebitmapOptionsSupported = true;
-export default async function parseToImageBitmap(arrayBuffer, options, url) {
-  let blob;
-
-  if (isSVG(url)) {
-    const image = await parseToImage(arrayBuffer, options, url);
-    blob = image;
-  } else {
-    blob = getBlob(arrayBuffer, url);
-  }
-
-  const imagebitmapOptions = options && options.imagebitmap;
-  return await safeCreateImageBitmap(blob, imagebitmapOptions);
+/**
+ * Asynchronously parses an array buffer into an ImageBitmap - this contains the decoded data
+ * ImageBitmaps are supported on worker threads, but not supported on Edge, IE11 and Safari
+ * https://developer.mozilla.org/en-US/docs/Web/API/ImageBitmap#Browser_compatibility
+ *
+ * TODO - createImageBitmap supports source rect (5 param overload), pass through?
+ */
+async function parseToImageBitmap(arrayBuffer, options, url) {
+    let blob;
+    // Cannot parse SVG directly to ImageBitmap, parse to Image first
+    if ((0, svg_utils_1.isSVG)(url)) {
+        // Note: this only works on main thread
+        const image = await (0, parse_to_image_1.default)(arrayBuffer, options, url);
+        blob = image;
+    }
+    else {
+        // Create blob from the array buffer
+        blob = (0, svg_utils_1.getBlob)(arrayBuffer, url);
+    }
+    const imagebitmapOptions = options && options.imagebitmap;
+    return await safeCreateImageBitmap(blob, imagebitmapOptions);
 }
-
+exports.default = parseToImageBitmap;
+/**
+ * Safely creates an imageBitmap with options
+ * *
+ * Firefox crashes if imagebitmapOptions is supplied
+ * Avoid supplying if not provided or supported, remember if not supported
+ */
 async function safeCreateImageBitmap(blob, imagebitmapOptions = null) {
-  if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
-    imagebitmapOptions = null;
-  }
-
-  if (imagebitmapOptions) {
-    try {
-      return await createImageBitmap(blob, imagebitmapOptions);
-    } catch (error) {
-      console.warn(error);
-      imagebitmapOptionsSupported = false;
+    if (isEmptyObject(imagebitmapOptions) || !imagebitmapOptionsSupported) {
+        imagebitmapOptions = null;
     }
-  }
-
-  return await createImageBitmap(blob);
+    if (imagebitmapOptions) {
+        try {
+            // @ts-ignore Options
+            return await createImageBitmap(blob, imagebitmapOptions);
+        }
+        catch (error) {
+            console.warn(error); // eslint-disable-line
+            imagebitmapOptionsSupported = false;
+        }
+    }
+    return await createImageBitmap(blob);
 }
-
 function isEmptyObject(object) {
-  for (const key in object || EMPTY_OBJECT) {
-    return false;
-  }
-
-  return true;
+    // @ts-ignore
+    for (const key in object || EMPTY_OBJECT) {
+        return false;
+    }
+    return true;
 }
-//# sourceMappingURL=parse-to-image-bitmap.js.map

package/dist/lib/parsers/parse-to-image.js

@@ -1,34 +1,47 @@
-import { getBlobOrSVGDataUrl } from './svg-utils';
-export default async function parseToImage(arrayBuffer, options, url) {
-  const blobOrDataUrl = getBlobOrSVGDataUrl(arrayBuffer, url);
-  const URL = self.URL || self.webkitURL;
-  const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
-
-  try {
-    return await loadToImage(objectUrl || blobOrDataUrl, options);
-  } finally {
-    if (objectUrl) {
-      URL.revokeObjectURL(objectUrl);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadToImage = void 0;
+const svg_utils_1 = require("./svg-utils");
+// Parses html image from array buffer
+async function parseToImage(arrayBuffer, options, url) {
+    // Note: image parsing requires conversion to Blob (for createObjectURL).
+    // Potentially inefficient for not using `response.blob()` (and for File / Blob inputs)...
+    // But presumably not worth adding 'blob' flag to loader objects?
+    const blobOrDataUrl = (0, svg_utils_1.getBlobOrSVGDataUrl)(arrayBuffer, url);
+    const URL = self.URL || self.webkitURL;
+    const objectUrl = typeof blobOrDataUrl !== 'string' && URL.createObjectURL(blobOrDataUrl);
+    try {
+        return await loadToImage(objectUrl || blobOrDataUrl, options);
+    }
+    finally {
+        if (objectUrl) {
+            URL.revokeObjectURL(objectUrl);
+        }
     }
-  }
 }
-export async function loadToImage(url, options) {
-  const image = new Image();
-  image.src = url;
-
-  if (options.image && options.image.decode && image.decode) {
-    await image.decode();
-    return image;
-  }
-
-  return await new Promise((resolve, reject) => {
-    try {
-      image.onload = () => resolve(image);
-
-      image.onerror = err => reject(new Error("Could not load image ".concat(url, ": ").concat(err)));
-    } catch (error) {
-      reject(error);
+exports.default = parseToImage;
+async function loadToImage(url, options) {
+    const image = new Image();
+    image.src = url;
+    // The `image.onload()` callback does not guarantee that the image has been decoded
+    // so a main thread "freeze" can be incurred when using the image for the first time.
+    // `Image.decode()` returns a promise that completes when image is decoded.
+    // https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/decode
+    // Note: When calling `img.decode()`, we do not need to wait for `img.onload()`
+    // Note: `HTMLImageElement.decode()` is not available in Edge and IE11
+    if (options.image && options.image.decode && image.decode) {
+        await image.decode();
+        return image;
     }
-  });
+    // Create a promise that tracks onload/onerror callbacks
+    return await new Promise((resolve, reject) => {
+        try {
+            image.onload = () => resolve(image);
+            image.onerror = (err) => reject(new Error(`Could not load image ${url}: ${err}`));
+        }
+        catch (error) {
+            reject(error);
+        }
+    });
 }
-//# sourceMappingURL=parse-to-image.js.map
+exports.loadToImage = loadToImage;

package/dist/lib/parsers/parse-to-node-image.js

@@ -1,11 +1,14 @@
-import { assert } from '@loaders.gl/loader-utils';
-import { getBinaryImageMetadata } from '../category-api/binary-image-api';
-export default async function parseToNodeImage(arrayBuffer, options) {
-  const {
-    mimeType
-  } = getBinaryImageMetadata(arrayBuffer) || {};
-  const _parseImageNode = globalThis._parseImageNode;
-  assert(_parseImageNode);
-  return await _parseImageNode(arrayBuffer, mimeType);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const binary_image_api_1 = require("../category-api/binary-image-api");
+// Use polyfills if installed to parsed image using get-pixels
+async function parseToNodeImage(arrayBuffer, options) {
+    const { mimeType } = (0, binary_image_api_1.getBinaryImageMetadata)(arrayBuffer) || {};
+    // @ts-ignore
+    const _parseImageNode = globalThis._parseImageNode;
+    (0, loader_utils_1.assert)(_parseImageNode); // '@loaders.gl/polyfills not installed'
+    // @ts-expect-error TODO should we throw error in this case?
+    return await _parseImageNode(arrayBuffer, mimeType);
 }
-//# sourceMappingURL=parse-to-node-image.js.map
+exports.default = parseToNodeImage;

package/dist/lib/parsers/svg-utils.js

@@ -1,32 +1,42 @@
+"use strict";
+// SVG parsing has limitations, e.g:
+// https://bugs.chromium.org/p/chromium/issues/detail?id=606319
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBlob = exports.getBlobOrSVGDataUrl = exports.isSVG = void 0;
 const SVG_DATA_URL_PATTERN = /^data:image\/svg\+xml/;
 const SVG_URL_PATTERN = /\.svg((\?|#).*)?$/;
-export function isSVG(url) {
-  return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
+function isSVG(url) {
+    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
 }
-export function getBlobOrSVGDataUrl(arrayBuffer, url) {
-  if (isSVG(url)) {
-    const textDecoder = new TextDecoder();
-    let xmlText = textDecoder.decode(arrayBuffer);
-
-    try {
-      if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {
-        xmlText = unescape(encodeURIComponent(xmlText));
-      }
-    } catch (error) {
-      throw new Error(error.message);
+exports.isSVG = isSVG;
+function getBlobOrSVGDataUrl(arrayBuffer, url) {
+    if (isSVG(url)) {
+        // Prepare a properly tagged data URL, and load using normal mechanism
+        const textDecoder = new TextDecoder();
+        let xmlText = textDecoder.decode(arrayBuffer);
+        // TODO Escape in browser to support e.g. Chinese characters
+        try {
+            if (typeof unescape === 'function' && typeof encodeURIComponent === 'function') {
+                xmlText = unescape(encodeURIComponent(xmlText));
+            }
+        }
+        catch (error) {
+            throw new Error(error.message);
+        }
+        // base64 encoding is safer. utf-8 fails in some browsers
+        const src = `data:image/svg+xml;base64,${btoa(xmlText)}`;
+        return src;
     }
-
-    const src = "data:image/svg+xml;base64,".concat(btoa(xmlText));
-    return src;
-  }
-
-  return getBlob(arrayBuffer, url);
+    return getBlob(arrayBuffer, url);
 }
-export function getBlob(arrayBuffer, url) {
-  if (isSVG(url)) {
-    throw new Error('SVG cannot be parsed directly to imagebitmap');
-  }
-
-  return new Blob([new Uint8Array(arrayBuffer)]);
+exports.getBlobOrSVGDataUrl = getBlobOrSVGDataUrl;
+function getBlob(arrayBuffer, url) {
+    if (isSVG(url)) {
+        // https://bugs.chromium.org/p/chromium/issues/detail?id=606319
+        // return new Blob([new Uint8Array(arrayBuffer)], {type: 'image/svg+xml'});
+        throw new Error('SVG cannot be parsed directly to imagebitmap');
+    }
+    // TODO - how to determine mime type? Param? Sniff here?
+    return new Blob([new Uint8Array(arrayBuffer)]); // MIME type not needed?
 }
-//# sourceMappingURL=svg-utils.js.map
+exports.getBlob = getBlob;

package/dist/lib/texture-api/async-deep-map.js

@@ -1,39 +1,56 @@
-const isObject = value => value && typeof value === 'object';
+"use strict";
+/*
+Asynchronously maps a deep structure of values (e.g. objects and arrays of urls).
 
-export async function asyncDeepMap(tree, func, options = {}) {
-  return await mapSubtree(tree, func, options);
+E.g. a mipmapped cubemap
+{
+  [CUBE_FACE_FRONT]: [
+    "image-front-0.jpg",
+    "image-front-1.jpg",
+    "image-front-2.jpg",
+  ],
+  [CUBE_MAP_BACK]: [
+    ...
+  ]
 }
-export async function mapSubtree(object, func, options) {
-  if (Array.isArray(object)) {
-    return await mapArray(object, func, options);
-  }
-
-  if (isObject(object)) {
-    return await mapObject(object, func, options);
-  }
-
-  const url = object;
-  return await func(url, options);
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapSubtree = exports.asyncDeepMap = void 0;
+const isObject = (value) => 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
+async function asyncDeepMap(tree, func, options = {}) {
+    return await mapSubtree(tree, func, options);
 }
-
+exports.asyncDeepMap = asyncDeepMap;
+async function mapSubtree(object, func, options) {
+    if (Array.isArray(object)) {
+        return await mapArray(object, func, options);
+    }
+    if (isObject(object)) {
+        return await mapObject(object, func, options);
+    }
+    // TODO - ignore non-urls, non-arraybuffers?
+    const url = object;
+    return await func(url, options);
+}
+exports.mapSubtree = mapSubtree;
+// HELPERS
 async function mapObject(object, func, options) {
-  const promises = [];
-  const values = {};
-
-  for (const key in object) {
-    const url = object[key];
-    const promise = mapSubtree(url, func, options).then(value => {
-      values[key] = value;
-    });
-    promises.push(promise);
-  }
-
-  await Promise.all(promises);
-  return values;
+    const promises = [];
+    const values = {};
+    for (const key in object) {
+        const url = object[key];
+        const promise = mapSubtree(url, func, options).then((value) => {
+            values[key] = value;
+        });
+        promises.push(promise);
+    }
+    await Promise.all(promises);
+    return values;
 }
-
 async function mapArray(urlArray, func, options = {}) {
-  const promises = urlArray.map(url => mapSubtree(url, func, options));
-  return await Promise.all(promises);
+    const promises = urlArray.map((url) => mapSubtree(url, func, options));
+    return await Promise.all(promises);
 }
-//# sourceMappingURL=async-deep-map.js.map

package/dist/lib/texture-api/deep-load.js

@@ -1,10 +1,15 @@
-import { asyncDeepMap } from './async-deep-map';
-export async function deepLoad(urlTree, load, options) {
-  return await asyncDeepMap(urlTree, url => shallowLoad(url, load, options));
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shallowLoad = exports.deepLoad = void 0;
+const async_deep_map_1 = require("./async-deep-map");
+async function deepLoad(urlTree, load, options) {
+    return await (0, async_deep_map_1.asyncDeepMap)(urlTree, (url) => shallowLoad(url, load, options));
 }
-export async function shallowLoad(url, load, options) {
-  const response = await fetch(url, options.fetch);
-  const arrayBuffer = await response.arrayBuffer();
-  return await load(arrayBuffer, options);
+exports.deepLoad = deepLoad;
+async function shallowLoad(url, load, options) {
+    // console.error('loading', url);
+    const response = await fetch(url, options.fetch);
+    const arrayBuffer = await response.arrayBuffer();
+    return await load(arrayBuffer, options);
 }
-//# sourceMappingURL=deep-load.js.map
+exports.shallowLoad = shallowLoad;

package/dist/lib/texture-api/generate-url.js

@@ -1,22 +1,20 @@
-import { resolvePath, assert } from '@loaders.gl/loader-utils';
-export function generateUrl(getUrl, options, urlOptions) {
-  let url = getUrl;
-
-  if (typeof getUrl === 'function') {
-    url = getUrl({ ...options,
-      ...urlOptions
-    });
-  }
-
-  assert(typeof url === 'string');
-  const {
-    baseUrl
-  } = options;
-
-  if (baseUrl) {
-    url = baseUrl[baseUrl.length - 1] === '/' ? "".concat(baseUrl).concat(url) : "".concat(baseUrl, "/").concat(url);
-  }
-
-  return resolvePath(url);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateUrl = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+// Generate a url by calling getUrl with mix of options, applying options.baseUrl
+function generateUrl(getUrl, options, urlOptions) {
+    // Get url
+    let url = getUrl;
+    if (typeof getUrl === 'function') {
+        url = getUrl({ ...options, ...urlOptions });
+    }
+    (0, loader_utils_1.assert)(typeof url === 'string');
+    // Apply options.baseUrl
+    const { baseUrl } = options;
+    if (baseUrl) {
+        url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+    }
+    return (0, loader_utils_1.resolvePath)(url);
 }
-//# sourceMappingURL=generate-url.js.map
+exports.generateUrl = generateUrl;

package/dist/lib/texture-api/load-image.js

@@ -1,52 +1,47 @@
-import { assert } from '@loaders.gl/loader-utils';
-import parseImage from '../parsers/parse-image';
-import { getImageSize } from '../category-api/parsed-image-api';
-import { generateUrl } from './generate-url';
-import { deepLoad, shallowLoad } from './deep-load';
-export async function loadImage(getUrl, options = {}) {
-  const imageUrls = await getImageUrls(getUrl, options);
-  return await deepLoad(imageUrls, parseImage, options);
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMipLevels = exports.getImageUrls = exports.loadImage = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const parse_image_1 = __importDefault(require("../parsers/parse-image"));
+const parsed_image_api_1 = require("../category-api/parsed-image-api");
+const generate_url_1 = require("./generate-url");
+const deep_load_1 = require("./deep-load");
+async function loadImage(getUrl, options = {}) {
+    const imageUrls = await getImageUrls(getUrl, options);
+    return await (0, deep_load_1.deepLoad)(imageUrls, parse_image_1.default, options);
 }
-export async function getImageUrls(getUrl, options, urlOptions = {}) {
-  const mipLevels = options && options.image && options.image.mipLevels || 0;
-  return mipLevels !== 0 ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) : generateUrl(getUrl, options, urlOptions);
+exports.loadImage = loadImage;
+async function getImageUrls(getUrl, options, urlOptions = {}) {
+    const mipLevels = (options && options.image && options.image.mipLevels) || 0;
+    return mipLevels !== 0
+        ? await getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions)
+        : (0, generate_url_1.generateUrl)(getUrl, options, urlOptions);
 }
-
+exports.getImageUrls = getImageUrls;
 async function getMipmappedImageUrls(getUrl, mipLevels, options, urlOptions) {
-  const urls = [];
-
-  if (mipLevels === 'auto') {
-    const url = generateUrl(getUrl, options, { ...urlOptions,
-      lod: 0
-    });
-    const image = await shallowLoad(url, parseImage, options);
-    const {
-      width,
-      height
-    } = getImageSize(image);
-    mipLevels = getMipLevels({
-      width,
-      height
-    });
-    urls.push(url);
-  }
-
-  assert(mipLevels > 0);
-
-  for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {
-    const url = generateUrl(getUrl, options, { ...urlOptions,
-      lod: mipLevel
-    });
-    urls.push(url);
-  }
-
-  return urls;
+    const urls = [];
+    // If no mip levels supplied, we need to load the level 0 image and calculate based on size
+    if (mipLevels === 'auto') {
+        const url = (0, generate_url_1.generateUrl)(getUrl, options, { ...urlOptions, lod: 0 });
+        const image = await (0, deep_load_1.shallowLoad)(url, parse_image_1.default, options);
+        const { width, height } = (0, parsed_image_api_1.getImageSize)(image);
+        mipLevels = getMipLevels({ width, height });
+        // TODO - push image and make `deepLoad` pass through non-url values, avoid loading twice?
+        urls.push(url);
+    }
+    // We now know how many mipLevels we need, remaining image urls can now be constructed
+    (0, loader_utils_1.assert)(mipLevels > 0);
+    for (let mipLevel = urls.length; mipLevel < mipLevels; ++mipLevel) {
+        const url = (0, generate_url_1.generateUrl)(getUrl, options, { ...urlOptions, lod: mipLevel });
+        urls.push(url);
+    }
+    return urls;
 }
-
-export function getMipLevels({
-  width,
-  height
-}) {
-  return 1 + Math.floor(Math.log2(Math.max(width, height)));
+// Calculates number of mipmaps based on texture size (log2)
+function getMipLevels({ width, height }) {
+    return 1 + Math.floor(Math.log2(Math.max(width, height)));
 }
-//# sourceMappingURL=load-image.js.map
+exports.getMipLevels = getMipLevels;

package/dist/lib/utils/version.js

@@ -1,2 +1,7 @@
-export const VERSION = typeof "4.0.0-alpha.5" !== 'undefined' ? "4.0.0-alpha.5" : 'latest';
-//# sourceMappingURL=version.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+exports.VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 /**
  * data images
  */
-export declare type ImageDataType = {
+export type ImageDataType = {
     data: Uint8Array;
     width: number;
     height: number;
@@ -10,9 +10,9 @@ export declare type ImageDataType = {
 /**
  * Supported Image Types
  */
-export declare type ImageType = ImageBitmap | typeof Image | ImageDataType;
+export type ImageType = ImageBitmap | ImageDataType | HTMLImageElement;
 /**
  * Image type string used to control or determine the type of images returned from ImageLoader
  */
-export declare type ImageTypeEnum = 'imagebitmap' | 'image' | 'data';
+export type ImageTypeEnum = 'imagebitmap' | 'image' | 'data';
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,oBAAY,SAAS,GAAG,WAAW,GAAG,OAAO,KAAK,GAAG,aAAa,CAAC;AAEnE;;GAEG;AACH,oBAAY,aAAa,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,aAAa,GAAG,gBAAgB,CAAC;AAEvE;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,aAAa,GAAG,OAAO,GAAG,MAAM,CAAC"}

package/dist/types.js

@@ -1,2 +1,2 @@
-export {};
-//# sourceMappingURL=types.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/images",
-  "version": "4.0.0-alpha.5",
+  "version": "4.0.0-alpha.7",
   "description": "Framework-independent loaders and writers for images (PNG, JPG, ...)",
   "license": "MIT",
   "publishConfig": {
@@ -19,8 +19,8 @@
     "PLY"
   ],
   "types": "dist/index.d.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "sideEffects": false,
   "files": [
     "src",
@@ -32,7 +32,10 @@
     "build-bundle": "esbuild src/bundle.ts --outfile=dist/dist.min.js --bundle --minify --sourcemap"
   },
   "dependencies": {
-    "@loaders.gl/loader-utils": "4.0.0-alpha.5"
+    "@loaders.gl/loader-utils": "4.0.0-alpha.7"
   },
-  "gitHead": "7a71a54bdf1ddf985cc3af3db90b82e7fa97d025"
+  "gitHead": "afb59c4d8e5d8ebb9c28f111cb0c96c5527d0ffd",
+  "devDependencies": {
+    "@types/get-pixels": "^3.3.2"
+  }
 }

package/src/image-loader.ts

@@ -1,14 +1,17 @@
 import type {LoaderOptions, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {ImageType} from './types';
+// import type { ImageType } from '@loaders.gl/schema';
 import {VERSION} from './lib/utils/version';
 import parseImage from './lib/parsers/parse-image';
 import {getBinaryImageMetadata} from './lib/category-api/binary-image-api';
 
-const EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'svg'];
+const EXTENSIONS = ['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'ico', 'svg', 'avif'];
 const MIME_TYPES = [
   'image/png',
   'image/jpeg',
   'image/gif',
   'image/webp',
+  'image/avif',
   'image/bmp',
   'image/vnd.microsoft.icon',
   'image/svg+xml'
@@ -34,7 +37,7 @@ const DEFAULT_IMAGE_LOADER_OPTIONS: ImageLoaderOptions = {
  * Loads a platform-specific image type
  * Note: This type can be used as input data to WebGL texture creation
  */
-export const ImageLoader = {
+export const ImageLoader: LoaderWithParser<ImageType, never, ImageLoaderOptions> = {
   id: 'image',
   module: 'images',
   name: 'Images',
@@ -46,5 +49,3 @@ export const ImageLoader = {
   tests: [(arrayBuffer) => Boolean(getBinaryImageMetadata(new DataView(arrayBuffer)))],
   options: DEFAULT_IMAGE_LOADER_OPTIONS
 };
-
-export const _typecheckImageLoader: LoaderWithParser = ImageLoader;