@lazarv/react-server/adapters/*

Shared types and helpers for building deploy adapters. The same surface is re-exported from every @lazarv/react-server/adapters/<target> subpath — each concrete adapter is a thin wrapper around createAdapter.

function banner(message: string, options?: {
    forceVerbose?: boolean;
    emoji?: string;
}): void;

function clearDirectory(dir: string): Promise<void>;

function clearProgress(): void;

function copy(srcDir: string, destDir: string, reactServerOutDir: string): (file: string) => Promise<void>;

function copyFiles(message: string, files: string[], srcDir: string, destDir: string, reactServerOutDir: string, emoji?: string): Promise<void>;

function copyMessage(file: string, srcDir: string, destDir: string, reactServerOutDir: string): void;

function createAdapter<T = any, R = void>(options: {
    name: string;
    outDir: string;
    outStaticDir?: string;
    outServerDir?: string;
    handler: (options: {
        adapterOptions: T;
        files: {
            static: () => Promise<string[]>;
            compressed: () => Promise<string[]>;
            assets: () => Promise<string[]>;
            client: () => Promise<string[]>;
            public: () => Promise<string[]>;
            server: () => Promise<string[]>;
            dependencies: (adapterFiles: string[]) => Promise<{
                src: string;
                dest: string;
            }[]>;
            all: () => Promise<string[]>;
        };
        copy: {
            static: (out?: string) => Promise<void>;
            compressed: (out?: string) => Promise<void>;
            assets: (out?: string) => Promise<void>;
            client: (out?: string) => Promise<void>;
            public: (out?: string) => Promise<void>;
            server: (out?: string) => Promise<void>;
            dependencies: (out: string, adapterFiles?: string[]) => Promise<void>;
        };
        config: Record<string, any>;
        reactServerDir: string;
        reactServerOutDir: string;
        root: string;
        options: Record<string, any>;
    }) => Promise<R>;
    deploy?: DeployCommandDescriptor | ((context: {
        adapterOptions: T;
        options: Record<string, any>;
        handlerResult: R;
    }) => DeployCommandDescriptor | Promise<DeployCommandDescriptor> | void | Promise<void>);
}): Adapter<T>;

function deepMerge<T extends Record<string, any>>(source: T, target: Partial<T>): T;

function defineConfig<T = any>(adapterOptions?: T): (config: any, root: string, options: any) => Promise<void>;

function getConfig(): Record<string, any>;

function getDependencies(adapterFiles: string[], reactServerDir: string): Promise<{
    src: string;
    dest: string;
}[]>;

function getFiles(pattern: string | string[], srcDir?: string): Promise<string[]>;

function getPublicDir(): string;

function mergeTomlConfig<T = Record<string, any>>(existingPath: string, adapterConfig: Partial<T>): T;

function message(primary: string, secondary?: string): void;

function readToml<T = Record<string, any>>(filePath: string): T | null;

function spawnCommand(command: string, args: string[], options?: {
    cwd?: string;
}): Promise<void>;

function success(message: string): void;

function writeJSON(path: string, data: Record<string, any>): Promise<void>;

function writeToml(filePath: string, data: Record<string, any>): Promise<void>;

let adapter: Adapter;

let buildOptions: BuildOptions | undefined;

interface Adapter<T = any> {
    (adapterOptions: T, root: string, options: any): Promise<void>;
}

type BuildOptions = {
    edge?: {
        entry: string;
    };
};

type DeployCommandDescriptor = {
    command: string;
    args: string[];
    cwd?: string;
    message?: string;
    afterDeploy?: () => void | Promise<void>;
};