@loaders.gl/images 4.0.0-alpha.9 → 4.0.0-beta.1

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

@@ -1,57 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const image_type_1 = require("../category-api/image-type");
-const parsed_image_api_1 = require("../category-api/parsed-image-api");
-const parse_to_image_1 = __importDefault(require("./parse-to-image"));
-const parse_to_image_bitmap_1 = __importDefault(require("./parse-to-image-bitmap"));
-const parse_to_node_image_1 = __importDefault(require("./parse-to-node-image"));
-// Parse to platform defined image type (data on node, ImageBitmap or HTMLImage on browser)
-// eslint-disable-next-line complexity
-async function parseImage(arrayBuffer, options, context) {
-    options = options || {};
-    const imageOptions = options.image || {};
-    // The user can request a specific output format via `options.image.type`
-    const imageType = imageOptions.type || 'auto';
-    const { url } = context || {};
-    // Note: For options.image.type === `data`, we may still need to load as `image` or `imagebitmap`
-    const loadType = getLoadableImageType(imageType);
-    let image;
-    switch (loadType) {
-        case 'imagebitmap':
-            image = await (0, parse_to_image_bitmap_1.default)(arrayBuffer, options, url);
-            break;
-        case 'image':
-            image = await (0, parse_to_image_1.default)(arrayBuffer, options, url);
-            break;
-        case 'data':
-            // Node.js loads imagedata directly
-            image = await (0, parse_to_node_image_1.default)(arrayBuffer, options);
-            break;
-        default:
-            (0, loader_utils_1.assert)(false);
-    }
-    // Browser: if options.image.type === 'data', we can now extract data from the loaded image
-    if (imageType === 'data') {
-        image = (0, parsed_image_api_1.getImageData)(image);
-    }
-    return image;
-}
-exports.default = parseImage;
-// Get a loadable image type from image type
-function getLoadableImageType(type) {
-    switch (type) {
-        case 'auto':
-        case 'data':
-            // Browser: For image data we need still need to load using an image format
-            // Node: the default image type is `data`.
-            return (0, image_type_1.getDefaultImageType)();
-        default:
-            // Throw an error if not supported
-            (0, image_type_1.isImageTypeSupported)(type);
-            return type;
-    }
-}

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

@@ -1,61 +0,0 @@
-"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;
-/**
- * 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 {
-            // @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) {
-    // @ts-ignore
-    for (const key in object || EMPTY_OBJECT) {
-        return false;
-    }
-    return true;
-}

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

@@ -1,47 +0,0 @@
-"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);
-        }
-    }
-}
-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);
-        }
-    });
-}
-exports.loadToImage = loadToImage;

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

@@ -1,14 +0,0 @@
-"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);
-}
-exports.default = parseToNodeImage;

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

@@ -1,42 +0,0 @@
-"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((\?|#).*)?$/;
-function isSVG(url) {
-    return url && (SVG_DATA_URL_PATTERN.test(url) || SVG_URL_PATTERN.test(url));
-}
-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;
-    }
-    return getBlob(arrayBuffer, url);
-}
-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?
-}
-exports.getBlob = getBlob;

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

@@ -1,56 +0,0 @@
-"use strict";
-/*
-Asynchronously maps a deep structure of values (e.g. objects and arrays of urls).
-
-E.g. a mipmapped cubemap
-{
-  [CUBE_FACE_FRONT]: [
-    "image-front-0.jpg",
-    "image-front-1.jpg",
-    "image-front-2.jpg",
-  ],
-  [CUBE_MAP_BACK]: [
-    ...
-  ]
-}
-*/
-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;
-}
-async function mapArray(urlArray, func, options = {}) {
-    const promises = urlArray.map((url) => mapSubtree(url, func, options));
-    return await Promise.all(promises);
-}

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

@@ -1,15 +0,0 @@
-"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));
-}
-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);
-}
-exports.shallowLoad = shallowLoad;

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

@@ -1,20 +0,0 @@
-"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);
-}
-exports.generateUrl = generateUrl;

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

@@ -1,47 +0,0 @@
-"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);
-}
-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 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;
-}
-// Calculates number of mipmaps based on texture size (log2)
-function getMipLevels({ width, height }) {
-    return 1 + Math.floor(Math.log2(Math.max(width, height)));
-}
-exports.getMipLevels = getMipLevels;

package/dist/lib/utils/version.js

@@ -1,7 +0,0 @@
-"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.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });