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 () {