repackaging: all the file moves

modules/@angular/common/src/pipes/async_pipe.ts

@@ -0,0 +1,129 @@
+import {isBlank, isPresent, isPromise} from 'angular2/src/facade/lang';
+import {ObservableWrapper, Observable, EventEmitter} from 'angular2/src/facade/async';
+import {Pipe, Injectable, ChangeDetectorRef, OnDestroy, WrappedValue} from 'angular2/core';
+
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+class ObservableStrategy {
+  createSubscription(async: any, updateLatestValue: any): any {
+    return ObservableWrapper.subscribe(async, updateLatestValue, e => { throw e; });
+  }
+
+  dispose(subscription: any): void { ObservableWrapper.dispose(subscription); }
+
+  onDestroy(subscription: any): void { ObservableWrapper.dispose(subscription); }
+}
+
+class PromiseStrategy {
+  createSubscription(async: Promise<any>, updateLatestValue: (v: any) => any): any {
+    return async.then(updateLatestValue);
+  }
+
+  dispose(subscription: any): void {}
+
+  onDestroy(subscription: any): void {}
+}
+
+var _promiseStrategy = new PromiseStrategy();
+var _observableStrategy = new ObservableStrategy();
+var __unused: Promise<any>;  // avoid unused import when Promise union types are erased
+
+/**
+ * The `async` pipe subscribes to an Observable or Promise and returns the latest value it has
+ * emitted.
+ * When a new value is emitted, the `async` pipe marks the component to be checked for changes.
+ *
+ * ### Example
+ *
+ * This example binds a `Promise` to the view. Clicking the `Resolve` button resolves the
+ * promise.
+ *
+ * {@example core/pipes/ts/async_pipe/async_pipe_example.ts region='AsyncPipe'}
+ *
+ * It's also possible to use `async` with Observables. The example below binds the `time` Observable
+ * to the view. Every 500ms, the `time` Observable updates the view with the current time.
+ *
+ * ```typescript
+ * ```
+ */
+@Pipe({name: 'async', pure: false})
+@Injectable()
+export class AsyncPipe implements OnDestroy {
+  /** @internal */
+  _latestValue: Object = null;
+  /** @internal */
+  _latestReturnedValue: Object = null;
+
+  /** @internal */
+  _subscription: Object = null;
+  /** @internal */
+  _obj: Observable<any>| Promise<any>| EventEmitter<any> = null;
+  private _strategy: any = null;
+  /** @internal */
+  public _ref: ChangeDetectorRef;
+  constructor(_ref: ChangeDetectorRef) { this._ref = _ref; }
+
+  ngOnDestroy(): void {
+    if (isPresent(this._subscription)) {
+      this._dispose();
+    }
+  }
+
+  transform(obj: Observable<any>| Promise<any>| EventEmitter<any>): any {
+    if (isBlank(this._obj)) {
+      if (isPresent(obj)) {
+        this._subscribe(obj);
+      }
+      this._latestReturnedValue = this._latestValue;
+      return this._latestValue;
+    }
+
+    if (obj !== this._obj) {
+      this._dispose();
+      return this.transform(obj);
+    }
+
+    if (this._latestValue === this._latestReturnedValue) {
+      return this._latestReturnedValue;
+    } else {
+      this._latestReturnedValue = this._latestValue;
+      return WrappedValue.wrap(this._latestValue);
+    }
+  }
+
+  /** @internal */
+  _subscribe(obj: Observable<any>| Promise<any>| EventEmitter<any>): void {
+    this._obj = obj;
+    this._strategy = this._selectStrategy(obj);
+    this._subscription = this._strategy.createSubscription(
+        obj, (value: Object) => this._updateLatestValue(obj, value));
+  }
+
+  /** @internal */
+  _selectStrategy(obj: Observable<any>| Promise<any>| EventEmitter<any>): any {
+    if (isPromise(obj)) {
+      return _promiseStrategy;
+    } else if (ObservableWrapper.isObservable(obj)) {
+      return _observableStrategy;
+    } else {
+      throw new InvalidPipeArgumentException(AsyncPipe, obj);
+    }
+  }
+
+  /** @internal */
+  _dispose(): void {
+    this._strategy.dispose(this._subscription);
+    this._latestValue = null;
+    this._latestReturnedValue = null;
+    this._subscription = null;
+    this._obj = null;
+  }
+
+  /** @internal */
+  _updateLatestValue(async: any, value: Object) {
+    if (async === this._obj) {
+      this._latestValue = value;
+      this._ref.markForCheck();
+    }
+  }
+}

