Skip to content

Commit

Permalink
refactor(es6): Update DefinePlugin to es2015 (webpack#3632)
Browse files Browse the repository at this point in the history 
* convert DefinePlugin to es2015
  • Loading branch information
@neeharv @TheLarkInn
neeharv authored and TheLarkInn committed Dec 30, 2016
1 parent aa8d01b commit 7d17746
Showing 1 changed file with 101 additions and 109 deletions.
210 changes: 101 additions & 109 deletions lib/DefinePlugin.js
View file
Original file line number Diff line number Diff line change
Expand Up @@ -2,129 +2,121 @@
MIT License http://www.opensource.org/licenses/mit-license.php
Author Tobias Koppers @sokra
*/
var ConstDependency = require("./dependencies/ConstDependency");
var BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
"use strict";

var NullFactory = require("./NullFactory");
const ConstDependency = require("./dependencies/ConstDependency");
const BasicEvaluatedExpression = require("./BasicEvaluatedExpression");
const NullFactory = require("./NullFactory");

function DefinePlugin(definitions) {
this.definitions = definitions;
}
module.exports = DefinePlugin;
DefinePlugin.prototype.apply = function(compiler) {
var definitions = this.definitions;
compiler.plugin("compilation", function(compilation, params) {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());
class DefinePlugin {
constructor(definitions) {
this.definitions = definitions;
}

params.normalModuleFactory.plugin("parser", function(parser) {
(function walkDefinitions(definitions, prefix) {
Object.keys(definitions).forEach(function(key) {
var code = definitions[key];
if(code && typeof code === "object" && !(code instanceof RegExp)) {
walkDefinitions(code, prefix + key + ".");
applyObjectDefine(prefix + key, code);
return;
}
applyDefineKey(prefix, key);
applyDefine(prefix + key, code);
});
}(definitions, ""));
apply(compiler) {
let definitions = this.definitions;
compiler.plugin("compilation", (compilation, params) => {
compilation.dependencyFactories.set(ConstDependency, new NullFactory());
compilation.dependencyTemplates.set(ConstDependency, new ConstDependency.Template());

function stringifyObj(obj) {
return "{" + Object.keys(obj).map(function(key) {
var code = obj[key];
return JSON.stringify(key) + ":" + toCode(code);
}).join(",") + "}";
}
params.normalModuleFactory.plugin("parser", (parser) => {
(function walkDefinitions(definitions, prefix) {
Object.keys(definitions).forEach((key) => {
let code = definitions[key];
if(code && typeof code === "object" && !(code instanceof RegExp)) {
walkDefinitions(code, prefix + key + ".");
applyObjectDefine(prefix + key, code);
return;
}
applyDefineKey(prefix, key);
applyDefine(prefix + key, code);
});
}(definitions, ""));

function toCode(code) {
if(code === null) return "null";
else if(code === undefined) return "undefined";
else if(code instanceof RegExp && code.toString) return code.toString();
else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
else if(typeof code === "object") return stringifyObj(code);
else return code + "";
}
function stringifyObj(obj) {
return "{" + Object.keys(obj).map((key) => {
let code = obj[key];
return JSON.stringify(key) + ":" + toCode(code);
}).join(",") + "}";
}

function applyDefineKey(prefix, key) {
var splittedKey = key.split(".");
splittedKey.slice(1).forEach(function(_, i) {
var fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
parser.plugin("can-rename " + fullKey, function() {
return true;
});
});
}
function toCode(code) {
if(code === null) return "null";
else if(code === undefined) return "undefined";
else if(code instanceof RegExp && code.toString) return code.toString();
else if(typeof code === "function" && code.toString) return "(" + code.toString() + ")";
else if(typeof code === "object") return stringifyObj(code);
else return code + "";
}

function applyDefine(key, code) {
var isTypeof = /^typeof\s+/.test(key);
if(isTypeof) key = key.replace(/^typeof\s+/, "");
var recurse = false;
var recurseTypeof = false;
code = toCode(code);
if(!isTypeof) {
parser.plugin("can-rename " + key, function() {
return true;
function applyDefineKey(prefix, key) {
const splittedKey = key.split(".");
splittedKey.slice(1).forEach((_, i) => {
const fullKey = prefix + splittedKey.slice(0, i + 1).join(".");
parser.plugin("can-rename " + fullKey, () => true);
});
parser.plugin("evaluate Identifier " + key, function(expr) {
if(recurse) return;
recurse = true;
var res = this.evaluate(code);
recurse = false;
}

function applyDefine(key, code) {
let isTypeof = /^typeof\s+/.test(key);
if(isTypeof) key = key.replace(/^typeof\s+/, "");
let recurse = false;
let recurseTypeof = false;
code = toCode(code);
if(!isTypeof) {
parser.plugin("can-rename " + key, () => true);
parser.plugin("evaluate Identifier " + key, (expr) => {
if(recurse) return;
let res = parser.evaluate(code);
recurse = false;
res.setRange(expr.range);
return res;
});
parser.plugin("expression " + key, (expr) => {
let dep = new ConstDependency(code, expr.range);
dep.loc = expr.loc;
parser.state.current.addDependency(dep);
return true;
});
}
let typeofCode = isTypeof ? code : "typeof (" + code + ")";
parser.plugin("evaluate typeof " + key, (expr) => {
if(recurseTypeof) return;
let res = parser.evaluate(typeofCode);
recurseTypeof = false;
res.setRange(expr.range);
return res;
});
parser.plugin("expression " + key, function(expr) {
var dep = new ConstDependency(code, expr.range);
parser.plugin("typeof " + key, (expr) => {
let res = parser.evaluate(typeofCode);
if(!res.isString()) return;
let dep = new ConstDependency(JSON.stringify(res.string), expr.range);
dep.loc = expr.loc;
this.state.current.addDependency(dep);
parser.state.current.addDependency(dep);
return true;
});
}
var typeofCode = isTypeof ? code : "typeof (" + code + ")";
parser.plugin("evaluate typeof " + key, function(expr) {
if(recurseTypeof) return;
recurseTypeof = true;
var res = this.evaluate(typeofCode);
recurseTypeof = false;
res.setRange(expr.range);
return res;
});
parser.plugin("typeof " + key, function(expr) {
var res = this.evaluate(typeofCode);
if(!res.isString()) return;
var dep = new ConstDependency(JSON.stringify(res.string), expr.range);
dep.loc = expr.loc;
this.state.current.addDependency(dep);
return true;
});
}

function applyObjectDefine(key, obj) {
var code = stringifyObj(obj);
parser.plugin("can-rename " + key, function() {
return true;
});
parser.plugin("evaluate Identifier " + key, function(expr) {
return new BasicEvaluatedExpression().setRange(expr.range);
});
parser.plugin("evaluate typeof " + key, function(expr) {
return new BasicEvaluatedExpression().setString("object").setRange(expr.range);
});
parser.plugin("expression " + key, function(expr) {
var dep = new ConstDependency(code, expr.range);
dep.loc = expr.loc;
this.state.current.addDependency(dep);
return true;
});
parser.plugin("typeof " + key, function(expr) {
var dep = new ConstDependency("\"object\"", expr.range);
dep.loc = expr.loc;
this.state.current.addDependency(dep);
return true;
});
}
function applyObjectDefine(key, obj) {
let code = stringifyObj(obj);
parser.plugin("can-rename " + key, () => true);
parser.plugin("evaluate Identifier " + key, (expr) => new BasicEvaluatedExpression().setRange(expr.range));
parser.plugin("evaluate typeof " + key, expr => new BasicEvaluatedExpression().setString("object").setRange(expr.range));
parser.plugin("expression " + key, (expr) => {
let dep = new ConstDependency(code, expr.range);
dep.loc = expr.loc;
parser.state.current.addDependency(dep);
return true;
});
parser.plugin("typeof " + key, (expr) => {
let dep = new ConstDependency("\"object\"", expr.range);
dep.loc = expr.loc;
parser.state.current.addDependency(dep);
return true;
});
}
});
});
});
};
}
}
module.exports = DefinePlugin;

0 comments on commit 7d17746

Please sign in to comment.