function Url(path, child, auxiliary, params) {
if (child === void 0) { child = null; }
if (auxiliary === void 0) { auxiliary = lang_1.CONST_EXPR([]); }
if (params === void 0) { params = null; }
this.path = path;
this.child = child;
this.auxiliary = auxiliary;
this.params = params;
}
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var lang_1 = require('angular2/src/core/facade/lang');
var async_1 = require('angular2/src/core/facade/async');
var metadata_1 = require('angular2/src/core/metadata');
var di_1 = require('angular2/src/core/di');
var control_container_1 = require('./control_container');
var ng_control_1 = require('./ng_control');
var control_value_accessor_1 = require('./control_value_accessor');
var shared_1 = require('./shared');
var validators_1 = require('../validators');
var controlNameBinding = lang_1.CONST_EXPR(new di_1.Binding(ng_control_1.NgControl, { toAlias: di_1.forwardRef(function () { return NgControlName; }) }));
/**
* Creates and binds a control with a specified name to a DOM element.
*
* This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
* # Example
*
* In this example, we create the login and password controls.
* We can work with each control separately: check its validity, get its value, listen to its
* changes.
*
* ```
* @Component({selector: "login-comp"})
* @View({
* directives: [FORM_DIRECTIVES],
else if (!findInAncestors) {
return null;
}
if (dom_adapter_1.DOM.isShadowRoot(elem)) {
return this.findTestabilityInTree(dom_adapter_1.DOM.getHost(elem));
}
return this.findTestabilityInTree(dom_adapter_1.DOM.parentElement(elem));
};
TestabilityRegistry = __decorate([
di_1.Injectable(),
__metadata('design:paramtypes', [])
], TestabilityRegistry);
return TestabilityRegistry;
})();
exports.TestabilityRegistry = TestabilityRegistry;
var NoopGetTestability = (function () {
function NoopGetTestability() {
}
NoopGetTestability.prototype.addToWindow = function (registry) { };
NoopGetTestability = __decorate([
lang_1.CONST(),
__metadata('design:paramtypes', [])
], NoopGetTestability);
return NoopGetTestability;
})();
function setTestabilityGetter(getter) {
testabilityGetter = getter;
}
exports.setTestabilityGetter = setTestabilityGetter;
var testabilityGetter = lang_1.CONST_EXPR(new NoopGetTestability());
//# sourceMappingURL=testability.js.map
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var lang_1 = require('angular2/src/core/facade/lang');
var exceptions_1 = require('angular2/src/core/facade/exceptions');
var collection_1 = require('angular2/src/core/facade/collection');
var dom_adapter_1 = require('angular2/src/core/dom/dom_adapter');
var ng_zone_1 = require('angular2/src/core/zone/ng_zone');
var di_1 = require('angular2/src/core/di');
exports.EVENT_MANAGER_PLUGINS = lang_1.CONST_EXPR(new di_1.OpaqueToken("EventManagerPlugins"));
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);
};
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var di_1 = require('angular2/src/core/di');
var render_1 = require('angular2/src/core/render');
var linker_1 = require('angular2/src/core/linker');
var metadata_1 = require('angular2/src/core/metadata');
var async_1 = require('angular2/src/core/facade/async');
var control_value_accessor_1 = require('./control_value_accessor');
var lang_1 = require('angular2/src/core/facade/lang');
var shared_1 = require('./shared');
var SELECT_VALUE_ACCESSOR = lang_1.CONST_EXPR(new di_1.Provider(control_value_accessor_1.NG_VALUE_ACCESSOR, { useExisting: di_1.forwardRef(function () { return SelectControlValueAccessor; }), multi: true }));
/**
* Marks `<option>` as dynamic, so Angular can be notified when options change.
*
* #Example:
*
* ```
* <select ng-control="city">
* <option *ng-for="#c of cities" [value]="c"></option>
* </select>
* ```
*/
var NgSelectOption = (function () {
function NgSelectOption() {
}
NgSelectOption = __decorate([
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { Directive } from 'angular2/src/core/metadata';
import { Host, SkipSelf, forwardRef, Provider } from 'angular2/src/core/di';
import { CONST_EXPR } from 'angular2/src/core/facade/lang';
import { ControlContainer } from './control_container';
import { controlPath } from './shared';
const controlGroupBinding = CONST_EXPR(new Provider(ControlContainer, { useExisting: forwardRef(() => NgControlGroup) }));
/**
* Creates and binds a control group to a DOM element.
*
* This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
*
* # Example
*
* In this example, we create the credentials and personal control groups.
* We can work with each group separately: check its validity, get its value, listen to its changes.
*
* ```
* @Component({
* selector: "signup-comp",
* directives: [FORM_DIRECTIVES],
* template: `
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var lang_1 = require('angular2/src/core/facade/lang');
var async_1 = require('angular2/src/core/facade/async');
var metadata_1 = require('angular2/src/core/metadata');
var di_1 = require('angular2/src/core/di');
var ng_control_1 = require('./ng_control');
var validators_1 = require('../validators');
var control_value_accessor_1 = require('./control_value_accessor');
var shared_1 = require('./shared');
var formControlBinding = lang_1.CONST_EXPR(new di_1.Provider(ng_control_1.NgControl, { useExisting: di_1.forwardRef(function () { return NgFormControl; }) }));
/**
* Binds an existing {@link Control} to a DOM element.
*
* ### Example ([live demo](http://plnkr.co/edit/jcQlZ2tTh22BZZ2ucNAT?p=preview))
*
* In this example, we bind the control to an input element. When the value of the input element
* changes, the value of the control will reflect that change. Likewise, if the value of the
* control changes, the input element reflects that change.
*
* ```typescript
* @Component({
* selector: 'my-app',
* template: `
* <div>
* <h2>NgFormControl Example</h2>
return value;
}
}
static changeDetectionMode(strategy) {
return isDefaultChangeDetectionStrategy(strategy) ? ChangeDetectionStrategy.CheckAlways :
ChangeDetectionStrategy.CheckOnce;
}
static simpleChange(previousValue, currentValue) {
return _simpleChange(previousValue, currentValue);
}
static isValueBlank(value) { return isBlank(value); }
static s(value) { return isPresent(value) ? `${value}` : ''; }
static protoByIndex(protos, selfIndex) {
return selfIndex < 1 ?
null :
protos[selfIndex - 1]; // self index is shifted by one because of context
}
static callPipeOnDestroy(selectedPipe) {
if (implementsOnDestroy(selectedPipe.pipe)) {
selectedPipe.pipe.onDestroy();
}
}
static bindingTarget(mode, elementIndex, name, unit, debug) {
return new BindingTarget(mode, elementIndex, name, unit, debug);
}
static directiveIndex(elementIndex, directiveIndex) {
return new DirectiveIndex(elementIndex, directiveIndex);
}
}
ChangeDetectionUtil.uninitialized = CONST_EXPR(new Object());
//# sourceMappingURL=change_detection_util.js.map
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { CONST_EXPR } from 'angular2/src/core/facade/lang';
import { EventEmitter, ObservableWrapper } from 'angular2/src/core/facade/async';
import { Directive } from 'angular2/src/core/metadata';
import { forwardRef, Provider, Inject, Optional } from 'angular2/src/core/di';
import { NG_VALUE_ACCESSOR } from './control_value_accessor';
import { NgControl } from './ng_control';
import { Control } from '../model';
import { Validators, NG_VALIDATORS } from '../validators';
import { setUpControl, isPropertyUpdated, selectValueAccessor } from './shared';
const formControlBinding = CONST_EXPR(new Provider(NgControl, { useExisting: forwardRef(() => NgModel) }));
/**
* Binds a domain model to a form control.
*
* # Usage
*
* `ng-model` binds an existing domain model to a form control. For a
* two-way binding, use `[(ng-model)]` to ensure the model updates in
* both directions.
*
* ### Example ([live demo](http://plnkr.co/edit/R3UX5qDaUqFO2VYR0UzH?p=preview))
* ```typescript
* @Component({
* selector: "search-comp",
* directives: [FORM_DIRECTIVES],
* template: `<input type='text' [(ng-model)]="searchQuery">`
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var async_1 = require('angular2/src/core/facade/async');
var collection_1 = require('angular2/src/core/facade/collection');
var lang_1 = require('angular2/src/core/facade/lang');
var metadata_1 = require('angular2/src/core/metadata');
var di_1 = require('angular2/src/core/di');
var control_container_1 = require('./control_container');
var model_1 = require('../model');
var shared_1 = require('./shared');
var formDirectiveProvider = lang_1.CONST_EXPR(new di_1.Provider(control_container_1.ControlContainer, { useExisting: di_1.forwardRef(function () { return NgForm; }) }));
/**
* If `NgForm` is bound in a component, `<form>` elements in that component will be
* upgraded to use the Angular form system.
*
* # Typical Use
*
* Include `FORM_DIRECTIVES` in the `directives` section of a {@link View} annotation
* to use `NgForm` and its associated controls.
*
* # Structure
*
* An Angular form is a collection of `Control`s in some hierarchy.
* `Control`s can be at the top level or can be organized in `ControlGroup`s
* or `ControlArray`s. This hierarchy is reflected in the form's `value`, a
* JSON object that mirrors the form structure.
function RootUrl(path, child, auxiliary, params) {
if (child === void 0) { child = null; }
if (auxiliary === void 0) { auxiliary = lang_1.CONST_EXPR([]); }
if (params === void 0) { params = null; }
_super.call(this, path, child, auxiliary, params);
}
import { ListWrapper } from 'angular2/src/core/facade/collection';
import { resolveProviders } from './provider';
import { AbstractProviderError, NoProviderError, CyclicDependencyError, InstantiationError, OutOfBoundsError } from './exceptions';
import { isPresent, CONST_EXPR } from 'angular2/src/core/facade/lang';
import { Key } from './key';
import { SelfMetadata, HostMetadata, SkipSelfMetadata } from './metadata';
// Threshold for the dynamic version
const _MAX_CONSTRUCTION_COUNTER = 10;
export const UNDEFINED = CONST_EXPR(new Object());
/**
* Visibility of a {@link Provider}.
*/
export var Visibility;
(function (Visibility) {
/**
* A `Public` {@link Provider} is only visible to regular (as opposed to host) child injectors.
*/
Visibility[Visibility["Public"] = 0] = "Public";
/**
* A `Private` {@link Provider} is only visible to host (as opposed to regular) child injectors.
*/
Visibility[Visibility["Private"] = 1] = "Private";
/**
* A `PublicAndPrivate` {@link Provider} is visible to both host and regular child injectors.
*/
Visibility[Visibility["PublicAndPrivate"] = 2] = "PublicAndPrivate";
})(Visibility || (Visibility = {}));
function canSee(src, dst) {
return (src === dst) ||
(dst === Visibility.PublicAndPrivate || src === Visibility.PublicAndPrivate);
}
import { CONST_EXPR } from "angular2/src/core/facade/lang";
import { OpaqueToken } from "angular2/src/core/di";
export const ON_WEB_WORKER = CONST_EXPR(new OpaqueToken('WebWorker.onWebWorker'));
export class WebWorkerElementRef {
constructor(renderView, boundElementIndex) {
this.renderView = renderView;
this.boundElementIndex = boundElementIndex;
}
}
export class WebWorkerTemplateCmd {
visit(visitor, context) { return null; }
}
export class WebWorkerTextCmd {
constructor(isBound, ngContentIndex, value) {
this.isBound = isBound;
this.ngContentIndex = ngContentIndex;
this.value = value;
}
visit(visitor, context) {
return visitor.visitText(this, context);
}
}
export class WebWorkerNgContentCmd {
constructor(index, ngContentIndex) {
this.index = index;
this.ngContentIndex = ngContentIndex;
}
visit(visitor, context) {
return visitor.visitNgContent(this, context);
}
}
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
return c > 3 && r && Object.defineProperty(target, key, r), r;
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var di_1 = require('angular2/src/core/di');
var lang_1 = require('angular2/src/core/facade/lang');
var metadata_1 = require('angular2/src/core/metadata');
var validators_1 = require('../validators');
var lang_2 = require("angular2/src/core/facade/lang");
var REQUIRED_VALIDATOR = lang_1.CONST_EXPR(new di_1.Provider(validators_1.NG_VALIDATORS, { useValue: validators_1.Validators.required, multi: true }));
var RequiredValidator = (function () {
function RequiredValidator() {
}
RequiredValidator = __decorate([
metadata_1.Directive({
selector: '[required][ng-control],[required][ng-form-control],[required][ng-model]',
providers: [REQUIRED_VALIDATOR]
}),
__metadata('design:paramtypes', [])
], RequiredValidator);
return RequiredValidator;
})();
exports.RequiredValidator = RequiredValidator;
function createMinLengthValidator(dir) {
return validators_1.Validators.minLength(dir.minLength);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { CONST_EXPR } from 'angular2/src/core/facade/lang';
import { BaseException } from 'angular2/src/core/facade/exceptions';
import { ListWrapper } from 'angular2/src/core/facade/collection';
import { DOM } from 'angular2/src/core/dom/dom_adapter';
import { NgZone } from 'angular2/src/core/zone/ng_zone';
import { Injectable, Inject, OpaqueToken } from 'angular2/src/core/di';
export const EVENT_MANAGER_PLUGINS = CONST_EXPR(new OpaqueToken("EventManagerPlugins"));
export let EventManager = class {
constructor(plugins, _zone) {
this._zone = _zone;
plugins.forEach(p => p.manager = this);
this._plugins = ListWrapper.reversed(plugins);
}
addEventListener(element, eventName, handler) {
var plugin = this._findPluginFor(eventName);
plugin.addEventListener(element, eventName, handler);
}
addGlobalEventListener(target, eventName, handler) {
var plugin = this._findPluginFor(eventName);
return plugin.addGlobalEventListener(target, eventName, handler);
}
getZone() { return this._zone; }
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { Directive } from 'angular2/src/core/metadata';
import { Host, SkipSelf, forwardRef, Binding } from 'angular2/src/core/di';
import { CONST_EXPR } from 'angular2/src/core/facade/lang';
import { ControlContainer } from './control_container';
import { controlPath } from './shared';
const controlGroupBinding = CONST_EXPR(new Binding(ControlContainer, { toAlias: forwardRef(() => NgControlGroup) }));
/**
* Creates and binds a control group to a DOM element.
*
* This directive can only be used as a child of {@link NgForm} or {@link NgFormModel}.
*
* # Example
*
* In this example, we create the credentials and personal control groups.
* We can work with each group separately: check its validity, get its value, listen to its changes.
*
* ```
* @Component({selector: "signup-comp"})
* @View({
* directives: [FORM_DIRECTIVES],
* template: `
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { forwardRef, Provider } from 'angular2/src/core/di';
import { Renderer } from 'angular2/src/core/render';
import { ElementRef, QueryList } from 'angular2/src/core/linker';
import { Query, Directive } from 'angular2/src/core/metadata';
import { ObservableWrapper } from 'angular2/src/core/facade/async';
import { NG_VALUE_ACCESSOR } from './control_value_accessor';
import { CONST_EXPR } from 'angular2/src/core/facade/lang';
import { setProperty } from './shared';
const SELECT_VALUE_ACCESSOR = CONST_EXPR(new Provider(NG_VALUE_ACCESSOR, { useExisting: forwardRef(() => SelectControlValueAccessor), multi: true }));
/**
* Marks `<option>` as dynamic, so Angular can be notified when options change.
*
* #Example:
*
* ```
* <select ng-control="city">
* <option *ng-for="#c of cities" [value]="c"></option>
* </select>
* ```
*/
export let NgSelectOption = class {
};
NgSelectOption = __decorate([
Directive({ selector: 'option' }),
* @View({directives: [ROUTER_DIRECTIVES]})
* @RouteConfig([
* {...},
* ])
* class AppCmp {
* // ...
* }
*
* bootstrap(AppCmp, [
* routerBindings(AppCmp),
* PathLocationStrategy,
* bind(APP_BASE_HREF).toValue('/my/app')
* ]);
* ```
*/
exports.APP_BASE_HREF = lang_1.CONST_EXPR(new di_1.OpaqueToken('appBaseHref'));
/**
* `Location` is a service that applications can use to interact with a browser's URL.
* Depending on which {@link LocationStrategy} is used, `Location` will either persist
* to the URL's path or the URL's hash segment.
*
* Note: it's better to use {@link Router#navigate} service to trigger route changes. Use
* `Location` only if you need to interact with or create normalized URLs outside of
* routing.
*
* `Location` is responsible for normalizing the URL against the application's base href.
* A normalized URL is absolute from the URL host, includes the application's base href, and has no
* trailing slash:
* - `/my/app/user/123` is normalized
* - `my/app/user/123` **is not** normalized
* - `/my/app/user/123/` **is not** normalized
function DebugElementViewListener(_renderer) {
this._renderer = _renderer;
dom_adapter_1.DOM.setGlobalVar(INSPECT_GLOBAL_NAME, inspectNativeElement);
}
DebugElementViewListener.prototype.viewCreated = function (view) {
var viewId = _nextId++;
_allViewsById.set(viewId, view);
_allIdsByView.set(view, viewId);
for (var i = 0; i < view.elementRefs.length; i++) {
var el = view.elementRefs[i];
_setElementId(this._renderer.getNativeElementSync(el), [viewId, i]);
}
};
DebugElementViewListener.prototype.viewDestroyed = function (view) {
var viewId = _allIdsByView.get(view);
_allIdsByView.delete(view);
_allViewsById.delete(viewId);
};
DebugElementViewListener = __decorate([
di_1.Injectable(),
__metadata('design:paramtypes', [api_1.Renderer])
], DebugElementViewListener);
return DebugElementViewListener;
})();
exports.DebugElementViewListener = DebugElementViewListener;
exports.ELEMENT_PROBE_PROVIDERS = lang_1.CONST_EXPR([
DebugElementViewListener,
lang_1.CONST_EXPR(new di_1.Provider(view_listener_1.AppViewListener, { useExisting: DebugElementViewListener })),
]);
exports.ELEMENT_PROBE_BINDINGS = exports.ELEMENT_PROBE_PROVIDERS;
//# sourceMappingURL=debug_element_view_listener.js.map
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
import { CONST, CONST_EXPR } from 'angular2/src/core/facade/lang';
export let RouteLifecycleHook = class {
constructor(name) {
this.name = name;
}
};
RouteLifecycleHook = __decorate([
CONST(),
__metadata('design:paramtypes', [String])
], RouteLifecycleHook);
export let CanActivate = class {
constructor(fn) {
this.fn = fn;
}
};
CanActivate = __decorate([
CONST(),
__metadata('design:paramtypes', [Function])
], CanActivate);
export const canReuse = CONST_EXPR(new RouteLifecycleHook("canReuse"));
export const canDeactivate = CONST_EXPR(new RouteLifecycleHook("canDeactivate"));
export const onActivate = CONST_EXPR(new RouteLifecycleHook("onActivate"));
export const onReuse = CONST_EXPR(new RouteLifecycleHook("onReuse"));
export const onDeactivate = CONST_EXPR(new RouteLifecycleHook("onDeactivate"));
//# sourceMappingURL=lifecycle_annotations_impl.js.map
'use strict';var di_1 = require('angular2/src/core/di');
var lang_1 = require('angular2/src/core/facade/lang');
/**
* @internal
*/
exports.APP_COMPONENT_REF_PROMISE = lang_1.CONST_EXPR(new di_1.OpaqueToken('Promise<ComponentRef>'));
/**
* An {@link angular2/di/OpaqueToken} representing the application root type in the {@link
* Injector}.
*
* ```
* @Component(...)
* class MyApp {
* ...
* }
*
* bootstrap(MyApp).then((appRef:ApplicationRef) {
* expect(appRef.injector.get(appComponentTypeToken)).toEqual(MyApp);
* });
*
* ```
*/
exports.APP_COMPONENT = lang_1.CONST_EXPR(new di_1.OpaqueToken('AppComponent'));
/**
* A DI Token representing a unique string id assigned to the application by Angular and used
* primarily for prefixing application attributes and CSS styles when
* {@link ViewEncapsulation#Emulated} is being used.
*
* If you need to avoid randomly generated value to be used as an application id, you can provide
* a custom value via a DI provider <!-- TODO: provider --> configuring the root {@link Injector}
* using this token.
*
* This is a shorthand for importing them each individually.
*
* ### Example:
*
* ```typescript
* @Component({
* selector: 'my-app',
* directives: [FORM_DIRECTIVES]
* })
* class MyApp {}
* ```
*/
exports.FORM_DIRECTIVES = lang_1.CONST_EXPR([
ng_control_name_1.NgControlName,
ng_control_group_1.NgControlGroup,
ng_form_control_1.NgFormControl,
ng_model_1.NgModel,
ng_form_model_1.NgFormModel,
ng_form_1.NgForm,
select_control_value_accessor_1.NgSelectOption,
default_value_accessor_1.DefaultValueAccessor,
number_value_accessor_1.NumberValueAccessor,
checkbox_value_accessor_1.CheckboxControlValueAccessor,
select_control_value_accessor_1.SelectControlValueAccessor,
ng_control_status_1.NgControlStatus,
validators_1.RequiredValidator,
validators_1.MinLengthValidator,
validators_1.MaxLengthValidator
]);
//# sourceMappingURL=directives.js.map
'use strict';var lang_1 = require('angular2/src/core/facade/lang');
var di_1 = require('angular2/src/core/di');
exports.NG_VALUE_ACCESSOR = lang_1.CONST_EXPR(new di_1.OpaqueToken("NgValueAccessor"));
//# sourceMappingURL=control_value_accessor.js.map
import { OpaqueToken, Provider } from 'angular2/src/core/di';
import { CONST_EXPR, Math, StringWrapper } from 'angular2/src/core/facade/lang';
/**
* @internal
*/
export const APP_COMPONENT_REF_PROMISE = CONST_EXPR(new OpaqueToken('Promise<ComponentRef>'));
/**
* An {@link angular2/di/OpaqueToken} representing the application root type in the {@link
* Injector}.
*
* ```
* @Component(...)
* class MyApp {
* ...
* }
*
* bootstrap(MyApp).then((appRef:ApplicationRef) {
* expect(appRef.injector.get(appComponentTypeToken)).toEqual(MyApp);
* });
*
* ```
*/
export const APP_COMPONENT = CONST_EXPR(new OpaqueToken('AppComponent'));
/**
* A DI Token representing a unique string id assigned to the application by Angular and used
* primarily for prefixing application attributes and CSS styles when
* {@link ViewEncapsulation#Emulated} is being used.
*
* If you need to avoid randomly generated value to be used as an application id, you can provide
* a custom value via a DI provider <!-- TODO: provider --> configuring the root {@link Injector}
* using this token.
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var metadata_1 = require('angular2/src/core/metadata');
var di_1 = require('angular2/src/core/di');
var linker_1 = require('angular2/src/core/linker');
var lang_1 = require('angular2/src/core/facade/lang');
var collection_1 = require('angular2/src/core/facade/collection');
var _WHEN_DEFAULT = lang_1.CONST_EXPR(new Object());
var SwitchView = (function () {
function SwitchView(_viewContainerRef, _templateRef) {
this._viewContainerRef = _viewContainerRef;
this._templateRef = _templateRef;
}
SwitchView.prototype.create = function () { this._viewContainerRef.createEmbeddedView(this._templateRef); };
SwitchView.prototype.destroy = function () { this._viewContainerRef.clear(); };
return SwitchView;
})();
exports.SwitchView = SwitchView;
/**
* The `NgSwitch` directive is used to conditionally swap DOM structure on your template based on a
* scope expression.
* Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
* preserved at the location as specified in the template.
switch (arguments.length) {
case 2: return decorators.reduceRight(function(o, d) { return (d && d(o)) || o; }, target);
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
var di_1 = require('angular2/src/core/di');
var collection_1 = require('angular2/src/core/facade/collection');
var lang_1 = require('angular2/src/core/facade/lang');
exports.APP_VIEW_POOL_CAPACITY = lang_1.CONST_EXPR(new di_1.OpaqueToken('AppViewPool.viewPoolCapacity'));
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;
'use strict';var angular2_1 = require('angular2/angular2');
var lang_1 = require('angular2/src/core/facade/lang');
exports.ROUTE_DATA = lang_1.CONST_EXPR(new angular2_1.OpaqueToken('routeData'));
//# sourceMappingURL=route_data.js.map
var metadata_1 = require('./metadata');
var exceptions_2 = require('./exceptions');
var forward_ref_1 = require('./forward_ref');
var Dependency = (function () {
function Dependency(key, optional, lowerBoundVisibility, upperBoundVisibility, properties) {
this.key = key;
this.optional = optional;
this.lowerBoundVisibility = lowerBoundVisibility;
this.upperBoundVisibility = upperBoundVisibility;
this.properties = properties;
}
Dependency.fromKey = function (key) { return new Dependency(key, false, null, null, []); };
return Dependency;
})();
exports.Dependency = Dependency;
var _EMPTY_LIST = lang_1.CONST_EXPR([]);
/**
* Describes how the {@link Injector} should instantiate a given token.
*
* See {@link provide}.
*
* ### Example ([live demo](http://plnkr.co/edit/GNAyj6K6PfYg2NBzgwZ5?p%3Dpreview&p=preview))
*
* ```javascript
* var injector = Injector.resolveAndCreate([
* new Provider("message", { useValue: 'Hello' })
* ]);
*
* expect(injector.get("message")).toEqual('Hello');
* ```
*/
case 3: return decorators.reduceRight(function(o, d) { return (d && d(target, key)), void 0; }, void 0);
case 4: return decorators.reduceRight(function(o, d) { return (d && d(target, key, o)) || o; }, desc);
}
};
var __metadata = (this && this.__metadata) || function (k, v) {
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
return function (target, key) { decorator(target, key, paramIndex); }
};
import { Directive } from 'angular2/src/core/metadata';
import { Host } from 'angular2/src/core/di';
import { ViewContainerRef, TemplateRef } from 'angular2/src/core/linker';
import { isPresent, isBlank, normalizeBlank, CONST_EXPR } from 'angular2/src/core/facade/lang';
import { ListWrapper, Map } from 'angular2/src/core/facade/collection';
const _WHEN_DEFAULT = CONST_EXPR(new Object());
export class SwitchView {
constructor(_viewContainerRef, _templateRef) {
this._viewContainerRef = _viewContainerRef;
this._templateRef = _templateRef;
}
create() { this._viewContainerRef.createEmbeddedView(this._templateRef); }
destroy() { this._viewContainerRef.clear(); }
}
/**
* The `NgSwitch` directive is used to conditionally swap DOM structure on your template based on a
* scope expression.
* Elements within `NgSwitch` but without `NgSwitchWhen` or `NgSwitchDefault` directives will be
* preserved at the location as specified in the template.
*
* `NgSwitch` simply chooses nested elements and makes them visible based on which element matches
'use strict';var lang_1 = require("angular2/src/core/facade/lang");
var di_1 = require("angular2/src/core/di");
exports.ON_WEB_WORKER = lang_1.CONST_EXPR(new di_1.OpaqueToken('WebWorker.onWebWorker'));
var WebWorkerElementRef = (function () {
function WebWorkerElementRef(renderView, boundElementIndex) {
this.renderView = renderView;
this.boundElementIndex = boundElementIndex;
}
return WebWorkerElementRef;
})();
exports.WebWorkerElementRef = WebWorkerElementRef;
var WebWorkerTemplateCmd = (function () {
function WebWorkerTemplateCmd() {
}
WebWorkerTemplateCmd.prototype.visit = function (visitor, context) { return null; };
return WebWorkerTemplateCmd;
})();
exports.WebWorkerTemplateCmd = WebWorkerTemplateCmd;
var WebWorkerTextCmd = (function () {
function WebWorkerTextCmd(isBound, ngContentIndex, value) {
this.isBound = isBound;
this.ngContentIndex = ngContentIndex;
this.value = value;
}
WebWorkerTextCmd.prototype.visit = function (visitor, context) {
return visitor.visitText(this, context);
};
return WebWorkerTextCmd;
})();
exports.WebWorkerTextCmd = WebWorkerTextCmd;
var WebWorkerNgContentCmd = (function () {