Merge pull request #581 from javascript-obfuscator/multiple-sources-obfuscation

New `obfuscateMultiple` method

CHANGELOG.md

@@ -1,5 +1,9 @@
 Change Log
 
+v0.27.0
+---
+* **Feature:** new method `obfuscateMultiple` to obfuscation of multiple source codes
+
 v0.26.0
 ---
 * **Internal:** new code transformers mechanism

README.md

@@ -202,6 +202,18 @@ Method takes two parameters, `sourceCode` and `options` – the source code and
 
 For available options, see [options](#options).
 
+### `obfuscateMultiple(sourceCodesObject, options)`
+
+Accepts `sourceCodesObject` that is a map which keys are identifiers of source codes and values are source codes:
+```
+{
+    foo: 'var foo = 1;',
+    bar: 'var bar = 2;'
+}
+```
+
+Returns a map object which keys are identifiers of source codes and values are `ObfuscationResult` objects.
+
 ## CLI usage
 
 See [CLI options](#cli-options).

index.d.ts

@@ -1,6 +1,8 @@
 import { TInputOptions } from './src/types/options/TInputOptions';
+import { TObject } from './src/types/TObject';
 
 import { IObfuscatedCode } from './src/interfaces/source-code/IObfuscatedCode';
+import { TObfuscationResultsObject } from './src/types/TObfuscationResultsObject';
 
 export type ObfuscatorOptions = TInputOptions;
 
@@ -13,6 +15,16 @@ export interface ObfuscatedCode extends IObfuscatedCode {}
  */
 export function obfuscate (sourceCode: string, inputOptions?: ObfuscatorOptions): ObfuscatedCode;
 
+/**
+ * @param {TSourceCodesObject} sourceCodesObject
+ * @param {TInputOptions} inputOptions
+ * @returns {TObfuscationResultsObject<TSourceCodesObject>}
+ */
+export function obfuscateMultiple <TSourceCodesObject extends TObject<string>> (
+    sourceCodesObject: TSourceCodesObject,
+    inputOptions?: TInputOptions
+): TObfuscationResultsObject<TSourceCodesObject>;
+
 /**
  * @type {string}
  */

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",

src/JavaScriptObfuscatorFacade.ts

@@ -3,6 +3,8 @@ import 'reflect-metadata';
 import { ServiceIdentifiers } from './container/ServiceIdentifiers';
 
 import { TInputOptions } from './types/options/TInputOptions';
+import { TObfuscationResultsObject } from './types/TObfuscationResultsObject';
+import { TObject } from './types/TObject';
 
 import { IInversifyContainerFacade } from './interfaces/container/IInversifyContainerFacade';
 import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
@@ -34,6 +36,34 @@ class JavaScriptObfuscatorFacade {
 
         return obfuscatedCode;
     }
+
+    /**
+     * @param {TSourceCodesObject} sourceCodesObject
+     * @param {TInputOptions} inputOptions
+     * @returns {TObfuscationResultsObject<TSourceCodesObject>}
+     */
+    public static obfuscateMultiple <TSourceCodesObject extends TObject<string>> (
+        sourceCodesObject: TSourceCodesObject,
+        inputOptions: TInputOptions = {}
+    ): TObfuscationResultsObject<TSourceCodesObject> {
+        if (typeof sourceCodesObject !== 'object') {
+            throw new Error('Source codes object should be a plain object');
+        }
+
+        return Object
+            .keys(sourceCodesObject)
+            .reduce(
+                (acc: TObfuscationResultsObject<TSourceCodesObject>, sourceCodeIdentifier: keyof TSourceCodesObject) => {
+                    const sourceCode: string = sourceCodesObject[sourceCodeIdentifier];
+
+                    return {
+                        ...acc,
+                        [sourceCodeIdentifier]: JavaScriptObfuscatorFacade.obfuscate(sourceCode, inputOptions)
+                    };
+                },
+                <TObfuscationResultsObject<TSourceCodesObject>>{}
+            );
+    }
 }
 
 export { JavaScriptObfuscatorFacade as JavaScriptObfuscator };

src/types/TObfuscationResultsObject.ts

@@ -0,0 +1,3 @@
+import { IObfuscatedCode } from '../interfaces/source-code/IObfuscatedCode';
+
+export type TObfuscationResultsObject <TSourceCodesObject> = {[key in keyof TSourceCodesObject]: IObfuscatedCode};

test/functional-tests/code-transformers/preparing-transformers/hashbang-operator-transformer/HashbangOperatorTransformer.spec.ts

@@ -89,7 +89,7 @@ describe('HashbangOperatorTransformer', () => {
         let obfuscatedCode: string;
 
         before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/hashbang-indent.fixture');
+            const code: string = readFileAsString(__dirname + '/fixtures/hashbang-indent.js');
 
             obfuscatedCode = JavaScriptObfuscator.obfuscate(
                 code,

test/functional-tests/javascript-obfuscator/JavaScriptObfuscator.spec.ts

@@ -2,6 +2,7 @@ import { assert } from 'chai';
 import { TypeFromEnum } from '@gradecam/tsenum';
 
 import { TInputOptions } from '../../../src/types/options/TInputOptions';
+import { TObject } from '../../../src/types/TObject';
 
 import { IObfuscatedCode } from '../../../src/interfaces/source-code/IObfuscatedCode';
 
@@ -899,4 +900,58 @@ describe('JavaScriptObfuscator', () => {
             });
         });
     });
+
+    describe('obfuscateMultiple', () => {
+        describe('multiple source codes', () => {
+            const regExp1: RegExp = /var _0x(\w){4,6} *= *0x1;/;
+            const regExp2: RegExp = /var _0x(\w){4,6} *= *'abc';/;
+
+            let obfuscatedCode1: string;
+            let obfuscatedCode2: string;
+
+            beforeEach(() => {
+                const sourceCode1: string = readFileAsString(__dirname + '/fixtures/simple-input-1.js');
+                const sourceCode2: string = readFileAsString(__dirname + '/fixtures/simple-input-2.js');
+                const obfuscationResultsObject = JavaScriptObfuscator.obfuscateMultiple(
+                    {
+                        sourceCode1,
+                        sourceCode2
+                    },
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        renameGlobals: true
+                    }
+                );
+
+                obfuscatedCode1 = obfuscationResultsObject.sourceCode1.getObfuscatedCode();
+                obfuscatedCode2 = obfuscationResultsObject.sourceCode2.getObfuscatedCode();
+            });
+
+            it('Match #1: should return correct obfuscated code', () => {
+                assert.match(obfuscatedCode1, regExp1);
+            });
+
+            it('Match #2: should return correct obfuscated code', () => {
+                assert.match(obfuscatedCode2, regExp2);
+            });
+        });
+
+        describe('invalid source codes object', () => {
+            let testFunc: () => TObject<IObfuscatedCode>;
+
+            beforeEach(() => {
+                testFunc = () => JavaScriptObfuscator.obfuscateMultiple(
+                    'foo' as any,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        renameGlobals: true
+                    }
+                );
+            });
+
+            it('Should throw an error if source codes object is not a plain object', () => {
+                assert.throw(testFunc, Error);
+            });
+        });
+    });
 });