chore(docz): simplify bundler constructor

packages/docz-bundler-webpack/src/index.ts

@@ -1,22 +1,19 @@
-import { Configuration } from 'webpack'
+import { Configuration as CFG } from 'webpack'
 import { ConfigArgs, createBundler, BundlerCreate } from 'docz'
-import * as WebpackDevServer from 'webpack-dev-server'
+import * as Server from 'webpack-dev-server'
 import webpack from 'webpack'
 
 import { devServerConfig } from './devserver'
 import { createConfig as config } from './config'
 
-export const compiler = (args: ConfigArgs) => (cfg: Configuration) =>
-  webpack(cfg)
+export const server = (args: ConfigArgs) => (config: CFG): Server => {
+  const compiler = webpack(config)
+  const devserver = devServerConfig(args)
 
-export const server = (cfg: ConfigArgs) => (comp: any): WebpackDevServer =>
-  new WebpackDevServer(comp, devServerConfig(cfg))
+  return new Server(compiler, devserver)
+}
 
-export const bundler: BundlerCreate<
-  Configuration,
-  WebpackDevServer
-> = createBundler<Configuration, WebpackDevServer>({
-  compiler,
+export const bundler: BundlerCreate<CFG, Server> = createBundler<CFG, Server>({
   config,
   server,
   id: 'webpack',

packages/docz/src/Bundler.ts

@@ -2,8 +2,7 @@ import { Plugin } from './Plugin'
 import { ConfigArgs } from './Server'
 
 export type TConfigFn<C> = () => C
-export type TCompilerFn<C> = (config: C) => any
-export type TServerFn<S> = (compiler: any) => S
+export type TServerFn<C, S> = (config: C) => S
 
 export interface CompilerOpts {
   args: ConfigArgs
@@ -12,57 +11,60 @@ export interface CompilerOpts {
 export interface BundlerConstructor<C, S> extends CompilerOpts {
   id: string
   config: TConfigFn<C>
-  compiler: TCompilerFn<C>
-  server: TServerFn<S>
+  server: TServerFn<C, S>
 }
 
 export class Bundler<C = any, S = any> {
   public readonly id: string
   private readonly args: ConfigArgs
   private config: TConfigFn<C>
-  private compiler: TCompilerFn<C>
-  private server: TServerFn<S>
+  private server: TServerFn<C, S>
 
   constructor(params: BundlerConstructor<C, S>) {
-    const { args, id, config, compiler, server } = params
+    const { args, id, config, server } = params
 
     this.args = args
     this.id = id
     this.config = config
-    this.compiler = compiler
     this.server = server
   }
 
-  public async createCompiler(): Promise<any> {
-    return this.compiler(this.mountConfig())
+  public getConfig(): C {
+    return this.mountConfig(this.config())
   }
 
-  public async createServer(compiler: any): Promise<S> {
-    return this.server(compiler)
+  public async createServer(config: C): Promise<S> {
+    const { plugins } = this.args
+    const server = await this.server(config)
+
+    if (plugins && plugins.length > 0) {
+      for (const plugin of plugins) {
+        await plugin.bundlerServer(server)
+      }
+    }
+
+    return server
   }
 
   private reduceWithPlugins(dev: boolean): any {
     return (config: C, plugin: Plugin) =>
       plugin.bundlerConfig(config, dev) || config
   }
 
-  private mountConfig(): C {
+  private mountConfig(config: C): C {
     const { plugins, env } = this.args
-
     const dev = env === 'development'
-    const initialConfig = this.config()
 
     return plugins && plugins.length > 0
-      ? plugins.reduce(this.reduceWithPlugins(dev), initialConfig)
-      : initialConfig
+      ? plugins.reduce(this.reduceWithPlugins(dev), config)
+      : config
   }
 }
 
 export interface Factory<C, S> {
   id: string
   config: (args: ConfigArgs) => TConfigFn<C>
-  compiler: (args: ConfigArgs) => TCompilerFn<C>
-  server: (args: ConfigArgs) => TServerFn<S>
+  server: (args: ConfigArgs) => TServerFn<C, S>
 }
 
 export type BundlerCreate<C, S> = (args: ConfigArgs) => Bundler<C, S>
@@ -73,7 +75,6 @@ export function createBundler<C, S>(
   return (args: ConfigArgs): Bundler<C, S> =>
     new Bundler({
       args,
-      compiler: factory.compiler(args),
       config: factory.config(args),
       id: factory.id,
       server: factory.server(args),

packages/docz/src/Server.ts

@@ -55,20 +55,13 @@ export class Server {
   }
 
   public async start(): Promise<void> {
-    const { plugins, port } = this.config
+    const { port } = this.config
 
     del.sync(paths.docz)
     this.processEntries(this.config)
 
-    const compiler = await this.bundler.createCompiler()
-    const server = await this.bundler.createServer(compiler)
-
-    if (plugins && plugins.length > 0) {
-      for (const plugin of plugins) {
-        await plugin.bundlerCompiler(compiler)
-        await plugin.bundlerServer(server)
-      }
-    }
+    const config = this.bundler.getConfig()
+    const server = await this.bundler.createServer(config)
 
     server.listen(port)
   }
@@ -84,7 +77,6 @@ export class Server {
 
   private processEntries(config: ConfigArgs): void {
     const entries = new Entries(config)
-
     const update = () => entries.write()
 
     const onUnlink = (file: string) => {