Refactor exported API types

Author: pimterry

src/config.ts

@@ -2,13 +2,10 @@ import * as fs from 'fs/promises';
 import * as os from 'os';
 import * as path from 'path';
 import packageJson from '../package.json' with { type: 'json' };
+import type { Config } from './core-types.js';
 
 const defaultConfigFile = os.homedir() + '/.config/' + packageJson.name.split('/')[1] + '/config.json';
 
-interface Config {
-    browsers: any[];
-}
-
 interface ReadResult {
     data: Config | null;
     configDir: string;

src/core-types.ts

@@ -0,0 +1,32 @@
+export interface Browser {
+    name: string;
+    version: string;
+    type: string;
+    command: string;
+    profile: string | boolean;
+    processName?: string;
+    tempDir?: string;
+    neverStartFresh?: boolean;
+    headless?: boolean;
+    regex?: RegExp;
+}
+
+export type BrowserInfo = Pick<Browser, 'name' | 'version' | 'type' | 'command'>;
+
+export interface Config {
+    browsers: Browser[];
+}
+
+export interface LaunchOptions {
+    browser: string;
+    version?: string;
+    proxy?: string;
+    options?: string[];
+    skipDefaults?: boolean;
+    detached?: boolean;
+    noProxy?: string | string[];
+    headless?: boolean;
+    prefs?: { [key: string]: any };
+    profile?: string | null;
+    tempDir?: string;
+}

src/create_profiles.ts

@@ -1,18 +1,7 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import type { Browser } from './core-types.js';
 
-interface Browser {
-    type: string;
-    name: string;
-    version: string;
-    profile: string | boolean;
-}
-
-/**
- * Create profiles for the given browsers
- * @param browsers Array of browsers
- * @param configDir Path to a directory, where the profiles should be put
- */
 async function createProfiles(browsers: Browser[], configDir: string): Promise<void> {
     function dirName(name: string, version: string): string {
         const dir = name + '-' + version;

src/detect.ts

@@ -3,23 +3,15 @@ import { darwinBrowsers } from './darwin/index.js';
 import assign from 'lodash/assign.js';
 import { Browsers } from './browsers.js';
 import winDetectBrowsers from 'win-detect-browsers';
+import type { Browser } from './core-types.js';
 
 const browsers = new Browsers();
 
-interface DetectedBrowser {
-    type: string;
-    name: string;
-    command: string;
-    version: string;
-    profile?: string | boolean;
-    [key: string]: any;
-}
-
 /**
  * Detect all available browsers on Windows systems.
  * Returns an array of detected browsers.
  */
-async function detectWindows(): Promise<DetectedBrowser[]> {
+async function detectWindows(): Promise<Browser[]> {
     const results = await winDetectBrowsers();
 
     return results.map((browser) => {
@@ -131,7 +123,7 @@ async function checkUnix(commands: string[], regex: RegExp): Promise<{ version:
  * Detect all available web browsers.
  * Returns an array of available browsers.
  */
-async function detect(): Promise<DetectedBrowser[]> {
+async function detect(): Promise<Browser[]> {
     if (process.platform === 'win32') {
         try {
             return await detectWindows();
@@ -177,12 +169,12 @@ async function detect(): Promise<DetectedBrowser[]> {
                 name: browserPlatform.darwin || browserPlatform.type,
                 command: command,
                 version: version
-            }) as DetectedBrowser;
+            }) as Browser;
         })
     );
 
     return results
-        .filter((result): result is PromiseFulfilledResult<DetectedBrowser> => result.status === 'fulfilled')
+        .filter((result): result is PromiseFulfilledResult<Browser> => result.status === 'fulfilled')
         .map(result => result.value);
 }
 

src/index.ts

@@ -5,34 +5,11 @@ import { detect } from './detect.js';
 import { runBrowser } from './run.js';
 import { createProfiles } from './create_profiles.js';
 import { BrowserInstance } from './instance.js';
-
-interface Config {
-    browsers: any[];
-}
-
-interface LaunchOptions {
-    browser: string;
-    version?: string;
-    proxy?: string;
-    options?: string[];
-    skipDefaults?: boolean;
-    detached?: boolean;
-    noProxy?: string | string[];
-    headless?: boolean;
-    prefs?: { [key: string]: any };
-    profile?: string | null;
-}
-
-interface Browser {
-    name: string;
-    version: string;
-    type: string;
-    command: string;
-}
+import type { Config, LaunchOptions, Browser, BrowserInfo } from './core-types.js';
 
 interface LaunchFunction {
     (uri: string, options: string | LaunchOptions): Promise<BrowserInstance>;
-    browsers: any[];
+    browsers: Browser[];
 }
 
 /**
@@ -85,19 +62,19 @@ async function getLauncher(configFile?: string): Promise<LaunchFunction> {
 /**
  * Detect available browsers
  */
-async function detectBrowsers(): Promise<Browser[]> {
+async function detectBrowsers(): Promise<BrowserInfo[]> {
     const browsers = await detect();
     return browsers.map((browser) => {
         return pick(browser, ['name', 'version', 'type', 'command']);
-    }) as Browser[];
+    }) as BrowserInfo[];
 }
 
 /**
  * Detect the available browsers and build appropriate profiles if necessary
  */
 async function buildConfig(configDir: string): Promise<Config> {
     const browsers = await detect();
-    await createProfiles(browsers as any, configDir);
+    await createProfiles(browsers, configDir);
     return { browsers };
 }
 
@@ -127,5 +104,6 @@ async function updateBrowsers(configFile?: string): Promise<Config> {
 }
 
 export { getLauncher, detectBrowsers, updateBrowsers };
-export type { Config, LaunchOptions, Browser, LaunchFunction };
+export type { Config, LaunchOptions, Browser, BrowserInfo } from './core-types.js';
+export type { LaunchFunction };
 export { BrowserInstance } from './instance.js';

src/run.ts

@@ -5,36 +5,7 @@ import * as path from 'path';
 import assign from 'lodash/assign.js';
 import { BrowserInstance } from './instance.js';
 import headless from 'headless';
-
-interface Browser {
-    type: string;
-    name: string;
-    version: string;
-    command: string;
-    profile: string | boolean;
-    processName?: string;
-    tempDir?: string;
-    neverStartFresh?: boolean;
-    [key: string]: any;
-}
-
-interface Config {
-    browsers: Browser[];
-}
-
-interface LaunchOptions {
-    browser?: string;
-    version?: string;
-    proxy?: string;
-    options?: string[];
-    skipDefaults?: boolean;
-    detached?: boolean;
-    noProxy?: string | string[];
-    headless?: boolean;
-    prefs?: { [key: string]: any };
-    profile?: string | null;
-    tempDir?: string;
-}
+import type { Browser, Config, LaunchOptions } from './core-types.js';
 
 type SetupResult = { args: string[]; defaultArgs: string[] };
 type BrowserRunner = (uri: string, options: LaunchOptions) => Promise<BrowserInstance>;