@speckle/objectloader2/dist/esm/core/traverser.js

This is an updated objectloader for the Speckle viewer written in typescript

import { isScalar, isBase, isReference } from '../types/functions.js';
export default class Traverser {
    #loader;
    #options;
    #totalChildrenCount = 0;
    #traversedReferencesCount = 0;
    constructor(loader, options) {
        this.#options = options || {};
        this.#loader = loader;
    }
    async traverse(onProgress) {
        let firstObjectPromise = undefined;
        for await (const obj of this.#loader.getObjectIterator()) {
            if (!firstObjectPromise) {
                firstObjectPromise = this.traverseBase(obj, onProgress);
            }
        }
        if (firstObjectPromise) {
            return await firstObjectPromise;
        }
        else {
            throw new Error('No objects found');
        }
    }
    async traverseArray(array, onProgress) {
        for (let i = 0; i < 10; i++) {
            const prop = array[i];
            if (isScalar(prop))
                continue;
            if (isBase(prop)) {
                array[i] = await this.traverseBase(prop, onProgress);
            }
            else if (isReference(prop)) {
                array[i] = await this.traverseBase(await this.#loader.getObject({ id: prop.referencedId }), onProgress);
            }
        }
    }
    async traverseBase(base, onProgress) {
        for (const ignoredProp of this.#options.excludeProps || []) {
            delete base[ignoredProp];
        }
        if (base.__closure) {
            const ids = Object.keys(base.__closure);
            const promises = [];
            for (const id of ids) {
                promises.push(this.traverseBase(await this.#loader.getObject({ id }), onProgress));
            }
            await Promise.all(promises);
        }
        delete base['__closure'];
        // De-chunk
        if (base.speckle_type?.includes('DataChunk')) {
            const chunk = base;
            if (chunk.data) {
                await this.traverseArray(chunk.data, onProgress);
            }
        }
        //other props
        for (const prop in base) {
            if (prop === '__closure')
                continue;
            if (prop === 'referenceId')
                continue;
            if (prop === 'speckle_type')
                continue;
            if (prop === 'data')
                continue;
            const baseProp = base[prop];
            if (isScalar(baseProp))
                continue;
            if (isBase(baseProp)) {
                await this.traverseBase(baseProp, onProgress);
            }
            else if (isReference(baseProp)) {
                await this.traverseBase(await this.#loader.getObject({ id: baseProp.referencedId }), onProgress);
            }
            else if (Array.isArray(baseProp)) {
                await this.traverseArray(baseProp, onProgress);
            }
        }
        if (onProgress) {
            onProgress({
                stage: 'construction',
                current: ++this.#traversedReferencesCount > this.#totalChildrenCount
                    ? this.#totalChildrenCount
                    : this.#traversedReferencesCount,
                total: this.#totalChildrenCount
            });
        }
        return base;
    }
}
//# sourceMappingURL=traverser.js.map