TypeScript ListWrapper.removeAt方法代码示例

      it('should handle incremental swapping element', () => {
        let l = ['a', 'b', 'c'];
        differ.check(l);

        ListWrapper.removeAt(l, 1);
        ListWrapper.insert(l, 0, 'b');
        differ.check(l);
        expect(differ.toString())
            .toEqual(iterableChangesAsString({
              collection: ['b[1->0]', 'a[0->1]', 'c'],
              previous: ['a[0->1]', 'b[1->0]', 'c'],
              moves: ['b[1->0]', 'a[0->1]']
            }));

        ListWrapper.removeAt(l, 1);
        l.push('a');
        differ.check(l);
        expect(differ.toString())
            .toEqual(iterableChangesAsString({
              collection: ['b', 'c[2->1]', 'a[1->2]'],
              previous: ['b', 'a[1->2]', 'c[2->1]'],
              moves: ['c[2->1]', 'a[1->2]']
            }));
      });

 _bindDirectiveProperty(dirProperty, bindConfig, compileElement, directiveBinder) {
   var pipes = this._splitBindConfig(bindConfig);
   var elProp = ListWrapper.removeAt(pipes, 0);
   var bindingAst = MapWrapper.get(compileElement.bindElement().propertyBindings, dashCaseToCamelCase(elProp));
   if (isBlank(bindingAst)) {
     var attributeValue = MapWrapper.get(compileElement.attrs(), camelCaseToDashCase(elProp));
     if (isPresent(attributeValue)) {
       bindingAst = this._parser.wrapLiteralPrimitive(attributeValue, compileElement.elementDescription);
     }
   }
   if (isPresent(bindingAst)) {
     var fullExpAstWithBindPipes = this._parser.addPipes(bindingAst, pipes);
     directiveBinder.bindProperty(dirProperty, fullExpAstWithBindPipes);
   }
 }

      it('should detect changes in list', () => {
        let l = [];
        differ.check(l);

        l.push('a');
        differ.check(l);
        expect(differ.toString()).toEqual(iterableChangesAsString({
          collection: ['a[null->0]'],
          additions: ['a[null->0]']
        }));

        l.push('b');
        differ.check(l);
        expect(differ.toString())
            .toEqual(iterableChangesAsString(
                {collection: ['a', 'b[null->1]'], previous: ['a'], additions: ['b[null->1]']}));

        l.push('c');
        l.push('d');
        differ.check(l);
        expect(differ.toString()).toEqual(iterableChangesAsString({
          collection: ['a', 'b', 'c[null->2]', 'd[null->3]'],
          previous: ['a', 'b'],
          additions: ['c[null->2]', 'd[null->3]']
        }));

        ListWrapper.removeAt(l, 2);
        differ.check(l);
        expect(differ.toString()).toEqual(iterableChangesAsString({
          collection: ['a', 'b', 'd[3->2]'],
          previous: ['a', 'b', 'c[2->null]', 'd[3->2]'],
          moves: ['d[3->2]'],
          removals: ['c[2->null]']
        }));

        ListWrapper.clear(l);
        l.push('d');
        l.push('c');
        l.push('b');
        l.push('a');
        differ.check(l);
        expect(differ.toString()).toEqual(iterableChangesAsString({
          collection: ['d[2->0]', 'c[null->1]', 'b[1->2]', 'a[0->3]'],
          previous: ['a[0->3]', 'b[1->2]', 'd[2->0]'],
          additions: ['c[null->1]'],
          moves: ['d[2->0]', 'b[1->2]', 'a[0->3]']
        }));
      });

 detach(atIndex = -1) {
   if (atIndex == -1)
     atIndex = this._views.length - 1;
   var detachedView = this.get(atIndex);
   ListWrapper.removeAt(this._views, atIndex);
   if (isBlank(this._lightDom)) {
     ViewContainer.removeViewNodes(detachedView);
   } else {
     this._lightDom.redistribute();
   }
   if (isPresent(this.hostLightDom)) {
     this.hostLightDom.redistribute();
   }
   detachedView.changeDetector.remove();
   this._unlinkElementInjectors(detachedView);
   return detachedView;
 }

 mergeChildComponentProtoViews(protoViews, target) {
   var nestedProtoView;
   if (isPresent(this.componentId)) {
     nestedProtoView = ListWrapper.removeAt(protoViews, 0);
   } else if (isPresent(this.nestedProtoView)) {
     nestedProtoView = this.nestedProtoView.mergeChildComponentProtoViews(protoViews, target);
   }
   return new ElementBinder({
     parentIndex: this.parentIndex,
     textNodeIndices: this.textNodeIndices,
     contentTagSelector: this.contentTagSelector,
     nestedProtoView: nestedProtoView,
     componentId: this.componentId,
     eventLocals: this.eventLocals,
     eventNames: this.eventNames,
     distanceToParent: this.distanceToParent,
     propertySetters: this.propertySetters
   });
 }

 it('should remove and add same item', () => {
   l = ['a', 'b', 'c'];
   changes.check(l);
   ListWrapper.removeAt(l, 1);
   changes.check(l);
   expect(changes.toString()).toEqual(iterableChangesAsString({
     collection: ['a', 'c[2->1]'],
     previous: ['a', 'b[1->null]', 'c[2->1]'],
     moves: ['c[2->1]'],
     removals: ['b[1->null]']
   }));
   ListWrapper.insert(l, 1, 'b');
   changes.check(l);
   expect(changes.toString()).toEqual(iterableChangesAsString({
     collection: ['a', 'b[null->1]', 'c[1->2]'],
     previous: ['a', 'c[1->2]'],
     additions: ['b[null->1]'],
     moves: ['c[1->2]']
   }));
 });

  _bindDirectiveProperty(bindConfig: string, compileElement: CompileElement,
                         directiveBinderBuilder: DirectiveBuilder) {
    // Name of the property on the directive
    let dirProperty: string;
    // Name of the property on the element
    let elProp: string;
    let pipes: List<string>;
    let assignIndex: number = bindConfig.indexOf(':');

    if (assignIndex > -1) {
      // canonical syntax: `dirProp: elProp | pipe0 | ... | pipeN`
      dirProperty = StringWrapper.substring(bindConfig, 0, assignIndex).trim();
      pipes = this._splitBindConfig(StringWrapper.substring(bindConfig, assignIndex + 1));
      elProp = ListWrapper.removeAt(pipes, 0);
    } else {
      // shorthand syntax when the name of the property on the directive and on the element is the
      // same, ie `property`
      dirProperty = bindConfig;
      elProp = bindConfig;
      pipes = [];
    }

    var bindingAst =
        MapWrapper.get(compileElement.bindElement().propertyBindings, dashCaseToCamelCase(elProp));

    if (isBlank(bindingAst)) {
      var attributeValue = MapWrapper.get(compileElement.attrs(), camelCaseToDashCase(elProp));
      if (isPresent(attributeValue)) {
        bindingAst =
            this._parser.wrapLiteralPrimitive(attributeValue, compileElement.elementDescription);
      }
    }

    // Bindings are optional, so this binding only needs to be set up if an expression is given.
    if (isPresent(bindingAst)) {
      var fullExpAstWithBindPipes = this._parser.addPipes(bindingAst, pipes);
      directiveBinderBuilder.bindProperty(dirProperty, fullExpAstWithBindPipes);
    }
  }

  _bindDirectiveProperty(dirProperty: string, bindConfig: string, compileElement: CompileElement,
                         directiveBinderBuilder: DirectiveBuilder) {
    var pipes = this._splitBindConfig(bindConfig);
    var elProp = ListWrapper.removeAt(pipes, 0);

    var bindingAst =
        MapWrapper.get(compileElement.bindElement().propertyBindings, dashCaseToCamelCase(elProp));

    if (isBlank(bindingAst)) {
      var attributeValue = MapWrapper.get(compileElement.attrs(), camelCaseToDashCase(elProp));
      if (isPresent(attributeValue)) {
        bindingAst =
            this._parser.wrapLiteralPrimitive(attributeValue, compileElement.elementDescription);
      }
    }

    // Bindings are optional, so this binding only needs to be set up if an expression is given.
    if (isPresent(bindingAst)) {
      var fullExpAstWithBindPipes = this._parser.addPipes(bindingAst, pipes);
      directiveBinderBuilder.bindProperty(dirProperty, fullExpAstWithBindPipes);
    }
  }

