@loaders.gl/loader-utils 4.0.0-alpha.23 → 4.0.0-alpha.25

package/dist/lib/path-utils/file-aliases.js

@@ -1,47 +0,0 @@
-"use strict";
-// Simple file alias mechanisms for tests.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolvePath = exports.addAliases = exports.getPathPrefix = exports.setPathPrefix = void 0;
-let pathPrefix = '';
-const fileAliases = {};
-/*
- * Set a relative path prefix
- */
-function setPathPrefix(prefix) {
-    pathPrefix = prefix;
-}
-exports.setPathPrefix = setPathPrefix;
-/*
- * Get the relative path prefix
- */
-function getPathPrefix() {
-    return pathPrefix;
-}
-exports.getPathPrefix = getPathPrefix;
-/**
- *
- * @param aliases
- *
- * Note: addAliases are an experimental export, they are only for testing of loaders.gl loaders
- * not intended as a generic aliasing mechanism
- */
-function addAliases(aliases) {
-    Object.assign(fileAliases, aliases);
-}
-exports.addAliases = addAliases;
-/**
- * Resolves aliases and adds path-prefix to paths
- */
-function resolvePath(filename) {
-    for (const alias in fileAliases) {
-        if (filename.startsWith(alias)) {
-            const replacement = fileAliases[alias];
-            filename = filename.replace(alias, replacement);
-        }
-    }
-    if (!filename.startsWith('http://') && !filename.startsWith('https://')) {
-        filename = `${pathPrefix}${filename}`;
-    }
-    return filename;
-}
-exports.resolvePath = resolvePath;

package/dist/lib/path-utils/get-cwd.js

@@ -1,12 +0,0 @@
-"use strict";
-// loaders.gl MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCWD = void 0;
-function getCWD() {
-    if (typeof process !== 'undefined' && typeof process.cwd !== 'undefined') {
-        return process.cwd();
-    }
-    const pathname = window.location?.pathname;
-    return pathname?.slice(0, pathname.lastIndexOf('/') + 1) || '';
-}
-exports.getCWD = getCWD;

package/dist/lib/path-utils/path.js

