react-grid-layout 1.5.2 → 2.0.0

package/build/components/WidthProvider.js

@@ -1,111 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = WidthProvideRGL;
-var React = _interopRequireWildcard(require("react"));
-var _propTypes = _interopRequireDefault(require("prop-types"));
-var _resizeObserverPolyfill = _interopRequireDefault(require("resize-observer-polyfill"));
-var _clsx = _interopRequireDefault(require("clsx"));
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-function _extends() { return _extends = Object.assign ? Object.assign.bind() : function (n) { for (var e = 1; e < arguments.length; e++) { var t = arguments[e]; for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]); } return n; }, _extends.apply(null, arguments); }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/*:: import type { ReactRef } from "../ReactGridLayoutPropTypes";*/
-/*:: type WPDefaultProps = {|
-  measureBeforeMount: boolean
-|};*/
-/*:: type WPProps = {|
-  className?: string,
-  style?: Object,
-  ...WPDefaultProps
-|};*/
-// eslint-disable-next-line no-unused-vars
-/*:: type WPState = {|
-  width: number
-|};*/
-/*:: type ComposedProps<Config> = {|
-  ...Config,
-  measureBeforeMount?: boolean,
-  className?: string,
-  style?: Object,
-  width?: number
-|};*/
-const layoutClassName = "react-grid-layout";
-
-/*
- * A simple HOC that provides facility for listening to container resizes.
- *
- * The Flow type is pretty janky here. I can't just spread `WPProps` into this returned object - I wish I could - but it triggers
- * a flow bug of some sort that causes it to stop typechecking.
- */
-function WidthProvideRGL /*:: <Config>*/(ComposedComponent /*: React.AbstractComponent<Config>*/) /*: React.AbstractComponent<ComposedProps<Config>>*/{
-  var _WidthProvider;
-  return _WidthProvider = class WidthProvider extends React.Component
-  /*:: <
-      ComposedProps<Config>,
-      WPState
-    >*/
-  {
-    constructor() {
-      super(...arguments);
-      _defineProperty(this, "state", {
-        width: 1280
-      });
-      _defineProperty(this, "elementRef", /*#__PURE__*/React.createRef());
-      _defineProperty(this, "mounted", false);
-      _defineProperty(this, "resizeObserver", void 0);
-    }
-    componentDidMount() {
-      this.mounted = true;
-      this.resizeObserver = new _resizeObserverPolyfill.default(entries => {
-        const node = this.elementRef.current;
-        if (node instanceof HTMLElement) {
-          const width = entries[0].contentRect.width;
-          this.setState({
-            width
-          });
-        }
-      });
-      const node = this.elementRef.current;
-      if (node instanceof HTMLElement) {
-        this.resizeObserver.observe(node);
-      }
-    }
-    componentWillUnmount() {
-      this.mounted = false;
-      const node = this.elementRef.current;
-      if (node instanceof HTMLElement) {
-        this.resizeObserver.unobserve(node);
-      }
-      this.resizeObserver.disconnect();
-    }
-    render() {
-      const {
-        measureBeforeMount,
-        ...rest
-      } = this.props;
-      if (measureBeforeMount && !this.mounted) {
-        return /*#__PURE__*/React.createElement("div", {
-          className: (0, _clsx.default)(this.props.className, layoutClassName),
-          style: this.props.style
-          // $FlowIgnore ref types
-          ,
-          ref: this.elementRef
-        });
-      }
-      return /*#__PURE__*/React.createElement(ComposedComponent, _extends({
-        innerRef: this.elementRef
-      }, rest, this.state));
-    }
-  }, _defineProperty(_WidthProvider, "defaultProps", {
-    measureBeforeMount: false
-  }), _defineProperty(_WidthProvider, "propTypes", {
-    // If true, will not render children until mounted. Useful for getting the exact width before
-    // rendering, to prevent any unsightly resizing.
-    measureBeforeMount: _propTypes.default.bool
-  }), _WidthProvider;
-}

package/build/fastRGLPropsEqual.js

@@ -1,5 +0,0 @@
-// this file was prevaled
-module.exports = function fastRGLPropsEqual(a, b, isEqualImpl) {
-  if (a === b) return true;
-  return a.className === b.className && isEqualImpl(a.style, b.style) && a.width === b.width && a.autoSize === b.autoSize && a.cols === b.cols && a.draggableCancel === b.draggableCancel && a.draggableHandle === b.draggableHandle && isEqualImpl(a.verticalCompact, b.verticalCompact) && isEqualImpl(a.compactType, b.compactType) && isEqualImpl(a.layout, b.layout) && isEqualImpl(a.margin, b.margin) && isEqualImpl(a.containerPadding, b.containerPadding) && a.rowHeight === b.rowHeight && a.maxRows === b.maxRows && a.isBounded === b.isBounded && a.isDraggable === b.isDraggable && a.isResizable === b.isResizable && a.allowOverlap === b.allowOverlap && a.preventCollision === b.preventCollision && a.useCSSTransforms === b.useCSSTransforms && a.transformScale === b.transformScale && a.isDroppable === b.isDroppable && isEqualImpl(a.resizeHandles, b.resizeHandles) && isEqualImpl(a.resizeHandle, b.resizeHandle) && a.onLayoutChange === b.onLayoutChange && a.onDragStart === b.onDragStart && a.onDrag === b.onDrag && a.onDragStop === b.onDragStop && a.onResizeStart === b.onResizeStart && a.onResize === b.onResize && a.onResizeStop === b.onResizeStop && a.onDrop === b.onDrop && isEqualImpl(a.droppingItem, b.droppingItem) && isEqualImpl(a.innerRef, b.innerRef);
-};

