var NgFormControl = (function (_super) {
__extends(NgFormControl, _super);
function NgFormControl(validators, valueAccessors) {
_super.call(this);
this.update = new async_1.EventEmitter();
/** @internal */
this._added = false;
this.validators = validators;
this.valueAccessor = shared_1.selectValueAccessor(this, valueAccessors);
}
NgFormControl.prototype.onChanges = function (changes) {
if (!this._added) {
shared_1.setUpControl(this.form, this);
this.form.updateValidity();
this._added = true;
}
if (shared_1.isPropertyUpdated(changes, this.viewModel)) {
this.form.updateValue(this.model);
this.viewModel = this.model;
}
};
Object.defineProperty(NgFormControl.prototype, "path", {
get: function () { return []; },
enumerable: true,
configurable: true
});
Object.defineProperty(NgFormControl.prototype, "control", {
get: function () { return this.form; },
enumerable: true,
configurable: true
});
Object.defineProperty(NgFormControl.prototype, "validator", {
get: function () { return validators_1.Validators.compose(this.validators); },
enumerable: true,
configurable: true
});
NgFormControl.prototype.viewToModelUpdate = function (newValue) {
this.viewModel = newValue;
async_1.ObservableWrapper.callNext(this.update, newValue);
};
NgFormControl = __decorate([
metadata_1.Directive({
selector: '[ng-form-control]',
bindings: [formControlBinding],
inputs: ['form: ngFormControl', 'model: ngModel'],
outputs: ['update: ngModelChange'],
exportAs: 'form'
}),
__param(0, di_1.Optional()),
__param(0, di_1.Inject(validators_1.NG_VALIDATORS)),
__param(1, di_1.Optional()),
__param(1, di_1.Inject(control_value_accessor_1.NG_VALUE_ACCESSOR)),
__metadata('design:paramtypes', [Array, Array])
], NgFormControl);
return NgFormControl;
})(ng_control_1.NgControl);
var DomSharedStylesHost = (function (_super) {
__extends(DomSharedStylesHost, _super);
function DomSharedStylesHost(doc) {
_super.call(this);
this._hostNodes = new Set();
this._hostNodes.add(doc.head);
}
/** @internal */
DomSharedStylesHost.prototype._addStylesToHost = function (styles, host) {
for (var i = 0; i < styles.length; i++) {
var style = styles[i];
dom_adapter_1.DOM.appendChild(host, dom_adapter_1.DOM.createStyleElement(style));
}
};
DomSharedStylesHost.prototype.addHost = function (hostNode) {
this._addStylesToHost(this._styles, hostNode);
this._hostNodes.add(hostNode);
};
DomSharedStylesHost.prototype.removeHost = function (hostNode) { collection_1.SetWrapper.delete(this._hostNodes, hostNode); };
DomSharedStylesHost.prototype.onStylesAdded = function (additions) {
var _this = this;
this._hostNodes.forEach(function (hostNode) { _this._addStylesToHost(additions, hostNode); });
};
DomSharedStylesHost = __decorate([
di_1.Injectable(),
__param(0, di_1.Inject(dom_tokens_1.DOCUMENT)),
__metadata('design:paramtypes', [Object])
], DomSharedStylesHost);
return DomSharedStylesHost;
})(SharedStylesHost);
var AppViewPool = (function () {
function AppViewPool(poolCapacityPerProtoView) {
/** @internal */
this._pooledViewsPerProtoView = new collection_1.Map();
this._poolCapacityPerProtoView = poolCapacityPerProtoView;
}
AppViewPool.prototype.getView = function (protoView) {
var pooledViews = this._pooledViewsPerProtoView.get(protoView);
if (lang_1.isPresent(pooledViews) && pooledViews.length > 0) {
return pooledViews.pop();
}
return null;
};
AppViewPool.prototype.returnView = function (view) {
var protoView = view.proto;
var pooledViews = this._pooledViewsPerProtoView.get(protoView);
if (lang_1.isBlank(pooledViews)) {
pooledViews = [];
this._pooledViewsPerProtoView.set(protoView, pooledViews);
}
var haveRemainingCapacity = pooledViews.length < this._poolCapacityPerProtoView;
if (haveRemainingCapacity) {
pooledViews.push(view);
}
return haveRemainingCapacity;
};
AppViewPool = __decorate([
di_1.Injectable(),
__param(0, di_1.Inject(exports.APP_VIEW_POOL_CAPACITY)),
__metadata('design:paramtypes', [Object])
], AppViewPool);
return AppViewPool;
})();
var EventManager = (function () {
function EventManager(plugins, _zone) {
var _this = this;
this._zone = _zone;
plugins.forEach(function (p) { return p.manager = _this; });
this._plugins = collection_1.ListWrapper.reversed(plugins);
}
EventManager.prototype.addEventListener = function (element, eventName, handler) {
var plugin = this._findPluginFor(eventName);
plugin.addEventListener(element, eventName, handler);
};
EventManager.prototype.addGlobalEventListener = function (target, eventName, handler) {
var plugin = this._findPluginFor(eventName);
return plugin.addGlobalEventListener(target, eventName, handler);
};
EventManager.prototype.getZone = function () { return this._zone; };
/** @internal */
EventManager.prototype._findPluginFor = function (eventName) {
var plugins = this._plugins;
for (var i = 0; i < plugins.length; i++) {
var plugin = plugins[i];
if (plugin.supports(eventName)) {
return plugin;
}
}
throw new exceptions_1.BaseException("No event manager plugin found for event " + eventName);
};
EventManager = __decorate([
di_1.Injectable(),
__param(0, di_1.Inject(exports.EVENT_MANAGER_PLUGINS)),
__metadata('design:paramtypes', [Array, ng_zone_1.NgZone])
], EventManager);
return EventManager;
})();
return plugin.addGlobalEventListener(target, eventName, handler);
}
getZone() { return this._zone; }
/** @internal */
_findPluginFor(eventName) {
var plugins = this._plugins;
for (var i = 0; i < plugins.length; i++) {
var plugin = plugins[i];
if (plugin.supports(eventName)) {
return plugin;
}
}
throw new BaseException(`No event manager plugin found for event ${eventName}`);
}
};
EventManager = __decorate([
Injectable(),
__param(0, Inject(EVENT_MANAGER_PLUGINS)),
__metadata('design:paramtypes', [Array, NgZone])
], EventManager);
export class EventManagerPlugin {
// That is equivalent to having supporting $event.target
supports(eventName) { return false; }
addEventListener(element, eventName, handler) {
throw "not implemented";
}
addGlobalEventListener(element, eventName, handler) {
throw "not implemented";
}
}
refRenderNode = refNode.nativeElement;
}
else {
refRenderNode = refNode;
}
view.renderer.attachViewAfter(refRenderNode, flattenNestedViewRenderNodes(view.rootNodesOrAppElements));
}
// TODO: This is only needed when a view is destroyed,
// not when it is detached for reordering with ng-for...
vcAppElement.parentView.changeDetector.addContentChild(view.changeDetector);
vcAppElement.traverseAndSetQueriesAsDirty();
}
_detachViewInContainer(vcAppElement, viewIndex) {
var view = ListWrapper.removeAt(vcAppElement.nestedViews, viewIndex);
if (view.proto.type === ViewType.COMPONENT) {
throw new BaseException(`Component views can't be moved!`);
}
vcAppElement.traverseAndSetQueriesAsDirty();
view.renderer.detachView(flattenNestedViewRenderNodes(view.rootNodesOrAppElements));
// TODO: This is only needed when a view is destroyed,
// not when it is detached for reordering with ng-for...
view.changeDetector.remove();
return view;
}
};
AppViewManager_ = __decorate([
Injectable(),
__param(2, Inject(APP_ID)),
__metadata('design:paramtypes', [RootRenderer, AppViewListener, String])
], AppViewManager_);
var renderer = this._registeredComponents.get(componentProto.id);
if (isBlank(renderer)) {
renderer = new DomRenderer(this, componentProto);
this._registeredComponents.set(componentProto.id, renderer);
}
return renderer;
}
}
export let DomRootRenderer_ = class DomRootRenderer_ extends DomRootRenderer {
constructor(_document, _eventManager, sharedStylesHost, animate) {
super(_document, _eventManager, sharedStylesHost, animate);
}
};
DomRootRenderer_ = __decorate([
Injectable(),
__param(0, Inject(DOCUMENT)),
__metadata('design:paramtypes', [Object, EventManager, DomSharedStylesHost, AnimationBuilder])
], DomRootRenderer_);
export class DomRenderer {
constructor(_rootRenderer, componentProto) {
this._rootRenderer = _rootRenderer;
this.componentProto = componentProto;
this._styles = _flattenStyles(componentProto.id, componentProto.styles, []);
if (componentProto.encapsulation !== ViewEncapsulation.Native) {
this._rootRenderer.sharedStylesHost.addStyles(this._styles);
}
if (this.componentProto.encapsulation === ViewEncapsulation.Emulated) {
this._contentAttr = _shimContentAttribute(componentProto.id);
this._hostAttr = _shimHostAttribute(componentProto.id);
}
else {
var RuntimeMetadataResolver = (function () {
function RuntimeMetadataResolver(_directiveResolver, _viewResolver, _platformDirectives) {
this._directiveResolver = _directiveResolver;
this._viewResolver = _viewResolver;
this._platformDirectives = _platformDirectives;
this._cache = new Map();
}
RuntimeMetadataResolver.prototype.getMetadata = function (directiveType) {
var meta = this._cache.get(directiveType);
if (lang_1.isBlank(meta)) {
var dirMeta = this._directiveResolver.resolve(directiveType);
var moduleUrl = calcModuleUrl(directiveType, dirMeta);
var templateMeta = null;
var changeDetectionStrategy = null;
if (dirMeta instanceof md.ComponentMetadata) {
var cmpMeta = dirMeta;
var viewMeta = this._viewResolver.resolve(directiveType);
templateMeta = new cpl.CompileTemplateMetadata({
encapsulation: viewMeta.encapsulation,
template: viewMeta.template,
templateUrl: viewMeta.templateUrl,
styles: viewMeta.styles,
styleUrls: viewMeta.styleUrls
});
changeDetectionStrategy = cmpMeta.changeDetection;
}
meta = cpl.CompileDirectiveMetadata.create({
selector: dirMeta.selector,
exportAs: dirMeta.exportAs,
isComponent: lang_1.isPresent(templateMeta),
dynamicLoadable: true,
type: new cpl.CompileTypeMetadata({ name: lang_1.stringify(directiveType), moduleUrl: moduleUrl, runtime: directiveType }),
template: templateMeta,
changeDetection: changeDetectionStrategy,
inputs: dirMeta.inputs,
outputs: dirMeta.outputs,
host: dirMeta.host,
lifecycleHooks: interfaces_1.LIFECYCLE_HOOKS_VALUES.filter(function (hook) { return directive_lifecycle_reflector_1.hasLifecycleHook(hook, directiveType); })
});
this._cache.set(directiveType, meta);
}
return meta;
};
RuntimeMetadataResolver.prototype.getViewDirectivesMetadata = function (component) {
var _this = this;
var view = this._viewResolver.resolve(component);
var directives = flattenDirectives(view, this._platformDirectives);
for (var i = 0; i < directives.length; i++) {
if (!isValidDirective(directives[i])) {
throw new exceptions_1.BaseException("Unexpected directive value '" + lang_1.stringify(directives[i]) + "' on the View of component '" + lang_1.stringify(component) + "'");
}
}
return removeDuplicates(directives).map(function (type) { return _this.getMetadata(type); });
};
RuntimeMetadataResolver = __decorate([
di_2.Injectable(),
__param(2, di_2.Optional()),
__param(2, di_2.Inject(platform_directives_and_pipes_1.PLATFORM_DIRECTIVES)),
__metadata('design:paramtypes', [directive_resolver_1.DirectiveResolver, view_resolver_1.ViewResolver, Array])
], RuntimeMetadataResolver);
return RuntimeMetadataResolver;
})();
var tpl = this._componentTpls.get(templateId);
for (var i = 0; i < tpl.styles.length; i++) {
DOM.appendChild(sr, DOM.createStyleElement(tpl.styles[i]));
}
return sr;
}
on(element, eventName, callback) {
this._eventManager.addEventListener(element, eventName, decoratePreventDefault(callback));
}
globalOn(target, eventName, callback) {
return this._eventManager.addGlobalEventListener(target, eventName, decoratePreventDefault(callback));
}
};
DomRenderer_ = __decorate([
Injectable(),
__param(3, Inject(DOCUMENT)),
__metadata('design:paramtypes', [EventManager, DomSharedStylesHost, AnimationBuilder, Object])
], DomRenderer_);
function resolveInternalDomView(viewRef) {
return viewRef;
}
function resolveInternalDomFragment(fragmentRef) {
return fragmentRef.nodes;
}
function moveNodesAfterSibling(sibling, nodes) {
var parent = DOM.parentElement(sibling);
if (nodes.length > 0 && isPresent(parent)) {
var nextSibling = DOM.nextSibling(sibling);
if (isPresent(nextSibling)) {
for (var i = 0; i < nodes.length; i++) {
DOM.insertBefore(nextSibling, nodes[i]);
if (this._packagePrefix === _ASSET_SCHEME) {
var pathSegements = path.split(/\//);
resolvedUrl = `asset:${pathSegements[0]}/lib/${pathSegements.slice(1).join('/')}`;
}
else {
prefix = StringWrapper.stripRight(prefix, '/');
path = StringWrapper.stripLeft(path, '/');
return `${prefix}/${path}`;
}
}
return resolvedUrl;
}
};
UrlResolver = __decorate([
Injectable(),
__param(0, Inject(PACKAGE_ROOT_URL)),
__metadata('design:paramtypes', [String])
], UrlResolver);
/**
* Extract the scheme of a URL.
*/
export function getUrlScheme(url) {
var match = _split(url);
return (match && match[_ComponentIndex.Scheme]) || "";
}
// The code below is adapted from Traceur:
// https://github.com/google/traceur-compiler/blob/9511c1dafa972bf0de1202a8a863bad02f0f95a8/src/runtime/url.js
/**
* Builds a URI string from already-encoded parts.
*
* No encoding is performed. Any component may be omitted as either null or
/** @internal */
this._pooledViewsPerProtoView = new Map();
this._poolCapacityPerProtoView = poolCapacityPerProtoView;
}
getView(protoView) {
var pooledViews = this._pooledViewsPerProtoView.get(protoView);
if (isPresent(pooledViews) && pooledViews.length > 0) {
return pooledViews.pop();
}
return null;
}
returnView(view) {
var protoView = view.proto;
var pooledViews = this._pooledViewsPerProtoView.get(protoView);
if (isBlank(pooledViews)) {
pooledViews = [];
this._pooledViewsPerProtoView.set(protoView, pooledViews);
}
var haveRemainingCapacity = pooledViews.length < this._poolCapacityPerProtoView;
if (haveRemainingCapacity) {
pooledViews.push(view);
}
return haveRemainingCapacity;
}
};
AppViewPool = __decorate([
Injectable(),
__param(0, Inject(APP_VIEW_POOL_CAPACITY)),
__metadata('design:paramtypes', [Object])
], AppViewPool);
this._destroyPooledView(view);
}
}
/** @internal */
_viewDehydrateRecurse(view) {
if (view.hydrated()) {
this._utils.dehydrateView(view);
}
var viewContainers = view.viewContainers;
var startViewOffset = view.viewOffset;
var endViewOffset = view.viewOffset + view.proto.mergeInfo.viewCount - 1;
var elementOffset = view.elementOffset;
for (var viewIdx = startViewOffset; viewIdx <= endViewOffset; viewIdx++) {
var currView = view.views[viewIdx];
for (var binderIdx = 0; binderIdx < currView.proto.elementBinders.length; binderIdx++, elementOffset++) {
var vc = viewContainers[elementOffset];
if (isPresent(vc)) {
for (var j = vc.views.length - 1; j >= 0; j--) {
this._destroyViewInContainer(currView, elementOffset, j);
}
}
}
}
}
};
AppViewManager_ = __decorate([
Injectable(),
__param(4, Inject(forwardRef(() => ProtoViewFactory))),
__metadata('design:paramtypes', [AppViewPool, AppViewListener, AppViewManagerUtils, Renderer, Object])
], AppViewManager_);
var DomRenderer_ = (function (_super) {
__extends(DomRenderer_, _super);
function DomRenderer_(_eventManager, _domSharedStylesHost, _animate, document) {
_super.call(this);
this._eventManager = _eventManager;
this._domSharedStylesHost = _domSharedStylesHost;
this._animate = _animate;
this._componentCmds = new Map();
this._nativeShadowStyles = new Map();
/** @internal */
this._createRootHostViewScope = profile_1.wtfCreateScope('DomRenderer#createRootHostView()');
/** @internal */
this._createViewScope = profile_1.wtfCreateScope('DomRenderer#createView()');
/** @internal */
this._detachFragmentScope = profile_1.wtfCreateScope('DomRenderer#detachFragment()');
this._document = document;
}
DomRenderer_.prototype.registerComponentTemplate = function (templateId, commands, styles, nativeShadow) {
this._componentCmds.set(templateId, commands);
if (nativeShadow) {
this._nativeShadowStyles.set(templateId, styles);
}
else {
this._domSharedStylesHost.addStyles(styles);
}
};
DomRenderer_.prototype.resolveComponentTemplate = function (templateId) {
return this._componentCmds.get(templateId);
};
DomRenderer_.prototype.createRootHostView = function (hostProtoViewRef, fragmentCount, hostElementSelector) {
var s = this._createRootHostViewScope();
var element = dom_adapter_1.DOM.querySelector(this._document, hostElementSelector);
if (lang_1.isBlank(element)) {
profile_1.wtfLeave(s);
throw new exceptions_1.BaseException("The selector \"" + hostElementSelector + "\" did not match any elements");
}
return profile_1.wtfLeave(s, this._createView(hostProtoViewRef, element));
};
DomRenderer_.prototype.createView = function (protoViewRef, fragmentCount) {
var s = this._createViewScope();
return profile_1.wtfLeave(s, this._createView(protoViewRef, null));
};
DomRenderer_.prototype._createView = function (protoViewRef, inplaceElement) {
var view = view_factory_1.createRenderView(protoViewRef.cmds, inplaceElement, this);
var sdRoots = view.nativeShadowRoots;
for (var i = 0; i < sdRoots.length; i++) {
this._domSharedStylesHost.addHost(sdRoots[i]);
}
return new api_1.RenderViewWithFragments(view, view.fragments);
};
DomRenderer_.prototype.destroyView = function (viewRef) {
var view = viewRef;
var sdRoots = view.nativeShadowRoots;
for (var i = 0; i < sdRoots.length; i++) {
this._domSharedStylesHost.removeHost(sdRoots[i]);
}
};
DomRenderer_.prototype.animateNodeEnter = function (node) {
if (dom_adapter_1.DOM.isElementNode(node) && dom_adapter_1.DOM.hasClass(node, 'ng-animate')) {
dom_adapter_1.DOM.addClass(node, 'ng-enter');
this._animate.css()
.addAnimationClass('ng-enter-active')
.start(node)
.onComplete(function () { dom_adapter_1.DOM.removeClass(node, 'ng-enter'); });
}
};
DomRenderer_.prototype.animateNodeLeave = function (node) {
if (dom_adapter_1.DOM.isElementNode(node) && dom_adapter_1.DOM.hasClass(node, 'ng-animate')) {
dom_adapter_1.DOM.addClass(node, 'ng-leave');
this._animate.css()
.addAnimationClass('ng-leave-active')
.start(node)
.onComplete(function () {
dom_adapter_1.DOM.removeClass(node, 'ng-leave');
dom_adapter_1.DOM.remove(node);
});
}
else {
dom_adapter_1.DOM.remove(node);
}
};
DomRenderer_.prototype.detachFragment = function (fragmentRef) {
var s = this._detachFragmentScope();
var fragmentNodes = resolveInternalDomFragment(fragmentRef);
for (var i = 0; i < fragmentNodes.length; i++) {
this.animateNodeLeave(fragmentNodes[i]);
}
profile_1.wtfLeave(s);
};
DomRenderer_.prototype.createElement = function (name, attrNameAndValues) {
var el = dom_adapter_1.DOM.createElement(name);
this._setAttributes(el, attrNameAndValues);
return el;
};
DomRenderer_.prototype.mergeElement = function (existing, attrNameAndValues) {
dom_adapter_1.DOM.clearNodes(existing);
this._setAttributes(existing, attrNameAndValues);
};
DomRenderer_.prototype._setAttributes = function (node, attrNameAndValues) {
for (var attrIdx = 0; attrIdx < attrNameAndValues.length; attrIdx += 2) {
dom_adapter_1.DOM.setAttribute(node, attrNameAndValues[attrIdx], attrNameAndValues[attrIdx + 1]);
}
};
DomRenderer_.prototype.createRootContentInsertionPoint = function () {
return dom_adapter_1.DOM.createComment('root-content-insertion-point');
};
DomRenderer_.prototype.createShadowRoot = function (host, templateId) {
var sr = dom_adapter_1.DOM.createShadowRoot(host);
var styles = this._nativeShadowStyles.get(templateId);
for (var i = 0; i < styles.length; i++) {
dom_adapter_1.DOM.appendChild(sr, dom_adapter_1.DOM.createStyleElement(styles[i]));
}
return sr;
};
DomRenderer_.prototype.on = function (element, eventName, callback) {
this._eventManager.addEventListener(element, eventName, decoratePreventDefault(callback));
};
DomRenderer_.prototype.globalOn = function (target, eventName, callback) {
return this._eventManager.addGlobalEventListener(target, eventName, decoratePreventDefault(callback));
};
DomRenderer_ = __decorate([
di_1.Injectable(),
__param(3, di_1.Inject(dom_tokens_1.DOCUMENT)),
__metadata('design:paramtypes', [event_manager_1.EventManager, shared_styles_host_1.DomSharedStylesHost, animation_builder_1.AnimationBuilder, Object])
], DomRenderer_);
return DomRenderer_;
})(DomRenderer);
var NgControlName = (function (_super) {
__extends(NgControlName, _super);
function NgControlName(parent, validators, valueAccessors) {
_super.call(this);
this.update = new async_1.EventEmitter();
/** @internal */
this._added = false;
this._parent = parent;
this.validators = validators;
this.valueAccessor = shared_1.selectValueAccessor(this, valueAccessors);
}
NgControlName.prototype.onChanges = function (changes) {
if (!this._added) {
this.formDirective.addControl(this);
this._added = true;
}
if (shared_1.isPropertyUpdated(changes, this.viewModel)) {
this.viewModel = this.model;
this.formDirective.updateModel(this, this.model);
}
};
NgControlName.prototype.onDestroy = function () { this.formDirective.removeControl(this); };
NgControlName.prototype.viewToModelUpdate = function (newValue) {
this.viewModel = newValue;
async_1.ObservableWrapper.callNext(this.update, newValue);
};
Object.defineProperty(NgControlName.prototype, "path", {
get: function () { return shared_1.controlPath(this.name, this._parent); },
enumerable: true,
configurable: true
});
Object.defineProperty(NgControlName.prototype, "formDirective", {
get: function () { return this._parent.formDirective; },
enumerable: true,
configurable: true
});
Object.defineProperty(NgControlName.prototype, "control", {
get: function () { return this.formDirective.getControl(this); },
enumerable: true,
configurable: true
});
Object.defineProperty(NgControlName.prototype, "validator", {
get: function () { return validators_1.Validators.compose(this.validators); },
enumerable: true,
configurable: true
});
NgControlName = __decorate([
metadata_1.Directive({
selector: '[ng-control]',
bindings: [controlNameBinding],
inputs: ['name: ngControl', 'model: ngModel'],
outputs: ['update: ngModelChange'],
exportAs: 'form'
}),
__param(0, di_1.Host()),
__param(0, di_1.SkipSelf()),
__param(1, di_1.Optional()),
__param(1, di_1.Inject(validators_1.NG_VALIDATORS)),
__param(2, di_1.Optional()),
__param(2, di_1.Inject(control_value_accessor_1.NG_VALUE_ACCESSOR)),
__metadata('design:paramtypes', [control_container_1.ControlContainer, Array, Array])
], NgControlName);
return NgControlName;
})(ng_control_1.NgControl);
this._nextCompTypeId = 0;
}
/**
* Used by the generated code
*/
createRenderComponentType(templateUrl, slotCount, encapsulation, styles) {
return new RenderComponentType(`${this._appId}-${this._nextCompTypeId++}`, templateUrl, slotCount, encapsulation, styles);
}
/** @internal */
renderComponent(renderComponentType) {
return this._renderer.renderComponent(renderComponentType);
}
};
ViewUtils = __decorate([
Injectable(),
__param(1, Inject(APP_ID)),
__metadata('design:paramtypes', [RootRenderer, String])
], ViewUtils);
export function flattenNestedViewRenderNodes(nodes) {
return _flattenNestedViewRenderNodes(nodes, []);
}
function _flattenNestedViewRenderNodes(nodes, renderNodes) {
for (var i = 0; i < nodes.length; i++) {
var node = nodes[i];
if (node instanceof AppElement) {
var appEl = node;
renderNodes.push(appEl.nativeElement);
if (isPresent(appEl.nestedViews)) {
for (var k = 0; k < appEl.nestedViews.length; k++) {
_flattenNestedViewRenderNodes(appEl.nestedViews[k].rootNodesOrAppElements, renderNodes);
}
}
getViewPipesMetadata(component) {
var view = this._viewResolver.resolve(component);
var pipes = flattenPipes(view, this._platformPipes);
for (var i = 0; i < pipes.length; i++) {
if (!isValidType(pipes[i])) {
throw new BaseException(`Unexpected piped value '${stringify(pipes[i])}' on the View of component '${stringify(component)}'`);
}
}
return pipes.map(type => this.getPipeMetadata(type));
}
};
RuntimeMetadataResolver = __decorate([
Injectable(),
__param(3, Optional()),
__param(3, Inject(PLATFORM_DIRECTIVES)),
__param(4, Optional()),
__param(4, Inject(PLATFORM_PIPES)),
__metadata('design:paramtypes', [DirectiveResolver, PipeResolver, ViewResolver, Array, Array])
], RuntimeMetadataResolver);
function flattenDirectives(view, platformDirectives) {
let directives = [];
if (isPresent(platformDirectives)) {
flattenArray(platformDirectives, directives);
}
if (isPresent(view.directives)) {
flattenArray(view.directives, directives);
}
return directives;
}
function flattenPipes(view, platformPipes) {
}
}
get path() { return []; }
get validator() { return composeValidators(this._validators); }
get asyncValidator() { return composeAsyncValidators(this._asyncValidators); }
get control() { return this.form; }
viewToModelUpdate(newValue) {
this.viewModel = newValue;
ObservableWrapper.callNext(this.update, newValue);
}
_isControlChanged(changes) {
return StringMapWrapper.contains(changes, "form");
}
};
NgFormControl = __decorate([
Directive({
selector: '[ng-form-control]',
bindings: [formControlBinding],
inputs: ['form: ngFormControl', 'model: ngModel'],
outputs: ['update: ngModelChange'],
exportAs: 'form'
}),
__param(0, Optional()),
__param(0, Inject(NG_VALIDATORS)),
__param(1, Optional()),
__param(1, Inject(NG_ASYNC_VALIDATORS)),
__param(2, Optional()),
__param(2, Inject(NG_VALUE_ACCESSOR)),
__metadata('design:paramtypes', [Array, Array, Array])
], NgFormControl);
//# sourceMappingURL=ng_form_control.js.map