modules/@angular/common/src/pipes/common_pipes.ts

@@ -0,0 +1,37 @@
+/**
+ * @module
+ * @description
+ * This module provides a set of common Pipes.
+ */
+import {AsyncPipe} from './async_pipe';
+import {UpperCasePipe} from './uppercase_pipe';
+import {LowerCasePipe} from './lowercase_pipe';
+import {JsonPipe} from './json_pipe';
+import {SlicePipe} from './slice_pipe';
+import {DatePipe} from './date_pipe';
+import {DecimalPipe, PercentPipe, CurrencyPipe} from './number_pipe';
+import {ReplacePipe} from './replace_pipe';
+import {I18nPluralPipe} from './i18n_plural_pipe';
+import {I18nSelectPipe} from './i18n_select_pipe';
+
+/**
+ * A collection of Angular core pipes that are likely to be used in each and every
+ * application.
+ *
+ * This collection can be used to quickly enumerate all the built-in pipes in the `pipes`
+ * property of the `@Component` decorator.
+ */
+export const COMMON_PIPES = /*@ts2dart_const*/[
+  AsyncPipe,
+  UpperCasePipe,
+  LowerCasePipe,
+  JsonPipe,
+  SlicePipe,
+  DecimalPipe,
+  PercentPipe,
+  CurrencyPipe,
+  DatePipe,
+  ReplacePipe,
+  I18nPluralPipe,
+  I18nSelectPipe
+];

modules/@angular/common/src/pipes/date_pipe.ts

