TypeScript StringMapWrapper.get方法代码示例

 /**
  * Construct a new {@link ControlGroup} with the given map of configuration.
  * Valid keys for the `extra` parameter map are `optionals` and `validator`.
  *
  * See the {@link ControlGroup} constructor for more details.
  */
 group(controlsConfig: {[key: string]: any},
       extra: {[key: string]: any} = null): modelModule.ControlGroup {
   var controls = this._reduceControls(controlsConfig);
   var optionals = isPresent(extra) ? StringMapWrapper.get(extra, "optionals") : null;
   var validator = isPresent(extra) ? StringMapWrapper.get(extra, "validator") : null;
   var asyncValidator = isPresent(extra) ? StringMapWrapper.get(extra, "asyncValidator") : null;
   return new modelModule.ControlGroup(controls, optionals, validator, asyncValidator);
 }

 group(controlsConfig, extra = null) {
   var controls = this._reduceControls(controlsConfig);
   var optionals = isPresent(extra) ? StringMapWrapper.get(extra, "optionals") : null;
   var validator = isPresent(extra) ? StringMapWrapper.get(extra, "validator") : null;
   if (isPresent(validator)) {
     return new modelModule.ControlGroup(controls, optionals, validator);
   } else {
     return new modelModule.ControlGroup(controls, optionals);
   }
 }

export function setterFactory(property: string): Function {
  var setterFn, styleParts, styleSuffix;
  if (StringWrapper.startsWith(property, ATTRIBUTE_PREFIX)) {
    setterFn = attributeSetterFactory(StringWrapper.substring(property, ATTRIBUTE_PREFIX.length));
  } else if (StringWrapper.startsWith(property, CLASS_PREFIX)) {
    setterFn = classSetterFactory(StringWrapper.substring(property, CLASS_PREFIX.length));
  } else if (StringWrapper.startsWith(property, STYLE_PREFIX)) {
    styleParts = property.split(STYLE_SEPARATOR);
    styleSuffix = styleParts.length > 2 ? ListWrapper.get(styleParts, 2) : '';
    setterFn = styleSetterFactory(ListWrapper.get(styleParts, 1), styleSuffix);
  } else if (StringWrapper.equals(property, 'innerHtml')) {
    if (isBlank(innerHTMLSetterCache)) {
      innerHTMLSetterCache = (el, value) => DOM.setInnerHTML(el, value);
    }
    setterFn = innerHTMLSetterCache;
  } else {
    property = resolvePropertyName(property);
    setterFn = StringMapWrapper.get(propertySettersCache, property);
    if (isBlank(setterFn)) {
      var propertySetterFn = reflector.setter(property);
      setterFn = function(receiver, value) {
        if (DOM.hasProperty(receiver, property)) {
          return propertySetterFn(receiver, value);
        }
      };
      StringMapWrapper.set(propertySettersCache, property, setterFn);
    }
  }
  return setterFn;
}

 createProtoChangeDetector(definition: ChangeDetectorDefinition): ProtoChangeDetector {
   var id = definition.id;
   if (StringMapWrapper.contains(this._protoChangeDetectors, id)) {
     return StringMapWrapper.get(this._protoChangeDetectors, id)(this.registry);
   }
   return this._dynamicChangeDetection.createProtoChangeDetector(definition);
 }

  load(template: ViewDefinition): Promise</*element*/ any> {
    if (isPresent(template.template)) {
      return PromiseWrapper.resolve(DOM.createTemplate(template.template));
    }
    var url = template.absUrl;
    if (isPresent(url)) {
      var promise = StringMapWrapper.get(this._htmlCache, url);

      if (isBlank(promise)) {
        // TODO(vicb): change error when TS gets fixed
        // https://github.com/angular/angular/issues/2280
        // throw new BaseException(`Failed to fetch url "${url}"`);
        promise = PromiseWrapper.then(this._xhr.get(url), html => {
          var template = DOM.createTemplate(html);
          return template;
        }, _ => PromiseWrapper.reject(new BaseException(`Failed to fetch url "${url}"`), null));

        StringMapWrapper.set(this._htmlCache, url, promise);
      }

      // We need to clone the result as others might change it
      // (e.g. the compiler).
      return promise.then((tplElement) => DOM.clone(tplElement));
    }

    throw new BaseException('View should have either the url or template property set');
  }

 generate(params: StringMap<string, string>): string {
   if (!StringMapWrapper.contains(params, this.name)) {
     throw new BaseException(
         `Route generator for '${this.name}' was not included in parameters passed.`)
   }
   return normalizeBlank(StringMapWrapper.get(params, this.name));
 }

 ListWrapper.forEach(modifierKeys, (modifierName) => {
   if (modifierName != key) {
     var modifierGetter = StringMapWrapper.get(modifierKeyGetters, modifierName);
     if (modifierGetter(event)) {
       fullKey += modifierName + '.';
     }
   }
 });

 triggerEventHandlers(eventName, eventObj, binderIndex) {
   var handlers = this.proto.eventHandlers[binderIndex];
   if (isBlank(handlers))
     return ;
   var handler = StringMapWrapper.get(handlers, eventName);
   if (isBlank(handler))
     return ;
   handler(eventObj, this);
 }

  addEventListener(element: HTMLElement, eventName: string, handler: (Event: any) => any) {
    var parsedEvent = KeyEventsPlugin.parseEventName(eventName);

    var outsideHandler = KeyEventsPlugin.eventCallback(
        element, StringMapWrapper.get(parsedEvent, 'fullKey'), handler, this.manager.getZone());

    this.manager.getZone().runOutsideAngular(() => {
      DOM.on(element, StringMapWrapper.get(parsedEvent, 'domEventName'), outsideHandler);
    });
  }

  static create({id, selector, compileChildren, events, host, properties, readAttributes, type,
                 callOnDestroy, callOnChange, callOnCheck, callOnInit, callOnAllChangesDone,
                 changeDetection, exportAs}: {
    id?: string,
    selector?: string,
    compileChildren?: boolean,
    events?: List<string>,
    host?: Map<string, string>,
    properties?: List<string>,
    readAttributes?: List<string>,
    type?: number,
    callOnDestroy?: boolean,
    callOnChange?: boolean,
    callOnCheck?: boolean,
    callOnInit?: boolean,
    callOnAllChangesDone?: boolean,
    changeDetection?: string,
    exportAs?: string
  }) {
    let hostConfig = DirectiveMetadata.parseHostConfig(host);

    return new DirectiveMetadata({
      id: id,
      selector: selector,
      compileChildren: compileChildren,
      events: events,
      hostListeners: StringMapWrapper.get(hostConfig, 'hostListeners'),
      hostProperties: StringMapWrapper.get(hostConfig, 'hostProperties'),
      hostAttributes: StringMapWrapper.get(hostConfig, 'hostAttributes'),
      hostActions: StringMapWrapper.get(hostConfig, 'hostActions'),
      properties: properties,
      readAttributes: readAttributes,
      type: type,
      callOnDestroy: callOnDestroy,
      callOnChange: callOnChange,
      callOnCheck: callOnCheck,
      callOnInit: callOnInit,
      callOnAllChangesDone: callOnAllChangesDone,
      changeDetection: changeDetection,
      exportAs: exportAs
    });
  }