@@ -1,178 +0,0 @@
-"use strict";
-// Beginning of a minimal implementation of the Node.js path API, that doesn't pull in big polyfills.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolve = exports.join = exports.dirname = exports.filename = void 0;
-const get_cwd_1 = require("./get-cwd");
-/**
- * Replacement for Node.js path.filename
- * @param url
- */
-function filename(url) {
-    const slashIndex = url ? url.lastIndexOf('/') : -1;
-    return slashIndex >= 0 ? url.substr(slashIndex + 1) : '';
-}
-exports.filename = filename;
-/**
- * Replacement for Node.js path.dirname
- * @param url
- */
-function dirname(url) {
-    const slashIndex = url ? url.lastIndexOf('/') : -1;
-    return slashIndex >= 0 ? url.substr(0, slashIndex) : '';
-}
-exports.dirname = dirname;
-/**
- * Replacement for Node.js path.join
- * @param parts
- */
-function join(...parts) {
-    const separator = '/';
-    parts = parts.map((part, index) => {
-        if (index) {
-            part = part.replace(new RegExp(`^${separator}`), '');
-        }
-        if (index !== parts.length - 1) {
-            part = part.replace(new RegExp(`${separator}$`), '');
-        }
-        return part;
-    });
-    return parts.join(separator);
-}
-exports.join = join;
-/* eslint-disable no-continue */
-/**
- * https://nodejs.org/api/path.html#path_path_resolve_paths
- * @param paths A sequence of paths or path segments.
- * @return resolved path
- * Forked from BTOdell/path-resolve under MIT license
- * @see https://github.com/BTOdell/path-resolve/blob/master/LICENSE
- */
-function resolve(...components) {
-    const paths = [];
-    for (let _i = 0; _i < components.length; _i++) {
-        paths[_i] = components[_i];
-    }
-    let resolvedPath = '';
-    let resolvedAbsolute = false;
-    let cwd;
-    for (let i = paths.length - 1; i >= -1 && !resolvedAbsolute; i--) {
-        let path;
-        if (i >= 0) {
-            path = paths[i];
-        }
-        else {
-            if (cwd === undefined) {
-                cwd = (0, get_cwd_1.getCWD)();
-            }
-            path = cwd;
-        }
-        // Skip empty entries
-        if (path.length === 0) {
-            continue;
-        }
-        resolvedPath = `${path}/${resolvedPath}`;
-        resolvedAbsolute = path.charCodeAt(0) === SLASH;
-    }
-    // At this point the path should be resolved to a full absolute path, but
-    // handle relative paths to be safe (might happen when process.cwd() fails)
-    // Normalize the path (removes leading slash)
-    resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
-    if (resolvedAbsolute) {
-        return `/${resolvedPath}`;
-    }
-    else if (resolvedPath.length > 0) {
-        return resolvedPath;
-    }
-    return '.';
-}
-exports.resolve = resolve;
-const SLASH = 47;
-const DOT = 46;
-/**
- * Resolves . and .. elements in a path with directory names
- * Forked from BTOdell/path-resolve under MIT license
- * @see https://github.com/BTOdell/path-resolve/blob/master/LICENSE
- */
-/* eslint-disable max-depth */
-// eslint-disable-next-line complexity, max-statements
-function normalizeStringPosix(path, allowAboveRoot) {
-    let res = '';
-    let lastSlash = -1;
-    let dots = 0;
-    let code;
-    let isAboveRoot = false;
-    for (let i = 0; i <= path.length; ++i) {
-        if (i < path.length) {
-            code = path.charCodeAt(i);
-        }
-        else if (code === SLASH) {
-            break;
-        }
-        else {
-            code = SLASH;
-        }
-        if (code === SLASH) {
-            if (lastSlash === i - 1 || dots === 1) {
-                // NOOP
-            }
-            else if (lastSlash !== i - 1 && dots === 2) {
-                if (res.length < 2 ||
-                    !isAboveRoot ||
-                    res.charCodeAt(res.length - 1) !== DOT ||
-                    res.charCodeAt(res.length - 2) !== DOT) {
-                    if (res.length > 2) {
-                        const start = res.length - 1;
-                        let j = start;
-                        for (; j >= 0; --j) {
-                            if (res.charCodeAt(j) === SLASH) {
-                                break;
-                            }
-                        }
-                        if (j !== start) {
-                            res = j === -1 ? '' : res.slice(0, j);
-                            lastSlash = i;
-                            dots = 0;
-                            isAboveRoot = false;
-                            continue;
-                        }
-                    }
-                    else if (res.length === 2 || res.length === 1) {
-                        res = '';
-                        lastSlash = i;
-                        dots = 0;
-                        isAboveRoot = false;
-                        continue;
-                    }
-                }
-                if (allowAboveRoot) {
-                    if (res.length > 0) {
-                        res += '/..';
-                    }
-                    else {
-                        res = '..';
-                    }
-                    isAboveRoot = true;
-                }
-            }
-            else {
-                const slice = path.slice(lastSlash + 1, i);
-                if (res.length > 0) {
-                    res += `/${slice}`;
-                }
-                else {
-                    res = slice;
-                }
-                isAboveRoot = false;
-            }
-            lastSlash = i;
-            dots = 0;
-        }
-        else if (code === DOT && dots !== -1) {
-            ++dots;
-        }
-        else {
-            dots = -1;
-        }
-    }
-    return res;
-}

package/dist/lib/request-utils/request-scheduler.js

