| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| var glob = require('glob'); |
| var fsExtra = require('fs-extra'); |
| var esprima = require('esprima'); |
| |
| function run(cb) { |
| glob('**/*.js', { |
| cwd: __dirname + '/../src/' |
| }, function (err, files) { |
| files.forEach(function (filePath) { |
| var code = parse(fsExtra.readFileSync( |
| __dirname + '/../src/' + filePath, 'utf-8')); |
| code = code.replace(/require\(([\'"])zrender\//g, 'require($1zrender/lib/'); |
| fsExtra.outputFileSync( |
| __dirname + '/../lib/' + filePath, |
| code, 'utf-8'); |
| }); |
| |
| cb && cb(); |
| }); |
| } |
| |
| if (require.main === module) { |
| run(); |
| } |
| else { |
| module.exports = run; |
| } |
| |
| var MAGIC_DEPS = { |
| 'exports' : true, |
| 'module' : true, |
| 'require' : true |
| }; |
| |
| var SIMPLIFIED_CJS = ['require', 'exports', 'module']; |
| |
| // Convert AMD-style JavaScript string into node.js compatible module |
| function parse (raw){ |
| var output = ''; |
| var ast = esprima.parse(raw, { |
| range: true, |
| raw: true |
| }); |
| |
| var defines = ast.body.filter(isDefine); |
| |
| if ( defines.length > 1 ){ |
| throw new Error('Each file can have only a single define call. Found "'+ defines.length +'"'); |
| } else if (!defines.length){ |
| return raw; |
| } |
| |
| var def = defines[0]; |
| var args = def.expression['arguments']; |
| var factory = getFactory( args ); |
| var useStrict = getUseStrict( factory ); |
| |
| // do replacements in-place to avoid modifying the code more than needed |
| if (useStrict) { |
| output += useStrict.expression.raw +';\n'; |
| } |
| output += raw.substring( 0, def.range[0] ); // anything before define |
| output += getRequires(args, factory); // add requires |
| output += getBody(raw, factory.body, useStrict); // module body |
| |
| output += raw.substring( def.range[1], raw.length ); // anything after define |
| |
| return output; |
| } |
| |
| |
| function getRequires(args, factory){ |
| var requires = []; |
| var deps = getDependenciesNames( args ); |
| var params = factory.params.map(function(param, i){ |
| return { |
| name : param.name, |
| // simplified cjs doesn't have deps |
| dep : (deps.length)? deps[i] : SIMPLIFIED_CJS[i] |
| }; |
| }); |
| |
| params.forEach(function(param){ |
| if ( MAGIC_DEPS[param.dep] && !MAGIC_DEPS[param.name] ) { |
| // if user remaped magic dependency we declare a var |
| requires.push( 'var '+ param.name +' = '+ param.dep +';' ); |
| } else if ( param.dep && !MAGIC_DEPS[param.dep] ) { |
| // only do require for params that have a matching dependency also |
| // skip "magic" dependencies |
| requires.push( 'var '+ param.name +' = require(\''+ param.dep +'\');' ); |
| } |
| }); |
| |
| return requires.join('\n'); |
| } |
| |
| |
| function getDependenciesNames(args){ |
| var deps = []; |
| var arr = args.filter(function(arg){ |
| return arg.type === 'ArrayExpression'; |
| })[0]; |
| |
| if (arr) { |
| deps = arr.elements.map(function(el){ |
| return el.value; |
| }); |
| } |
| |
| return deps; |
| } |
| |
| |
| function isDefine(node){ |
| return node.type === 'ExpressionStatement' && |
| node.expression.type === 'CallExpression' && |
| node.expression.callee.type === 'Identifier' && |
| node.expression.callee.name === 'define'; |
| } |
| |
| |
| function getFactory(args){ |
| return args.filter(function(arg){ |
| return arg.type === 'FunctionExpression'; |
| })[0]; |
| } |
| |
| |
| function getBody(raw, factoryBody, useStrict){ |
| var returnStatement = factoryBody.body.filter(function(node){ |
| return node.type === 'ReturnStatement'; |
| })[0]; |
| |
| var body = ''; |
| var bodyStart = useStrict ? useStrict.expression.range[1] + 1 : factoryBody.range[0] + 1; |
| |
| if (returnStatement) { |
| body += raw.substring( bodyStart, returnStatement.range[0] ); |
| // "return ".length === 7 so we add "6" to returnStatement start |
| body += 'module.exports ='+ raw.substring( returnStatement.range[0] + 6, factoryBody.range[1] - 1 ); |
| } else { |
| // if using exports or module.exports or just a private module we |
| // simply return the factoryBody content |
| body = raw.substring( bodyStart, factoryBody.range[1] - 1 ); |
| } |
| |
| return body; |
| } |
| |
| |
| function getUseStrict(factory){ |
| return factory.body.body.filter(isUseStrict)[0]; |
| } |
| |
| |
| function isUseStrict(node){ |
| return node.type === 'ExpressionStatement' && |
| node.expression.type === 'Literal' && |
| node.expression.value === 'use strict'; |
| } |