@cornerstonejs/core/dist/esm/loaders/cornerstoneMeshLoader.js

Cornerstone3D Core

import { createMesh } from './utils/mesh/createMesh.js';
import { Events } from '../enums/index.js';
import eventTarget from '../eventTarget.js';
import triggerEvent from '../utilities/triggerEvent.js';
function fetchArrayBuffer({ url, signal, onload, loaderOptions, }) {
    return new Promise(async (resolve, reject) => {
        const xhr = new XMLHttpRequest();
        xhr.open('GET', url, true);
        const defaultHeaders = {};
        const beforeSendHeaders = await loaderOptions.beforeSend(xhr, defaultHeaders);
        const headers = Object.assign({}, defaultHeaders, beforeSendHeaders);
        xhr.responseType = 'arraybuffer';
        Object.keys(headers).forEach(function (key) {
            if (headers[key] === null) {
                return;
            }
            xhr.setRequestHeader(key, headers[key]);
        });
        const onLoadHandler = function (e) {
            if (onload && typeof onload === 'function') {
                onload();
            }
            if (signal) {
                signal.removeEventListener('abort', onAbortHandler);
            }
            resolve(xhr.response);
        };
        const onAbortHandler = () => {
            xhr.abort();
            xhr.removeEventListener('load', onLoadHandler);
            reject(new Error('Request aborted'));
        };
        xhr.addEventListener('load', onLoadHandler);
        const onProgress = (loaded, total) => {
            const data = { url, loaded, total };
            triggerEvent(eventTarget, Events.GEOMETRY_LOAD_PROGRESS, { data });
        };
        xhr.onprogress = function (e) {
            onProgress(e.loaded, e.total);
        };
        if (signal && signal.aborted) {
            xhr.abort();
            reject(new Error('Request aborted'));
        }
        else if (signal) {
            signal.addEventListener('abort', onAbortHandler);
        }
        xhr.send();
    });
}
function cornerstoneMeshLoader(meshId, options, loaderOptions) {
    const promise = new Promise((resolve, reject) => {
        fetchAndProcessMeshData(meshId, options, loaderOptions)
            .then(resolve)
            .catch(reject);
    });
    return {
        promise: promise,
        cancelFn: undefined,
        decache: () => { },
    };
}
async function fetchAndProcessMeshData(meshId, options, loaderOptions) {
    const parts = meshId.split(':');
    const url = parts.slice(1).join(':');
    const meshBuffer = await fetchArrayBuffer({ url, loaderOptions });
    if (!options || !('geometryData' in options)) {
        throw new Error('Mesh must have a geometryData');
    }
    return createMesh(url, {
        ...options.geometryData,
        arrayBuffer: meshBuffer,
    });
}
export { cornerstoneMeshLoader };