Refactor context

.eslintrc

@@ -6,6 +6,7 @@
     "mocha": true
   },
   "rules": {
+    "no-debugger": 0,
     "strict": [0],
     "eqeqeq": 2,
     "quotes": [2, "single", {"allowTemplateLiterals": true}],

package.json

@@ -4,7 +4,7 @@
   "description": "",
   "main": "lib/wepy.js",
   "scripts": {
-    "lint": "eslint ./ --ext .js",
+    "lint": "eslint ./ --fix --ext .js",
     "dev:core": "rollup -w -c scripts/config.js --environment TARGET:core",
     "dev:all": "node ./scripts/build.js",
     "dev:watch": "chokidar '**/*.wpy' '**/*.js' -c 'npm run dev:all' -i '/dist/'",

packages/cli/core/CacheFile.js

@@ -0,0 +1,14 @@
+class CacheFile {
+  constructor() {
+    this._data = {};
+  }
+
+  set(k, v) {
+    this._data[k] = v;
+  }
+  get(k) {
+    return this._data[k];
+  }
+}
+
+exports = module.exports = CacheFile;

packages/cli/core/Producer.js

@@ -0,0 +1,58 @@
+const fs = require('fs');
+
+class Producer {
+  constructor() {
+    this.sequence = 0;
+    this.beads = [];
+    this.beadsMap = {};
+    this._vendors = [];
+    this._assets = [];
+  }
+
+  make(BeadType, filepath, id, content) {
+    if (!id) {
+      id = filepath;
+    }
+    if (!content) {
+      try {
+        content = fs.readFileSync(filepath, 'utf-8');
+      } catch (err) {
+        content = '';
+      }
+    }
+    let bead;
+    if (this.beadsMap[id]) {
+      bead = this.beadsMap[id];
+      bead.reload(content);
+    } else {
+      bead = new BeadType(id, filepath, content);
+      bead.no = this.sequence;
+      this.sequence++;
+      this.beads.push(bead);
+      this.beadsMap[id] = bead;
+    }
+    return bead;
+  }
+
+  vendors(chain) {
+    if (chain !== undefined) {
+      if (!this._vendors.includes(chain)) {
+        this._vendors.push(chain);
+      }
+    } else {
+      return this._vendors;
+    }
+  }
+
+  assets(chain) {
+    if (chain !== undefined) {
+      if (!this._assets.includes(chain)) {
+        this._assets.push(chain);
+      }
+    } else {
+      return this._assets;
+    }
+  }
+}
+
+exports = module.exports = Producer;

packages/cli/core/Resolver.js

@@ -0,0 +1,58 @@
+const ResolverFactory = require('enhanced-resolve').ResolverFactory;
+const node = require('enhanced-resolve/lib/node');
+const NodeJsInputFileSystem = require('enhanced-resolve/lib/NodeJsInputFileSystem');
+const CachedInputFileSystem = require('enhanced-resolve/lib/CachedInputFileSystem');
+
+exports = module.exports = class Resolver {
+  constructor(options) {
+    this._options = options;
+    this.inputFileSystem = new CachedInputFileSystem(new NodeJsInputFileSystem(), 60000);
+  }
+
+  wrapper(context) {
+    let fnBak = context.resolve;
+
+    context.resolve = function(...args) {
+      return new Promise((resolve, reject) => {
+        args.push(function(err, filepath, meta) {
+          if (err) {
+            reject(err);
+          } else {
+            resolve({ path: filepath, meta: meta });
+          }
+        });
+        fnBak.apply(context, args);
+      });
+    };
+
+    return context;
+  }
+
+  create(options = {}) {
+    const context = ResolverFactory.createResolver(
+      Object.assign(
+        {
+          fileSystem: this.inputFileSystem
+        },
+        this._options,
+        options
+      )
+    );
+
+    return this.wrapper(context);
+  }
+
+  createSync(options = {}) {
+    const context = node.create.sync(
+      Object.assign(
+        {
+          fileSystem: this.inputFileSystem
+        },
+        this._options,
+        options
+      )
+    );
+
+    return context;
+  }
+};

packages/cli/core/ast/walker.js

@@ -1,11 +1,9 @@
 class AstWalker {
-  constructor(compilation, ast, lang) {
+  constructor(ast, chain) {
     this.ast = ast;
     this.state = {};
-    this.deps = [];
+    this.chain = chain;
     this.replacements = [];
-    this.compilation = compilation;
-    this.lang = lang;
   }
 
   run() {
@@ -234,7 +232,7 @@ class AstWalker {
       module: source,
       loc: statement.source.loc
     };
-    this.deps.push(dep);
+    this.chain.bead.parsed.dependences.push(dep);
     return;
     /*
     // this.applyPluginsBailResult("import", statement, source);
@@ -383,8 +381,8 @@ class AstWalker {
         case 'VariableDeclarator': {
           this.enterPattern(declarator.id, (name, decl) => {
             // For old version compiler-babel, we can remove it later
-            if (this.compilation.hasHook('prewalk-' + declarator.type, this, declarator, name, decl)) {
-              this.compilation.hook('prewalk-' + declarator.type, this, declarator, name, decl);
+            if (this.chain.hasHook('prewalk-' + declarator.type, this, declarator, name, decl)) {
+              this.chain.hook('prewalk-' + declarator.type, this, declarator, name, decl);
             } else {
               // Ignore child scope
               if (this.scope.instances && declarator.init && declarator.init.type === 'CallExpression') {
@@ -558,8 +556,8 @@ class AstWalker {
       const exprName = this.getNameForExpression(expression.argument);
       if (exprName && exprName.free) {
         let hookName = 'walker-unary-expression-undefined';
-        if (this.compilation.hasHook(hookName)) {
-          this.compilation.hookSeq(hookName, this, expression, exprName);
+        if (this.chain.hasHook(hookName)) {
+          this.chain.hookSeq(hookName, this, expression, exprName);
         }
       }
     }
@@ -732,8 +730,8 @@ class AstWalker {
       if (expression.callee.type === 'MemberExpression') {
         let exprName = this.getNameForExpression(expression.callee);
         // For old version compiler-babel, we can remove it later
-        if (this.compilation.hasHook('walker-detect-entry')) {
-          this.compilation.hook('walker-detect-entry', this, expression, exprName);
+        if (this.chain.hasHook('walker-detect-entry')) {
+          this.chain.hook('walker-detect-entry', this, expression, exprName);
         } else {
           if (this.scope.instances && exprName && this.scope.instances.indexOf(exprName.instance) !== -1) {
             // calling wepy instance
@@ -772,8 +770,8 @@ class AstWalker {
     const exprName = this.getNameForExpression(expression);
     if (exprName && exprName.free) {
       let hookName = 'walker-member-expression-undefined';
-      if (this.compilation.hasHook(hookName)) {
-        this.compilation.hookSeq(hookName, this, expression, exprName);
+      if (this.chain.hasHook(hookName)) {
+        this.chain.hookSeq(hookName, this, expression, exprName);
       }
     }
     this.walkExpression(expression.object);
@@ -783,8 +781,8 @@ class AstWalker {
   walkIdentifier(expression) {
     if (this.scope.definitions.indexOf(expression.name) === -1) {
       let hookName = 'walker-identifier-undefined';
-      if (this.compilation.hasHook(hookName)) {
-        this.compilation.hookSeq(hookName, this, expression);
+      if (this.chain.hasHook(hookName)) {
+        this.chain.hookSeq(hookName, this, expression);
       }
     }
   }
@@ -1195,7 +1193,7 @@ class AstWalker {
         this.state.module,
         expr.loc
       );*/
-      this.deps.push(dep);
+      this.chain.bead.parsed.dependences.push(dep);
       this.state.current = dep;
     }