react-grid-layout 0.17.1 → 0.18.3

package/build/utils.js

@@ -7,6 +7,7 @@ exports.bottom = bottom;
 exports.cloneLayout = cloneLayout;
 exports.cloneLayoutItem = cloneLayoutItem;
 exports.childrenEqual = childrenEqual;
+exports.fastPositionEqual = fastPositionEqual;
 exports.collides = collides;
 exports.compact = compact;
 exports.compactItem = compactItem;
@@ -25,8 +26,9 @@ exports.sortLayoutItemsByRowCol = sortLayoutItemsByRowCol;
 exports.sortLayoutItemsByColRow = sortLayoutItemsByColRow;
 exports.synchronizeLayoutWithChildren = synchronizeLayoutWithChildren;
 exports.validateLayout = validateLayout;
+exports.compactType = compactType;
 exports.autoBindHandlers = autoBindHandlers;
-exports.noop = void 0;
+exports.noop = exports.fastRGLPropsEqual = void 0;
 
 var _lodash = _interopRequireDefault(require("lodash.isequal"));
 
@@ -36,7 +38,7 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(source, true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(source).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
@@ -121,6 +123,32 @@ function childrenEqual(a
     return c.key;
   }));
 }
+/**
+ * See `fastRGLPropsEqual.js`.
+ * We want this to run as fast as possible - it is called often - and to be
+ * resilient to new props that we add. So rather than call lodash.isEqual,
+ * which isn't suited to comparing props very well, we use this specialized
+ * function in conjunction with preval to generate the fastest possible comparison
+ * function, tuned for exactly our props.
+ */
+
+/*:: type FastRGLPropsEqual = (Object, Object, Function) => boolean;*/
+
+
+var fastRGLPropsEqual
+/*: FastRGLPropsEqual*/
+= require("./fastRGLPropsEqual"); // Like the above, but a lot simpler.
+
+
+exports.fastRGLPropsEqual = fastRGLPropsEqual;
+
+function fastPositionEqual(a
+/*: Position*/
+, b
+/*: Position*/
+) {
+  return a.left === b.left && a.top === b.top && a.width === b.width && a.height === b.height;
+}
 /**
  * Given two layoutitems, check if they collide.
  */
