@logic-pad/core/dist/data/solver/eventIteratingSolver.js

import { Serializer } from '../serializer/allSerializers.js';
import Solver from './solver.js';
import { EventIterator } from 'event-iterator';
export default class EventIteratingSolver extends Solver {
    constructor() {
        super(...arguments);
        Object.defineProperty(this, "supportsCancellation", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: true
        });
    }
    isEnvironmentSupported() {
        try {
            const worker = this.createWorker();
            worker.terminate();
            return Promise.resolve(true);
        }
        catch (ex) {
            return Promise.resolve(false);
        }
    }
    async *solve(grid, abortSignal) {
        const worker = this.createWorker();
        const terminateHandler = () => worker.terminate();
        abortSignal?.addEventListener('abort', terminateHandler);
        try {
            const iterator = new EventIterator(({ push, stop, fail }) => {
                worker.postMessage(Serializer.stringifyGrid(grid.resetTiles()));
                worker.addEventListener('message', (e) => {
                    if (e.data) {
                        push(Serializer.parseGrid(e.data));
                    }
                    else if (e.data === null) {
                        push(null);
                        stop(); // Stop after the first signal for out of solutions
                    }
                    else {
                        stop();
                    }
                });
                worker.addEventListener('error', (e) => {
                    alert(`Error while solving!\n${e.message}`);
                    fail(e);
                });
            });
            for await (const solution of iterator) {
                yield solution;
            }
        }
        finally {
            worker.terminate();
            abortSignal?.removeEventListener('abort', terminateHandler);
        }
    }
}