export async function generateCode()

in modules/code-generator/src/standalone-loader.ts [27:99]
64 lines of code
10 McCabe index (conditional complexity)

export async function generateCode(options: {
  solution: 'icejs' | 'rax';
  schema: IPublicTypeProjectSchema;
  flattenResult?: boolean;
  workerJsUrl?: string;
  timeoutInMs?: number;
}): Promise<Result> {
  if (typeof self !== 'object') {
    throw new Error('self is not defined');
  }

  if (typeof Worker !== 'function') {
    throw new Error('Worker is not supported');
  }

  const workerJsUrl = options.workerJsUrl || DEFAULT_WORKER_JS;

  const workerJs = await loadWorkerJs(workerJsUrl);

  const worker = new Worker(workerJs.url, {
    type: 'classic',
    credentials: 'omit',
  });

  return new Promise((resolve, reject) => {
    const timer = setTimeout(() => {
      reject(new Error('timeout'));
      worker.terminate();
    }, options.timeoutInMs || DEFAULT_TIMEOUT_IN_MS);

    worker.onmessage = (event: any) => {
      const msg = event.data;
      switch (msg.type) {
        case 'ready':
          print('worker is ready.');
          break;

        case 'run:begin':
          print('worker is running...');
          break;
        case 'run:end':
          print('worker is done.');
          resolve(msg.result);
          clearTimeout(timer);
          worker.terminate();
          break;
        case 'run:error':
          printErr(`worker error: ${msg.errorMsg}`);
          clearTimeout(timer);
          reject(new Error(msg.errorMsg || 'unknown error'));
          worker.terminate();
          break;
        default:
          print('got unknown msg: %o', msg);
          break;
      }
    };

    worker.onerror = (err: any) => {
      printErr('worker error: %o', err);
      clearTimeout(timer);
      reject(err);
      worker.terminate();
    };

    worker.postMessage({
      type: 'run',
      solution: options.solution,
      schema: options.schema,
      flattenResult: options.flattenResult,
    });
  });
}