@@ -0,0 +1,119 @@
+import {
+  isDate,
+  isNumber,
+  isPresent,
+  Date,
+  DateWrapper,
+  isBlank,
+  FunctionWrapper
+} from 'angular2/src/facade/lang';
+import {DateFormatter} from 'angular2/src/facade/intl';
+import {PipeTransform, WrappedValue, Pipe, Injectable} from 'angular2/core';
+import {StringMapWrapper, ListWrapper} from 'angular2/src/facade/collection';
+
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+
+// TODO: move to a global configurable location along with other i18n components.
+var defaultLocale: string = 'en-US';
+
+/**
+ * Formats a date value to a string based on the requested format.
+ *
+ * WARNINGS:
+ * - this pipe is marked as pure hence it will not be re-evaluated when the input is mutated.
+ *   Instead users should treat the date as an immutable object and change the reference when the
+ *   pipe needs to re-run (this is to avoid reformatting the date on every change detection run
+ *   which would be an expensive operation).
+ * - this pipe uses the Internationalization API. Therefore it is only reliable in Chrome and Opera
+ *   browsers.
+ *
+ * ## Usage
+ *
+ *     expression | date[:format]
+ *
+ * where `expression` is a date object or a number (milliseconds since UTC epoch) and
+ * `format` indicates which date/time components to include:
+ *
+ *  | Component | Symbol | Short Form   | Long Form         | Numeric   | 2-digit   |
+ *  |-----------|:------:|--------------|-------------------|-----------|-----------|
+ *  | era       |   G    | G (AD)       | GGGG (Anno Domini)| -         | -         |
+ *  | year      |   y    | -            | -                 | y (2015)  | yy (15)   |
+ *  | month     |   M    | MMM (Sep)    | MMMM (September)  | M (9)     | MM (09)   |
+ *  | day       |   d    | -            | -                 | d (3)     | dd (03)   |
+ *  | weekday   |   E    | EEE (Sun)    | EEEE (Sunday)     | -         | -         |
+ *  | hour      |   j    | -            | -                 | j (13)    | jj (13)   |
+ *  | hour12    |   h    | -            | -                 | h (1 PM)  | hh (01 PM)|
+ *  | hour24    |   H    | -            | -                 | H (13)    | HH (13)   |
+ *  | minute    |   m    | -            | -                 | m (5)     | mm (05)   |
+ *  | second    |   s    | -            | -                 | s (9)     | ss (09)   |
+ *  | timezone  |   z    | -            | z (Pacific Standard Time)| -  | -         |
+ *  | timezone  |   Z    | Z (GMT-8:00) | -                 | -         | -         |
+ *
+ * In javascript, only the components specified will be respected (not the ordering,
+ * punctuations, ...) and details of the formatting will be dependent on the locale.
+ * On the other hand in Dart version, you can also include quoted text as well as some extra
+ * date/time components such as quarter. For more information see:
+ * https://api.dartlang.org/apidocs/channels/stable/dartdoc-viewer/intl/intl.DateFormat.
+ *
+ * `format` can also be one of the following predefined formats:
+ *
+ *  - `'medium'`: equivalent to `'yMMMdjms'` (e.g. Sep 3, 2010, 12:05:08 PM for en-US)
+ *  - `'short'`: equivalent to `'yMdjm'` (e.g. 9/3/2010, 12:05 PM for en-US)
+ *  - `'fullDate'`: equivalent to `'yMMMMEEEEd'` (e.g. Friday, September 3, 2010 for en-US)
+ *  - `'longDate'`: equivalent to `'yMMMMd'` (e.g. September 3, 2010)
+ *  - `'mediumDate'`: equivalent to `'yMMMd'` (e.g. Sep 3, 2010 for en-US)
+ *  - `'shortDate'`: equivalent to `'yMd'` (e.g. 9/3/2010 for en-US)
+ *  - `'mediumTime'`: equivalent to `'jms'` (e.g. 12:05:08 PM for en-US)
+ *  - `'shortTime'`: equivalent to `'jm'` (e.g. 12:05 PM for en-US)
+ *
+ * Timezone of the formatted text will be the local system timezone of the end-users machine.
+ *
+ * ### Examples
+ *
+ * Assuming `dateObj` is (year: 2015, month: 6, day: 15, hour: 21, minute: 43, second: 11)
+ * in the _local_ time and locale is 'en-US':
+ *
+ * ```
+ *     {{ dateObj | date }}               // output is 'Jun 15, 2015'
+ *     {{ dateObj | date:'medium' }}      // output is 'Jun 15, 2015, 9:43:11 PM'
+ *     {{ dateObj | date:'shortTime' }}   // output is '9:43 PM'
+ *     {{ dateObj | date:'mmss' }}        // output is '43:11'
+ * ```
+ *
+ * {@example core/pipes/ts/date_pipe/date_pipe_example.ts region='DatePipe'}
+ */
+@Pipe({name: 'date', pure: true})
+@Injectable()
+export class DatePipe implements PipeTransform {
+  /** @internal */
+  static _ALIASES: {[key: string]: String} = {
+    'medium': 'yMMMdjms',
+    'short': 'yMdjm',
+    'fullDate': 'yMMMMEEEEd',
+    'longDate': 'yMMMMd',
+    'mediumDate': 'yMMMd',
+    'shortDate': 'yMd',
+    'mediumTime': 'jms',
+    'shortTime': 'jm'
+  };
+
+
+  transform(value: any, pattern: string = 'mediumDate'): string {
+    if (isBlank(value)) return null;
+
+    if (!this.supports(value)) {
+      throw new InvalidPipeArgumentException(DatePipe, value);
+    }
+
+    if (isNumber(value)) {
+      value = DateWrapper.fromMillis(value);
+    }
+    if (StringMapWrapper.contains(DatePipe._ALIASES, pattern)) {
+      pattern = <string>StringMapWrapper.get(DatePipe._ALIASES, pattern);
+    }
+    return DateFormatter.format(value, defaultLocale, pattern);
+  }
+
+  supports(obj: any): boolean { return isDate(obj) || isNumber(obj); }
+}

modules/@angular/common/src/pipes/i18n_plural_pipe.ts

