ion
Version:
ion language ========================
1,269 lines (1,259 loc) • 33.8 MB
JavaScript
(function() {
var ensureLoaded, getCompiledCode, loaded, modules, normalize, require, resolve, used;
if (this.global == null) {
this.global = (function() {
return this;
})();
}
if (this.require != null) {
return;
}
used = {};
require = function(path) {
var i, m, object, originalPath, steps;
if (path === 'ion/browser/require') {
return require;
}
originalPath = path;
m = modules[path];
if (!m) {
if (path[path.length - 1] !== '/') {
path += '/';
}
path += "index";
m = modules[path];
}
if (!m) {
steps = path.replace(/\/index$/, "").split(/\//);
object = this;
i = 0;
while ((object != null) && i < steps.length) {
object = object[steps[i]];
i++;
}
if (object != null) {
m = modules[originalPath] = {
exports: object
};
}
}
if (!m) {
throw new Error("Couldn't find module for: " + path);
}
if (!m.exports) {
m.exports = {};
m.id = path;
m.call(this, m, m.exports, resolve(path));
}
used[path] = true;
return m.exports;
};
modules = {};
require.getUnusedIds = function() {
var key, results;
results = [];
for (key in modules) {
if (!used[key]) {
results.push(key);
}
}
return results;
};
normalize = require.normalize = function(curr, path) {
var i, seg, segs;
segs = curr.split("/");
seg = void 0;
if (path[0] !== ".") {
return path;
}
segs.pop();
path = path.split("/");
i = 0;
while (i < path.length) {
seg = path[i];
if (seg === "..") {
segs.pop();
} else {
if (seg !== ".") {
segs.push(seg);
}
}
++i;
}
return segs.join("/");
};
resolve = function(path) {
return function(p) {
return require(normalize(path, p));
};
};
require.register = function(path, fn) {
return modules[path] = fn;
};
require.loadAll = function() {
var id, _results;
_results = [];
for (id in modules) {
_results.push(require(id));
}
return _results;
};
require.getModuleIds = function() {
return Object.keys(modules);
};
require.runTests = function(callback) {
var fn;
fn = function() {
return require("ion/browser/tester").runTests(require.getModuleIds(), callback);
};
if (global.setTimeout != null) {
return setTimeout(fn, 0);
} else {
return fn();
}
};
getCompiledCode = function(scriptElement) {
var compiledCode, compiler, source;
source = scriptElement.innerHTML;
compiledCode = sessionStorage.getItem(source);
if (compiledCode == null) {
console.log('checking source code, didnt find it, so compiling');
compiler = require('ion/compiler');
compiledCode = compiler.compile(source);
sessionStorage.setItem(source, compiledCode);
}
return compiledCode;
};
require.compileScripts = function() {
var compiledCode, compiledWrapper, ion, removeLastResult, result, scriptElement, template, _i, _len, _ref;
ion = require('ion');
_ref = document.querySelectorAll("script[type=ion]");
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
scriptElement = _ref[_i];
compiledCode = getCompiledCode(scriptElement);
compiledWrapper = eval("(function(){ " + compiledCode + " })");
result = compiledWrapper.call(scriptElement);
if (result != null) {
if (typeof result.template) {
template = result.call(scriptElement);
removeLastResult = null;
template.observe(function(templateResult) {
var container;
if (typeof removeLastResult === "function") {
removeLastResult();
}
removeLastResult = null;
if (templateResult != null) {
container = scriptElement.parentElement;
if (global.Polymer) {
container = Polymer.dom(container);
}
container.appendChild(templateResult);
return removeLastResult = function() {
return scriptElement.parentElement.removeChild(templateResult);
};
}
});
} else {
scriptElement.parentElement.appendChild(document.createTextNode(result));
}
}
}
return ion.sync();
};
if (typeof module === "undefined") {
this.require = require;
} else {
module.exports = require;
}
if (global.window != null) {
loaded = false;
ensureLoaded = function() {
if (!loaded) {
loaded = true;
return require.compileScripts();
}
};
window.addEventListener('load', ensureLoaded);
return window.addEventListener('WebComponentsReady', ensureLoaded);
}
})();
void (function(){var _ion_Object_ = function(module,exports,require){'use strict';
var ion = require('./');
var typeKey = ion.typeKey;
var _ref2 = {};
{
_ref2[typeKey] = ion.patch.combine(_ref2[typeKey], {
visible: false,
type: 'string',
get: function () {
return this.constructor.name;
},
set: function () {
}
});
_ref2.toJSON = function () {
var properties = {};
properties[typeKey] = this[typeKey];
{
var _ref = this;
for (var key in _ref) {
var value = _ref[key];
var descriptor = this.constructor.properties != null ? this.constructor.properties[key] : void 0;
if ((descriptor != null ? descriptor.serializable : void 0) !== false) {
properties[key] = value;
}
}
}
return properties;
};
}
var Object = ion.defineClass({
name: 'Object',
constructor: function Object(properties) {
for (var _i = 0; _i < arguments.length; _i++) {
var arg = arguments[_i];
if (arg != null) {
for (var key in arg) {
var value = arg[key];
this[key] = value;
}
}
}
},
typeKey: typeKey,
is: function (object) {
return object != null ? object.constructor.types != null ? object.constructor.types.has != null ? object.constructor.types.has(this) : void 0 : void 0 : void 0;
},
properties: _ref2,
test: function () {
var object = new Object();
if (!Object.is(object))
throw new Error('Assertion Failed: (Object.is(object))');
}
}, null);
module.exports = exports = Object;
}
if (typeof require === 'function') {
if (require.register)
require.register('ion/Object',_ion_Object_);
else
_ion_Object_.call(this, module, exports, require);
}
else {
_ion_Object_.call(this);
}
}).call(this)
'use strict';
(function () {
if (!(global.window != null)) {
return;
}
var defaultNS = 'http://www.w3.org/1999/xhtml';
var capitalize = function (x) {
return x[0].toUpperCase() + x.substring(1);
};
var registerElements = function (elements, ns) {
if (ns == null)
ns = defaultNS;
for (var _i = 0; _i < elements.length; _i++) {
var name = elements[_i];
var jsName = name.split('-').map(capitalize).join('');
window[jsName] = function (ns, name) {
return function (attributes) {
var ion = require('ion');
var isValue = void 0;
for (var _i2 = 0; _i2 < arguments.length; _i2++) {
var arg = arguments[_i2];
if ((arg != null ? arg.is : void 0) != null) {
isValue = arg.is;
}
}
var element = document.createElementNS(ns, name, isValue);
for (var _i3 = 0; _i3 < arguments.length; _i3++) {
var arg = arguments[_i3];
if (arg != null) {
for (var key in arg) {
var value = arg[key];
if (value != null) {
element.setAttribute(key, value);
}
}
}
}
return element;
};
}(ns, name);
}
};
global.registerElements = registerElements;
var syncOnRefresh = function (e) {
var ion = require('ion');
requestAnimationFrame(ion.sync);
};
window.addEventListener('hashchange', syncOnRefresh);
window.addEventListener('transitionend', syncOnRefresh);
window.document.addEventListener('keypress', syncOnRefresh);
window.document.addEventListener('keydown', syncOnRefresh);
window.document.addEventListener('keyup', syncOnRefresh);
var nsElements = {
'http://www.w3.org/1999/xhtml': [
'div',
'span',
'input',
'textarea',
'a',
'br',
'img',
'p',
'button',
'caption',
'fieldset',
'form',
'frame',
'frameset',
'h1',
'h2',
'h3',
'h4',
'h5',
'h6',
'hr',
'legend',
'menu',
'option',
'select',
'script',
'pre',
'table',
'tbody',
'td',
'tr',
'thead',
'canvas',
'head',
'meta',
'body',
'script',
'section',
'header',
'footer',
'article',
'ul',
'ol',
'li',
'label',
'strong',
'datalist'
],
'http://www.w3.org/2000/svg': [
'svg',
'path',
'circle',
'text'
]
};
for (var ns in nsElements) {
var elements = nsElements[ns];
registerElements(elements, ns);
}
}());
void (function(){var _ion_browser_index_ = function(module,exports,require){Object.defineProperty(exports, 'elements', {get:function(){ return require('./elements') }, enumerable: true})
Object.defineProperty(exports, 'require', {get:function(){ return require('./require') }, enumerable: true})
Object.defineProperty(exports, 'tester', {get:function(){ return require('./tester') }, enumerable: true})
}
if (typeof require === 'function') {
if (require.register)
require.register('ion/browser/index',_ion_browser_index_);
else
_ion_browser_index_.call(this, module, exports, require);
}
else {
_ion_browser_index_.call(this);
}
}).call(this)
void (function(){var _ion_browser_tester_ = function(module,exports,require){var args, file, manifest, manifestFile, moduleId, modules, np, runTest, runTests, spawnTests, utility, _i, _len, _ref;
runTest = function(name, test, callback) {
var e, expectedCallbacks, key, result, value;
expectedCallbacks = [];
if (typeof test === 'object') {
for (key in test) {
value = test[key];
expectedCallbacks = expectedCallbacks.concat(runTest(name + ' ' + key, value, callback));
}
} else if (typeof test === 'function') {
if (/^\s*function\s*[a-zA-Z_0-9]*\s*\(\s*(done)?\s*\)/.test(test.toString())) {
expectedCallbacks.push(name);
try {
if (test.length === 1) {
test(function(error, warning) {
return callback(name, error, warning);
});
} else {
result = test();
callback(name, null, result);
}
} catch (_error) {
e = _error;
callback(name, e, null);
}
}
}
return expectedCallbacks;
};
exports.spawnTests = spawnTests = function(manifestFile) {
var command;
command = "node " + __filename + " " + manifestFile;
require('../builder/utility').spawn(command);
};
exports.runTests = runTests = function(moduleIds, callback) {
var array, duration, e, error, expectedCallbacks, getIncompleteCallbacks, handler, inc, key, module, moduleId, name, timeout, waitingForFinishTimeout, warning, _i, _len;
if (!moduleIds) {
throw new Error("moduleIds is required");
}
if (callback == null) {
callback = exports.createCallback();
}
expectedCallbacks = {};
waitingForFinishTimeout = null;
handler = function(name, error, warning) {
var inc;
expectedCallbacks[name] = true;
callback(name, error, warning);
if (waitingForFinishTimeout != null) {
inc = getIncompleteCallbacks();
if (inc.length === 0) {
clearTimeout(waitingForFinishTimeout);
return callback();
}
}
};
for (key in moduleIds) {
moduleId = moduleIds[key];
try {
module = require(moduleId);
name = Array.isArray(moduleIds) ? moduleId : key;
array = runTest(name, module.test, handler);
for (_i = 0, _len = array.length; _i < _len; _i++) {
name = array[_i];
if (expectedCallbacks[name] == null) {
expectedCallbacks[name] = false;
}
}
} catch (_error) {
e = _error;
handler(moduleId, e, null);
}
}
getIncompleteCallbacks = function() {
var value;
return (function() {
var _results;
_results = [];
for (name in expectedCallbacks) {
value = expectedCallbacks[name];
if (!value) {
_results.push(name);
}
}
return _results;
})();
};
inc = getIncompleteCallbacks();
if (inc.length === 0) {
return callback();
} else {
duration = 1000;
error = "Timed out after " + duration + " ms";
warning = void 0;
timeout = (function(_this) {
return function() {
var _j, _len1;
inc = getIncompleteCallbacks();
for (_j = 0, _len1 = inc.length; _j < _len1; _j++) {
name = inc[_j];
callback(name, error, warning);
}
return callback();
};
})(this);
if (global.setTimeout != null) {
return waitingForFinishTimeout = setTimeout(timeout, duration);
} else {
error = void 0;
warning = "Platform missing setTimeout";
return timeout();
}
}
};
exports.createCallback = function(options, html) {
var beep, blue, endColor, endLine, fails, green, log, plain, red, start, tests, _ref, _ref1, _ref2, _ref3, _ref4, _ref5, _ref6, _ref7;
if (html == null) {
html = global.window != null;
}
if (options == null) {
options = html ? {
red: '<span style="color:red;white-space:pre">',
green: '<span style="color:green;white-space:pre">',
blue: '<span style="color:blue;white-space:pre">',
plain: '<span>',
endColor: '</span>',
log: function(x) {
return document.body.innerHTML += x;
},
beep: '',
endLine: '<br>'
} : {};
}
red = (_ref = options.red) != null ? _ref : '\u001b[31m';
green = (_ref1 = options.green) != null ? _ref1 : '\u001b[32m';
blue = (_ref2 = options.blue) != null ? _ref2 : '\u001b[36m';
endColor = (_ref3 = options.endColor) != null ? _ref3 : '\u001b[0m';
plain = (_ref4 = options.plain) != null ? _ref4 : '';
beep = (_ref5 = options.beep) != null ? _ref5 : '\u0007';
log = (_ref6 = options.log) != null ? _ref6 : function(x) {
return console.log(x);
};
endLine = (_ref7 = options.endLine) != null ? _ref7 : '';
tests = 0;
fails = 0;
start = null;
return function(name, error, result) {
var color, finish, passed, time, title, _ref10, _ref8, _ref9;
if (start == null) {
start = new Date().getTime();
}
if (name != null) {
tests++;
if (error != null) {
fails++;
}
color = error != null ? red : result != null ? blue : null;
if (color != null) {
return log(color + name + ": " + ((_ref8 = (_ref9 = (_ref10 = error != null ? error.stack : void 0) != null ? _ref10 : error) != null ? _ref9 : result) != null ? _ref8 : "") + endColor + endLine);
} else {
return process.stdout.write('.');
}
} else {
finish = new Date().getTime();
time = finish - start;
passed = tests - fails;
log(endLine);
color = passed === tests ? green : red + beep;
log(color + (title = "" + passed + "/" + tests + " Passed (" + time + " ms).") + endColor + endLine);
if (global.document) {
document.title = title;
}
return log(endLine);
}
};
};
exports.test = function() {
var assert, tests;
assert = {
equal: function(a, b) {
if (!a == b) {
throw new Error("" + a + " != " + b);
}
}
};
tests = {
alpha: function() {
throw "Failure";
},
beta: function() {},
charlie: function() {
return "Return value";
}
};
runTest('fail', (function() {
throw 'Failure';
}), function(name, error, result) {
assert.equal(name, 'fail');
assert.equal(error, 'Failure');
return assert.equal(result, null);
});
runTest('pass', (function() {}), function(name, error, result) {
assert.equal(name, 'pass');
assert.equal(error, null);
return assert.equal(result, null);
});
runTest('warn', (function() {
return 'warning';
}), function(name, error, result) {
assert.equal(name, 'warn');
assert.equal(error, null);
return assert.equal(result, 'warning');
});
};
if (require.main === module) {
np = require('path');
args = process.argv.slice(2).map(function(x) {
return x.replace(/\\/g, '\/');
});
if (args.length < 1) {
console.log("Usage: tester manifestFile");
return;
}
manifestFile = args[0];
utility = require('../builder/utility');
manifest = JSON.parse(utility.read(manifestFile));
modules = {};
_ref = manifest.files;
for (_i = 0, _len = _ref.length; _i < _len; _i++) {
file = _ref[_i];
moduleId = np.join(process.cwd(), np.dirname(manifestFile), file);
modules[file] = moduleId;
}
runTests(modules);
}
}
if (typeof require === 'function') {
if (require.register)
require.register('ion/browser/tester',_ion_browser_tester_);
else
_ion_browser_tester_.call(this, module, exports, require);
}
else {
_ion_browser_tester_.call(this);
}
}).call(this)
void (function(){var _ion_builder_Directory_ = function(module,exports,require){'use strict';
if (global.Window) {
return;
}
var ion = require('../'), fs = require('fs'), np = require('path'), utility = require('./utility'), watcher = require('./watcher'), File = require('./File');
var Directory = ion.defineClass({
name: 'Directory',
constructor: function Directory(path) {
if (path != null) {
this.path = String(path);
}
},
properties: {
create: function () {
utility.makeDirectories(this.path);
},
exists: {
get: function () {
return fs.existsSync(this.path);
}
},
path: '.',
toString: function () {
return this.path;
},
get: function (path) {
if (this.hasOwnProperty(path) || this[path] != null) {
return this[path];
}
path = this.getAbsoluteName(path);
if (fs.existsSync(path)) {
return utility.read(path);
} else {
return void 0;
}
},
set: function (path, content) {
if (this.hasOwnProperty(path) || this[path] != null) {
return this[path] = content;
}
path = this.getAbsoluteName(path);
if (content != null) {
console.log('Writing: ' + path);
} else {
console.log('Deleting: ' + path);
}
utility.write(path, content);
return content;
},
read: function (path) {
if (this.hasOwnProperty(path) || this[path] != null) {
return this[path];
}
path = this.getAbsoluteName(path);
if (fs.existsSync(path)) {
return utility.read(path);
} else {
return void 0;
}
},
write: function (path, content, options) {
if (options == null)
options = {};
var _ref = options;
var encoding = _ref.encoding;
var force = _ref.force;
if (!(content != null)) {
return;
}
if (this.hasOwnProperty(path) || this[path] != null) {
return this[path] = content;
}
path = this.getAbsoluteName(path);
if (force || utility.read(path, encoding) !== content) {
console.log('Writing: ' + path);
utility.write(path, content, encoding);
}
},
delete: function (path) {
console.log('Deleting: ' + path);
path = this.getAbsoluteName(path);
utility.write(path, null);
},
getFile: function (path) {
return new File(this.getAbsoluteName(path));
},
getDirectory: function (path) {
return new Directory(this.getAbsoluteName(path));
},
getRelativeName: function (path) {
return np.relative(this.path, String(path));
},
getAbsoluteName: function (path) {
return np.join(this.path, String(path));
},
search: function (include, exclude, options) {
options = options != null ? options : { initial: false };
if (include != null) {
options.include = include;
}
if (exclude != null) {
options.exclude = exclude;
}
var results = {};
ion.makeReactive(results, ion.bind(function () {
var unwatch = watcher.watchDirectory(this.path, options, ion.bind(function (filename) {
var path = this.getRelativeName(filename);
if (fs.existsSync(filename)) {
if (!(results[path] != null)) {
results[path] = new File(filename);
} else {
var file = results[path];
var modified = utility.getModified(filename);
if (modified !== file.modified) {
file.modified = modified;
} else {
return;
}
}
} else {
delete results[path];
}
ion.sync();
}, this));
return unwatch;
}, this));
var files = utility.list(this.path, options);
for (var _i = 0; _i < files.length; _i++) {
var path = files[_i];
results[this.getRelativeName(path)] = new File(path);
}
return results;
}
}
});
module.exports = exports = Directory;
}
if (typeof require === 'function') {
if (require.register)
require.register('ion/builder/Directory',_ion_builder_Directory_);
else
_ion_builder_Directory_.call(this, module, exports, require);
}
else {
_ion_builder_Directory_.call(this);
}
}).call(this)
void (function(){var _ion_builder_File_ = function(module,exports,require){'use strict';
if (global.Window) {
return;
}
var ion = require('../'), fs = require('fs'), np = require('path'), utility = require('./utility');
var File = ion.defineClass({
name: 'File',
constructor: function File(path) {
if ((path != null ? path.constructor : void 0) === File) {
return path;
}
if (this.constructor !== File) {
return new File(path);
}
if (typeof path !== 'string') {
throw new Error('path string is required');
}
Object.defineProperties(this, {
path: {
value: path,
enumerable: true,
writable: false
}
});
this.modified = utility.getModified(path);
ion.makeReactive(this, ion.bind(function () {
var watcher;
if (utility.exists(this.path)) {
watcher = fs.watch(this.path, ion.bind(function () {
var modified = utility.getModified(this.path);
if (this.modified !== modified) {
this.modified = modified;
ion.sync();
}
}, this));
}
return function () {
return watcher != null ? watcher.close() : void 0;
};
}, this));
},
properties: {
isFile: {
get: function () {
return !this.isDirectory;
}
},
isDirectory: {
get: function () {
return utility.isDirectory(this.path);
}
},
directoryName: {
get: function () {
return np.dirname(this.path) != null ? np.dirname(this.path) : '';
}
},
exists: {
get: function () {
return utility.exists(this.path);
}
},
copyFrom: function (file) {
file = File(file);
var content = file.read(null);
if (content.length === 0) {
console.log('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n' + file + ' ' + file.modified + '\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX');
} else {
this.write(content, null);
console.log('Copied: ' + np.normalize(this.path));
}
},
read: function () {
var _lastModified = {};
var _content = {};
return function (encoding) {
if (utility.exists(this.path)) {
var modified = utility.getModified(this.path);
var content;
if (modified === _lastModified[this.path]) {
content = _content[this.path];
} else {
content = utility.read(this.path, encoding);
if (content.length > 0) {
_content[this.path] = content;
_lastModified[this.path] = modified;
} else {
delete _content[this.path];
delete _lastModified[this.path];
}
}
return content;
} else {
return null;
}
};
}(),
getExtension: function () {
var index = this.path.lastIndexOf('.');
return index < 0 ? '' : this.path.substring(index);
},
write: function (content, encoding, forceWrite) {
if (forceWrite == null)
forceWrite = false;
utility.write(this.path, content, encoding);
},
delete: function () {
return utility.write(this.path, null);
},
toString: function () {
return this.path;
},
valueOf: function () {
return this.path;
}
}
});
module.exports = exports = File;
}
if (typeof require === 'function') {
if (require.register)
require.register('ion/builder/File',_ion_builder_File_);
else
_ion_builder_File_.call(this, module, exports, require);
}
else {
_ion_builder_File_.call(this);
}
}).call(this)
void (function(){var _ion_builder_ModuleBuilder_ = function(module,exports,require){'use strict';
if (global.window) {
return;
}
var ion = require('../'), np = require('path'), File = require('./File'), Directory = require('./Directory'), builder = require('./'), utility = require('./utility'), compilers = {
'.coffee': { compile: builder.compileCoffeeScript },
'.pegjs': { compile: builder.compilePegjs },
'.js': { compile: builder.shimJavascript },
'.ion': {
compile: builder.compileIon,
compileWithSourceMap: builder.compileIonWithSourceMap
}
};
module.exports = exports = ion.template(function (packagePatch) {
return ion.createRuntime({
type: 'Template',
id: null,
body: [
{
type: 'VariableDeclaration',
declarations: [{
type: 'VariableDeclarator',
id: {
type: 'Identifier',
name: 'packageJson',
loc: {
start: {
line: 26,
column: 8,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 19,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
init: {
type: 'CallExpression',
callee: {
type: 'MemberExpression',
computed: false,
object: {
type: 'Identifier',
name: 'ion',
loc: {
start: {
line: 26,
column: 22,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 25,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
property: {
type: 'Identifier',
name: 'patch',
loc: {
start: {
line: 26,
column: 26,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 31,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
loc: {
start: {
line: 26,
column: 22,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 31,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
arguments: [
{
type: 'CallExpression',
callee: {
type: 'MemberExpression',
computed: false,
object: {
type: 'Identifier',
name: 'JSON',
loc: {
start: {
line: 26,
column: 32,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 36,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
property: {
type: 'Identifier',
name: 'parse',
loc: {
start: {
line: 26,
column: 37,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 42,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
loc: {
start: {
line: 26,
column: 32,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 42,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
arguments: [{
type: 'CallExpression',
callee: {
type: 'MemberExpression',
computed: false,
object: {
type: 'NewExpression',
callee: {
type: 'Identifier',
name: 'File',
loc: {
start: {
line: 26,
column: 47,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 51,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
arguments: [{
type: 'Literal',
value: 'package.json'
}],
loc: {
start: {
line: 26,
column: 43,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 67,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
property: {
type: 'Identifier',
name: 'read',
loc: {
start: {
line: 26,
column: 68,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 72,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
loc: {
start: {
line: 26,
column: 43,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 72,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
arguments: [],
loc: {
start: {
line: 26,
column: 43,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 74,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
}],
loc: {
start: {
line: 26,
column: 32,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 75,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
{
type: 'ConditionalExpression',
test: {
type: 'BinaryExpression',
operator: '!=',
left: {
type: 'Identifier',
name: 'packagePatch',
loc: {
start: {
line: 26,
column: 77,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 89,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
right: {
type: 'Literal',
value: null
}
},
consequent: {
type: 'Identifier',
name: 'packagePatch',
loc: {
start: {
line: 26,
column: 77,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 89,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
alternate: {
type: 'ObjectExpression',
properties: []
}
}
],
loc: {
start: {
line: 26,
column: 22,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 26,
column: 95,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
}
}],
kind: 'let',
order: '0'
},
{
type: 'VariableDeclaration',
declarations: [{
type: 'VariableDeclarator',
id: {
type: 'Identifier',
name: 'inputs',
loc: {
start: {
line: 27,
column: 8,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
},
end: {
line: 27,
column: 14,
fixed: true,
source: 'ion/builder/ModuleBuilder.ion'
}
}
},
init: {
type: 'CallExpression',
callee: {
type: 'Function',
context: true,
value: function (_context) {
return function (packageJson) {
var Directory = _context.get('Directory');
var names = packageJson.directories.src != null ? packageJson.directories.src : 'src';