📦 Akryum / meteor-vite

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120import Path from 'node:path'
import type { ViteDevServer } from 'vite'
import { createServer, resolveConfig } from 'vite'
import Logger from '../../Logger'
import type { MeteorIPCMessage } from '../../meteor/MeteorEvents'
import MeteorEvents from '../../meteor/MeteorEvents'
import type { MeteorViteConfig } from '../../vite/MeteorViteConfig'
import { MeteorStubs } from '../../vite'
import type { ProjectJson } from '../../vite/plugin/MeteorStubs'
import { RefreshNeeded } from '../../vite/ViteLoadRequest'
import type { IPCReply } from './IPC/interface'
import CreateIPCInterface from './IPC/interface'

let server: ViteDevServer & { config: MeteorViteConfig }
let viteConfig: MeteorViteConfig

type Replies = IPCReply<{
  kind: 'viteConfig'
  data: {
    host?: string | boolean
    port?: number
    entryFile?: string
  }
} | {
  kind: 'refreshNeeded'
  data: unknown
}>

interface DevServerOptions {
  packageJson: ProjectJson
  globalMeteorPackagesDir: string
}

export default CreateIPCInterface({
  'vite.getDevServerConfig': async function (replyInterface: Replies) {
    sendViteConfig(replyInterface)
  },

  'meteor.ipcMessage': async function (reply, data: MeteorIPCMessage) {
    MeteorEvents.ingest(data)
  },

  // todo: Add reply for triggering a server restart
  'vite.startDevServer': async function (replyInterface: Replies, { packageJson, globalMeteorPackagesDir }: DevServerOptions) {
    let listening = false
    viteConfig = await resolveConfig({
      configFile: packageJson?.meteor?.viteConfig,
    }, 'serve')

    if (!server) {
      server = await createServer({
        configFile: viteConfig.configFile,
        plugins: [
          MeteorStubs({
            meteor: {
              packagePath: Path.join('.meteor', 'local', 'build', 'programs', 'web.browser', 'packages'),
              isopackPath: Path.join('.meteor', 'local', 'isopacks'),
              globalMeteorPackagesDir,
            },
            packageJson,
            stubValidation: viteConfig.meteor?.stubValidation,
          }),
          {
            name: 'meteor-handle-restart',
            buildStart() {
              if (!listening)
                sendViteConfig(replyInterface)
            },
          },
        ],
      })

      process.on('warning', (warning) => {
        if (warning.name !== RefreshNeeded.name)
          return

        replyInterface({
          kind: 'refreshNeeded',
          data: {},
        })
      })
    }

    await server.listen()
    sendViteConfig(replyInterface)
    listening = true
  },

  'vite.stopDevServer': async function () {
    if (!server)
      return
    try {
      console.log('Shutting down vite server...')
      await server.close()
      console.log('Vite server shut down successfully!')
    }
    catch (error) {
      console.error('Failed to shut down Vite server:', error)
    }
  },
})

function sendViteConfig(reply: Replies) {
  if (!server) {
    Logger.debug('Tried to get config from Vite server before it has been created!')
    return
  }

  const { config } = server

  reply({
    kind: 'viteConfig',
    data: {
      host: config.server?.host,
      port: config.server?.port,
      entryFile: config.meteor?.clientEntry,
    },
  })
}