edgespec/dist/dev/dev.d.ts

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

import * as http from 'http';
import { R as ResolvedEdgeSpecConfig } from '../index-BskygOvH.js';
import { M as Middleware } from '../edge-spec-CQZ1EUiH.js';
import * as birpc from 'birpc';
import { ChannelOptions } from 'birpc';
import { E as EdgeSpecConfig } from '../config-Buk9QCcE.js';
import 'type-fest';
import 'zod';
import 'openapi3-ts/oas31';

type BundlerBuildResult = {
    buildUpdatedAtMs: number;
} & ({
    type: "success";
    bundlePath: string;
} | {
    type: "failure";
    errorMessage: string;
});
type BundlerRpcFunctions = {
    waitForAvailableBuild: () => Promise<BundlerBuildResult>;
};
type HttpServerRpcFunctions = {
    onBuildStart: () => void;
    onBuildEnd: (build: BundlerBuildResult) => void;
};

interface StartHeadlessDevServerOptions {
    port: number;
    config: ResolvedEdgeSpecConfig;
    rpcChannel: ChannelOptions;
    middleware?: Middleware[];
    onListening?: (port: number) => void;
    onBuildStart?: HttpServerRpcFunctions["onBuildStart"];
    onBuildEnd?: HttpServerRpcFunctions["onBuildEnd"];
}

interface StartHeadlessDevBundlerOptions {
    config: ResolvedEdgeSpecConfig;
    initialRpcChannels?: ChannelOptions[];
}

type StartDevServerOptions = {
    rootDirectory?: string;
    config?: EdgeSpecConfig;
    port?: number;
} & Pick<StartHeadlessDevServerOptions, "middleware" | "onListening" | "onBuildStart" | "onBuildEnd">;

declare const devServer: {
    startDevServer: (options: StartDevServerOptions) => Promise<{
        port: string;
        stop: () => Promise<void>;
    }>;
    headless: {
        startBundler: ({ config, initialRpcChannels, }: StartHeadlessDevBundlerOptions) => Promise<{
            stop: () => Promise<void>;
            birpc: birpc.BirpcGroup<HttpServerRpcFunctions, BundlerRpcFunctions>;
        }>;
        startServer: ({ port, config, rpcChannel, middleware, onListening, onBuildStart, onBuildEnd, }: StartHeadlessDevServerOptions) => Promise<{
            server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
            stop: () => Promise<void>;
            getBuildResult: () => Promise<BundlerBuildResult>;
        }>;
    };
};

export { devServer };