818 lines
33 KiB
JavaScript
818 lines
33 KiB
JavaScript
"format register";
|
|
System.register("angular2/src/upgrade/metadata", ["angular2/core"], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
var core_1 = require("angular2/core");
|
|
var COMPONENT_SELECTOR = /^[\w|-]*$/;
|
|
var SKEWER_CASE = /-(\w)/g;
|
|
var directiveResolver = new core_1.DirectiveResolver();
|
|
function getComponentInfo(type) {
|
|
var resolvedMetadata = directiveResolver.resolve(type);
|
|
var selector = resolvedMetadata.selector;
|
|
if (!selector.match(COMPONENT_SELECTOR)) {
|
|
throw new Error('Only selectors matching element names are supported, got: ' + selector);
|
|
}
|
|
var selector = selector.replace(SKEWER_CASE, function(all, letter) {
|
|
return letter.toUpperCase();
|
|
});
|
|
return {
|
|
type: type,
|
|
selector: selector,
|
|
inputs: parseFields(resolvedMetadata.inputs),
|
|
outputs: parseFields(resolvedMetadata.outputs)
|
|
};
|
|
}
|
|
exports.getComponentInfo = getComponentInfo;
|
|
function parseFields(names) {
|
|
var attrProps = [];
|
|
if (names) {
|
|
for (var i = 0; i < names.length; i++) {
|
|
var parts = names[i].split(':');
|
|
var prop = parts[0].trim();
|
|
var attr = (parts[1] || parts[0]).trim();
|
|
var capitalAttr = attr.charAt(0).toUpperCase() + attr.substr(1);
|
|
attrProps.push({
|
|
prop: prop,
|
|
attr: attr,
|
|
bracketAttr: "[" + attr + "]",
|
|
parenAttr: "(" + attr + ")",
|
|
bracketParenAttr: "[(" + attr + ")]",
|
|
onAttr: "on" + capitalAttr,
|
|
bindAttr: "bind" + capitalAttr,
|
|
bindonAttr: "bindon" + capitalAttr
|
|
});
|
|
}
|
|
}
|
|
return attrProps;
|
|
}
|
|
exports.parseFields = parseFields;
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
System.register("angular2/src/upgrade/util", [], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
function stringify(obj) {
|
|
if (typeof obj == 'function')
|
|
return obj.name || obj.toString();
|
|
return '' + obj;
|
|
}
|
|
exports.stringify = stringify;
|
|
function onError(e) {
|
|
console.log(e, e.stack);
|
|
throw e;
|
|
}
|
|
exports.onError = onError;
|
|
function controllerKey(name) {
|
|
return '$' + name + 'Controller';
|
|
}
|
|
exports.controllerKey = controllerKey;
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
System.register("angular2/src/upgrade/constants", [], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
exports.NG2_APP_VIEW_MANAGER = 'ng2.AppViewManager';
|
|
exports.NG2_COMPILER = 'ng2.Compiler';
|
|
exports.NG2_INJECTOR = 'ng2.Injector';
|
|
exports.NG2_HOST_VIEW_FACTORY_REF_MAP = 'ng2.HostViewFactoryRefMap';
|
|
exports.NG2_ZONE = 'ng2.NgZone';
|
|
exports.NG1_CONTROLLER = '$controller';
|
|
exports.NG1_SCOPE = '$scope';
|
|
exports.NG1_ROOT_SCOPE = '$rootScope';
|
|
exports.NG1_COMPILE = '$compile';
|
|
exports.NG1_HTTP_BACKEND = '$httpBackend';
|
|
exports.NG1_INJECTOR = '$injector';
|
|
exports.NG1_PARSE = '$parse';
|
|
exports.NG1_TEMPLATE_CACHE = '$templateCache';
|
|
exports.NG1_TESTABILITY = '$$testability';
|
|
exports.REQUIRE_INJECTOR = '^' + exports.NG2_INJECTOR;
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
System.register("angular2/src/upgrade/downgrade_ng2_adapter", ["angular2/core", "angular2/src/upgrade/constants"], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
var core_1 = require("angular2/core");
|
|
var constants_1 = require("angular2/src/upgrade/constants");
|
|
var INITIAL_VALUE = {__UNINITIALIZED__: true};
|
|
var DowngradeNg2ComponentAdapter = (function() {
|
|
function DowngradeNg2ComponentAdapter(id, info, element, attrs, scope, parentInjector, parse, viewManager, hostViewFactory) {
|
|
this.id = id;
|
|
this.info = info;
|
|
this.element = element;
|
|
this.attrs = attrs;
|
|
this.scope = scope;
|
|
this.parentInjector = parentInjector;
|
|
this.parse = parse;
|
|
this.viewManager = viewManager;
|
|
this.hostViewFactory = hostViewFactory;
|
|
this.component = null;
|
|
this.inputChangeCount = 0;
|
|
this.inputChanges = null;
|
|
this.hostViewRef = null;
|
|
this.changeDetector = null;
|
|
this.contentInsertionPoint = null;
|
|
this.element[0].id = id;
|
|
this.componentScope = scope.$new();
|
|
this.childNodes = element.contents();
|
|
}
|
|
DowngradeNg2ComponentAdapter.prototype.bootstrapNg2 = function() {
|
|
var childInjector = this.parentInjector.resolveAndCreateChild([core_1.provide(constants_1.NG1_SCOPE, {useValue: this.componentScope})]);
|
|
this.contentInsertionPoint = document.createComment('ng1 insertion point');
|
|
this.hostViewRef = this.viewManager.createRootHostView(this.hostViewFactory, '#' + this.id, childInjector, [[this.contentInsertionPoint]]);
|
|
var hostElement = this.viewManager.getHostElement(this.hostViewRef);
|
|
this.changeDetector = this.hostViewRef.changeDetectorRef;
|
|
this.component = this.viewManager.getComponent(hostElement);
|
|
};
|
|
DowngradeNg2ComponentAdapter.prototype.setupInputs = function() {
|
|
var _this = this;
|
|
var attrs = this.attrs;
|
|
var inputs = this.info.inputs;
|
|
for (var i = 0; i < inputs.length; i++) {
|
|
var input = inputs[i];
|
|
var expr = null;
|
|
if (attrs.hasOwnProperty(input.attr)) {
|
|
var observeFn = (function(prop) {
|
|
var prevValue = INITIAL_VALUE;
|
|
return function(value) {
|
|
if (_this.inputChanges !== null) {
|
|
_this.inputChangeCount++;
|
|
_this.inputChanges[prop] = new Ng1Change(value, prevValue === INITIAL_VALUE ? value : prevValue);
|
|
prevValue = value;
|
|
}
|
|
_this.component[prop] = value;
|
|
};
|
|
})(input.prop);
|
|
attrs.$observe(input.attr, observeFn);
|
|
} else if (attrs.hasOwnProperty(input.bindAttr)) {
|
|
expr = attrs[input.bindAttr];
|
|
} else if (attrs.hasOwnProperty(input.bracketAttr)) {
|
|
expr = attrs[input.bracketAttr];
|
|
} else if (attrs.hasOwnProperty(input.bindonAttr)) {
|
|
expr = attrs[input.bindonAttr];
|
|
} else if (attrs.hasOwnProperty(input.bracketParenAttr)) {
|
|
expr = attrs[input.bracketParenAttr];
|
|
}
|
|
if (expr != null) {
|
|
var watchFn = (function(prop) {
|
|
return function(value, prevValue) {
|
|
if (_this.inputChanges != null) {
|
|
_this.inputChangeCount++;
|
|
_this.inputChanges[prop] = new Ng1Change(prevValue, value);
|
|
}
|
|
_this.component[prop] = value;
|
|
};
|
|
})(input.prop);
|
|
this.componentScope.$watch(expr, watchFn);
|
|
}
|
|
}
|
|
var prototype = this.info.type.prototype;
|
|
if (prototype && prototype.ngOnChanges) {
|
|
this.inputChanges = {};
|
|
this.componentScope.$watch(function() {
|
|
return _this.inputChangeCount;
|
|
}, function() {
|
|
var inputChanges = _this.inputChanges;
|
|
_this.inputChanges = {};
|
|
_this.component.ngOnChanges(inputChanges);
|
|
});
|
|
}
|
|
this.componentScope.$watch(function() {
|
|
return _this.changeDetector && _this.changeDetector.detectChanges();
|
|
});
|
|
};
|
|
DowngradeNg2ComponentAdapter.prototype.projectContent = function() {
|
|
var childNodes = this.childNodes;
|
|
var parent = this.contentInsertionPoint.parentNode;
|
|
if (parent) {
|
|
for (var i = 0,
|
|
ii = childNodes.length; i < ii; i++) {
|
|
parent.insertBefore(childNodes[i], this.contentInsertionPoint);
|
|
}
|
|
}
|
|
};
|
|
DowngradeNg2ComponentAdapter.prototype.setupOutputs = function() {
|
|
var _this = this;
|
|
var attrs = this.attrs;
|
|
var outputs = this.info.outputs;
|
|
for (var j = 0; j < outputs.length; j++) {
|
|
var output = outputs[j];
|
|
var expr = null;
|
|
var assignExpr = false;
|
|
var bindonAttr = output.bindonAttr ? output.bindonAttr.substring(0, output.bindonAttr.length - 6) : null;
|
|
var bracketParenAttr = output.bracketParenAttr ? "[(" + output.bracketParenAttr.substring(2, output.bracketParenAttr.length - 8) + ")]" : null;
|
|
if (attrs.hasOwnProperty(output.onAttr)) {
|
|
expr = attrs[output.onAttr];
|
|
} else if (attrs.hasOwnProperty(output.parenAttr)) {
|
|
expr = attrs[output.parenAttr];
|
|
} else if (attrs.hasOwnProperty(bindonAttr)) {
|
|
expr = attrs[bindonAttr];
|
|
assignExpr = true;
|
|
} else if (attrs.hasOwnProperty(bracketParenAttr)) {
|
|
expr = attrs[bracketParenAttr];
|
|
assignExpr = true;
|
|
}
|
|
if (expr != null && assignExpr != null) {
|
|
var getter = this.parse(expr);
|
|
var setter = getter.assign;
|
|
if (assignExpr && !setter) {
|
|
throw new Error("Expression '" + expr + "' is not assignable!");
|
|
}
|
|
var emitter = this.component[output.prop];
|
|
if (emitter) {
|
|
emitter.subscribe({next: assignExpr ? (function(setter) {
|
|
return function(value) {
|
|
return setter(_this.scope, value);
|
|
};
|
|
})(setter) : (function(getter) {
|
|
return function(value) {
|
|
return getter(_this.scope, {$event: value});
|
|
};
|
|
})(getter)});
|
|
} else {
|
|
throw new Error("Missing emitter '" + output.prop + "' on component '" + this.info.selector + "'!");
|
|
}
|
|
}
|
|
}
|
|
};
|
|
DowngradeNg2ComponentAdapter.prototype.registerCleanup = function() {
|
|
var _this = this;
|
|
this.element.bind('$remove', function() {
|
|
return _this.viewManager.destroyRootHostView(_this.hostViewRef);
|
|
});
|
|
};
|
|
return DowngradeNg2ComponentAdapter;
|
|
})();
|
|
exports.DowngradeNg2ComponentAdapter = DowngradeNg2ComponentAdapter;
|
|
var Ng1Change = (function() {
|
|
function Ng1Change(previousValue, currentValue) {
|
|
this.previousValue = previousValue;
|
|
this.currentValue = currentValue;
|
|
}
|
|
Ng1Change.prototype.isFirstChange = function() {
|
|
return this.previousValue === this.currentValue;
|
|
};
|
|
return Ng1Change;
|
|
})();
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
System.register("angular2/src/upgrade/angular_js", [], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
function noNg() {
|
|
throw new Error('AngularJS v1.x is not loaded!');
|
|
}
|
|
var angular = {
|
|
bootstrap: noNg,
|
|
module: noNg,
|
|
element: noNg,
|
|
version: noNg,
|
|
resumeBootstrap: noNg,
|
|
getTestability: noNg
|
|
};
|
|
try {
|
|
if (window.hasOwnProperty('angular')) {
|
|
angular = window.angular;
|
|
}
|
|
} catch (e) {}
|
|
exports.bootstrap = angular.bootstrap;
|
|
exports.module = angular.module;
|
|
exports.element = angular.element;
|
|
exports.version = angular.version;
|
|
exports.resumeBootstrap = angular.resumeBootstrap;
|
|
exports.getTestability = angular.getTestability;
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
System.register("angular2/src/upgrade/upgrade_ng1_adapter", ["angular2/core", "angular2/src/upgrade/constants", "angular2/src/upgrade/util", "angular2/src/upgrade/angular_js"], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
var core_1 = require("angular2/core");
|
|
var constants_1 = require("angular2/src/upgrade/constants");
|
|
var util_1 = require("angular2/src/upgrade/util");
|
|
var angular = require("angular2/src/upgrade/angular_js");
|
|
var CAMEL_CASE = /([A-Z])/g;
|
|
var INITIAL_VALUE = {__UNINITIALIZED__: true};
|
|
var NOT_SUPPORTED = 'NOT_SUPPORTED';
|
|
var UpgradeNg1ComponentAdapterBuilder = (function() {
|
|
function UpgradeNg1ComponentAdapterBuilder(name) {
|
|
this.name = name;
|
|
this.inputs = [];
|
|
this.inputsRename = [];
|
|
this.outputs = [];
|
|
this.outputsRename = [];
|
|
this.propertyOutputs = [];
|
|
this.checkProperties = [];
|
|
this.propertyMap = {};
|
|
this.linkFn = null;
|
|
this.directive = null;
|
|
this.$controller = null;
|
|
var selector = name.replace(CAMEL_CASE, function(all, next) {
|
|
return '-' + next.toLowerCase();
|
|
});
|
|
var self = this;
|
|
this.type = core_1.Directive({
|
|
selector: selector,
|
|
inputs: this.inputsRename,
|
|
outputs: this.outputsRename
|
|
}).Class({
|
|
constructor: [new core_1.Inject(constants_1.NG1_SCOPE), core_1.ElementRef, function(scope, elementRef) {
|
|
return new UpgradeNg1ComponentAdapter(self.linkFn, scope, self.directive, elementRef, self.$controller, self.inputs, self.outputs, self.propertyOutputs, self.checkProperties, self.propertyMap);
|
|
}],
|
|
ngOnChanges: function() {},
|
|
ngDoCheck: function() {}
|
|
});
|
|
}
|
|
UpgradeNg1ComponentAdapterBuilder.prototype.extractDirective = function(injector) {
|
|
var directives = injector.get(this.name + 'Directive');
|
|
if (directives.length > 1) {
|
|
throw new Error('Only support single directive definition for: ' + this.name);
|
|
}
|
|
var directive = directives[0];
|
|
if (directive.replace)
|
|
this.notSupported('replace');
|
|
if (directive.terminal)
|
|
this.notSupported('terminal');
|
|
var link = directive.link;
|
|
if (typeof link == 'object') {
|
|
if (link.post)
|
|
this.notSupported('link.post');
|
|
}
|
|
return directive;
|
|
};
|
|
UpgradeNg1ComponentAdapterBuilder.prototype.notSupported = function(feature) {
|
|
throw new Error("Upgraded directive '" + this.name + "' does not support '" + feature + "'.");
|
|
};
|
|
UpgradeNg1ComponentAdapterBuilder.prototype.extractBindings = function() {
|
|
var btcIsObject = typeof this.directive.bindToController === 'object';
|
|
if (btcIsObject && Object.keys(this.directive.scope).length) {
|
|
throw new Error("Binding definitions on scope and controller at the same time are not supported.");
|
|
}
|
|
var context = (btcIsObject) ? this.directive.bindToController : this.directive.scope;
|
|
if (typeof context == 'object') {
|
|
for (var name in context) {
|
|
if (context.hasOwnProperty(name)) {
|
|
var localName = context[name];
|
|
var type = localName.charAt(0);
|
|
localName = localName.substr(1) || name;
|
|
var outputName = 'output_' + name;
|
|
var outputNameRename = outputName + ': ' + name;
|
|
var outputNameRenameChange = outputName + ': ' + name + 'Change';
|
|
var inputName = 'input_' + name;
|
|
var inputNameRename = inputName + ': ' + name;
|
|
switch (type) {
|
|
case '=':
|
|
this.propertyOutputs.push(outputName);
|
|
this.checkProperties.push(localName);
|
|
this.outputs.push(outputName);
|
|
this.outputsRename.push(outputNameRenameChange);
|
|
this.propertyMap[outputName] = localName;
|
|
case '@':
|
|
this.inputs.push(inputName);
|
|
this.inputsRename.push(inputNameRename);
|
|
this.propertyMap[inputName] = localName;
|
|
break;
|
|
case '&':
|
|
this.outputs.push(outputName);
|
|
this.outputsRename.push(outputNameRename);
|
|
this.propertyMap[outputName] = localName;
|
|
break;
|
|
default:
|
|
var json = JSON.stringify(context);
|
|
throw new Error("Unexpected mapping '" + type + "' in '" + json + "' in '" + this.name + "' directive.");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
};
|
|
UpgradeNg1ComponentAdapterBuilder.prototype.compileTemplate = function(compile, templateCache, httpBackend) {
|
|
var _this = this;
|
|
if (this.directive.template !== undefined) {
|
|
this.linkFn = compileHtml(this.directive.template);
|
|
} else if (this.directive.templateUrl) {
|
|
var url = this.directive.templateUrl;
|
|
var html = templateCache.get(url);
|
|
if (html !== undefined) {
|
|
this.linkFn = compileHtml(html);
|
|
} else {
|
|
return new Promise(function(resolve, err) {
|
|
httpBackend('GET', url, null, function(status, response) {
|
|
if (status == 200) {
|
|
resolve(_this.linkFn = compileHtml(templateCache.put(url, response)));
|
|
} else {
|
|
err("GET " + url + " returned " + status + ": " + response);
|
|
}
|
|
});
|
|
});
|
|
}
|
|
} else {
|
|
throw new Error("Directive '" + this.name + "' is not a component, it is missing template.");
|
|
}
|
|
return null;
|
|
function compileHtml(html) {
|
|
var div = document.createElement('div');
|
|
div.innerHTML = html;
|
|
return compile(div.childNodes);
|
|
}
|
|
};
|
|
UpgradeNg1ComponentAdapterBuilder.resolve = function(exportedComponents, injector) {
|
|
var promises = [];
|
|
var compile = injector.get(constants_1.NG1_COMPILE);
|
|
var templateCache = injector.get(constants_1.NG1_TEMPLATE_CACHE);
|
|
var httpBackend = injector.get(constants_1.NG1_HTTP_BACKEND);
|
|
var $controller = injector.get(constants_1.NG1_CONTROLLER);
|
|
for (var name in exportedComponents) {
|
|
if (exportedComponents.hasOwnProperty(name)) {
|
|
var exportedComponent = exportedComponents[name];
|
|
exportedComponent.directive = exportedComponent.extractDirective(injector);
|
|
exportedComponent.$controller = $controller;
|
|
exportedComponent.extractBindings();
|
|
var promise = exportedComponent.compileTemplate(compile, templateCache, httpBackend);
|
|
if (promise)
|
|
promises.push(promise);
|
|
}
|
|
}
|
|
return Promise.all(promises);
|
|
};
|
|
return UpgradeNg1ComponentAdapterBuilder;
|
|
})();
|
|
exports.UpgradeNg1ComponentAdapterBuilder = UpgradeNg1ComponentAdapterBuilder;
|
|
var UpgradeNg1ComponentAdapter = (function() {
|
|
function UpgradeNg1ComponentAdapter(linkFn, scope, directive, elementRef, $controller, inputs, outputs, propOuts, checkProperties, propertyMap) {
|
|
this.directive = directive;
|
|
this.inputs = inputs;
|
|
this.outputs = outputs;
|
|
this.propOuts = propOuts;
|
|
this.checkProperties = checkProperties;
|
|
this.propertyMap = propertyMap;
|
|
this.destinationObj = null;
|
|
this.checkLastValues = [];
|
|
var element = elementRef.nativeElement;
|
|
var childNodes = [];
|
|
var childNode;
|
|
while (childNode = element.firstChild) {
|
|
element.removeChild(childNode);
|
|
childNodes.push(childNode);
|
|
}
|
|
var componentScope = scope.$new(!!directive.scope);
|
|
var $element = angular.element(element);
|
|
var controllerType = directive.controller;
|
|
var controller = null;
|
|
if (controllerType) {
|
|
var locals = {
|
|
$scope: componentScope,
|
|
$element: $element
|
|
};
|
|
controller = $controller(controllerType, locals, null, directive.controllerAs);
|
|
$element.data(util_1.controllerKey(directive.name), controller);
|
|
}
|
|
var link = directive.link;
|
|
if (typeof link == 'object')
|
|
link = link.pre;
|
|
if (link) {
|
|
var attrs = NOT_SUPPORTED;
|
|
var transcludeFn = NOT_SUPPORTED;
|
|
var linkController = this.resolveRequired($element, directive.require);
|
|
directive.link(componentScope, $element, attrs, linkController, transcludeFn);
|
|
}
|
|
this.destinationObj = directive.bindToController && controller ? controller : componentScope;
|
|
linkFn(componentScope, function(clonedElement, scope) {
|
|
for (var i = 0,
|
|
ii = clonedElement.length; i < ii; i++) {
|
|
element.appendChild(clonedElement[i]);
|
|
}
|
|
}, {parentBoundTranscludeFn: function(scope, cloneAttach) {
|
|
cloneAttach(childNodes);
|
|
}});
|
|
for (var i = 0; i < inputs.length; i++) {
|
|
this[inputs[i]] = null;
|
|
}
|
|
for (var j = 0; j < outputs.length; j++) {
|
|
var emitter = this[outputs[j]] = new core_1.EventEmitter();
|
|
this.setComponentProperty(outputs[j], (function(emitter) {
|
|
return function(value) {
|
|
return emitter.emit(value);
|
|
};
|
|
})(emitter));
|
|
}
|
|
for (var k = 0; k < propOuts.length; k++) {
|
|
this[propOuts[k]] = new core_1.EventEmitter();
|
|
this.checkLastValues.push(INITIAL_VALUE);
|
|
}
|
|
}
|
|
UpgradeNg1ComponentAdapter.prototype.ngOnChanges = function(changes) {
|
|
for (var name in changes) {
|
|
if (changes.hasOwnProperty(name)) {
|
|
var change = changes[name];
|
|
this.setComponentProperty(name, change.currentValue);
|
|
}
|
|
}
|
|
};
|
|
UpgradeNg1ComponentAdapter.prototype.ngDoCheck = function() {
|
|
var count = 0;
|
|
var destinationObj = this.destinationObj;
|
|
var lastValues = this.checkLastValues;
|
|
var checkProperties = this.checkProperties;
|
|
for (var i = 0; i < checkProperties.length; i++) {
|
|
var value = destinationObj[checkProperties[i]];
|
|
var last = lastValues[i];
|
|
if (value !== last) {
|
|
if (typeof value == 'number' && isNaN(value) && typeof last == 'number' && isNaN(last)) {} else {
|
|
var eventEmitter = this[this.propOuts[i]];
|
|
eventEmitter.emit(lastValues[i] = value);
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
};
|
|
UpgradeNg1ComponentAdapter.prototype.setComponentProperty = function(name, value) {
|
|
this.destinationObj[this.propertyMap[name]] = value;
|
|
};
|
|
UpgradeNg1ComponentAdapter.prototype.resolveRequired = function($element, require) {
|
|
if (!require) {
|
|
return undefined;
|
|
} else if (typeof require == 'string') {
|
|
var name = require;
|
|
var isOptional = false;
|
|
var startParent = false;
|
|
var searchParents = false;
|
|
var ch;
|
|
if (name.charAt(0) == '?') {
|
|
isOptional = true;
|
|
name = name.substr(1);
|
|
}
|
|
if (name.charAt(0) == '^') {
|
|
searchParents = true;
|
|
name = name.substr(1);
|
|
}
|
|
if (name.charAt(0) == '^') {
|
|
startParent = true;
|
|
name = name.substr(1);
|
|
}
|
|
var key = util_1.controllerKey(name);
|
|
if (startParent)
|
|
$element = $element.parent();
|
|
var dep = searchParents ? $element.inheritedData(key) : $element.data(key);
|
|
if (!dep && !isOptional) {
|
|
throw new Error("Can not locate '" + require + "' in '" + this.directive.name + "'.");
|
|
}
|
|
return dep;
|
|
} else if (require instanceof Array) {
|
|
var deps = [];
|
|
for (var i = 0; i < require.length; i++) {
|
|
deps.push(this.resolveRequired($element, require[i]));
|
|
}
|
|
return deps;
|
|
}
|
|
throw new Error("Directive '" + this.directive.name + "' require syntax unrecognized: " + this.directive.require);
|
|
};
|
|
return UpgradeNg1ComponentAdapter;
|
|
})();
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
System.register("angular2/src/upgrade/upgrade_adapter", ["angular2/core", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/platform/browser", "angular2/src/upgrade/metadata", "angular2/src/upgrade/util", "angular2/src/upgrade/constants", "angular2/src/upgrade/downgrade_ng2_adapter", "angular2/src/upgrade/upgrade_ng1_adapter", "angular2/src/upgrade/angular_js"], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
var core_1 = require("angular2/core");
|
|
var lang_1 = require("angular2/src/facade/lang");
|
|
var async_1 = require("angular2/src/facade/async");
|
|
var browser_1 = require("angular2/platform/browser");
|
|
var metadata_1 = require("angular2/src/upgrade/metadata");
|
|
var util_1 = require("angular2/src/upgrade/util");
|
|
var constants_1 = require("angular2/src/upgrade/constants");
|
|
var downgrade_ng2_adapter_1 = require("angular2/src/upgrade/downgrade_ng2_adapter");
|
|
var upgrade_ng1_adapter_1 = require("angular2/src/upgrade/upgrade_ng1_adapter");
|
|
var angular = require("angular2/src/upgrade/angular_js");
|
|
var upgradeCount = 0;
|
|
var UpgradeAdapter = (function() {
|
|
function UpgradeAdapter() {
|
|
this.idPrefix = "NG2_UPGRADE_" + upgradeCount++ + "_";
|
|
this.upgradedComponents = [];
|
|
this.downgradedComponents = {};
|
|
this.providers = [];
|
|
}
|
|
UpgradeAdapter.prototype.downgradeNg2Component = function(type) {
|
|
this.upgradedComponents.push(type);
|
|
var info = metadata_1.getComponentInfo(type);
|
|
return ng1ComponentDirective(info, "" + this.idPrefix + info.selector + "_c");
|
|
};
|
|
UpgradeAdapter.prototype.upgradeNg1Component = function(name) {
|
|
if (this.downgradedComponents.hasOwnProperty(name)) {
|
|
return this.downgradedComponents[name].type;
|
|
} else {
|
|
return (this.downgradedComponents[name] = new upgrade_ng1_adapter_1.UpgradeNg1ComponentAdapterBuilder(name)).type;
|
|
}
|
|
};
|
|
UpgradeAdapter.prototype.bootstrap = function(element, modules, config) {
|
|
var _this = this;
|
|
var upgrade = new UpgradeAdapterRef();
|
|
var ng1Injector = null;
|
|
var platformRef = core_1.platform(browser_1.BROWSER_PROVIDERS);
|
|
var applicationRef = platformRef.application([browser_1.BROWSER_APP_PROVIDERS, core_1.provide(constants_1.NG1_INJECTOR, {useFactory: function() {
|
|
return ng1Injector;
|
|
}}), core_1.provide(constants_1.NG1_COMPILE, {useFactory: function() {
|
|
return ng1Injector.get(constants_1.NG1_COMPILE);
|
|
}}), this.providers]);
|
|
var injector = applicationRef.injector;
|
|
var ngZone = injector.get(core_1.NgZone);
|
|
var compiler = injector.get(core_1.Compiler);
|
|
var delayApplyExps = [];
|
|
var original$applyFn;
|
|
var rootScopePrototype;
|
|
var rootScope;
|
|
var hostViewFactoryRefMap = {};
|
|
var ng1Module = angular.module(this.idPrefix, modules);
|
|
var ng1BootstrapPromise = null;
|
|
var ng1compilePromise = null;
|
|
ng1Module.value(constants_1.NG2_INJECTOR, injector).value(constants_1.NG2_ZONE, ngZone).value(constants_1.NG2_COMPILER, compiler).value(constants_1.NG2_HOST_VIEW_FACTORY_REF_MAP, hostViewFactoryRefMap).value(constants_1.NG2_APP_VIEW_MANAGER, injector.get(core_1.AppViewManager)).config(['$provide', function(provide) {
|
|
provide.decorator(constants_1.NG1_ROOT_SCOPE, ['$delegate', function(rootScopeDelegate) {
|
|
rootScopePrototype = rootScopeDelegate.constructor.prototype;
|
|
if (rootScopePrototype.hasOwnProperty('$apply')) {
|
|
original$applyFn = rootScopePrototype.$apply;
|
|
rootScopePrototype.$apply = function(exp) {
|
|
return delayApplyExps.push(exp);
|
|
};
|
|
} else {
|
|
throw new Error("Failed to find '$apply' on '$rootScope'!");
|
|
}
|
|
return rootScope = rootScopeDelegate;
|
|
}]);
|
|
provide.decorator(constants_1.NG1_TESTABILITY, ['$delegate', function(testabilityDelegate) {
|
|
var _this = this;
|
|
var ng2Testability = injector.get(core_1.Testability);
|
|
var origonalWhenStable = testabilityDelegate.whenStable;
|
|
var newWhenStable = function(callback) {
|
|
var whenStableContext = _this;
|
|
origonalWhenStable.call(_this, function() {
|
|
if (ng2Testability.isStable()) {
|
|
callback.apply(this, arguments);
|
|
} else {
|
|
ng2Testability.whenStable(newWhenStable.bind(whenStableContext, callback));
|
|
}
|
|
});
|
|
};
|
|
testabilityDelegate.whenStable = newWhenStable;
|
|
return testabilityDelegate;
|
|
}]);
|
|
}]);
|
|
ng1compilePromise = new Promise(function(resolve, reject) {
|
|
ng1Module.run(['$injector', '$rootScope', function(injector, rootScope) {
|
|
ng1Injector = injector;
|
|
async_1.ObservableWrapper.subscribe(ngZone.onMicrotaskEmpty, function(_) {
|
|
return ngZone.runOutsideAngular(function() {
|
|
return rootScope.$apply();
|
|
});
|
|
});
|
|
upgrade_ng1_adapter_1.UpgradeNg1ComponentAdapterBuilder.resolve(_this.downgradedComponents, injector).then(resolve, reject);
|
|
}]);
|
|
});
|
|
var windowAngular = lang_1.global.angular;
|
|
windowAngular.resumeBootstrap = undefined;
|
|
angular.element(element).data(util_1.controllerKey(constants_1.NG2_INJECTOR), injector);
|
|
ngZone.run(function() {
|
|
angular.bootstrap(element, [_this.idPrefix], config);
|
|
});
|
|
ng1BootstrapPromise = new Promise(function(resolve, reject) {
|
|
if (windowAngular.resumeBootstrap) {
|
|
var originalResumeBootstrap = windowAngular.resumeBootstrap;
|
|
windowAngular.resumeBootstrap = function() {
|
|
windowAngular.resumeBootstrap = originalResumeBootstrap;
|
|
windowAngular.resumeBootstrap.apply(this, arguments);
|
|
resolve();
|
|
};
|
|
} else {
|
|
resolve();
|
|
}
|
|
});
|
|
Promise.all([this.compileNg2Components(compiler, hostViewFactoryRefMap), ng1BootstrapPromise, ng1compilePromise]).then(function() {
|
|
ngZone.run(function() {
|
|
if (rootScopePrototype) {
|
|
rootScopePrototype.$apply = original$applyFn;
|
|
while (delayApplyExps.length) {
|
|
rootScope.$apply(delayApplyExps.shift());
|
|
}
|
|
upgrade._bootstrapDone(applicationRef, ng1Injector);
|
|
rootScopePrototype = null;
|
|
}
|
|
});
|
|
}, util_1.onError);
|
|
return upgrade;
|
|
};
|
|
UpgradeAdapter.prototype.addProvider = function(provider) {
|
|
this.providers.push(provider);
|
|
};
|
|
UpgradeAdapter.prototype.upgradeNg1Provider = function(name, options) {
|
|
var token = options && options.asToken || name;
|
|
this.providers.push(core_1.provide(token, {
|
|
useFactory: function(ng1Injector) {
|
|
return ng1Injector.get(name);
|
|
},
|
|
deps: [constants_1.NG1_INJECTOR]
|
|
}));
|
|
};
|
|
UpgradeAdapter.prototype.downgradeNg2Provider = function(token) {
|
|
var factory = function(injector) {
|
|
return injector.get(token);
|
|
};
|
|
factory.$inject = [constants_1.NG2_INJECTOR];
|
|
return factory;
|
|
};
|
|
UpgradeAdapter.prototype.compileNg2Components = function(compiler, hostViewFactoryRefMap) {
|
|
var _this = this;
|
|
var promises = [];
|
|
var types = this.upgradedComponents;
|
|
for (var i = 0; i < types.length; i++) {
|
|
promises.push(compiler.compileInHost(types[i]));
|
|
}
|
|
return Promise.all(promises).then(function(hostViewFactories) {
|
|
var types = _this.upgradedComponents;
|
|
for (var i = 0; i < hostViewFactories.length; i++) {
|
|
hostViewFactoryRefMap[metadata_1.getComponentInfo(types[i]).selector] = hostViewFactories[i];
|
|
}
|
|
return hostViewFactoryRefMap;
|
|
}, util_1.onError);
|
|
};
|
|
return UpgradeAdapter;
|
|
})();
|
|
exports.UpgradeAdapter = UpgradeAdapter;
|
|
function ng1ComponentDirective(info, idPrefix) {
|
|
directiveFactory.$inject = [constants_1.NG2_HOST_VIEW_FACTORY_REF_MAP, constants_1.NG2_APP_VIEW_MANAGER, constants_1.NG1_PARSE];
|
|
function directiveFactory(hostViewFactoryRefMap, viewManager, parse) {
|
|
var hostViewFactory = hostViewFactoryRefMap[info.selector];
|
|
if (!hostViewFactory)
|
|
throw new Error('Expecting HostViewFactoryRef for: ' + info.selector);
|
|
var idCount = 0;
|
|
return {
|
|
restrict: 'E',
|
|
require: constants_1.REQUIRE_INJECTOR,
|
|
link: {post: function(scope, element, attrs, parentInjector, transclude) {
|
|
var domElement = element[0];
|
|
var facade = new downgrade_ng2_adapter_1.DowngradeNg2ComponentAdapter(idPrefix + (idCount++), info, element, attrs, scope, parentInjector, parse, viewManager, hostViewFactory);
|
|
facade.setupInputs();
|
|
facade.bootstrapNg2();
|
|
facade.projectContent();
|
|
facade.setupOutputs();
|
|
facade.registerCleanup();
|
|
}}
|
|
};
|
|
}
|
|
return directiveFactory;
|
|
}
|
|
var UpgradeAdapterRef = (function() {
|
|
function UpgradeAdapterRef() {
|
|
this._readyFn = null;
|
|
this.ng1RootScope = null;
|
|
this.ng1Injector = null;
|
|
this.ng2ApplicationRef = null;
|
|
this.ng2Injector = null;
|
|
}
|
|
UpgradeAdapterRef.prototype._bootstrapDone = function(applicationRef, ng1Injector) {
|
|
this.ng2ApplicationRef = applicationRef;
|
|
this.ng2Injector = applicationRef.injector;
|
|
this.ng1Injector = ng1Injector;
|
|
this.ng1RootScope = ng1Injector.get(constants_1.NG1_ROOT_SCOPE);
|
|
this._readyFn && this._readyFn(this);
|
|
};
|
|
UpgradeAdapterRef.prototype.ready = function(fn) {
|
|
this._readyFn = fn;
|
|
};
|
|
UpgradeAdapterRef.prototype.dispose = function() {
|
|
this.ng1Injector.get(constants_1.NG1_ROOT_SCOPE).$destroy();
|
|
this.ng2ApplicationRef.dispose();
|
|
};
|
|
return UpgradeAdapterRef;
|
|
})();
|
|
exports.UpgradeAdapterRef = UpgradeAdapterRef;
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
System.register("angular2/upgrade", ["angular2/src/upgrade/upgrade_adapter"], true, function(require, exports, module) {
|
|
var global = System.global,
|
|
__define = global.define;
|
|
global.define = undefined;
|
|
var upgrade_adapter_1 = require("angular2/src/upgrade/upgrade_adapter");
|
|
exports.UpgradeAdapter = upgrade_adapter_1.UpgradeAdapter;
|
|
exports.UpgradeAdapterRef = upgrade_adapter_1.UpgradeAdapterRef;
|
|
global.define = __define;
|
|
return module.exports;
|
|
});
|
|
|
|
//# sourceMappingURLDisabled=upgrade.js.map
|