85 lines
2.8 KiB
TypeScript
85 lines
2.8 KiB
TypeScript
import {isBlank, isString, isNumber, isFunction, RegExpWrapper, StringWrapper} from 'angular2/src/facade/lang';
|
|
import {BaseException} from 'angular2/src/facade/exceptions';
|
|
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, args: any[]): any {
|
|
if (isBlank(args) || args.length !== 2) {
|
|
throw new BaseException('ReplacePipe requires two arguments');
|
|
}
|
|
|
|
if (isBlank(value)) {
|
|
return value;
|
|
}
|
|
|
|
if (!this._supportedInput(value)) {
|
|
throw new InvalidPipeArgumentException(ReplacePipe, value);
|
|
}
|
|
|
|
var input = value.toString();
|
|
var pattern = args[0];
|
|
var replacement = args[1];
|
|
|
|
|
|
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(pattern) : pattern;
|
|
|
|
return StringWrapper.replaceAllMapped(input, rgxPattern, replacement);
|
|
}
|
|
if (pattern instanceof RegExp) {
|
|
// use the replaceAll variant
|
|
return StringWrapper.replaceAll(input, pattern, replacement);
|
|
}
|
|
|
|
return StringWrapper.replace(input, pattern, 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);
|
|
}
|
|
}
|