@lincyaw/web 1.0.0-rc.0 → 1.0.0-rc.2

package/src/node/vite.ts

@@ -1,166 +0,0 @@
-import { createHash } from 'node:crypto'
-import { readFileSync } from 'node:fs'
-import type { AddressInfo } from 'node:net'
-import MiniSearch from 'minisearch'
-import { localRequestRefusal, tokenize } from '@lincyaw/kernel'
-import { IR_ENDPOINT, SOURCE_ENDPOINT } from '../domain/links.ts'
-
-export const IR_MODULE = 'virtual:presmium/ir'
-export const UPDATE_EVENT = 'presmium:update'
-const RESOLVED = `\0${IR_MODULE}`
-
-export function revisionOf(json: string): string {
-  return createHash('sha256').update(json).digest('hex').slice(0, 16)
-}
-
-export interface UpdateEvent {
-  update: unknown
-  base: string
-  revision: string
-}
-
-export type DevMessage =
-  | ({ type: 'presmium:update' } & UpdateEvent)
-  | { type: 'presmium:ready', port: number }
-  | { type: 'presmium:source', file: string, line: number }
-  | { type: 'presmium:translations' }
-
-interface Request { url?: string, method?: string, headers: Record<string, string | string[] | undefined> }
-interface Response { statusCode: number, setHeader(name: string, value: string): void, end(body?: string): void }
-
-interface Module { id: string | null }
-
-interface DevServer {
-  config: { server: { allowedHosts?: true | string[] } }
-  httpServer: { once(event: 'listening' | 'close', listener: () => void): unknown, address(): AddressInfo | string | null } | null
-  middlewares: { use(path: string, handler: (req: Request, res: Response, next?: () => void) => void): unknown }
-  moduleGraph: {
-    getModuleById(id: string): Module | undefined
-    invalidateModule(module: Module, seen?: Set<Module>, timestamp?: number, isHmr?: boolean): void
-  }
-  ws: { send(event: string, data: unknown): void }
-  reloadModule(module: Module): Promise<void>
-}
-
-const SEARCH_INDEX = '/@localSearchIndex'
-
-function searchIndex(documentsFile: string): string {
-  const index = new MiniSearch({ fields: ['title', 'titles', 'text'], storeFields: ['title', 'titles'], tokenize })
-  index.addAll(JSON.parse(readFileSync(documentsFile, 'utf8')))
-  return JSON.stringify(index)
-}
-
-function localeFile(file: string, lang: string): string {
-  return file.replace(/\.json$/, `.${lang}.json`)
-}
-
-export function presmiumFrame(policy: string) {
-  return {
-    name: 'presmium:frame',
-    configureServer(server: DevServer) {
-      server.middlewares.use('/', (_req, res, next) => {
-        res.setHeader('Content-Security-Policy', policy)
-        next?.()
-      })
-    },
-  }
-}
-
-export function presmiumReady() {
-  return {
-    name: 'presmium:ready',
-    configureServer(server: DevServer) {
-      server.httpServer?.once('listening', () => {
-        const address = server.httpServer?.address()
-        if (address && typeof address === 'object') process.send?.({ type: 'presmium:ready', port: address.port } satisfies DevMessage)
-      })
-    },
-  }
-}
-
-export function presmiumIR(irFile: string, searchDocuments: string, endpoints: { ir: string, source: string } = { ir: IR_ENDPOINT, source: SOURCE_ENDPOINT }, locales: string[] = []) {
-  let dev = false
-  const names = ['root', ...locales]
-  const documentsOf = (name: string) => (name === 'root' ? searchDocuments : localeFile(searchDocuments, name))
-  return {
-    name: 'presmium:ir',
-    enforce: 'pre' as const,
-    resolveId(id: string) {
-      if (id === IR_MODULE) return RESOLVED
-      return id.startsWith(`${IR_MODULE}/`) && locales.includes(id.slice(IR_MODULE.length + 1)) ? `\0${id}` : undefined
-    },
-    load(id: string) {
-      if (id === RESOLVED) {
-        const json = readFileSync(irFile, 'utf8')
-        const translations = locales.map(lang => `${JSON.stringify(lang)}: () => import(${JSON.stringify(`${IR_MODULE}/${lang}`)})`)
-        return `export default JSON.parse(${JSON.stringify(json)})\nexport const revision = ${JSON.stringify(revisionOf(json))}\nexport const translations = { ${translations.join(', ')} }`
-      }
-      if (id.startsWith(`${RESOLVED}/`)) return `export default JSON.parse(${JSON.stringify(readFileSync(localeFile(irFile, id.slice(RESOLVED.length + 1)), 'utf8'))})`
-      const module = id.split('?')[0]!
-      if (module === SEARCH_INDEX) {
-        const load = (name: string) => dev ? `import(/* @vite-ignore */ ${JSON.stringify(`.${SEARCH_INDEX}${name}?t=`)} + Date.now())` : `import(${JSON.stringify(`${SEARCH_INDEX.slice(1)}${name}`)})`
-        return `export default { ${names.map(name => `${JSON.stringify(name)}: () => ${load(name)}`).join(', ')} }`
-      }
-      const name = module.startsWith(SEARCH_INDEX) ? module.slice(SEARCH_INDEX.length) : undefined
-      if (name && names.includes(name)) return `export default ${JSON.stringify(searchIndex(documentsOf(name)))}`
-      return undefined
-    },
-    configureServer(server: DevServer) {
-      dev = true
-      const refreshSearch = () => {
-        const index = server.moduleGraph.getModuleById(SEARCH_INDEX)
-        if (!index) return
-        for (const name of names) {
-          const module = server.moduleGraph.getModuleById(`${SEARCH_INDEX}${name}`)
-          if (module) server.moduleGraph.invalidateModule(module, new Set(), Date.now(), true)
-        }
-        void server.reloadModule(index)
-      }
-      const receive = (message: DevMessage) => {
-        if (message?.type !== 'presmium:update' && message?.type !== 'presmium:translations') return
-        for (const id of [RESOLVED, ...locales.map(lang => `${RESOLVED}/${lang}`)]) {
-          const module = server.moduleGraph.getModuleById(id)
-          if (module) server.moduleGraph.invalidateModule(module)
-        }
-        if (message.type === 'presmium:update') server.ws.send(UPDATE_EVENT, { update: message.update, base: message.base, revision: message.revision } satisfies UpdateEvent)
-        refreshSearch()
-      }
-      process.on('message', receive)
-      server.httpServer?.once('close', () => process.off('message', receive))
-      const refused = (req: { headers: Record<string, string | string[] | undefined> }, res: { statusCode: number, end(body?: string): void }) => {
-        const reason = localRequestRefusal(req.headers, server.config.server.allowedHosts)
-        if (reason) {
-          res.statusCode = 403
-          res.end(reason)
-        }
-        return reason !== undefined
-      }
-      server.middlewares.use(endpoints.ir, (req, res) => {
-        if (refused(req, res)) return
-        const json = readFileSync(irFile, 'utf8')
-        res.statusCode = 200
-        res.setHeader('Content-Type', 'application/json')
-        res.setHeader('Cache-Control', 'no-store')
-        res.end(`{"revision":${JSON.stringify(revisionOf(json))},"doc":${json}}`)
-      })
-      server.middlewares.use(endpoints.source, (req, res) => {
-        if (refused(req, res)) return
-        if (req.method !== 'POST' || req.headers['presmium-request'] !== 'source') {
-          res.statusCode = 405
-          res.end()
-          return
-        }
-        const params = new URL(req.url ?? '', 'http://localhost').searchParams
-        const file = params.get('file')
-        const line = Number(params.get('line'))
-        if (file) process.send?.({ type: 'presmium:source', file, line: Number.isInteger(line) && line > 0 ? line : 1 } satisfies DevMessage)
-        res.statusCode = file ? 204 : 400
-        res.end()
-      })
-      server.httpServer?.once('listening', () => {
-        const address = server.httpServer?.address()
-        if (address && typeof address === 'object') process.send?.({ type: 'presmium:ready', port: address.port } satisfies DevMessage)
-      })
-    },
-  }
-}