@@ -1,142 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const stats_1 = require("@probe.gl/stats");
-const STAT_QUEUED_REQUESTS = 'Queued Requests';
-const STAT_ACTIVE_REQUESTS = 'Active Requests';
-const STAT_CANCELLED_REQUESTS = 'Cancelled Requests';
-const STAT_QUEUED_REQUESTS_EVER = 'Queued Requests Ever';
-const STAT_ACTIVE_REQUESTS_EVER = 'Active Requests Ever';
-const DEFAULT_PROPS = {
-    id: 'request-scheduler',
-    // Specifies if the request scheduler should throttle incoming requests, mainly for comparative testing
-    throttleRequests: true,
-    // The maximum number of simultaneous active requests. Un-throttled requests do not observe this limit.
-    maxRequests: 6
-};
-/**
- * Used to issue a request, without having them "deeply queued" by the browser.
- * @todo - Track requests globally, across multiple servers
- */
-class RequestScheduler {
-    constructor(props = {}) {
-        this.activeRequestCount = 0;
-        /** Tracks the number of active requests and prioritizes/cancels queued requests. */
-        this.requestQueue = [];
-        this.requestMap = new Map();
-        this.deferredUpdate = null;
-        this.props = { ...DEFAULT_PROPS, ...props };
-        // Returns the statistics used by the request scheduler.
-        this.stats = new stats_1.Stats({ id: this.props.id });
-        this.stats.get(STAT_QUEUED_REQUESTS);
-        this.stats.get(STAT_ACTIVE_REQUESTS);
-        this.stats.get(STAT_CANCELLED_REQUESTS);
-        this.stats.get(STAT_QUEUED_REQUESTS_EVER);
-        this.stats.get(STAT_ACTIVE_REQUESTS_EVER);
-    }
-    /**
-     * Called by an application that wants to issue a request, without having it deeply queued by the browser
-     *
-     * When the returned promise resolved, it is OK for the application to issue a request.
-     * The promise resolves to an object that contains a `done` method.
-     * When the application's request has completed (or failed), the application must call the `done` function
-     *
-     * @param handle
-     * @param getPriority will be called when request "slots" open up,
-     *    allowing the caller to update priority or cancel the request
-     *    Highest priority executes first, priority < 0 cancels the request
-     * @returns a promise
-     *   - resolves to a object (with a `done` field) when the request can be issued without queueing,
-     *   - resolves to `null` if the request has been cancelled (by the callback return < 0).
-     *     In this case the application should not issue the request
-     */
-    scheduleRequest(handle, getPriority = () => 0) {
-        // Allows throttling to be disabled
-        if (!this.props.throttleRequests) {
-            return Promise.resolve({ done: () => { } });
-        }
-        // dedupe
-        if (this.requestMap.has(handle)) {
-            return this.requestMap.get(handle);
-        }
-        const request = { handle, priority: 0, getPriority };
-        const promise = new Promise((resolve) => {
-            // @ts-ignore
-            request.resolve = resolve;
-            return request;
-        });
-        this.requestQueue.push(request);
-        this.requestMap.set(handle, promise);
-        this._issueNewRequests();
-        return promise;
-    }
-    // PRIVATE
-    _issueRequest(request) {
-        const { handle, resolve } = request;
-        let isDone = false;
-        const done = () => {
-            // can only be called once
-            if (!isDone) {
-                isDone = true;
-                // Stop tracking a request - it has completed, failed, cancelled etc
-                this.requestMap.delete(handle);
-                this.activeRequestCount--;
-                // A slot just freed up, see if any queued requests are waiting
-                this._issueNewRequests();
-            }
-        };
-        // Track this request
-        this.activeRequestCount++;
-        return resolve ? resolve({ done }) : Promise.resolve({ done });
-    }
-    /** We check requests asynchronously, to prevent multiple updates */
-    _issueNewRequests() {
-        if (!this.deferredUpdate) {
-            this.deferredUpdate = setTimeout(() => this._issueNewRequestsAsync(), 0);
-        }
-    }
-    /** Refresh all requests  */
-    _issueNewRequestsAsync() {
-        // TODO - shouldn't we clear the timeout?
-        this.deferredUpdate = null;
-        const freeSlots = Math.max(this.props.maxRequests - this.activeRequestCount, 0);
-        if (freeSlots === 0) {
-            return;
-        }
-        this._updateAllRequests();
-        // Resolve pending promises for the top-priority requests
-        for (let i = 0; i < freeSlots; ++i) {
-            const request = this.requestQueue.shift();
-            if (request) {
-                this._issueRequest(request); // eslint-disable-line @typescript-eslint/no-floating-promises
-            }
-        }
-        // Uncomment to debug
-        // console.log(`${freeSlots} free slots, ${this.requestQueue.length} queued requests`);
-    }
-    /** Ensure all requests have updated priorities, and that no longer valid requests are cancelled */
-    _updateAllRequests() {
-        const requestQueue = this.requestQueue;
-        for (let i = 0; i < requestQueue.length; ++i) {
-            const request = requestQueue[i];
-            if (!this._updateRequest(request)) {
-                // Remove the element and make sure to adjust the counter to account for shortened array
-                requestQueue.splice(i, 1);
-                this.requestMap.delete(request.handle);
-                i--;
-            }
-        }
-        // Sort the remaining requests based on priority
-        requestQueue.sort((a, b) => a.priority - b.priority);
-    }
-    /** Update a single request by calling the callback */
-    _updateRequest(request) {
-        request.priority = request.getPriority(request.handle); // eslint-disable-line callback-return
-        // by returning a negative priority, the callback cancels the request
-        if (request.priority < 0) {
-            request.resolve(null);
-            return false;
-        }
-        return true;
-    }
-}
-exports.default = RequestScheduler;

