Merge pull request #54 from mauricedoepke/master

Major overhaul

Author: sanex3339

.gitignore

@@ -3,4 +3,5 @@ node_modules
 npm-debug.log
 *.js.map
 test/output
-yarn.lock
+yarn.lock
+dist

.npmignore

@@ -0,0 +1,9 @@
+node_modules
+.git
+.gitignore
+.npmignore
+.travis.yml
+*.ts
+# include the .d.ts files
+!*.d.ts
+tsconfig.json

.travis.yml

@@ -0,0 +1,20 @@
+language: node_js
+node_js:
+  - "8"
+
+before_script:
+  - npm run setup
+  - npm run build
+
+script:
+  - npm run test
+
+after_success:
+  - git config --global user.email "[email protected]"
+  - git config --global user.name "Travis CI"
+  - git checkout -b dist
+  - git add -f "dist/*"
+  - git commit -m "Travis Build - $TRAVIS_COMMIT" -m "[skip ci]"
+  - git remote rm origin
+  - git remote add origin https://${GH_USERNAME}:${GH_TOKEN}@github.com/${GH_REPOUSER}/webpack-obfuscator.git > /dev/null 2>&1
+  - git push origin dist:master

dist/index.d.ts

@@ -0,0 +1,12 @@
+import { Compiler } from 'webpack';
+import { TInputOptions as JavascriptObfuscatorOptions } from 'javascript-obfuscator/src/types/options/TInputOptions';
+declare class WebpackObfuscator {
+    options: JavascriptObfuscatorOptions;
+    excludes: string[];
+    constructor(options: JavascriptObfuscatorOptions, excludes?: string | string[]);
+    apply(compiler: Compiler): void;
+    private shouldExclude;
+    private extractSourceAndSourceMap;
+    private obfuscate;
+}
+export = WebpackObfuscator;

dist/index.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const javascript_obfuscator_1 = __importDefault(require("javascript-obfuscator"));
+const webpack_sources_1 = require("webpack-sources");
+const multimatch_1 = __importDefault(require("multimatch"));
+const transferSourceMap = require("multi-stage-sourcemap").transfer;
+class WebpackObfuscator {
+    constructor(options, excludes) {
+        this.options = options;
+        this.excludes = [];
+        this.excludes = this.excludes.concat(excludes || []);
+    }
+    apply(compiler) {
+        const isDevServer = process.argv.find(v => v.includes('webpack-dev-server'));
+        if (isDevServer) {
+            console.info('JavascriptObfuscator is disabled on webpack-dev-server as the reloading scripts ', 'and the obfuscator can interfere with each other and break the build');
+            return;
+        }
+        const pluginName = this.constructor.name;
+        compiler.hooks.emit.tap(pluginName, (compilation) => {
+            for (const fileName in compilation.assets) {
+                if (!fileName.toLowerCase().endsWith('.js') || this.shouldExclude(fileName)) {
+                    return;
+                }
+                const asset = compilation.assets[fileName];
+                const { inputSource, inputSourceMap } = this.extractSourceAndSourceMap(asset);
+                const { obfuscatedSource, obfuscationSourceMap } = this.obfuscate(inputSource);
+                if (this.options.sourceMap && inputSourceMap) {
+                    const transferredSourceMap = transferSourceMap({
+                        fromSourceMap: obfuscationSourceMap,
+                        toSourceMap: inputSource
+                    });
+                    compilation.assets[fileName] = new webpack_sources_1.SourceMapSource(obfuscatedSource, fileName, transferredSourceMap, inputSource, inputSourceMap);
+                }
+                else {
+                    compilation.assets[fileName] = new webpack_sources_1.RawSource(obfuscatedSource);
+                }
+            }
+        });
+    }
+    shouldExclude(filePath) {
+        return multimatch_1.default(filePath, this.excludes).length > 0;
+    }
+    extractSourceAndSourceMap(asset) {
+        if (asset.sourceAndMap) {
+            const { source, map } = asset.sourceAndMap();
+            return { inputSource: source, inputSourceMap: map };
+        }
+        else {
+            return {
+                inputSource: asset.source(),
+                inputSourceMap: asset.map()
+            };
+        }
+    }
+    obfuscate(javascript) {
+        const obfuscationResult = javascript_obfuscator_1.default.obfuscate(javascript, this.options);
+        return {
+            obfuscatedSource: obfuscationResult.getObfuscatedCode(),
+            obfuscationSourceMap: obfuscationResult.getSourceMap()
+        };
+    }
+}
+module.exports = WebpackObfuscator;

index.js

@@ -1,127 +1,90 @@
 "use strict";
 
-import { Compiler } from 'webpack';
-
-const JavaScriptObfuscator = require('javascript-obfuscator');
-const RawSource = require("webpack-sources").RawSource;
-const SourceMapSource = require("webpack-sources").SourceMapSource;
-const multimatch = require('multimatch');
+import { Compiler, compilation } from 'webpack';
+import JavaScriptObfuscator from 'javascript-obfuscator';
+import { RawSource, SourceMapSource } from 'webpack-sources';
+import multimatch from 'multimatch';
+import { RawSourceMap } from 'source-map';
+import { TInputOptions as JavascriptObfuscatorOptions } from 'javascript-obfuscator/src/types/options/TInputOptions';
 const transferSourceMap = require("multi-stage-sourcemap").transfer;
 
