chore: bump version

Author: sonofmagic

.changeset/youhua-postinstall.md

@@ -0,0 +1,5 @@
+---
+"@weapp-tailwindcss/merge": patch
+---
+
+- 调整 postinstall 引导脚本，优先加载 ESM 版本并补充回退与错误处理逻辑。

packages/merge/package.json

@@ -60,7 +60,7 @@
     "release": "pnpm publish",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "postinstall": "node scripts/postinstall.cjs"
+    "postinstall": "node scripts/postinstall.mjs"
   },
   "publishConfig": {
     "exports": {

packages/merge/scripts/postinstall.cjs

@@ -0,0 +1,83 @@
+import { existsSync as defaultExistsSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import process from 'node:process'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const requireFn = createRequire(import.meta.url)
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+/**
+ * @param {object} [options]
+ * @param {(path: string) => boolean} [options.existsSync]
+ * @param {(path: string) => Promise<unknown>} [options.loadEsm]
+ * @param {(path: string) => unknown | Promise<unknown>} [options.loadCjs]
+ * @param {{ log: typeof console.log, error: typeof console.error }} [options.logger]
+ */
+export async function run(options = {}) {
+  const {
+    existsSync = defaultExistsSync,
+    loadEsm = async filePath => import(pathToFileURL(filePath).href),
+    loadCjs = filePath => requireFn(filePath),
+    logger = console,
+  } = options
+
+  const esmPath = path.resolve(__dirname, '../dist/postinstall.js')
+  const cjsPath = path.resolve(__dirname, '../dist/postinstall.cjs')
+
+  const hasEsm = existsSync(esmPath)
+  const hasCjs = existsSync(cjsPath)
+
+  const loadErrors = []
+
+  if (hasEsm) {
+    try {
+      await loadEsm(esmPath)
+      return
+    }
+    catch (error) {
+      loadErrors.push(error)
+    }
+  }
+
+  if (hasCjs) {
+    try {
+      await loadCjs(cjsPath)
+      return
+    }
+    catch (error) {
+      loadErrors.push(error)
+    }
+  }
+
+  if (!hasEsm && !hasCjs) {
+    logger.log('postinstall bundle not found')
+    return
+  }
+
+  logger.error('Failed to load postinstall bundle.')
+  for (const error of loadErrors) {
+    logger.error(error)
+  }
+  process.exitCode = process.exitCode ?? 1
+}
+
+const entryUrl = (() => {
+  const candidate = process.argv[1]
+  if (!candidate) {
+    return undefined
+  }
+  try {
+    return pathToFileURL(candidate).href
+  }
+  catch {
+    return undefined
+  }
+})()
+
+if (entryUrl === import.meta.url) {
+  run().catch((error) => {
+    console.error('Failed to execute postinstall entry.', error)
+    process.exitCode = process.exitCode ?? 1
+  })
+}

packages/merge/scripts/postinstall.mjs

@@ -210,7 +210,19 @@ function ensureVariant(distDir: string, variant: RuntimeVariant): {
 }
 
 function main() {
-  const distDir = fileURLToPath(new URL('../dist/', import.meta.url))
+  const resolveDistDir = (): string => {
+    // When executed via the CJS bundle (loaded through the bootstrap script), __dirname is available
+    if (typeof __dirname === 'string') {
+      return __dirname
+    }
+
+    // Fallback for the ESM bundle evaluated directly
+    // eslint-disable-next-line no-new-func
+    const getImportMetaUrl = new Function('return import.meta.url') as () => string
+    return fileURLToPath(new URL('./', getImportMetaUrl()))
+  }
+
+  const distDir = resolveDistDir()
 
   if (!fs.existsSync(distDir)) {
     warn('dist directory not found. Skipping runtime switch.')

packages/merge/src/postinstall.ts

@@ -1,68 +1,104 @@
-import fs from 'node:fs'
-import { createRequire } from 'node:module'
 import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-import vm from 'node:vm'
-import { describe, expect, it, vi } from 'vitest'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
-const requireFn = createRequire(import.meta.url)
 const testDir = path.dirname(fileURLToPath(import.meta.url))
-const scriptPath = path.resolve(testDir, '../scripts/postinstall.cjs')
-const builtScriptPath = path.resolve(testDir, '../dist/postinstall.cjs')
-const scriptSource = fs.readFileSync(scriptPath, 'utf8')
-
-function executeLegacyPostinstall(hasBuiltScript: boolean) {
-  const existsSync = vi.fn(() => hasBuiltScript)
-  let distModuleLoads = 0
-  const consoleLog = vi.fn()
-
-  const contextRequire = (specifier: string) => {
-    if (specifier === 'node:fs') {
-      return {
-        existsSync,
-      }
-    }
-    if (specifier === 'node:path') {
-      return requireFn('node:path')
-    }
-    if (specifier === builtScriptPath) {
-      distModuleLoads += 1
-      return {}
-    }
-    throw new Error(`Unexpected require: ${specifier}`)
-  }
-
-  const context = {
-    require: contextRequire,
-    module: { exports: {} },
-    exports: {},
-    __dirname: path.dirname(scriptPath),
-    console: { log: consoleLog },
-  }
-
-  vm.runInNewContext(scriptSource, context, { filename: scriptPath })
-
-  return {
-    existsSync,
-    consoleLog,
-    distModuleLoads,
-  }
+const scriptPath = path.resolve(testDir, '../scripts/postinstall.mjs')
+const scriptUrl = pathToFileURL(scriptPath).href
+const esmBundlePath = path.resolve(testDir, '../dist/postinstall.js')
+const cjsBundlePath = path.resolve(testDir, '../dist/postinstall.cjs')
+
+interface Logger {
+  log: (...args: unknown[]) => void
+  error: (...args: unknown[]) => void
+}
+
+interface RunOptions {
+  existsSync?: (file: string) => boolean
+  loadEsm?: (file: string) => Promise<unknown>
+  loadCjs?: (file: string) => unknown | Promise<unknown>
+  logger?: Logger
+}
+
+const originalExitCode = process.exitCode
+
+async function runWithOptions(options?: RunOptions) {
+  const { run } = await import(scriptUrl) as { run: (options?: RunOptions) => Promise<void> }
+  await run(options)
 }
 
-describe('legacy postinstall entry', () => {
-  it('skips when built postinstall script is missing', () => {
-    const result = executeLegacyPostinstall(false)
+beforeEach(() => {
+  process.exitCode = undefined
+})
+
+afterEach(() => {
+  vi.restoreAllMocks()
+  process.exitCode = originalExitCode
+})
+
+describe('postinstall bootstrap script', () => {
+  it('prefers the ESM bundle when available', async () => {
+    const existsSync = vi.fn((file: string) => file === esmBundlePath)
+    const loadEsm = vi.fn(async () => {})
+    const loadCjs = vi.fn()
+    const logger = { log: vi.fn(), error: vi.fn() }
 
-    expect(result.existsSync).toHaveBeenCalledWith(builtScriptPath)
-    expect(result.consoleLog).toHaveBeenCalledWith('postinstall.cjs not found')
-    expect(result.distModuleLoads).toBe(0)
+    await runWithOptions({ existsSync, loadEsm, loadCjs, logger })
+
+    expect(loadEsm).toHaveBeenCalledWith(esmBundlePath)
+    expect(loadCjs).not.toHaveBeenCalled()
+    expect(logger.log).not.toHaveBeenCalled()
+    expect(logger.error).not.toHaveBeenCalled()
+  })
+
+  it('falls back to the CJS bundle when ESM is unavailable', async () => {
+    const existsSync = vi.fn((file: string) => file === cjsBundlePath)
+    const loadEsm = vi.fn()
+    const loadCjs = vi.fn(async () => {})
+    const logger = { log: vi.fn(), error: vi.fn() }
+
+    await runWithOptions({ existsSync, loadEsm, loadCjs, logger })
+
+    expect(loadEsm).not.toHaveBeenCalled()
+    expect(loadCjs).toHaveBeenCalledWith(cjsBundlePath)
+    expect(logger.log).not.toHaveBeenCalled()
+    expect(logger.error).not.toHaveBeenCalled()
   })
 
-  it('loads built postinstall script when present', () => {
-    const result = executeLegacyPostinstall(true)
+  it('logs when no bundle is present', async () => {
+    const existsSync = vi.fn(() => false)
+    const loadEsm = vi.fn()
+    const loadCjs = vi.fn()
+    const logger = { log: vi.fn(), error: vi.fn() }
+
+    await runWithOptions({ existsSync, loadEsm, loadCjs, logger })
+
+    expect(loadEsm).not.toHaveBeenCalled()
+    expect(loadCjs).not.toHaveBeenCalled()
+    expect(logger.log).toHaveBeenCalledWith('postinstall bundle not found')
+    expect(logger.error).not.toHaveBeenCalled()
+  })
+
+  it('reports errors when both bundle loads fail', async () => {
+    const existsSync = vi.fn((file: string) => file === esmBundlePath || file === cjsBundlePath)
+    const esmError = new Error('esm failed')
+    const cjsError = new Error('cjs failed')
+    const loadEsm = vi.fn(async () => {
+      throw esmError
+    })
+    const loadCjs = vi.fn(async () => {
+      throw cjsError
+    })
+    const logger = { log: vi.fn(), error: vi.fn() }
+
+    await runWithOptions({ existsSync, loadEsm, loadCjs, logger })
 
-    expect(result.existsSync).toHaveBeenCalledWith(builtScriptPath)
-    expect(result.consoleLog).not.toHaveBeenCalled()
-    expect(result.distModuleLoads).toBe(1)
+    expect(loadEsm).toHaveBeenCalledWith(esmBundlePath)
+    expect(loadCjs).toHaveBeenCalledWith(cjsBundlePath)
+    expect(logger.error).toHaveBeenCalledWith('Failed to load postinstall bundle.')
+    expect(logger.error).toHaveBeenCalledWith(esmError)
+    expect(logger.error).toHaveBeenCalledWith(cjsError)
+    expect(process.exitCode).toBe(1)
+    expect(logger.log).not.toHaveBeenCalled()
   })
 })

packages/merge/test/scripts-postinstall.test.ts

@@ -59,7 +59,8 @@ async function syncTemplate(url: string): Promise<void> {
 
   const branch = await getCurrentBranch(repoDir)
   await execa('git', ['reset', '--hard', `origin/${branch}`], { cwd: repoDir, stdio: 'inherit' })
-  await execa('git', ['clean', '-fdx'], { cwd: repoDir, stdio: 'inherit' })
+  // 保留被 .gitignore 忽略的缓存目录，避免每次清理 node_modules/dist 时的额外开销
+  await execa('git', ['clean', '-fd'], { cwd: repoDir, stdio: 'inherit' })
 
   console.log(`同步 ${localDir} -> ${repoDir}`)
   await execa(