TypeScript StringWrapper.replaceAllMapped方法代码示例

export function normalizeCSS(css: string): string {
  css = StringWrapper.replaceAll(css, RegExpWrapper.create('\\s+'), ' ');
  css = StringWrapper.replaceAll(css, RegExpWrapper.create(':\\s'), ':');
  css = StringWrapper.replaceAll(css, RegExpWrapper.create("\\'"), '"');
  css = StringWrapper.replaceAllMapped(css, RegExpWrapper.create('url\\(\\"(.+)\\"\\)'),
                                       (match) => `url(${match[1]})`);
  css = StringWrapper.replaceAllMapped(css, RegExpWrapper.create('\\[(.+)=([^"\\]]+)\\]'),
                                       (match) => `[${match[1]}="${match[2]}"]`);
  return css;
}

 // return a selector with [name] suffix on each simple selector
 // e.g. .foo.bar > .zot becomes .foo[name].bar[name] > .zot[name]
 _applyStrictSelectorScope(selector: string, scopeSelector: string): string {
   var isRe = RegExpWrapper.create('\\[is=([^\\]]*)\\]');
   scopeSelector = StringWrapper.replaceAllMapped(scopeSelector, isRe, (m) => m[1]);
   var splits = [' ', '>', '+', '~'],
     scoped = selector,
     attrName = '[' + scopeSelector + ']';
   for (var i = 0; i < splits.length; i++) {
     var sep = splits[i];
     var parts = scoped.split(sep);
     scoped = ListWrapper.map(parts, function(p) {
       // remove :host since it should be unnecessary
       var t = StringWrapper.replaceAll(p.trim(), _polyfillHostRe, '');
       if (t.length > 0 &&
         !ListWrapper.contains(splits, t) &&
         !StringWrapper.contains(t, attrName)) {
         var re = RegExpWrapper.create('([^:]*)(:*)(.*)');
         var m = RegExpWrapper.firstMatch(re, t);
         if (isPresent(m)) {
           p = m[1] + attrName + m[2] + m[3];
         }
       }
       return p;
     }).join(sep);
   }
   return scoped;
 }

 _insertPolyfillRulesInCssText(cssText) {
   return StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function(m) {
     var rule = m[0];
     rule = StringWrapper.replace(rule, m[1], '');
     rule = StringWrapper.replace(rule, m[2], '');
     return m[3] + rule;
   });
 }

 /*
  * Process styles to add rules which will only apply under the polyfill
  *
  * For example, we convert this rule:
  *
  * polyfill-rule {
  *   content: ':host menu-item';
  * ...
  * }
  *
  * to this:
  *
  * scopeName menu-item {...}
  *
 **/
 _insertPolyfillRulesInCssText(cssText: string): string {
   // Difference with webcomponents.js: does not handle comments
   return StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function(m) {
     var rule = m[0];
     rule = StringWrapper.replace(rule, m[1], '');
     rule = StringWrapper.replace(rule, m[2], '');
     return m[3] + rule;
   });
 }

 _replaceUrls(cssText, re, baseUrl) {
   return StringWrapper.replaceAllMapped(cssText, re, (m) => {
     var pre = m[1];
     var url = StringWrapper.replaceAll(m[2], _quoteRe, '');
     var post = m[3];
     var resolvedUrl = this._resolver.resolve(baseUrl, url);
     return pre + "'" + resolvedUrl + "'" + post;
   });
 }

function escapeString(input: string, re: RegExp): string {
  return StringWrapper.replaceAllMapped(input, re, (match) => {
    if (match[0] == '$') {
      return IS_DART ? '\\$' : '$';
    } else if (match[0] == '\n') {
      return '\\n';
    } else {
      return `\\${match[0]}`;
    }
  });
}

export function extractStyleUrls(resolver: UrlResolver, baseUrl: string,
                                 cssText: string): StyleWithImports {
  var foundUrls = [];
  var modifiedCssText = StringWrapper.replaceAllMapped(cssText, _cssImportRe, (m) => {
    var url = isPresent(m[1]) ? m[1] : m[2];
    if (!isStyleUrlResolvable(url)) {
      // Do not attempt to resolve non-package absolute URLs with URI scheme
      return m[0];
    }
    foundUrls.push(resolver.resolve(baseUrl, url));
    return '';
  });
  return new StyleWithImports(modifiedCssText, foundUrls);
}

  _replaceUrls(cssText: string, re: RegExp, baseUrl: string) {
    return StringWrapper.replaceAllMapped(cssText, re, (m) => {
      var pre = m[1];
      var originalUrl = m[2];
      if (RegExpWrapper.test(_dataUrlRe, originalUrl)) {
        // Do not attempt to resolve data: URLs
        return m[0];
      }
      var url = StringWrapper.replaceAll(originalUrl, _quoteRe, '');
      var post = m[3];

      var resolvedUrl = this._resolver.resolve(baseUrl, url);

      return pre + "'" + resolvedUrl + "'" + post;
    });
  }

 _convertColonRule(cssText: string, regExp: RegExp, partReplacer: Function): string {
   // p1 = :host, p2 = contents of (), p3 rest of rule
   return StringWrapper.replaceAllMapped(cssText, regExp, function(m) {
     if (isPresent(m[2])) {
       var parts = m[2].split(','), r = [];
       for (var i = 0; i < parts.length; i++) {
         var p = parts[i];
         if (isBlank(p)) break;
         p = p.trim();
         ListWrapper.push(r, partReplacer(_polyfillHostNoCombinator, p, m[3]));
       }
       return r.join(',');
     } else {
       return _polyfillHostNoCombinator + m[3];
     }
   });
 }

 getSourceWithImports(): SourceWithImports {
   var moduleAliases = {};
   var imports: string[][] = [];
   var newSource =
       StringWrapper.replaceAllMapped(this.sourceWithModuleRefs, MODULE_REGEXP, (match) => {
         var moduleUrl = match[1];
         var alias = moduleAliases[moduleUrl];
         if (isBlank(alias)) {
           if (moduleUrl == this.moduleUrl) {
             alias = '';
           } else {
             alias = `import${imports.length}`;
             imports.push([moduleUrl, alias]);
           }
           moduleAliases[moduleUrl] = alias;
         }
         return alias.length > 0 ? `${alias}.` : '';
       });
   return new SourceWithImports(newSource, imports);
 }