vue-cli-plugin-javascript-obfuscator 1.0.2 → 1.0.4

package/index.js

@@ -1,93 +1,11 @@
-// @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 || {}
+    const pluginInstance = new JavascriptObfuscatorPlugin(options)
 
-    const JavascriptObfuscatorPlugin = {
-      apply: (compiler) => {
-        compiler.hooks.emit.tapAsync(
-          'JavascriptObfuscatorPlugin',
-          async (compilation, callback) => {
-            const promises = []
-
-            // 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
-    config.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.2",
+  "version": "1.0.4",
   "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,81 @@
+// @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 = [], excludes = [], obfuscatorOptions = {} } = {}) {
+    this.includes = Array.isArray(includes) ? includes : [includes]
+    this.excludes = Array.isArray(excludes) ? excludes : [excludes]
+    this.obfuscatorOptions = obfuscatorOptions
+  }
+
+  apply(compiler) {
+    compiler.hooks.emit.tapAsync(
+      'JavascriptObfuscatorPlugin',
+      async (compilation, callback) => {
+        const promises = []
+
+        for (const assetName of Object.keys(compilation.assets)) {
+          // Include filter
+          if (
+            this.includes.length &&
+            !micromatch.isMatch(assetName, this.includes)
+          ) {
+            continue
+          }
+
+          // Exclude filter
+          if (micromatch.isMatch(assetName, this.excludes)) {
+            console.log(`Skipping obfuscation for: ${assetName}`)
+            continue
+          }
+
+          console.log(`Obfuscating: ${assetName}`)
+          const asset = compilation.assets[assetName]
+
+          promises.push(
+            new Promise((resolve, reject) => {
+              try {
+                const obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                  asset.source(),
+                  {
+                    compact: true,
+                    disableConsoleOutput: false,
+                    rotateStringArray: true,
+                    identifierNamesGenerator: 'hexadecimal',
+                    selfDefending: true,
+                    ...this.obfuscatorOptions
+                  }
+                ).getObfuscatedCode()
+
+                compilation.assets[assetName] = {
+                  source: () => obfuscatedCode,
+                  size: () => obfuscatedCode.length
+                }
+
+                resolve()
+              } catch (err) {
+                console.error(`Failed to obfuscate ${assetName}:`, err)
+                reject(err)
+              }
+            })
+          )
+        }
+
+        await Promise.all(promises)
+        callback()
+      }
+    )
+  }
+}
+
+module.exports = JavascriptObfuscatorPlugin