package/src/node/vitepress.ts

@@ -1,72 +0,0 @@
-import { spawn } from 'node:child_process'
-import { realpathSync } from 'node:fs'
-import type { ChildProcess } from 'node:child_process'
-import { createServer } from 'node:net'
-import type { AddressInfo } from 'node:net'
-import { createRequire } from 'node:module'
-import { dirname, join } from 'node:path'
-import { TYPESCRIPT_IMPORT } from '@lincyaw/kernel/node'
-import type { DevMessage } from './vite.ts'
-
-function bin(): string {
-  const require = createRequire(import.meta.url)
-  const pkg = require.resolve('vitepress/package.json')
-  return join(dirname(pkg), (require(pkg) as { bin: Record<string, string> }).bin.vitepress!)
-}
-
-export function vitepressBuild(root: string, outDir: string): Promise<number> {
-  return new Promise((done) => {
-    const child = spawn(process.execPath, [...TYPESCRIPT_IMPORT, bin(), 'build', realpathSync(root), '--outDir', outDir], { stdio: ['ignore', 2, 2] })
-    child.on('exit', code => done(code ?? 1))
-    child.on('error', () => done(1))
-  })
-}
-
-export function freePort(host: string): Promise<number> {
-  return new Promise((resolve, reject) => {
-    const probe = createServer()
-    probe.once('error', reject)
-    probe.listen(0, host, () => {
-      const { port } = probe.address() as AddressInfo
-      probe.close(() => resolve(port))
-    })
-  })
-}
-
-export interface DevProcess {
-  port: number
-  send(message: DevMessage): void
-  close(): Promise<void>
-}
-
-export async function vitepressDev(root: string, port: number | undefined, receive: (message: DevMessage) => void, options: { host?: string, signal?: AbortSignal } = {}): Promise<DevProcess> {
-  const listen = port === 0 ? await freePort(options.host ?? '127.0.0.1') : port
-  const args = [...TYPESCRIPT_IMPORT, bin(), 'dev', realpathSync(root), ...(listen ? ['--port', String(listen)] : []), ...(options.host ? ['--host', options.host] : [])]
-  const child: ChildProcess = spawn(process.execPath, args, { stdio: ['ignore', 'inherit', 'inherit', 'ipc'] })
-  const exited = new Promise<void>(resolve => child.once('exit', () => resolve()))
-  const stop = () => {
-    if (child.exitCode === null) child.kill('SIGTERM')
-  }
-  options.signal?.addEventListener('abort', stop, { once: true })
-  return new Promise((resolve, reject) => {
-    child.once('error', reject)
-    child.once('exit', code => reject(new Error(`vitepress dev exited with code ${code}`)))
-    child.on('message', (message: DevMessage) => {
-      if (message?.type !== 'presmium:ready') {
-        receive(message)
-        return
-      }
-      resolve({
-        port: message.port,
-        send: m => void child.send(m),
-        async close() {
-          options.signal?.removeEventListener('abort', stop)
-          stop()
-          const timer = setTimeout(() => child.kill('SIGKILL'), 3000)
-          await exited
-          clearTimeout(timer)
-        },
-      })
-    })
-  })
-}