@@ -0,0 +1,54 @@
+import {isStringMap, StringWrapper, isPresent, RegExpWrapper} from 'angular2/src/facade/lang';
+import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+var interpolationExp: RegExp = RegExpWrapper.create('#');
+
+/**
+ *
+ *  Maps a value to a string that pluralizes the value properly.
+ *
+ *  ## Usage
+ *
+ *  expression | i18nPlural:mapping
+ *
+ *  where `expression` is a number and `mapping` is an object that indicates the proper text for
+ *  when the `expression` evaluates to 0, 1, or some other number.  You can interpolate the actual
+ *  value into the text using the `#` sign.
+ *
+ *  ## Example
+ *
+ *  ```
+ *  <div>
+ *    {{ messages.length | i18nPlural: messageMapping }}
+ *  </div>
+ *
+ *  class MyApp {
+ *    messages: any[];
+ *    messageMapping: any = {
+ *      '=0': 'No messages.',
+ *      '=1': 'One message.',
+ *      'other': '# messages.'
+ *    }
+ *    ...
+ *  }
+ *  ```
+ *
+ */
+@Pipe({name: 'i18nPlural', pure: true})
+@Injectable()
+export class I18nPluralPipe implements PipeTransform {
+  transform(value: number, pluralMap: {[count: string]: string}): string {
+    var key: string;
+    var valueStr: string;
+
+    if (!isStringMap(pluralMap)) {
+      throw new InvalidPipeArgumentException(I18nPluralPipe, pluralMap);
+    }
+
+    key = value === 0 || value === 1 ? `=${value}` : 'other';
+    valueStr = isPresent(value) ? value.toString() : '';
+
+    return StringWrapper.replaceAll(pluralMap[key], interpolationExp, valueStr);
+  }
+}

modules/@angular/common/src/pipes/i18n_select_pipe.ts

@@ -0,0 +1,45 @@
+import {isStringMap} from 'angular2/src/facade/lang';
+import {StringMapWrapper} from 'angular2/src/facade/collection';
+import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+/**
+ *
+ *  Generic selector that displays the string that matches the current value.
+ *
+ *  ## Usage
+ *
+ *  expression | i18nSelect:mapping
+ *
+ *  where `mapping` is an object that indicates the text that should be displayed
+ *  for different values of the provided `expression`.
+ *
+ *  ## Example
+ *
+ *  ```
+ *  <div>
+ *    {{ gender | i18nSelect: inviteMap }}
+ *  </div>
+ *
+ *  class MyApp {
+ *    gender: string = 'male';
+ *    inviteMap: any = {
+ *      'male': 'Invite her.',
+ *      'female': 'Invite him.',
+ *      'other': 'Invite them.'
+ *    }
+ *    ...
+ *  }
+ *  ```
+ */
+@Pipe({name: 'i18nSelect', pure: true})
+@Injectable()
+export class I18nSelectPipe implements PipeTransform {
+  transform(value: string, mapping: {[key: string]: string}): string {
+    if (!isStringMap(mapping)) {
+      throw new InvalidPipeArgumentException(I18nSelectPipe, mapping);
+    }
+
+    return StringMapWrapper.contains(mapping, value) ? mapping[value] : mapping['other'];
+  }
+}

modules/@angular/common/src/pipes/invalid_pipe_argument_exception.ts

@@ -0,0 +1,8 @@
+import {Type, stringify} from 'angular2/src/facade/lang';
+import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
+
+export class InvalidPipeArgumentException extends BaseException {
+  constructor(type: Type, value: Object) {
+    super(`Invalid argument '${value}' for pipe '${stringify(type)}'`);
+  }
+}

modules/@angular/common/src/pipes/json_pipe.ts

@@ -0,0 +1,15 @@
+import {isBlank, isPresent, Json} from 'angular2/src/facade/lang';
+import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+
+/**
+ * Transforms any input value using `JSON.stringify`. Useful for debugging.
+ *
+ * ### Example
+ * {@example core/pipes/ts/json_pipe/json_pipe_example.ts region='JsonPipe'}
+ */
+/* @ts2dart_const */
+@Pipe({name: 'json', pure: false})
+@Injectable()
+export class JsonPipe implements PipeTransform {
+  transform(value: any): string { return Json.stringify(value); }
+}

