let items = [

{x: 0, y: 0, w: 2, h: 2},

{x: 2, y: 5}

];

grids.forEach(function (grid, i) {

addEvents(grid, i);

**Table of Contents** *generated with [DocToc](http://doctoc.herokuapp.com/)*

- [10.2.1 (2024-06-23)](#1021-2024-06-23)

- [10.2.0 (2024-06-02)](#1020-2024-06-02)

- [10.1.2 (2024-03-30)](#1012-2024-03-30)

* fix: [#2683](https://github.com/gridstack/gridstack.js/issues/2683) check for fixed grid maxRow during resize

* fix: [#2694](https://github.com/gridstack/gridstack.js/issues/2694) prevent 'r' rotation to items that can't resize (locked, noResize, fixed sizes)

protected _prevFloat: boolean;

/** @internal cached layouts of difference column count so we can restore back (eg 12 -> 1 -> 12) */

protected _layouts?: GridStackNode[][]; // maps column # to array of values nodes

/** @internal true while we are resizing widgets during column resize to skip certain parts */

protected _inColumnResize?: boolean;

/** @internal true if we have some items locked */

// during while() collisions MAKE SURE to check entire row so larger items don't leap frog small ones (push them all down starting last in grid)

let area = nn;

area = {x: 0, w: this.column, y: nn.y, h: nn.h};

collide = this.collide(node, area, opt.skip); // force new hit

}

let newOpt: GridStackMoveOpts = {nested: true, pack: false};

while (collide = collide || this.collide(node, area, opt.skip)) { // could collide with more than 1 item... so repeat for each

let moved: boolean;

// but remember that skip down so we only do this once (and push others otherwise).

// can take space we had, or before where we're going

(!this.collide(collide, {...collide, y: node.y}, node) || !this.collide(collide, {...collide, y: nn.y - collide.h}, node))) {

node._skipDown = (node._skipDown || nn.y > node.y);

moved = this.moveNode(node, {...nn, y: collide.y + collide.h, ...newOpt});

Utils.copyPos(nn, node); // moving after lock become our new desired location

} else if (!collide.locked && moved && opt.pack) {

// we moved after and will pack: do it now and keep the original drop location, but past the old collide to see what else we might push way

protected _sizeThrottle: () => void;

/** @internal limit auto cell resizing method */

protected prevWidth: number;

/** @internal extra row added when dragging at the bottom of the grid */

protected _extraDragRow = 0;

/** @internal true if nested grid should get column count from our width */

// load any passed in children as well, which overrides any DOM layout done above

if (opts.children) {

delete opts.children;

if (children.length) this.load(children); // don't load empty

}

node = this.engine.prepareNode(options);

this._writeAttr(el, options);

this.makeWidget(el, options);

// make sure size 1x1 (default) is present as it may need to override current sizes

items.forEach(n => { n.w = n.w || 1; n.h = n.h || 1 });

// if we're loading a layout into for example 1 column and items don't fit, make sure to save

// the original wanted layout so we can scale back up correctly #1471

this._ignoreLayoutsNodeChange = true; // skip layout update

}

// if given a different callback, temporally set it as global option so creating will use it

let removed: GridStackNode[] = [];

this.batchUpdate();

// see if any items are missing from new layout and need to be removed first

let copyNodes = [...this.engine.nodes]; // don't loop through array you modify

copyNodes.forEach(n => {

if (!n.id) return;

let item = Utils.find(items, n.id);

if (!item) {

removed.push(n); // batch keep track

this.removeWidget(n.el, true, false);

}

// now add/update the widgets - starting with removing items in the new layout we will reposition

// to reduce collision and add no-coord ones at next available spot

let updateNodes: GridStackWidget[] = [];

this.engine.nodes = this.engine.nodes.filter(n => {

if (Utils.find(items, n.id)) { updateNodes.push(n); return false; } // remove if found from list

let sub = item.el.querySelector('.grid-stack') as GridHTMLElement;

if (sub && sub.gridstack) {

sub.gridstack.load(w.subGridOpts.children); // TODO: support updating grid options ?

}

}

} else if (addRemove) {

this.addWidget(w);

}

});

this.engine.removedNodes = removed;

this.batchUpdate(false);

// after commit, clear that flag

delete this._ignoreLayoutsNodeChange;

prevCB ? GridStack.addRemoveCB = prevCB : delete GridStack.addRemoveCB;

// delay adding animation back

return this;

}