cleanup startDevServer() interface

plugins/web-test-runner-plugin/plugin.js

@@ -22,7 +22,7 @@ To Resolve:
     name: 'snowpack-plugin',
     async serverStart({fileWatcher}) {
       fileWatcher.add(Object.keys(config.mount));
-      server = await snowpack.startServer({
+      server = await snowpack.startDevServer({
         cwd,
         config,
         lockfile: null,
@@ -50,7 +50,7 @@ To Resolve:
         source.indexOf('?') === -1 ? undefined : source.indexOf('?'),
       );
       const sourcePath = path.join(cwd, reqPath);
-      const mountedUrl = snowpack.unstable__getUrlForFile(sourcePath, config);
+      const mountedUrl = snowpack.getUrlForFile(sourcePath, config);
       if (!mountedUrl) {
         throw new Error(`${source} could not be mounted!`);
       }

snowpack/src/commands/dev.ts

@@ -62,7 +62,7 @@ import {
   transformFileImports,
 } from '../rewrite-imports';
 import {matchDynamicImportValue} from '../scan-imports';
-import {CommandOptions, ImportMap, SnowpackBuildMap} from '../types/snowpack';
+import {CommandOptions, ImportMap, SnowpackBuildMap, LoadResult, SnowpackDevServer} from '../types/snowpack';
 import {
   BUILD_CACHE,
   checkLockfileHash,
@@ -84,52 +84,6 @@ import {getInstallTargets, run as installRunner} from './install';
 import {getPort, getServerInfoMessage, paintDashboard, paintEvent} from './paint';
 import {isBinaryFile} from 'isbinaryfile';
 
-interface LoadResult<T = Buffer | string> {
-  contents: T;
-  originalFileLoc: string | null;
-  responseFileName: string;
-  checkStale?: () => Promise<void>;
-}
-
-export interface ServerResult {
-  loadUrl: {
-    (
-      reqUrl: string,
-      opt?:
-        | {
-            isSSR?: boolean | undefined;
-            allowStale?: boolean | undefined;
-            encoding?: undefined;
-          }
-        | undefined,
-    ): Promise<LoadResult<Buffer | string>>;
-    (
-      reqUrl: string,
-      opt: {
-        isSSR?: boolean;
-        allowStale?: boolean;
-        encoding: BufferEncoding;
-      },
-    ): Promise<LoadResult<string>>;
-    (
-      reqUrl: string,
-      opt: {
-        isSSR?: boolean;
-        allowStale?: boolean;
-        encoding: null;
-      },
-    ): Promise<LoadResult<Buffer>>;
-  };
-  handleRequest: (
-    req: http.IncomingMessage,
-    res: http.ServerResponse,
-    options?: {handleError?: boolean},
-  ) => Promise<void>;
-  sendResponseFile: typeof sendResponseFile;
-  sendResponseError: typeof sendResponseError;
-  shutdown(): Promise<void>;
-}
-
 interface FoundFile {
   fileLoc: string;
   isStatic: boolean;
@@ -325,7 +279,7 @@ function handleResponseError(req, res, err: Error | NotFoundError) {
   return;
 }
 
-export async function startServer(commandOptions: CommandOptions): Promise<ServerResult> {
+export async function startDevServer(commandOptions: CommandOptions): Promise<SnowpackDevServer> {
   // Start the startup timer!
   let serverStart = performance.now();
 
@@ -1433,6 +1387,7 @@ export async function startServer(commandOptions: CommandOptions): Promise<Serve
   depWatcher.on('unlink', onDepWatchEvent);
 
   return {
+    port,
     loadUrl,
     handleRequest,
     sendResponseFile,
@@ -1446,7 +1401,7 @@ export async function startServer(commandOptions: CommandOptions): Promise<Serve
 
 export async function command(commandOptions: CommandOptions) {
   try {
-    await startServer(commandOptions);
+    await startDevServer(commandOptions);
   } catch (err) {
     logger.error(err.message);
     logger.debug(err.stack);

snowpack/src/index.ts

@@ -13,19 +13,21 @@ import {clearCache, readLockfile} from './util.js';
 export * from './types/snowpack';
 
 // Stable API:
-export {startServer, ServerResult} from './commands/dev';
+export {startDevServer} from './commands/dev';
 export {loadAndValidateConfig};
-
-// Unstable: These APIs are in progress and subject to change across minor versions
-export {getUrlForFile as unstable__getUrlForFile} from './build/file-urls';
+export {getUrlForFile} from './build/file-urls';
 
 /** DEPRECATED: Promoted to startServer() **/
 export const unstable__startServer = () => {
-  throw new Error(`[snowpack 2.15] unstable__startServer is now startServer`);
+  throw new Error(`[snowpack 2.15] unstable__startServer() is now startServer()`);
 };
 /** DEPRECATED: Promoted to loadAndValidateConfig() **/
 export const unstable__loadAndValidateConfig = () => {
-  throw new Error(`[snowpack 2.15] unstable__loadAndValidateConfig is now loadAndValidateConfig`);
+  throw new Error(`[snowpack 2.15] unstable__loadAndValidateConfig() is now loadAndValidateConfig()`);
+};
+/** DEPRECATED: Promoted to getUrlForFile() **/
+export const unstable__getUrlForFile = () => {
+  throw new Error(`[snowpack 2.15] unstable__getUrlForFile() is now getUrlForFile()`);
 };
 
 const cwd = process.cwd();

snowpack/src/types/snowpack.ts

@@ -11,6 +11,59 @@ export type DeepPartial<T> = {
     : DeepPartial<T[P]>;
 };
 
+
+export interface LoadResult<T = Buffer | string> {
+  contents: T;
+  originalFileLoc: string | null;
+  responseFileName: string;
+  checkStale?: () => Promise<void>;
+}
+
+export interface SnowpackDevServer {
+  port: number;
+  loadUrl: {
+    (
+      reqUrl: string,
+      opt?:
+        | {
+            isSSR?: boolean | undefined;
+            allowStale?: boolean | undefined;
+            encoding?: undefined;
+          }
+        | undefined,
+    ): Promise<LoadResult<Buffer | string>>;
+    (
+      reqUrl: string,
+      opt: {
+        isSSR?: boolean;
+        allowStale?: boolean;
+        encoding: BufferEncoding;
+      },
+    ): Promise<LoadResult<string>>;
+    (
+      reqUrl: string,
+      opt: {
+        isSSR?: boolean;
+        allowStale?: boolean;
+        encoding: null;
+      },
+    ): Promise<LoadResult<Buffer>>;
+  };
+  handleRequest: (
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    options?: {handleError?: boolean},
+  ) => Promise<void>;
+  sendResponseFile: (
+    req: http.IncomingMessage,
+    res: http.ServerResponse,
+    {contents, originalFileLoc, responseFileName}: LoadResult,
+  ) => void;
+  sendResponseError: (req: http.IncomingMessage, res: http.ServerResponse, status: number) => void;
+  shutdown(): Promise<void>;
+}
+
+
 export type SnowpackBuiltFile = {
   code: string | Buffer;
   map?: string;