modules/@angular/common/src/pipes/lowercase_pipe.ts

@@ -0,0 +1,22 @@
+import {isString, isBlank} from 'angular2/src/facade/lang';
+import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+/**
+ * Transforms text to lowercase.
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
+ */
+@Pipe({name: 'lowercase'})
+@Injectable()
+export class LowerCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (isBlank(value)) return value;
+    if (!isString(value)) {
+      throw new InvalidPipeArgumentException(LowerCasePipe, value);
+    }
+    return value.toLowerCase();
+  }
+}

modules/@angular/common/src/pipes/number_pipe.ts

@@ -0,0 +1,143 @@
+import {
+  isNumber,
+  isPresent,
+  isBlank,
+  StringWrapper,
+  NumberWrapper,
+  RegExpWrapper,
+  FunctionWrapper
+} from 'angular2/src/facade/lang';
+import {BaseException, WrappedException} from 'angular2/src/facade/exceptions';
+import {NumberFormatter, NumberFormatStyle} from 'angular2/src/facade/intl';
+import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+var defaultLocale: string = 'en-US';
+var _re = RegExpWrapper.create('^(\\d+)?\\.((\\d+)(\\-(\\d+))?)?$');
+
+/**
+ * Internal base class for numeric pipes.
+ */
+@Injectable()
+export class NumberPipe {
+  /** @internal */
+  static _format(value: number, style: NumberFormatStyle, digits: string, currency: string = null,
+                 currencyAsSymbol: boolean = false): string {
+    if (isBlank(value)) return null;
+    if (!isNumber(value)) {
+      throw new InvalidPipeArgumentException(NumberPipe, value);
+    }
+    var minInt = 1, minFraction = 0, maxFraction = 3;
+    if (isPresent(digits)) {
+      var parts = RegExpWrapper.firstMatch(_re, digits);
+      if (isBlank(parts)) {
+        throw new BaseException(`${digits} is not a valid digit info for number pipes`);
+      }
+      if (isPresent(parts[1])) {  // min integer digits
+        minInt = NumberWrapper.parseIntAutoRadix(parts[1]);
+      }
+      if (isPresent(parts[3])) {  // min fraction digits
+        minFraction = NumberWrapper.parseIntAutoRadix(parts[3]);
+      }
+      if (isPresent(parts[5])) {  // max fraction digits
+        maxFraction = NumberWrapper.parseIntAutoRadix(parts[5]);
+      }
+    }
+    return NumberFormatter.format(value, defaultLocale, style, {
+      minimumIntegerDigits: minInt,
+      minimumFractionDigits: minFraction,
+      maximumFractionDigits: maxFraction,
+      currency: currency,
+      currencyAsSymbol: currencyAsSymbol
+    });
+  }
+}
+
+/**
+ * WARNING: this pipe uses the Internationalization API.
+ * Therefore it is only reliable in Chrome and Opera browsers.
+ *
+ * Formats a number as local text. i.e. group sizing and separator and other locale-specific
+ * configurations are based on the active locale.
+ *
+ * ### Usage
+ *
+ *     expression | number[:digitInfo]
+ *
+ * where `expression` is a number and `digitInfo` has the following format:
+ *
+ *     {minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}
+ *
+ * - minIntegerDigits is the minimum number of integer digits to use. Defaults to 1.
+ * - minFractionDigits is the minimum number of digits after fraction. Defaults to 0.
+ * - maxFractionDigits is the maximum number of digits after fraction. Defaults to 3.
+ *
+ * For more information on the acceptable range for each of these numbers and other
+ * details see your native internationalization library.
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='NumberPipe'}
+ */
+@Pipe({name: 'number'})
+@Injectable()
+export class DecimalPipe extends NumberPipe implements PipeTransform {
+  transform(value: any, digits: string = null): string {
+    return NumberPipe._format(value, NumberFormatStyle.Decimal, digits);
+  }
+}
+
+/**
+ * WARNING: this pipe uses the Internationalization API.
+ * Therefore it is only reliable in Chrome and Opera browsers.
+ *
+ * Formats a number as local percent.
+ *
+ * ### Usage
+ *
+ *     expression | percent[:digitInfo]
+ *
+ * For more information about `digitInfo` see {@link DecimalPipe}
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='PercentPipe'}
+ */
+@Pipe({name: 'percent'})
+@Injectable()
+export class PercentPipe extends NumberPipe implements PipeTransform {
+  transform(value: any, digits: string = null): string {
+    return NumberPipe._format(value, NumberFormatStyle.Percent, digits);
+  }
+}
+
+/**
+ * WARNING: this pipe uses the Internationalization API.
+ * Therefore it is only reliable in Chrome and Opera browsers.
+ *
+ * Formats a number as local currency.
+ *
+ * ### Usage
+ *
+ *     expression | currency[:currencyCode[:symbolDisplay[:digitInfo]]]
+ *
+ * where `currencyCode` is the ISO 4217 currency code, such as "USD" for the US dollar and
+ * "EUR" for the euro. `symbolDisplay` is a boolean indicating whether to use the currency
+ * symbol (e.g. $) or the currency code (e.g. USD) in the output. The default for this value
+ * is `false`.
+ * For more information about `digitInfo` see {@link DecimalPipe}
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/number_pipe/number_pipe_example.ts region='CurrencyPipe'}
+ */
+@Pipe({name: 'currency'})
+@Injectable()
+export class CurrencyPipe extends NumberPipe implements PipeTransform {
+  transform(value: any, currencyCode: string = 'USD', symbolDisplay: boolean = false,
+            digits: string = null): string {
+    return NumberPipe._format(value, NumberFormatStyle.Currency, digits, currencyCode,
+                              symbolDisplay);
+  }
+}

