unplugin-https-reverse-proxy 0.0.12 → 0.0.14

package/src/caddy/utils.ts

@@ -1,4 +1,8 @@
 import { createServer } from 'node:net'
+import ora from 'ora'
+import { consola } from '../utils'
+
+let spinner: ora.Ora
 
 /**
  * @returns whether the port is in use
@@ -23,3 +27,40 @@ export function tryPort(port: number) {
     }
   })
 }
+
+function getNumber(number: number) {
+  if (number <= 0)
+    return '0%'
+  else if (number < 100)
+    return `${number.toFixed(2)}%`
+  else
+    return '100%'
+}
+
+export function logProgress(percent: number | string) {
+  if (!spinner) {
+    // empty a line before start
+    consola.log('')
+    spinner = ora({
+      text: 'Start Download Caddy: 0%',
+      indent: 2,
+    })
+    spinner.start()
+  }
+  else { spinner.text = `Download Caddy: ${getNumber(Number(percent) * 100)}` }
+}
+
+export function logProgressOver() {
+  if (!spinner) {
+    spinner = ora({
+      text: 'Start Download Caddy: 100%',
+      indent: 2,
+    })
+    spinner.start()
+  }
+  else {
+    spinner.succeed()
+    // empty a line after succeed
+    consola.log('')
+  }
+}

package/src/index.ts

@@ -1,9 +1,9 @@
 import process from 'node:process'
 import type { UnpluginFactory } from 'unplugin'
 import { createUnplugin } from 'unplugin'
-import type { ResolvedConfig } from 'vite'
+import type { ResolvedConfig, ViteDevServer } from 'vite'
 import c from 'picocolors'
-import { consola } from './utils'
+import { consola, once } from './utils'
 import type { Options } from './types'
 import { CaddyInstant } from './caddy'
 
@@ -11,12 +11,59 @@ let config: ResolvedConfig
 
 let caddy: CaddyInstant
 
+let _stop: (callback?: () => any) => Promise<any>
+let _servce: ViteDevServer
+
+function registerExit(clear: (() => Promise<any>) | (() => any)) {
+  process.on('beforeExit', async (_code) => {
+    await clear()
+  })
+
+  process.on('uncaughtException', async (err) => {
+    console.error('An uncaught error occurred!', err.stack)
+    await clear()
+    process.nextTick(() => {
+      process.exit(1)
+    })
+  })
+
+  process.on('unhandledRejection', async (reason, promise) => {
+    console.error('Unhandled Rejection at:', promise, 'reason:', reason)
+    await clear()
+    process.nextTick(() => {
+      process.exit(1)
+    })
+  })
+
+  process.once('SIGINT', async () => {
+    await clear()
+    process.emit('SIGINT')
+  })
+
+  process.once('SIGTERM', async () => {
+    await clear()
+    process.emit('SIGTERM')
+  })
+}
+
 export const unpluginFactory: UnpluginFactory<Options> = options => ({
   name: 'unplugin-https-reverse-proxy',
-  enforce: 'post',
+  enforce: 'pre',
   vite: {
     configResolved(_config) {
       config = _config
+      registerExit(async () => {
+        try {
+          _servce && _servce.close()
+          _servce.httpServer?.close(async () => {
+            _stop && await _stop()
+          })
+          _stop && await _stop()
+        }
+        catch (e) {
+          consola.error(e)
+        }
+      })
     },
     configureServer(server) {
       const {
@@ -29,6 +76,9 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
         consola.fail('please provide target')
         return
       }
+
+      _servce = server
+
       const _printUrls = server.printUrls
       server.printUrls = () => {
         _printUrls()
@@ -40,19 +90,16 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
         }
         const base = server.config.base || '/'
         try {
-          const caddy = new CaddyInstant()
+          if (caddy)
+            return
+          caddy = new CaddyInstant()
           caddy.run(source, target, {
             base,
             showCaddyLog: options.showCaddyLog,
           }).then((stop) => {
             const colorUrl = (url: string) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`))
             consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`https://${target}${base}`)}`)
-
-            process.on('SIGINT', async () => {
-              await stop()
-              server.close()
-              process.exit()
-            })
+            !_stop && (_stop = once(stop))
           }).catch((e) => {
             throw e
           })
@@ -74,14 +121,43 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
       consola.fail('please provide target')
       return
     }
+
     try {
-      // @ts-expect-error vuecli
-      const devServer = compiler.options.devServer || process.VUE_CLI_SERVICE.projectOptions.devServer
-      const source = `${devServer?.host || '127.0.0.1'}:${devServer?.port || '8080'}`
+      // registerExit(async () => {
+      //   try {
+      //     _stop && await _stop()
+      //   }
+      //   catch (e) {
+      //     consola.error(e)
+      //   }
+      // })
+
+      const devServer = {
+        host: '127.0.0.1',
+        port: 8080,
+        ...compiler.options.devServer,
+        // @ts-expect-error vuecli
+        ...process.VUE_CLI_SERVICE.projectOptions.devServer,
+      }
+      const source = `${devServer.host}:${devServer.port}`
 
       if (caddy)
         return
 
+      // https://github.com/webpack/webpack-dev-server/blob/master/lib/Server.js#L1913
+      const _close = compiler.close.bind(compiler)
+      compiler.close = async (callback: Parameters<typeof _close>[0]) => {
+        try {
+          _stop && await _stop(() => {
+            _close && _close(callback)
+          })
+        }
+        catch (e) {
+          consola.error(e)
+          process.exit(1)
+        }
+      }
+
       caddy = new CaddyInstant()
 
       caddy.run(source, target, {
@@ -89,16 +165,10 @@ export const unpluginFactory: UnpluginFactory<Options> = options => ({
       }).then((stop) => {
         const colorUrl = (url: string) => c.green(url.replace(/:(\d+)\//, (_, port) => `:${c.bold(port)}/`))
 
-        compiler.hooks.done.tap('unplugin-https-reverse-proxy', (stats) => {
-          if (stats.hasErrors())
-            return
-
+        compiler.hooks.done.tap('unplugin-https-reverse-proxy', () => {
           consola.success(`  ${c.green('➜')}  ${c.bold('run caddy reverse proxy success')}: ${colorUrl(`https://${target}`)}`)
-        })
 
-        process.on('SIGINT', async () => {
-          await stop()
-          process.exit()
+          !_stop && (_stop = once(stop))
         })
       }).catch((e) => {
         throw e

package/src/utils.ts

@@ -3,3 +3,13 @@ import { createConsola } from 'consola'
 export const consola = createConsola({
   level: 3,
 }).withTag('reverse-proxy')
+
+export function once<T extends (...args: any[]) => any>(fn: T): (...args: Parameters<T>) => ReturnType<T> {
+  let called = false
+  return (...args: any[]) => {
+    if (called)
+      return
+    called = true
+    return fn(...args)
+  }
+}

package/dist/chunk-3HKPYCSE.js

@@ -1,9 +0,0 @@
-// src/utils.ts
-import { createConsola } from "consola";
-var consola = createConsola({
-  level: 3
-}).withTag("reverse-proxy");
-
-export {
-  consola
-};