edgespec/dist/testing/ava/index.js

Write Winter-CG compatible routes with filesystem routing and tons of features

import { devServer } from '../../chunk-325RCKH4.js';
import '../../chunk-TZHMALR4.js';
import '../../chunk-PRZQE4JB.js';
import '../../chunk-BA3OE4WS.js';
import '../../chunk-LSPDGEVE.js';
import '../../chunk-CE43QKKO.js';
import { loadConfig } from '../../chunk-TMYKADNK.js';
import '../../chunk-5WRI5ZAA.js';
import path from 'path';
import hash from 'object-hash';
import getPort from '@ava/get-port';
import { registerSharedWorker } from 'ava/plugin';
import { fileURLToPath } from 'url';
import { once } from 'events';

var getWorker = async (initialData) => {
  const key = hash(initialData);
  const dirname = path.dirname(fileURLToPath(import.meta.url));
  if (process.env.IS_TESTING_EDGESPEC) {
    const { registerSharedTypeScriptWorker } = await import('ava-typescript-worker');
    return registerSharedTypeScriptWorker({
      filename: new URL(
        `file:${path.resolve(dirname, "worker-wrapper.ts")}#${key}`
      ),
      initialData
    });
  }
  return registerSharedWorker({
    filename: new URL(
      `file:${path.resolve(dirname, "worker-wrapper.js")}#${key}`
    ),
    initialData,
    supportedProtocols: ["ava-4"]
  });
};
var getTestServer = async (t, options) => {
  const rootDirectory = options?.rootDirectory ?? process.cwd();
  const worker = await getWorker({
    rootDirectory
  });
  const [port] = await Promise.all([getPort(), worker.available]);
  let httpServerRpcCallback;
  const onReceivedBuildResult = (build) => {
    if (build.type === "failure") {
      console.error(build.errorMessage);
      t.fail("Failed to build");
    }
  };
  const serverFixture = await devServer.headless.startServer({
    port,
    config: await loadConfig(rootDirectory),
    rpcChannel: {
      post: (data) => worker.publish(data),
      on: (data) => {
        httpServerRpcCallback = data;
      }
    },
    middleware: options?.middleware ?? [],
    onBuildEnd(build) {
      onReceivedBuildResult(build);
    }
  });
  const messageHandlerAbortController = new AbortController();
  const messageHandlerPromise = Promise.race([
    once(messageHandlerAbortController.signal, "abort"),
    (async () => {
      for await (const msg of worker.subscribe()) {
        httpServerRpcCallback(msg.data);
        if (messageHandlerAbortController.signal.aborted) {
          break;
        }
      }
    })()
  ]);
  t.teardown(async () => {
    messageHandlerAbortController.abort();
    await messageHandlerPromise;
    await serverFixture.stop();
  });
  onReceivedBuildResult(await serverFixture.getBuildResult());
  return {
    port
  };
};

export { getTestServer };
//# sourceMappingURL=index.js.map
//# sourceMappingURL=index.js.map