modules/@angular/common/src/pipes/replace_pipe.ts

@@ -0,0 +1,83 @@
+import {
+  isBlank,
+  isString,
+  isNumber,
+  isFunction,
+  RegExpWrapper,
+  StringWrapper
+} from 'angular2/src/facade/lang';
+import {Injectable, PipeTransform, Pipe} from 'angular2/core';
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+/**
+ * Creates a new String with some or all of the matches of a pattern replaced by
+ * a replacement.
+ *
+ * The pattern to be matched is specified by the 'pattern' parameter.
+ *
+ * The replacement to be set is specified by the 'replacement' parameter.
+ *
+ * An optional 'flags' parameter can be set.
+ *
+ * ### Usage
+ *
+ *     expression | replace:pattern:replacement
+ *
+ * All behavior is based on the expected behavior of the JavaScript API
+ * String.prototype.replace() function.
+ *
+ * Where the input expression is a [String] or [Number] (to be treated as a string),
+ * the `pattern` is a [String] or [RegExp],
+ * the 'replacement' is a [String] or [Function].
+ *
+ * --Note--: The 'pattern' parameter will be converted to a RegExp instance. Make sure to escape the
+ * string properly if you are matching for regular expression special characters like parenthesis,
+ * brackets etc.
+ */
+
+@Pipe({name: 'replace'})
+@Injectable()
+export class ReplacePipe implements PipeTransform {
+  transform(value: any, pattern: string | RegExp, replacement: Function | string): any {
+    if (isBlank(value)) {
+      return value;
+    }
+
+    if (!this._supportedInput(value)) {
+      throw new InvalidPipeArgumentException(ReplacePipe, value);
+    }
+
+    var input = value.toString();
+
+    if (!this._supportedPattern(pattern)) {
+      throw new InvalidPipeArgumentException(ReplacePipe, pattern);
+    }
+    if (!this._supportedReplacement(replacement)) {
+      throw new InvalidPipeArgumentException(ReplacePipe, replacement);
+    }
+    // template fails with literal RegExp e.g /pattern/igm
+    // var rgx = pattern instanceof RegExp ? pattern : RegExpWrapper.create(pattern);
+
+    if (isFunction(replacement)) {
+      var rgxPattern = isString(pattern) ? RegExpWrapper.create(<string>pattern) : <RegExp>pattern;
+
+      return StringWrapper.replaceAllMapped(input, rgxPattern, <Function>replacement);
+    }
+    if (pattern instanceof RegExp) {
+      // use the replaceAll variant
+      return StringWrapper.replaceAll(input, pattern, <string>replacement);
+    }
+
+    return StringWrapper.replace(input, <string>pattern, <string>replacement);
+  }
+
+  private _supportedInput(input: any): boolean { return isString(input) || isNumber(input); }
+
+  private _supportedPattern(pattern: any): boolean {
+    return isString(pattern) || pattern instanceof RegExp;
+  }
+
+  private _supportedReplacement(replacement: any): boolean {
+    return isString(replacement) || isFunction(replacement);
+  }
+}