-type TObject = {[key: string]: any};
-
 class WebpackObfuscator {
-    /**
-     * @type {TObject}
-     */
-    public options: TObject = {};
 
-    /**
-     * @type {string}
-     */
-    public excludes: string[];
+    public excludes: string[] = [];
 
-    /**
-     * @param {TObject} options
-     * @param {string | string[]} excludes
-     */
-    constructor (options: TObject, excludes: string|string[]) {
-        this.options = options || {};
-        this.excludes = this.prepareExcludes(excludes);
+    constructor(
+        public options: JavascriptObfuscatorOptions,
+        excludes?: string | string[]
+    ) {
+        this.excludes = this.excludes.concat(excludes || []);
     }
 
-    /**
-     * @param {Compiler} compiler
-     */
-    public apply (compiler: Compiler): void {
-        compiler.plugin('compilation', (compilation: any) => {
-            compilation.plugin("optimize-chunk-assets", (chunks: any[], callback: () => void) => {
-                let files = [];
-
-                chunks.forEach((chunk) => {
-                    chunk['files'].forEach((file) => {
-                        files.push(file);
+    public apply(compiler: Compiler): void {
+        const isDevServer = process.argv.find(v => v.includes('webpack-dev-server'));
+        if (isDevServer) {
+            console.info(
+                'JavascriptObfuscator is disabled on webpack-dev-server as the reloading scripts ',
+                'and the obfuscator can interfere with each other and break the build');
+            return;
+        }
+        
+        const pluginName = this.constructor.name;
+        compiler.hooks.emit.tap(pluginName, (compilation: compilation.Compilation) => {
+            for (const fileName in compilation.assets) {
+                if (!fileName.toLowerCase().endsWith('.js') || this.shouldExclude(fileName)) {
+                    return;
+                }
+                const asset = compilation.assets[fileName]
+                const { inputSource, inputSourceMap } = this.extractSourceAndSourceMap(asset);
+                const { obfuscatedSource, obfuscationSourceMap } = this.obfuscate(inputSource);
+
+                if (this.options.sourceMap && inputSourceMap) {
+                    const transferredSourceMap = transferSourceMap({
+                        fromSourceMap: obfuscationSourceMap,
+                        toSourceMap: inputSource
                     });
-                });
-
-                compilation.additionalChunkAssets.forEach((file) => {
-                    files.push(file);
-                });
-
-                files.forEach((file) => {
-                    if (!/\.js($|\?)/i.test(file) || this.shouldExclude(file, this.excludes)) {
-                        return;
-                    }
-
-                    let asset = compilation.assets[file],
-                        input, inputSourceMap;
-
-                    if (this.options.sourceMap !== false) {
-                    	if (asset.sourceAndMap) {
-                    		let sourceAndMap = asset.sourceAndMap();
-                    		inputSourceMap = sourceAndMap.map;
-                    		input = sourceAndMap.source;
-                    	} else {
-                    		inputSourceMap = asset.map();
-                    		input = asset.source();
-                    	}
-
-                        if (inputSourceMap) {
-                            this.options.sourceMap = true;
-                        }
-                    } else {
-                    	input = asset.source();
-                    }
 
-                    let obfuscationResult: any = JavaScriptObfuscator.obfuscate(
-                        input,
-                        this.options
+                    compilation.assets[fileName] = new SourceMapSource(
+                        obfuscatedSource,
+                        fileName,
+                        transferredSourceMap,
+                        inputSource,
+                        inputSourceMap
                     );
-
-                    if (this.options.sourceMap) {
-                        let obfuscationSourceMap: any = obfuscationResult.getSourceMap(),
-                            transferredSourceMap: any = transferSourceMap({
-                                fromSourceMap: obfuscationSourceMap,
-                                toSourceMap: inputSourceMap
-                            });
-
-                        compilation.assets[file] = new SourceMapSource(
-                            obfuscationResult.toString(),
-                            file,
-                            JSON.parse(transferredSourceMap),
-                            asset.source(),
-                            inputSourceMap
-                        );
-                    } else {
-                        compilation.assets[file] = new RawSource(obfuscationResult.toString());
-                    }
-                });
-
-                callback();
-            });
+                } else {
+                    compilation.assets[fileName] = new RawSource(obfuscatedSource);
+                }
+            }
         });
     }
 
-    private prepareExcludes(inputExcludes: string|string[]): string[] {
-        if (Array.isArray(inputExcludes)) {
-            return inputExcludes;
-        }
+    private shouldExclude(filePath: string): boolean {
+        return multimatch(filePath, this.excludes).length > 0
+    }
 
-        if (typeof inputExcludes === 'string') {
-            return [inputExcludes];
+    private extractSourceAndSourceMap(asset: any): { inputSource: string, inputSourceMap: RawSourceMap } {
+        if (asset.sourceAndMap) {
+            const { source, map } = asset.sourceAndMap();
+            return { inputSource: source, inputSourceMap: map };
+        } else {
+            return {
+                inputSource: asset.source(),
+                inputSourceMap: asset.map()
+            }
         }
-
-        return [];
     }
 
-    /**
-     * @param filePath
-     * @param excludes
-     * @returns {boolean}
-     */
-    private shouldExclude (filePath: string, excludes: string[]): boolean {
-        return multimatch(filePath, excludes).length > 0
+    private obfuscate(javascript: string): { obfuscatedSource: string, obfuscationSourceMap: string } {
+        const obfuscationResult = JavaScriptObfuscator.obfuscate(
+            javascript,
+            this.options
+        );
+
+        return {
+            obfuscatedSource: obfuscationResult.getObfuscatedCode(),
+            obfuscationSourceMap: obfuscationResult.getSourceMap()
+        }
     }
 }
 
-module.exports = WebpackObfuscator;
+export = WebpackObfuscator;