Merge pull request #19 from electron-vite/v0.11.4

V0.11.4

Author: caoxiemeihao

CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.11.4 (2023-01-04)
+
+- 502f7f2 feat: support Pre-Bundling cache #15
+
 ## 0.11.3 (2022-11-18)
 
 - cbab7db fix: insert built-in modules to `optimizeDeps.exclude`

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vite-plugin-electron-renderer",
-  "version": "0.11.3",
+  "version": "0.11.4",
   "description": "Support use Node.js API in Electron-Renderer",
   "main": "index.mjs",
   "types": "types",
@@ -32,7 +32,8 @@
     "esbuild": "^0.16.11",
     "rollup": "^3.8.1",
     "typescript": "^4.9.4",
-    "vite": "^4.0.3"
+    "vite": "^4.0.3",
+    "vite-plugin-utils": "^0.3.6"
   },
   "files": [
     "types",

pnpm-lock.yaml

@@ -1,9 +1,11 @@
 import fs from 'node:fs'
 import path from 'node:path'
+import crypto from 'node:crypto'
 import { createRequire, builtinModules } from 'node:module'
 import type { Alias, Plugin, UserConfig } from 'vite'
 import esbuild from 'esbuild'
 import libEsm from 'lib-esm'
+import { COLOURS } from 'vite-plugin-utils/function'
 import { builtins } from './build-config'
 
 export type DepOptimizationConfig = {
@@ -27,6 +29,7 @@ const name = 'vite-plugin-electron-renderer:optimizer'
 
 let root: string
 let node_modules_path: string
+let cache: Cache
 
 export default function optimizer(options: DepOptimizationConfig = {}): Plugin[] | undefined {
   const { include, buildOptions } = options
@@ -38,8 +41,7 @@ export default function optimizer(options: DepOptimizationConfig = {}): Plugin[]
       config(config) {
         root = config.root ? path.resolve(config.root) : process.cwd()
         node_modules_path = node_modules(root)
-
-        fs.rmSync(path.join(node_modules_path, CACHE_DIR), { recursive: true, force: true })
+        cache = new Cache(path.join(node_modules_path, CACHE_DIR))
 
         const aliases: Alias[] = [
           {
@@ -97,10 +99,10 @@ export default function optimizer(options: DepOptimizationConfig = {}): Plugin[]
             continue
           }
 
-          const pkgId = path.join(node_modules_path, name, 'package.json')
-          if (fs.existsSync(pkgId)) {
+          const pkgJson = path.join(node_modules_path, name, 'package.json')
+          if (fs.existsSync(pkgJson)) {
             // bare module
-            const pkg = cjs_require(pkgId)
+            const pkg = cjs_require(pkgJson)
             if (pkg.type === 'module') {
               deps.push({ esm: name })
               continue
@@ -109,29 +111,30 @@ export default function optimizer(options: DepOptimizationConfig = {}): Plugin[]
             continue
           }
 
-          const tmp = path.join(node_modules_path, name)
+          const pkgPath = path.join(node_modules_path, name)
           try {
             // dirname or filename 🤔
             // `foo/bar` or `foo/bar/index.js`
-            const filename = cjs_require.resolve(tmp)
+            const filename = cjs_require.resolve(pkgPath)
             if (path.extname(filename) === '.mjs') {
               deps.push({ esm: name, filename })
               continue
             }
             deps.push({ cjs: name, filename })
             continue
           } catch (error) {
-            console.log('Can not resolve path:', tmp)
+            console.log(COLOURS.red('Can not resolve path:'), pkgPath)
           }
         }
 
         for (const dep of deps) {
           if (!dep.filename) {
             const module = (dep.cjs || dep.esm) as string
             try {
+              // TODO: resolve(, [paths condition])
               dep.filename = cjs_require.resolve(module)
             } catch (error) {
-              console.log('Can not resolve module:', module)
+              console.log(COLOURS.red('Can not resolve module:'), module)
             }
           }
           if (!dep.filename) {
@@ -173,9 +176,16 @@ function cjsBundling(args: {
   requireId: string
 }) {
   const { name, require, requireId } = args
+  const { destpath, destname } = dest(name)
+  if (cache.checkHash(destname)) return
+
   const { exports } = libEsm({ exports: Object.keys(cjs_require(requireId)) })
   const code = `const _M_ = require("${require}");\n${exports}`
-  writeFile({ name, code })
+
+  !fs.existsSync(destpath) && fs.mkdirSync(destpath, { recursive: true })
+  fs.writeFileSync(destname, code)
+  cache.writeCache(destname)
+  console.log(COLOURS.cyan('Pre-bundling:'), COLOURS.yellow(name))
 }
 
 async function esmBundling(args: {
@@ -185,6 +195,8 @@ async function esmBundling(args: {
 }) {
   const { name, entry, buildOptions } = args
   const { name_cjs, destname_cjs } = dest(name)
+  if (cache.checkHash(destname_cjs)) return
+
   return esbuild.build({
     entryPoints: [entry],
     outfile: destname_cjs,
@@ -199,6 +211,7 @@ async function esmBundling(args: {
     ...buildOptions,
   }).then(result => {
     if (!result.errors.length) {
+      cache.writeCache(destname_cjs)
       cjsBundling({
         name,
         require: `${CACHE_DIR}/${name}/${name_cjs}`,
@@ -209,17 +222,6 @@ async function esmBundling(args: {
   })
 }
 
-function writeFile(args: {
-  name: string
-  code: string
-}) {
-  const { name, code } = args
-  const { destpath, destname } = dest(name)
-  !fs.existsSync(destpath) && fs.mkdirSync(destpath, { recursive: true })
-  fs.writeFileSync(destname, code)
-  console.log('Pre-bundling:', name)
-}
-
 function dest(name: string) {
   const destpath = path.join(node_modules_path, CACHE_DIR, name)
   const name_js = 'index.js'
@@ -266,3 +268,72 @@ function node_modules(root: string, count = 0): string {
 }
 // For ts-check
 node_modules.p = ''
+
+// ----------------------------------------
+
+export interface ICache {
+  timestamp?: number
+  optimized?: {
+    [filename: string]: {
+      hash: string
+    }
+  }
+}
+
+class Cache {
+  static getHash(filename: string) {
+    return crypto.createHash('md5').update(fs.readFileSync(filename)).digest('hex')
+  }
+
+  constructor(
+    public root: string,
+    public cacheFile = path.join(root, '_metadata.json'),
+  ) {
+    // TODO: cleanup meta
+  }
+
+  checkHash(filename: string) {
+    if (!fs.existsSync(filename)) {
+      return false
+    }
+    let hash: string
+    try {
+      hash = Cache.getHash(filename)
+    } catch {
+      return false
+    }
+    const { optimized = {} } = this.readCache()
+    for (const [file, meta] of Object.entries(optimized)) {
+      if (filename === file && hash === meta.hash) {
+        return true
+      }
+    }
+    return false
+  }
+
+  readCache(): ICache {
+    const cache: ICache = {}
+    try {
+      const json = JSON.parse(fs.readFileSync(this.cacheFile, 'utf8'))
+      Object.assign(cache, { optimized: json.optimized })
+    } catch { }
+    return cache
+  }
+
+  writeCache(filename: string) {
+    if (!fs.existsSync(filename)) {
+      throw new Error(`${filename} is not exist!`)
+    }
+    const { optimized = {} } = this.readCache()
+    const newCache: ICache = {
+      timestamp: Date.now(),
+      optimized: {
+        ...optimized,
+        [filename]: {
+          hash: Cache.getHash(filename),
+        },
+      },
+    }
+    fs.writeFileSync(this.cacheFile, JSON.stringify(newCache, null, 2))
+  }
+}