package/dist/lib/worker-loader-utils/create-loader-worker.js

@@ -1,99 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLoaderWorker = void 0;
-const worker_utils_1 = require("@loaders.gl/worker-utils");
-// import {validateLoaderVersion} from './validate-loader-version';
-let requestId = 0;
-/**
- * Set up a WebWorkerGlobalScope to talk with the main thread
- * @param loader
- */
-function createLoaderWorker(loader) {
-    // Check that we are actually in a worker thread
-    if (!worker_utils_1.WorkerBody.inWorkerThread()) {
-        return;
-    }
-    worker_utils_1.WorkerBody.onmessage = async (type, payload) => {
-        switch (type) {
-            case 'process':
-                try {
-                    // validateLoaderVersion(loader, data.source.split('@')[1]);
-                    const { input, options = {}, context = {} } = payload;
-                    const result = await parseData({
-                        loader,
-                        arrayBuffer: input,
-                        options,
-                        // @ts-expect-error fetch missing
-                        context: {
-                            ...context,
-                            _parse: parseOnMainThread
-                        }
-                    });
-                    worker_utils_1.WorkerBody.postMessage('done', { result });
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : '';
-                    worker_utils_1.WorkerBody.postMessage('error', { error: message });
-                }
-                break;
-            default:
-        }
-    };
-}
-exports.createLoaderWorker = createLoaderWorker;
-function parseOnMainThread(arrayBuffer, loader, options, context) {
-    return new Promise((resolve, reject) => {
-        const id = requestId++;
-        /**
-         */
-        const onMessage = (type, payload) => {
-            if (payload.id !== id) {
-                // not ours
-                return;
-            }
-            switch (type) {
-                case 'done':
-                    worker_utils_1.WorkerBody.removeEventListener(onMessage);
-                    resolve(payload.result);
-                    break;
-                case 'error':
-                    worker_utils_1.WorkerBody.removeEventListener(onMessage);
-                    reject(payload.error);
-                    break;
-                default:
-                // ignore
-            }
-        };
-        worker_utils_1.WorkerBody.addEventListener(onMessage);
-        // Ask the main thread to decode data
-        const payload = { id, input: arrayBuffer, options };
-        worker_utils_1.WorkerBody.postMessage('process', payload);
-    });
-}
-// TODO - Support byteOffset and byteLength (enabling parsing of embedded binaries without copies)
-// TODO - Why not support async loader.parse* funcs here?
-// TODO - Why not reuse a common function instead of reimplementing loader.parse* selection logic? Keeping loader small?
-// TODO - Lack of appropriate parser functions can be detected when we create worker, no need to wait until parse
-async function parseData({ loader, arrayBuffer, options, context }) {
-    let data;
-    let parser;
-    if (loader.parseSync || loader.parse) {
-        data = arrayBuffer;
-        parser = loader.parseSync || loader.parse;
-    }
-    else if (loader.parseTextSync) {
-        const textDecoder = new TextDecoder();
-        data = textDecoder.decode(arrayBuffer);
-        parser = loader.parseTextSync;
-    }
-    else {
-        throw new Error(`Could not load data with ${loader.name} loader`);
-    }
-    // TODO - proper merge in of loader options...
-    options = {
-        ...options,
-        modules: (loader && loader.options && loader.options.modules) || {},
-        worker: false
-    };
-    return await parser(data, { ...options }, context, loader);
-}

package/dist/lib/worker-loader-utils/encode-with-worker.js

@@ -1,21 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.canEncodeWithWorker = void 0;
-const worker_utils_1 = require("@loaders.gl/worker-utils");
-const globals_1 = require("../env-utils/globals");
-/**
- * Determines if a loader can parse with worker
- * @param loader
- * @param options
- */
-function canEncodeWithWorker(writer, options) {
-    if (!worker_utils_1.WorkerFarm.isSupported()) {
-        return false;
-    }
-    // Node workers are still experimental
-    if (!globals_1.isBrowser && !options?._nodeWorkers) {
-        return false;
-    }
-    return writer.worker && options?.worker;
-}
-exports.canEncodeWithWorker = canEncodeWithWorker;