package/build/responsiveUtils.js

@@ -1,101 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.findOrGenerateResponsiveLayout = findOrGenerateResponsiveLayout;
-exports.getBreakpointFromWidth = getBreakpointFromWidth;
-exports.getColsFromBreakpoint = getColsFromBreakpoint;
-exports.sortBreakpoints = sortBreakpoints;
-var _utils = require("./utils");
-/*:: import type { CompactType, Layout } from "./utils";*/
-/*:: export type Breakpoint = string;*/
-/*:: export type DefaultBreakpoints = "lg" | "md" | "sm" | "xs" | "xxs";*/
-/*:: export type ResponsiveLayout<T: Breakpoint> = {
-  +[breakpoint: T]: Layout
-};*/
-// + indicates read-only
-/*:: export type Breakpoints<T: Breakpoint> = {
-  +[breakpoint: T]: number
-};*/
-/*:: export type OnLayoutChangeCallback = (
-  Layout,
-  { [key: Breakpoint]: Layout }
-) => void;*/
-/**
- * Given a width, find the highest breakpoint that matches is valid for it (width > breakpoint).
- *
- * @param  {Object} breakpoints Breakpoints object (e.g. {lg: 1200, md: 960, ...})
- * @param  {Number} width Screen width.
- * @return {String}       Highest breakpoint that is less than width.
- */
-function getBreakpointFromWidth(breakpoints /*: Breakpoints<Breakpoint>*/, width /*: number*/) /*: Breakpoint*/{
-  const sorted = sortBreakpoints(breakpoints);
-  let matching = sorted[0];
-  for (let i = 1, len = sorted.length; i < len; i++) {
-    const breakpointName = sorted[i];
-    if (width > breakpoints[breakpointName]) matching = breakpointName;
-  }
-  return matching;
-}
-
-/**
- * Given a breakpoint, get the # of cols set for it.
- * @param  {String} breakpoint Breakpoint name.
- * @param  {Object} cols       Map of breakpoints to cols.
- * @return {Number}            Number of cols.
- */
-function getColsFromBreakpoint(breakpoint /*: Breakpoint*/, cols /*: Breakpoints<Breakpoint>*/) /*: number*/{
-  if (!cols[breakpoint]) {
-    throw new Error("ResponsiveReactGridLayout: `cols` entry for breakpoint " + breakpoint + " is missing!");
-  }
-  return cols[breakpoint];
-}
-
-/**
- * Given existing layouts and a new breakpoint, find or generate a new layout.
- *
- * This finds the layout above the new one and generates from it, if it exists.
- *
- * @param  {Object} layouts     Existing layouts.
- * @param  {Array} breakpoints All breakpoints.
- * @param  {String} breakpoint New breakpoint.
- * @param  {String} breakpoint Last breakpoint (for fallback).
- * @param  {Number} cols       Column count at new breakpoint.
- * @param  {Boolean} verticalCompact Whether or not to compact the layout
- *   vertically.
- * @return {Array}             New layout.
- */
-function findOrGenerateResponsiveLayout(layouts /*: ResponsiveLayout<Breakpoint>*/, breakpoints /*: Breakpoints<Breakpoint>*/, breakpoint /*: Breakpoint*/, lastBreakpoint /*: Breakpoint*/, cols /*: number*/, compactType /*: CompactType*/) /*: Layout*/{
-  // If it already exists, just return it.
-  if (layouts[breakpoint]) return (0, _utils.cloneLayout)(layouts[breakpoint]);
-  // Find or generate the next layout
-  let layout = layouts[lastBreakpoint];
-  const breakpointsSorted = sortBreakpoints(breakpoints);
-  const breakpointsAbove = breakpointsSorted.slice(breakpointsSorted.indexOf(breakpoint));
-  for (let i = 0, len = breakpointsAbove.length; i < len; i++) {
-    const b = breakpointsAbove[i];
-    if (layouts[b]) {
-      layout = layouts[b];
-      break;
-    }
-  }
-  layout = (0, _utils.cloneLayout)(layout || []); // clone layout so we don't modify existing items
-  return (0, _utils.compact)((0, _utils.correctBounds)(layout, {
-    cols: cols
-  }), compactType, cols);
-}
-
-/**
- * Given breakpoints, return an array of breakpoints sorted by width. This is usually
- * e.g. ['xxs', 'xs', 'sm', ...]
- *
- * @param  {Object} breakpoints Key/value pair of breakpoint names to widths.
- * @return {Array}              Sorted breakpoints.
- */
-function sortBreakpoints(breakpoints /*: Breakpoints<Breakpoint>*/) /*: Array<Breakpoint>*/{
-  const keys /*: Array<string>*/ = Object.keys(breakpoints);
-  return keys.sort(function (a, b) {
-    return breakpoints[a] - breakpoints[b];
-  });
-}