@@ -149,6 +177,8 @@ function collides(l1
  * Given a layout, compact it. This involves going down each y coordinate and removing gaps
  * between items.
  *
+ * Does not modify layout items (clones). Creates a new layout array.
+ *
  * @param  {Array} layout Layout.
  * @param  {Boolean} verticalCompact Whether or not to compact the layout
  *   vertically.
@@ -231,6 +261,9 @@ function resolveCompactionCollision(layout
 }
 /**
  * Compact an item in the layout.
+ *
+ * Modifies item.
+ *
  */
 
 
@@ -289,6 +322,8 @@ function compactItem(compareWith
 /**
  * Given a layout, make sure all elements fit within its bounds.
  *
+ * Modifies layout items.
+ *
  * @param  {Array} layout Layout array.
  * @param  {Number} bounds Number of columns.
  */
@@ -396,6 +431,8 @@ function getStatics(layout
 /**
  * Move an element. Responsible for doing cascading movements of other elements.
  *
+ * Modifies layout items.
+ *
  * @param  {Array}      layout            Full layout to modify.
  * @param  {LayoutItem} l                 element to move.
  * @param  {Number}     [x]               X position in grid units.
@@ -422,7 +459,9 @@ function moveElement(layout
 )
 /*: Layout*/
 {
-  if (l.static) return layout; // Short-circuit if nothing to do.
+  // If this is static and not explicitly enabled as draggable,
+  // no move is possible, so we can short-circuit this immediately.
+  if (l.static && l.isDraggable !== true) return layout; // Short-circuit if nothing to do.
 
   if (l.y === y && l.x === x) return layout;
   log("Moving element ".concat(l.i, " to [").concat(String(x), ",").concat(String(y), "] from [").concat(l.x, ",").concat(l.y, "]"));
@@ -437,7 +476,8 @@ function moveElement(layout
   // nearest collision.
 
   var sorted = sortLayoutItems(layout, compactType);
-  var movingUp = compactType === "vertical" && typeof y === "number" ? oldY >= y : compactType === "horizontal" && typeof x === "number" ? oldX >= x : false;
+  var movingUp = compactType === "vertical" && typeof y === "number" ? oldY >= y : compactType === "horizontal" && typeof x === "number" ? oldX >= x : false; // $FlowIgnore acceptable modification of read-only array as it was recently cloned
+
   if (movingUp) sorted = sorted.reverse();
   var collisions = getAllCollisions(sorted, l); // There was a collision; abort
 
@@ -589,13 +629,20 @@ function sortLayoutItems(layout
 {
   if (compactType === "horizontal") return sortLayoutItemsByColRow(layout);else return sortLayoutItemsByRowCol(layout);
 }
+/**
+ * Sort layout items by row ascending and column ascending.
+ *
+ * Does not modify Layout.
+ */
+
 
 function sortLayoutItemsByRowCol(layout
 /*: Layout*/
 )
 /*: Layout*/
 {
-  return [].concat(layout).sort(function (a, b) {
+  // Slice to clone array as sort modifies
+  return layout.slice(0).sort(function (a, b) {
     if (a.y > b.y || a.y === b.y && a.x > b.x) {
       return 1;
     } else if (a.y === b.y && a.x === b.x) {
@@ -606,13 +653,19 @@ function sortLayoutItemsByRowCol(layout
     return -1;
   });
 }
+/**
+ * Sort layout items by column ascending then row ascending.
+ *
+ * Does not modify Layout.
+ */
+
 
 function sortLayoutItemsByColRow(layout
 /*: Layout*/
 )
 /*: Layout*/
 {
-  return [].concat(layout).sort(function (a, b) {
+  return layout.slice(0).sort(function (a, b) {
     if (a.x > b.x || a.x === b.x && a.y > b.y) {
       return 1;
     }
@@ -624,6 +677,8 @@ function sortLayoutItemsByColRow(layout
  * Generate a layout using the initialLayout and children as a template.
  * Missing entries will be added, extraneous ones will be truncated.
  *
+ * Does not modify initialLayout.
+ *
  * @param  {Array}  initialLayout Layout passed in through props.
  * @param  {String} breakpoint    Current responsive breakpoint.
  * @param  {?String} compact      Compaction option.
@@ -645,7 +700,7 @@ function synchronizeLayoutWithChildren(initialLayout
   initialLayout = initialLayout || []; // Generate one layout item per child.
 
   var layout
-  /*: Layout*/
+  /*: LayoutItem[]*/
   = [];
 
   _react.default.Children.forEach(children, function (child
@@ -688,11 +743,10 @@ function synchronizeLayoutWithChildren(initialLayout
   }); // Correct the layout.
 
 
-  layout = correctBounds(layout, {
+  var correctedLayout = correctBounds(layout, {
     cols: cols
   });
-  layout = compact(layout, compactType, cols);
-  return layout;
+  return compact(correctedLayout, compactType, cols);
 }
 /**
  * Validate a layout. Throws errors.
@@ -731,6 +785,19 @@ function validateLayout(layout
       throw new Error("ReactGridLayout: " + contextName + "[" + i + "].static must be a boolean!");
     }
   }
+} // Legacy support for verticalCompact: false
+
+
+function compactType(props
+/*: ?{ verticalCompact: boolean, compactType: CompactType }*/
+)
+/*: CompactType*/
+{
+  var _ref3 = props || {},
+      verticalCompact = _ref3.verticalCompact,
+      compactType = _ref3.compactType;
+
+  return verticalCompact === false ? null : compactType;
 } // Flow can't really figure this out, so we just use Object
 
 

package/css/styles.css

@@ -55,3 +55,7 @@
   border-right: 2px solid rgba(0, 0, 0, 0.4);
   border-bottom: 2px solid rgba(0, 0, 0, 0.4);
 }
+
+.react-resizable-hide > .react-resizable-handle {
+  display: none;
+}

package/flow-typed/npm/classnames_v2.x.x.js

@@ -0,0 +1,23 @@
+// flow-typed signature: a00cf41b09af4862583460529d5cfcb9
+// flow-typed version: c6154227d1/classnames_v2.x.x/flow_>=v0.104.x
+
+type $npm$classnames$Classes =
+  | string
+  | { [className: string]: *, ... }
+  | false
+  | void
+  | null;
+
+declare module "classnames" {
+  declare module.exports: (
+    ...classes: Array<$npm$classnames$Classes | $npm$classnames$Classes[]>
+  ) => string;
+}
+
+declare module "classnames/bind" {
+  declare module.exports: $Exports<"classnames">;
+}
+
+declare module "classnames/dedupe" {
+  declare module.exports: $Exports<"classnames">;
+}

package/flow-typed/npm/enzyme_v3.x.x.js

@@ -0,0 +1,143 @@
+// flow-typed signature: 931d5482afcb022bcbddb841fd08d683
+// flow-typed version: 5175c53189/enzyme_v3.x.x/flow_>=v0.104.x
+
+declare module "enzyme" {
+  declare type PredicateFunction<T: Wrapper<*>> = (
+    wrapper: T,
+    index: number
+  ) => boolean;
+  declare type UntypedSelector = string | { [key: string]: number|string|boolean, ... };
+  declare type EnzymeSelector = UntypedSelector | React$ElementType;
+
+  // CheerioWrapper is a type alias for an actual cheerio instance
+  // TODO: Reference correct type from cheerio's type declarations
+  declare type CheerioWrapper = any;
+
+  declare class Wrapper<RootComponent> {
+    equals(node: React$Element<any>): boolean,
+    find(selector: UntypedSelector): this,
+    find<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    findWhere(predicate: PredicateFunction<this>): this,
+    filter(selector: UntypedSelector): this,
+    filter<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    filterWhere(predicate: PredicateFunction<this>): this,
+    hostNodes(): this,
+    contains(nodes: React$Node): boolean,
+    containsMatchingElement(node: React$Node): boolean,
+    containsAllMatchingElements(nodes: React$Node): boolean,
+    containsAnyMatchingElements(nodes: React$Node): boolean,
+    dive(option?: { context?: Object, ... }): this,
+    exists(selector?: EnzymeSelector): boolean,
+    isEmptyRender(): boolean,
+    matchesElement(node: React$Node): boolean,
+    hasClass(className: string): boolean,
+    is(selector: EnzymeSelector): boolean,
+    isEmpty(): boolean,
+    not(selector: EnzymeSelector): this,
+    children(selector?: UntypedSelector): this,
+    children<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    childAt(index: number): this,
+    parents(selector?: UntypedSelector): this,
+    parents<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    parent(): this,
+    closest(selector: UntypedSelector): this,
+    closest<T: React$ElementType>(selector: T): ReactWrapper<T>,
+    render(): CheerioWrapper,
+    renderProp(propName: string): (...args: Array<any>) => this,
+    unmount(): this,
+    text(): string,
+    html(): string,
+    invoke(propName: string): (...args: $ReadOnlyArray<any>) => mixed,
+    get(index: number): React$Node,
+    getDOMNode(): HTMLElement | HTMLInputElement,
+    at(index: number): this,
+    first(): this,
+    last(): this,
+    state(key?: string): any,
+    context(key?: string): any,
+    props(): Object,
+    prop(key: string): any,
+    key(): string,
+    simulate(event: string, ...args: Array<any>): this,
+    simulateError(error: Error): this,
+    slice(begin?: number, end?: number): this,
+    setState(state: {...}, callback?: () => void): this,
+    setProps(props: {...}, callback?: () => void): this,
+    setContext(context: Object): this,
+    instance(): React$ElementRef<RootComponent>,
+    update(): this,
+    debug(options?: Object): string,
+    type(): string | Function | null,
+    name(): string,
+    forEach(fn: (node: this, index: number) => mixed): this,
+    map<T>(fn: (node: this, index: number) => T): Array<T>,
+    reduce<T>(
+      fn: (value: T, node: this, index: number) => T,
+      initialValue?: T
+    ): Array<T>,
+    reduceRight<T>(
+      fn: (value: T, node: this, index: number) => T,
+      initialValue?: T
+    ): Array<T>,
+    some(selector: EnzymeSelector): boolean,
+    someWhere(predicate: PredicateFunction<this>): boolean,
+    every(selector: EnzymeSelector): boolean,
+    everyWhere(predicate: PredicateFunction<this>): boolean,
+    length: number
+  }
+
+  declare class ReactWrapper<T> extends Wrapper<T> {
+    constructor(nodes: React$Element<T>, root: any, options?: ?Object): ReactWrapper<T>,
+    mount(): this,
+    ref(refName: string): this,
+    detach(): void
+  }
+
+  declare class ShallowWrapper<T> extends Wrapper<T> {
+    constructor(
+      nodes: React$Element<T>,
+      root: any,
+      options?: ?Object
+    ): ShallowWrapper<T>,
+    equals(node: React$Node): boolean,
+    shallow(options?: { context?: Object, ... }): ShallowWrapper<T>,
+    getElement(): React$Node,
+    getElements(): Array<React$Node>
+  }
+
+  declare function shallow<T>(
+    node: React$Element<T>,
+    options?: {
+      context?: Object,
+      disableLifecycleMethods?: boolean,
+      ...
+    }
+  ): ShallowWrapper<T>;
+  declare function mount<T>(
+    node: React$Element<T>,
+    options?: {
+      context?: Object,
+      attachTo?: HTMLElement,
+      childContextTypes?: Object,
+      ...
+    }
+  ): ReactWrapper<T>;
+  declare function render(
+    node: React$Node,
+    options?: { context?: Object, ... }
+  ): CheerioWrapper;
+
+  declare module.exports: {
+    configure(options: {
+      Adapter?: any,
+      disableLifecycleMethods?: boolean,
+      ...
+    }): void,
+    render: typeof render,
+    mount: typeof mount,
+    shallow: typeof shallow,
+    ShallowWrapper: typeof ShallowWrapper,
+    ReactWrapper: typeof ReactWrapper,
+    ...
+  };
+}