toolshed-8.x-1.x-dev/js/geom.js

"use strict";

/* eslint no-bitwise: ["error", { "allow": ["|"] }] */
(({
  Toolshed: ts
}) => {
  ts.Geom = {};

  /**
   * Defines a enumerations for different edges.
   *
   * @type {Object}
   */
  class Edges {
    static get TOP() {
      return 0x01;
    }
    static get BOTTOM() {
      return 0x02;
    }
    static get LEFT() {
      return 0x10;
    }
    static get RIGHT() {
      return 0x20;
    }
  }

  /**
   * Defines a directions enumerations or mask.
   *
   * @type {Object}
   */
  class Direction {
    static get VERTICAL() {
      return Edges.TOP | Edges.BOTTOM;
    }
    static get HORIZONTAL() {
      return Edges.LEFT | Edges.RIGHT;
    }
    static get ANY() {
      return Direction.HORIZONTAL | Direction.VERTICAL;
    }
  }

  /**
   * Coordinates to decribe a rectangular region in space.
   */
  class Rect {
    /**
     * Create a new Rect instance from the bounding area of a DOM element.
     *
     * @param {Element} el
     *   DOM element to create the Rectangle from.
     *
     * @return {Rect}
     *   A new Rect instance representing the bounding box of the element's
     *   client rectangular space.
     */
    static fromElement(el) {
      const b = el.getBoundingClientRect();
      return new Rect(b.left, b.top, b.right, b.bottom);
    }

    /**
     * @param {Toolshed.Rect|int} left
     *  Either a jQuery wrapper or Rect object to build the rectangle with.
     *  If just an integer, use this value as the left edge of the rectangle.
     * @param {int} top
     *  The coordinate of the top edge of the rectangle.
     * @param {int} right
     *  The coordinate of the right edge of the rectangle.
     * @param {int} bottom
     *  The coordinate of the bottom edge of the rectangle.
     */
    constructor(left, top, right, bottom) {
      if (left instanceof ts.Geom.Rect) {
        Object.assign(this, left);
      } else {
        if (top <= bottom) {
          this.top = top;
          this.bottom = bottom;
        } else {
          this.top = bottom;
          this.bottom = top;
        }
        if (left <= right) {
          this.left = left;
          this.right = right;
        } else {
          this.left = right;
          this.right = left;
        }
      }
    }

    /**
     * Get the a point indicating the top-left corner of the rectangle.
     *
     * @return {object}
     *   Object with a left and right property that present a point in space.
     */
    getPosition() {
      return {
        left: this.left,
        top: this.top
      };
    }

    /**
     * Get the width of the rectangle.
     *
     * @return {int}
     *   The width of the rectangular area.
     */
    getWidth() {
      return this.right - this.left;
    }

    /**
     * Get the height of the rectangle.
     *
     * @return {int}
     *   The height of the rectangular area.
     */
    getHeight() {
      return this.bottom - this.top;
    }

    /**
     * Check if a point in space is inside of the rectangle.
     *
     * @param {Object} pt
     *   An object with a left and top property to represent a point in space.
     *
     * @return {bool}
     *   If the point is inside of this rectangular area.
     */
    isInRect(pt) {
      const pos = this.getPosition();
      pt.left -= pos.left;
      pt.top -= pos.top;
      return pt.left >= 0 && pt.left <= this.getWidth() && pt.top >= 0 && pt.top <= this.getHeight();
    }

    /**
     * Get the volume / area represented by this rectangle.
     *
     * @return {int}
     *   The area represented by this rectangle.
     */
    getArea() {
      return this.getWidth() * this.getHeight();
    }

    /**
     * Offset the rectangle by a X and Y offset.
     *
     * @param {int} xOffset
     *   Number of units to move in the x axis. Can be negative.
     * @param {int} yOffset
     *   Number of units to move in the y axis. Can be negative.
     */
    offset(xOffset, yOffset) {
      this.top += yOffset;
      this.bottom += yOffset;
      this.left += xOffset;
      this.right += xOffset;
    }

    /**
     * Get a Rect object representing the intersection of the two rectangles.
     *
     * @param {Rect} rect
     *   The rectangle to find and intersection of.
     *
     * @return {Rect|null}
     *   The resulting intersection if there was one, otherwise NULL.
     */
    getIntersection(rect) {
      const o1 = rect.getPosition();
      const o2 = this.getPosition();
      const x = Math.max(o1.left, o2.left);
      const y = Math.max(o1.top, o2.top);
      const r = Math.min(o1.left + rect.getWidth(), o2.left + this.getWidth());
      const b = Math.min(o1.top + rect.getHeight(), o2.top + this.getHeight());

      // Check that this point is in the rectangle.
      return x > r || y > b ? null : new Rect(x, y, r, b);
    }

    /**
     * Test if a rectangle is completely inside this rectangle.
     *
     * @param {Rect} rect
     *   Rectangle to test if it was contained inside of.
     *
     * @return {bool}
     *   True IFF the rect parameter represents and area that is completely
     *   inside this Rect instance.
     */
    contains(rect) {
      return rect.left >= this.left && rect.right <= this.right && rect.top >= this.top && rect.bottom <= this.bottom;
    }
  }

  // Export the classes to the Toolshed namespace.
  ts.Geom.Edges = Edges;
  ts.Geom.Direction = Direction;
  ts.Geom.Rect = Rect;
})(Drupal);
//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"file":"geom.js","names":["Toolshed","ts","Geom","Edges","TOP","BOTTOM","LEFT","RIGHT","Direction","VERTICAL","HORIZONTAL","ANY","Rect","fromElement","el","b","getBoundingClientRect","left","top","right","bottom","constructor","Object","assign","getPosition","getWidth","getHeight","isInRect","pt","pos","getArea","offset","xOffset","yOffset","getIntersection","rect","o1","o2","x","Math","max","y","r","min","contains","Drupal"],"sources":["geom.es6.js"],"sourcesContent":["/* eslint no-bitwise: [\"error\", { \"allow\": [\"|\"] }] */\n(({ Toolshed: ts }) => {\n  ts.Geom = {};\n\n  /**\n   * Defines a enumerations for different edges.\n   *\n   * @type {Object}\n   */\n  class Edges {\n    static get TOP() {\n      return 0x01;\n    }\n\n    static get BOTTOM() {\n      return 0x02;\n    }\n\n    static get LEFT() {\n      return 0x10;\n    }\n\n    static get RIGHT() {\n      return 0x20;\n    }\n  }\n\n  /**\n   * Defines a directions enumerations or mask.\n   *\n   * @type {Object}\n   */\n  class Direction {\n    static get VERTICAL() {\n      return Edges.TOP | Edges.BOTTOM;\n    }\n\n    static get HORIZONTAL() {\n      return Edges.LEFT | Edges.RIGHT;\n    }\n\n    static get ANY() {\n      return Direction.HORIZONTAL | Direction.VERTICAL;\n    }\n  }\n\n  /**\n   * Coordinates to decribe a rectangular region in space.\n   */\n  class Rect {\n    /**\n     * Create a new Rect instance from the bounding area of a DOM element.\n     *\n     * @param {Element} el\n     *   DOM element to create the Rectangle from.\n     *\n     * @return {Rect}\n     *   A new Rect instance representing the bounding box of the element's\n     *   client rectangular space.\n     */\n    static fromElement(el) {\n      const b = el.getBoundingClientRect();\n      return new Rect(b.left, b.top, b.right, b.bottom);\n    }\n\n    /**\n     * @param {Toolshed.Rect|int} left\n     *  Either a jQuery wrapper or Rect object to build the rectangle with.\n     *  If just an integer, use this value as the left edge of the rectangle.\n     * @param {int} top\n     *  The coordinate of the top edge of the rectangle.\n     * @param {int} right\n     *  The coordinate of the right edge of the rectangle.\n     * @param {int} bottom\n     *  The coordinate of the bottom edge of the rectangle.\n     */\n    constructor(left, top, right, bottom) {\n      if (left instanceof ts.Geom.Rect) {\n        Object.assign(this, left);\n      }\n      else {\n        if (top <= bottom) {\n          this.top = top;\n          this.bottom = bottom;\n        }\n        else {\n          this.top = bottom;\n          this.bottom = top;\n        }\n\n        if (left <= right) {\n          this.left = left;\n          this.right = right;\n        }\n        else {\n          this.left = right;\n          this.right = left;\n        }\n      }\n    }\n\n    /**\n     * Get the a point indicating the top-left corner of the rectangle.\n     *\n     * @return {object}\n     *   Object with a left and right property that present a point in space.\n     */\n    getPosition() {\n      return { left: this.left, top: this.top };\n    }\n\n    /**\n     * Get the width of the rectangle.\n     *\n     * @return {int}\n     *   The width of the rectangular area.\n     */\n    getWidth() {\n      return this.right - this.left;\n    }\n\n    /**\n     * Get the height of the rectangle.\n     *\n     * @return {int}\n     *   The height of the rectangular area.\n     */\n    getHeight() {\n      return this.bottom - this.top;\n    }\n\n    /**\n     * Check if a point in space is inside of the rectangle.\n     *\n     * @param {Object} pt\n     *   An object with a left and top property to represent a point in space.\n     *\n     * @return {bool}\n     *   If the point is inside of this rectangular area.\n     */\n    isInRect(pt) {\n      const pos = this.getPosition();\n      pt.left -= pos.left;\n      pt.top -= pos.top;\n\n      return (pt.left >= 0 && pt.left <= this.getWidth())\n        && (pt.top >= 0 && pt.top <= this.getHeight());\n    }\n\n    /**\n     * Get the volume / area represented by this rectangle.\n     *\n     * @return {int}\n     *   The area represented by this rectangle.\n     */\n    getArea() {\n      return this.getWidth() * this.getHeight();\n    }\n\n    /**\n     * Offset the rectangle by a X and Y offset.\n     *\n     * @param {int} xOffset\n     *   Number of units to move in the x axis. Can be negative.\n     * @param {int} yOffset\n     *   Number of units to move in the y axis. Can be negative.\n     */\n    offset(xOffset, yOffset) {\n      this.top += yOffset;\n      this.bottom += yOffset;\n      this.left += xOffset;\n      this.right += xOffset;\n    }\n\n    /**\n     * Get a Rect object representing the intersection of the two rectangles.\n     *\n     * @param {Rect} rect\n     *   The rectangle to find and intersection of.\n     *\n     * @return {Rect|null}\n     *   The resulting intersection if there was one, otherwise NULL.\n     */\n    getIntersection(rect) {\n      const o1 = rect.getPosition();\n      const o2 = this.getPosition();\n\n      const x = Math.max(o1.left, o2.left);\n      const y = Math.max(o1.top, o2.top);\n      const r = Math.min(o1.left + rect.getWidth(), o2.left + this.getWidth());\n      const b = Math.min(o1.top + rect.getHeight(), o2.top + this.getHeight());\n\n      // Check that this point is in the rectangle.\n      return (x > r || y > b) ? null : new Rect(x, y, r, b);\n    }\n\n    /**\n     * Test if a rectangle is completely inside this rectangle.\n     *\n     * @param {Rect} rect\n     *   Rectangle to test if it was contained inside of.\n     *\n     * @return {bool}\n     *   True IFF the rect parameter represents and area that is completely\n     *   inside this Rect instance.\n     */\n    contains(rect) {\n      return rect.left >= this.left && rect.right <= this.right\n        && rect.top >= this.top && rect.bottom <= this.bottom;\n    }\n  }\n\n  // Export the classes to the Toolshed namespace.\n  ts.Geom.Edges = Edges;\n  ts.Geom.Direction = Direction;\n  ts.Geom.Rect = Rect;\n})(Drupal);\n"],"mappings":"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"}