vscroll/dist/esm5/classes/paddings.js

Virtual scroll engine

import { Direction } from '../inputs/index';
var Padding = /** @class */ (function () {
  function Padding(direction, routines) {
    var found = routines.findPaddingElement(direction);
    routines.checkElement(found);
    this.element = found;
    this.direction = direction;
    this.routines = routines;
  }
  Padding.prototype.reset = function (size) {
    this.size = size || 0;
  };
  Object.defineProperty(Padding.prototype, "size", {
    get: function () {
      return this.routines.getSizeStyle(this.element);
    },
    set: function (value) {
      this.routines.setSizeStyle(this.element, value);
    },
    enumerable: false,
    configurable: true
  });
  return Padding;
}());
export { Padding };
var Paddings = /** @class */ (function () {
  function Paddings(routines, settings) {
    this.settings = settings;
    this.forward = new Padding(Direction.forward, routines);
    this.backward = new Padding(Direction.backward, routines);
  }
  Paddings.prototype.byDirection = function (direction, opposite) {
    return direction === Direction.backward
      ? (opposite ? this.forward : this.backward)
      : (opposite ? this.backward : this.forward);
  };
  Paddings.prototype.reset = function (viewportSize, startIndex, offset) {
    var positive = this.getPositiveSize(startIndex, viewportSize, offset);
    var negative = this.getNegativeSize(startIndex);
    if (this.settings.inverse) {
      this.forward.reset(negative);
      this.backward.reset(positive);
      var diff = viewportSize - this.backward.size - offset;
      if (diff > 0) {
        this.backward.size += diff;
        this.forward.size -= diff;
      }
    }
    else {
      this.forward.reset(positive);
      this.backward.reset(negative);
      var diff = viewportSize - this.forward.size - offset;
      if (diff > 0) {
        this.backward.size -= diff;
        this.forward.size += diff;
      }
    }
  };
  Paddings.prototype.getPositiveSize = function (startIndex, viewportSize, offset) {
    var settings = this.settings;
    var positiveSize = viewportSize;
    if (isFinite(settings.maxIndex)) {
      positiveSize = (settings.maxIndex - startIndex + 1) * settings.itemSize;
    }
    if (offset) {
      positiveSize = Math.max(positiveSize - offset, 0);
    }
    return positiveSize;
  };
  Paddings.prototype.getNegativeSize = function (startIndex) {
    var settings = this.settings;
    var negativeSize = 0;
    if (isFinite(settings.minIndex)) {
      negativeSize = (startIndex - settings.minIndex) * settings.itemSize;
    }
    return negativeSize;
  };
  return Paddings;
}());
export { Paddings };
//# sourceMappingURL=paddings.js.map