modules/@angular/common/src/pipes/slice_pipe.ts

@@ -0,0 +1,73 @@
+import {isBlank, isString, isArray, StringWrapper} from 'angular2/src/facade/lang';
+import {ListWrapper} from 'angular2/src/facade/collection';
+import {Injectable, PipeTransform, WrappedValue, Pipe} from 'angular2/core';
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+/**
+ * Creates a new List or String containing only a subset (slice) of the
+ * elements.
+ *
+ * The starting index of the subset to return is specified by the `start` parameter.
+ *
+ * The ending index of the subset to return is specified by the optional `end` parameter.
+ *
+ * ### Usage
+ *
+ *     expression | slice:start[:end]
+ *
+ * All behavior is based on the expected behavior of the JavaScript API
+ * Array.prototype.slice() and String.prototype.slice()
+ *
+ * Where the input expression is a [List] or [String], and `start` is:
+ *
+ * - **a positive integer**: return the item at _start_ index and all items after
+ * in the list or string expression.
+ * - **a negative integer**: return the item at _start_ index from the end and all items after
+ * in the list or string expression.
+ * - **`|start|` greater than the size of the expression**: return an empty list or string.
+ * - **`|start|` negative greater than the size of the expression**: return entire list or
+ * string expression.
+ *
+ * and where `end` is:
+ *
+ * - **omitted**: return all items until the end of the input
+ * - **a positive integer**: return all items before _end_ index of the list or string
+ * expression.
+ * - **a negative integer**: return all items before _end_ index from the end of the list
+ * or string expression.
+ *
+ * When operating on a [List], the returned list is always a copy even when all
+ * the elements are being returned.
+ *
+ * ## List Example
+ *
+ * This `ngFor` example:
+ *
+ * {@example core/pipes/ts/slice_pipe/slice_pipe_example.ts region='SlicePipe_list'}
+ *
+ * produces the following:
+ *
+ *     <li>b</li>
+ *     <li>c</li>
+ *
+ * ## String Examples
+ *
+ * {@example core/pipes/ts/slice_pipe/slice_pipe_example.ts region='SlicePipe_string'}
+ */
+
+@Pipe({name: 'slice', pure: false})
+@Injectable()
+export class SlicePipe implements PipeTransform {
+  transform(value: any, start: number, end: number = null): any {
+    if (!this.supports(value)) {
+      throw new InvalidPipeArgumentException(SlicePipe, value);
+    }
+    if (isBlank(value)) return value;
+    if (isString(value)) {
+      return StringWrapper.slice(value, start, end);
+    }
+    return ListWrapper.slice(value, start, end);
+  }
+
+  private supports(obj: any): boolean { return isString(obj) || isArray(obj); }
+}

modules/@angular/common/src/pipes/uppercase_pipe.ts

@@ -0,0 +1,22 @@
+import {isString, isBlank} from 'angular2/src/facade/lang';
+import {PipeTransform, WrappedValue, Injectable, Pipe} from 'angular2/core';
+import {InvalidPipeArgumentException} from './invalid_pipe_argument_exception';
+
+/**
+ * Implements uppercase transforms to text.
+ *
+ * ### Example
+ *
+ * {@example core/pipes/ts/lowerupper_pipe/lowerupper_pipe_example.ts region='LowerUpperPipe'}
+ */
+@Pipe({name: 'uppercase'})
+@Injectable()
+export class UpperCasePipe implements PipeTransform {
+  transform(value: string): string {
+    if (isBlank(value)) return value;
+    if (!isString(value)) {
+      throw new InvalidPipeArgumentException(UpperCasePipe, value);
+    }
+    return value.toUpperCase();
+  }
+}