package/dist/lib/worker-loader-utils/parse-with-worker.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseWithWorker = exports.canParseWithWorker = void 0;
-const worker_utils_1 = require("@loaders.gl/worker-utils");
-const worker_utils_2 = require("@loaders.gl/worker-utils");
-/**
- * Determines if a loader can parse with worker
- * @param loader
- * @param options
- */
-function canParseWithWorker(loader, options) {
-    if (!worker_utils_2.WorkerFarm.isSupported()) {
-        return false;
-    }
-    // Node workers are still experimental
-    if (!worker_utils_1.isBrowser && !options?._nodeWorkers) {
-        return false;
-    }
-    return loader.worker && options?.worker;
-}
-exports.canParseWithWorker = canParseWithWorker;
-/**
- * this function expects that the worker function sends certain messages,
- * this can be automated if the worker is wrapper by a call to createLoaderWorker in @loaders.gl/loader-utils.
- */
-async function parseWithWorker(loader, data, options, context, parseOnMainThread) {
-    const name = loader.id; // TODO
-    const url = (0, worker_utils_2.getWorkerURL)(loader, options);
-    const workerFarm = worker_utils_2.WorkerFarm.getWorkerFarm(options);
-    const workerPool = workerFarm.getWorkerPool({ name, url });
-    // options.log object contains functions which cannot be transferred
-    // context.fetch & context.parse functions cannot be transferred
-    // TODO - decide how to handle logging on workers
-    options = JSON.parse(JSON.stringify(options));
-    context = JSON.parse(JSON.stringify(context || {}));
-    const job = await workerPool.startJob('process-on-worker', 
-    // @ts-expect-error
-    onMessage.bind(null, parseOnMainThread) // eslint-disable-line @typescript-eslint/no-misused-promises
-    );
-    job.postMessage('process', {
-        // @ts-ignore
-        input: data,
-        options,
-        context
-    });
-    const result = await job.result;
-    // TODO - what is going on here?
-    return await result.result;
-}
-exports.parseWithWorker = parseWithWorker;
-/**
- * Handle worker's responses to the main thread
- * @param job
- * @param type
- * @param payload
- */
-async function onMessage(parseOnMainThread, job, type, payload) {
-    switch (type) {
-        case 'done':
-            job.done(payload);
-            break;
-        case 'error':
-            job.error(new Error(payload.error));
-            break;
-        case 'process':
-            // Worker is asking for main thread to parseO
-            const { id, input, options } = payload;
-            try {
-                const result = await parseOnMainThread(input, options);
-                job.postMessage('done', { id, result });
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : 'unknown error';
-                job.postMessage('error', { id, error: message });
-            }
-            break;
-        default:
-            // eslint-disable-next-line
-            console.warn(`parse-with-worker unknown message ${type}`);
-    }
-}

package/dist/loader-types.js

@@ -1,36 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseInBatchesFromContext = exports.parseSyncFromContext = exports.parseFromContext = void 0;
-/**
- * Parses `data` using a specified loader
- * @param data
- * @param loaders
- * @param options
- * @param context
- */
-// implementation signature
-async function parseFromContext(data, loaders, options, context) {
-    return context._parse(data, loaders, options, context);
-}
-exports.parseFromContext = parseFromContext;
-/**
- * Parses `data` synchronously using the specified loader, parse function provided via the loader context
- */
-function parseSyncFromContext(data, loader, options, context) {
-    if (!context._parseSync) {
-        throw new Error('parseSync');
-    }
-    return context._parseSync(data, loader, options, context);
-}
-exports.parseSyncFromContext = parseSyncFromContext;
-/**
- * Parses `data` synchronously using a specified loader, parse function provided via the loader context
- */
-async function parseInBatchesFromContext(data, loader, options, context) {
-    if (!context._parseInBatches) {
-        throw new Error('parseInBatches');
-    }
-    return context._parseInBatches(data, loader, options, context);
-}
-exports.parseInBatchesFromContext = parseInBatchesFromContext;

package/dist/types.js

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

package/dist/workers/json-worker.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const create_loader_worker_1 = require("../lib/worker-loader-utils/create-loader-worker");
-const json_loader_1 = require("../json-loader");
-(0, create_loader_worker_1.createLoaderWorker)(json_loader_1.JSONLoader);

package/dist/writer-types.js

@@ -1,3 +0,0 @@
-"use strict";
-// loaders.gl, MIT license
-Object.defineProperty(exports, "__esModule", { value: true });