@bitbybit-dev/core/lib/api/init-kernels.js

Bit By Bit Developers Core CAD API to Program Geometry

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { OccStateEnum } from "@bitbybit-dev/occt-worker";
import { JscadStateEnum } from "@bitbybit-dev/jscad-worker";
import { ManifoldStateEnum } from "@bitbybit-dev/manifold-worker";
import { firstValueFrom, first, map } from "rxjs";
import { createWorkersFromCDN } from "./worker-utils";
/**
 * Waits for all enabled kernels to be initialized.
 * This is engine-agnostic and can be used by all engine packages.
 *
 * @param managers - The worker managers from BitByBitBase
 * @param options - Which kernels are enabled
 */
export function waitForKernelInitialization(managers, options) {
    return __awaiter(this, void 0, void 0, function* () {
        var _a;
        const initializationPromises = [];
        let anyKernelSelectedForInit = false;
        if (options.enableOCCT) {
            anyKernelSelectedForInit = true;
            if (managers.occtWorkerManager) {
                initializationPromises.push(firstValueFrom(managers.occtWorkerManager.occWorkerState$.pipe(first((s) => s.state === OccStateEnum.initialised), map(() => "OCCT"))));
            }
            else {
                console.warn("OCCT enabled in options, but occtWorkerManager not found after init.");
            }
        }
        if (options.enableJSCAD) {
            anyKernelSelectedForInit = true;
            if (managers.jscadWorkerManager) {
                initializationPromises.push(firstValueFrom(managers.jscadWorkerManager.jscadWorkerState$.pipe(first((s) => s.state === JscadStateEnum.initialised), map(() => "JSCAD"))));
            }
            else {
                console.warn("JSCAD enabled in options, but jscadWorkerManager not found after init.");
            }
        }
        if (options.enableManifold) {
            anyKernelSelectedForInit = true;
            if ((_a = managers.manifoldWorkerManager) === null || _a === void 0 ? void 0 : _a.manifoldWorkerState$) {
                initializationPromises.push(firstValueFrom(managers.manifoldWorkerManager.manifoldWorkerState$.pipe(first((s) => s.state === ManifoldStateEnum.initialised), map(() => "Manifold"))));
            }
            else {
                console.warn("Manifold enabled in options, but manifoldWorkerManager not found after init.");
            }
        }
        if (!anyKernelSelectedForInit) {
            console.log("No kernels selected for initialization.");
            return { message: "No kernels selected for initialization.", initializedKernels: [] };
        }
        if (initializationPromises.length === 0) {
            console.log("Kernels were selected, but none had managers available for awaiting initialization.");
            return {
                message: "Selected kernels were not awaitable for initialization state.",
                initializedKernels: [],
            };
        }
        const initializedKernels = yield Promise.all(initializationPromises);
        return {
            message: `Successfully initialized: ${initializedKernels.join(", ")}`,
            initializedKernels,
        };
    });
}
/**
 * Creates worker instances based on options.
 * If workers are provided in options, uses those. Otherwise creates from CDN.
 *
 * @param options - Initialization options
 */
export function getOrCreateWorkers(options) {
    if (options.workers) {
        return options.workers;
    }
    return createWorkersFromCDN(options);
}