/**
  * Removes dot segments in given path component, as described in
  * RFC 3986, section 5.2.4.
  *
  * @param {string} path A non-empty path component.
  * @return {string} Path component with removed dot segments.
  */
function _removeDotSegments(path: string): string {
  if (path == '/') return '/';

  var leadingSlash = path[0] == '/' ? '/' : '';
  var trailingSlash = path[path.length - 1] === '/' ? '/' : '';
  var segments = path.split('/');

  var out = [];
  var up = 0;
  for (var pos = 0; pos < segments.length; pos++) {
    var segment = segments[pos];
    switch (segment) {
      case '':
      case '.':
        break;
      case '..':
        if (out.length > 0) {
          ListWrapper.removeAt(out, out.length - 1);
        } else {
          up++;
        }
        break;
      default:
        out.push(segment);
    }
  }

  if (leadingSlash == '') {
    while (up-- > 0) {
      ListWrapper.insert(out, 0, '..');
    }

    if (out.length === 0) out.push('.');
  }

  return leadingSlash + out.join('/') + trailingSlash;
}

 createProtoView(componentAnnotation, renderProtoView, directives) {
   ListWrapper.push(this.requests, [componentAnnotation, renderProtoView, directives]);
   return ListWrapper.removeAt(this._results, 0);
 }