Configuration

/**
 * Main configuration interface
 * Defined in svelte.config.js
 */
interface Config {
  kit?: KitConfig;
  // Plus other Svelte/Vite config options
}

interface KitConfig {
  adapter?: Adapter;
  alias?: Record<string, string>;
  appDir?: string;
  csp?: CSPConfig;
  csrf?: CSRFConfig;
  embedded?: boolean;
  env?: EnvConfig;
  experimental?: ExperimentalConfig;
  files?: FilesConfig;
  inlineStyleThreshold?: number;
  moduleExtensions?: string[];
  outDir?: string;
  output?: OutputConfig;
  paths?: PathsConfig;
  prerender?: PrerenderConfig;
  router?: boolean | RouterConfig;
  serviceWorker?: ServiceWorkerConfig;
  typescript?: TypeScriptConfig;
  version?: VersionConfig;
}

// svelte.config.js
import adapter from '@sveltejs/adapter-auto';

/** @type {import('@sveltejs/kit').Config} */
const config = {
  kit: {
    adapter: adapter(),
    alias: {
      $components: 'src/components'
    },
    paths: {
      base: '/myapp'
    },
    prerender: {
      entries: ['*']
    }
  }
};

export default config;

/**
 * Interface for deployment adapters
 */
interface Adapter {
  name: string;
  adapt(builder: Builder): Promise<void> | void;
  supports?: {
    read?: (details: { config: any; route: { id: string } }) => boolean;
    instrumentation?: () => boolean;
  };
  emulate?: () => MaybePromise<Emulator>;
}

interface Builder {
  log: Logger;
  rimraf(dir: string): void;
  mkdirp(dir: string): void;
  config: ValidatedConfig;
  prerendered: Prerendered;
  routes: RouteDefinition[];
  appDir: string;
  appPath: string;
  writeClient(dest: string): string[];
  writePrerendered(dest: string): string[];
  writeServer(dest: string): string[];
  copy(from: string, to: string, options?: { filter?: (basename: string) => boolean; replace?: Record<string, string> }): string[];
  compress(directory: string): Promise<void>;
  createEntries(fn: (route: RouteDefinition) => AdapterEntry): Promise<void>;
  findServerAssets(routes: RouteDefinition[]): string[];
  generateFallback(dest: string): Promise<void>;
  generateEnvModule(): void;
  generateManifest(options: { relativePath: string; routes?: RouteDefinition[] }): string;
  getBuildDirectory(name: string): string;
  getClientDirectory(): string;
  getServerDirectory(): string;
  getAppPath(): string;
  hasServerInstrumentationFile(): boolean;
  instrument(args: {
    entrypoint: string;
    instrumentation: string;
    start?: string;
    module?: { exports: string[] } | { generateText: (args: { instrumentation: string; start: string }) => string };
  }): void;
}

// adapter.js
export default function adapter() {
  return {
    name: 'my-adapter',
    async adapt(builder) {
      builder.rimraf('.output');
      builder.mkdirp('.output');

      builder.writeClient('.output/client');
      builder.writeServer('.output/server');
      builder.writePrerendered('.output/prerendered');

      // Generate server entry
      builder.copy('entry.js', '.output/server/entry.js');
    }
  };
}

interface PathsConfig {
  base?: string;
  assets?: string;
  relative?: boolean;
}

interface PrerenderConfig {
  concurrency?: number;
  crawl?: boolean;
  entries?: string[];
  handleHttpError?: 'fail' | 'warn' | 'ignore' | ((details: { status: number; path: string; referrer: string | null; referenceType: string }) => 'fail' | 'warn' | 'ignore');
  handleMissingId?: 'fail' | 'warn' | 'ignore' | ((details: { path: string; id: string; referrers: string[] }) => 'fail' | 'warn' | 'ignore');
  origin?: string;
}

interface CSPConfig {
  mode?: 'hash' | 'nonce';
  directives?: CSPDirectives;
  reportOnly?: CSPDirectives;
}

interface CSRFConfig {
  checkOrigin?: boolean;
}

interface EnvConfig {
  dir?: string;
  publicPrefix?: string;
  privatePrefix?: string;
}

interface VersionConfig {
  name?: string;
  pollInterval?: number;
}

interface RouterConfig {
  type?: 'pathname' | 'hash';
  resolution?: 'client' | 'server';
}

interface ExperimentalConfig {
  tracing?: {
    server?: boolean;
  };
  instrumentation?: {
    server?: boolean;
  };
  remoteFunctions?: boolean;
}

interface OutputConfig {
  preloadStrategy?: 'modulepreload' | 'preload-js' | 'preload-mjs';
  bundleStrategy?: 'split' | 'single' | 'inline';
}