greybel-js/out/execute/mock/session.js

Transpiler/Interpreter for GreyScript. (GreyHack)

import { ModifierType } from 'another-ansi';
import { createGHMockEnv, init as initGHIntrinsics } from 'greybel-gh-mock-intrinsics';
import { HandlerContainer, ObjectValue, PrepareError, RuntimeError } from 'greybel-interpreter';
import { init as initIntrinsics } from 'greybel-intrinsics';
import { Interpreter } from 'greyscript-interpreter';
import { logger } from '../../helper/logger.js';
import { InterpreterResourceProvider } from '../../helper/resource.js';
import { ansiProvider, useColor } from '../output.js';
import GreybelPseudoDebugger from './debugger.js';
import CLIOutputHandler from './output.js';
function sessionExitHandler(options, exitCode) {
    MockSession.singleton?.stop();
}
process.on('exit', sessionExitHandler);
process.on('SIGINT', sessionExitHandler);
process.on('SIGUSR1', sessionExitHandler);
process.on('SIGUSR2', sessionExitHandler);
process.on('SIGTERM', sessionExitHandler);
process.on('uncaughtException', sessionExitHandler);
class MockSession {
    static singleton = null;
    target;
    debugMode;
    envMapper;
    resourceHandler;
    runtime;
    seed;
    constructor({ target, envMapper, debugMode = false, seed }) {
        this.target = target;
        this.seed = seed;
        this.debugMode = debugMode;
        this.resourceHandler = new InterpreterResourceProvider();
        this.envMapper = envMapper;
        this.runtime = null;
        MockSession.singleton = this;
    }
    async prepare() {
        this.runtime = new Interpreter({
            target: await this.resourceHandler.resolve(this.target),
            handler: new HandlerContainer({
                outputHandler: new CLIOutputHandler(),
                resourceHandler: this.resourceHandler
            }),
            environmentVariables: this.envMapper.toMap(),
            debugMode: this.debugMode
        });
        this.runtime.setApi(initIntrinsics(initGHIntrinsics(new ObjectValue(), createGHMockEnv(this.runtime, {
            seed: this.seed,
            myProgramContent: await this.resourceHandler.get(this.target)
        }))));
        this.runtime.setDebugger(new GreybelPseudoDebugger(this.runtime));
    }
    async run(params = []) {
        try {
            const startTime = Date.now();
            this.runtime.params = params;
            await this.runtime.run();
            logger.debug(`Execution time: ${Date.now() - startTime}ms`);
        }
        catch (err) {
            if (err instanceof PrepareError) {
                logger.error(useColor('red', `${ansiProvider.modify(ModifierType.Bold, 'Prepare error')}: ${err.message} at ${err.target}:${err.range?.start || 0}`));
            }
            else if (err instanceof RuntimeError) {
                logger.error(useColor('red', `${ansiProvider.modify(ModifierType.Bold, 'Runtime error')}: ${err.message} at ${err.target}\n${err.stack}`));
            }
            else {
                logger.error(useColor('red', `${ansiProvider.modify(ModifierType.Bold, 'Unexpected error')}: ${err.message}\n${err.stack}`));
            }
            return false;
        }
        return true;
    }
    async stop() {
        if (this.runtime) {
            await this.runtime.exit();
        }
    }
}
export { MockSession };