vue-cli-plugin-javascript-obfuscator 1.0.3 → 1.0.5

package/README.md

@@ -22,19 +22,10 @@ Example Configuration:
 module.exports = {
   pluginOptions: {
     javascriptObfuscator: {
-      // Directory where your assets are located (default is 'static')
-      assetsDir: 'static', // Optional, defaults to 'static'
-
       // Files to include in obfuscation (can be a string or an array of strings/regex patterns)
       includes: [
         'app.*.js',
-        '**/chunk-libs.*.js$',  // Matches chunk-libs files for obfuscation
-      ],
-
-      // Files to exclude from obfuscation (can be a string or an array of strings/regex patterns)
-      excludes: [
-        'vendor.*.js',
-        '**/*-bundle.*.js$',  // Matches any file ending with -bundle for exclusion
+        '**/chunk-libs.*.js',  // Matches chunk-libs files for obfuscation
       ],
 
       // Options for the javascript-obfuscator

package/index.js

@@ -1,93 +1,13 @@
-// @ts-nocheck
-const JavaScriptObfuscator = require('javascript-obfuscator')
+const JavascriptObfuscatorPlugin = require('./plugin.js')
 
-module.exports = (api, options) => {
-  api.chainWebpack((webpackConfig) => {
-    // Get user-configured options from vue.config.js
-    const opts = options.pluginOptions && options.pluginOptions.javascriptObfuscator
+module.exports = (api, options = {}) => {
+  api.chainWebpack((config) => {
+    const pluginOptions = options.pluginOptions?.javascriptObfuscator
 
-    // Default values for the plugin options
-    const assetsDir = opts.assetsDir || 'static'
-    const includes = Array.isArray(opts.includes)
-      ? opts.includes
-      : [opts.includes || []]
-    const excludes = Array.isArray(opts.excludes)
-      ? opts.excludes
-      : [opts.excludes || []]
-    const obfuscatorOptions = opts.obfuscatorOptions || {}
+    if (!pluginOptions) return
 
-    const JavascriptObfuscatorPlugin = {
-      apply: (compiler) => {
-        compiler.hooks.emit.tapAsync(
-          'JavascriptObfuscatorPlugin',
-          async (compilation, callback) => {
-            const promises = []
+    const pluginInstance = new JavascriptObfuscatorPlugin(pluginOptions)
 
-            // Generate regex patterns from includes and excludes
-            const includePatterns = includes.map((pattern) =>
-              typeof pattern === 'string'
-                ? new RegExp(pattern.replace('static', assetsDir))
-                : pattern
-            )
-            const excludePatterns = excludes.map((pattern) =>
-              typeof pattern === 'string'
-                ? new RegExp(pattern.replace('static', assetsDir))
-                : pattern
-            )
-
-            Object.keys(compilation.assets).forEach((assetName) => {
-              // Skip assets that don't match the include or match any of the exclude patterns
-              if (
-                includePatterns.length &&
-                !includePatterns.some((pattern) => pattern.test(assetName))
-              ) {
-                return
-              }
-
-              if (excludePatterns.some((pattern) => pattern.test(assetName))) {
-                console.log(`Skipping obfuscation for: ${assetName}`)
-                return
-              }
-
-              console.log(`Obfuscating: ${assetName}`)
-              const asset = compilation.assets[assetName]
-              promises.push(
-                new Promise((resolve, reject) => {
-                  try {
-                    const obfuscated = JavaScriptObfuscator.obfuscate(
-                      asset.source(),
-                      {
-                        compact: true,
-                        disableConsoleOutput: false,
-                        rotateStringArray: true,
-                        identifierNamesGenerator: 'hexadecimal',
-                        selfDefending: true,
-                        ...obfuscatorOptions // Spread any additional options
-                      }
-                    ).getObfuscatedCode()
-
-                    compilation.assets[assetName] = {
-                      source: () => obfuscated,
-                      size: () => obfuscated.length
-                    }
-
-                    resolve()
-                  } catch (err) {
-                    console.error(`Failed to obfuscate ${assetName}:`, err)
-                    reject(err) // Reject if there's an error in obfuscation
-                  }
-                })
-              )
-            })
-
-            // Wait for all files to be processed
-            await Promise.all(promises)
-            callback()
-          }
-        )
-      }
-    }
-    // Instantiate and apply the plugin to the Webpack config
-    webpackConfig.plugin('javascript-obfuscator').use(JavascriptObfuscatorPlugin)
+    config.plugin('javascript-obfuscator').use(pluginInstance, [pluginOptions])
   })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-cli-plugin-javascript-obfuscator",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Vue CLI plugin for JavaScript obfuscation using javascript-obfuscator@4.x",
   "main": "index.js",
   "scripts": {
@@ -22,6 +22,7 @@
   },
   "homepage": "https://github.com/nangongpo/vue-cli-plugin-javascript-obfuscator#readme",
   "dependencies": {
-    "javascript-obfuscator": "^4.0.0"
+    "javascript-obfuscator": "^4.0.0",
+    "micromatch": "^4.0.8"
   }
 }

package/plugin.js

@@ -0,0 +1,66 @@
+// @ts-nocheck
+const JavaScriptObfuscator = require('javascript-obfuscator')
+const micromatch = require('micromatch')
+
+/**
+ * Webpack plugin to obfuscate JavaScript assets using javascript-obfuscator.
+ */
+class JavascriptObfuscatorPlugin {
+  /**
+   * @param {Object} options
+   * @param {string[]} [options.includes] - Glob patterns for files to include.
+   * @param {string[]} [options.excludes] - Glob patterns for files to exclude.
+   * @param {Object} [options.obfuscatorOptions] - Options for javascript-obfuscator.
+   */
+  constructor({ includes = [], obfuscatorOptions = {} } = {}) {
+    this.includes = Array.isArray(includes) ? includes : includes ? [includes] : []
+    this.obfuscatorOptions = obfuscatorOptions
+  }
+
+  apply(compiler) {
+    compiler.hooks.emit.tapAsync(
+      'JavascriptObfuscatorPlugin',
+      async (compilation, callback) => {
+        try {
+          const assetNames = Object.keys(compilation.assets)
+          const jsFiles = assetNames.filter(name => name.endsWith('.js'))
+          const needObfuscateFiles = jsFiles.filter(name => {
+            const included = this.includes.length ? micromatch.isMatch(name, this.includes) : false
+            return included
+          })
+
+          const promises = needObfuscateFiles.map(name => {
+            return new Promise((resolve, reject) => {
+              try {
+                const asset = compilation.assets[name]
+                const obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                  asset.source(),
+                  this.obfuscatorOptions
+                ).getObfuscatedCode()
+
+                compilation.assets[name] = {
+                  source: () => obfuscatedCode,
+                  size: () => obfuscatedCode.length
+                }
+
+                console.log(`[Obfuscator] ✔ Obfuscated ${name}`)
+                resolve()
+              } catch (err) {
+                console.error(`Failed to obfuscate ${name}:`, err)
+                reject(err)
+              }
+            })
+          })
+
+          await Promise.all(promises)
+          callback()
+        } catch (error) {
+          console.error(`[Obfuscator] ✖ Build failed during obfuscation:`, error)
+          callback(error) // 传递错误让 Webpack 停止构建
+        }
+      }
+    )
+  }
+}
+
+module.exports = JavascriptObfuscatorPlugin