Resize event for textarea?

The current versions of Firefox and Chrome include a drag handler to resize a <textarea> box. I need to capture the resizing event, I thought it would be easy with jQuery's resize() event, but it doesn't work!

I have also tried the normal onResize event, but the result is the same. You can try it on JSFiddle.

Is there a way to capture it?

Chrome doesn't capture the resize event and that Chrome doesn't capture the mousedown, so you need to set the init state and then handle changes through mouseup:

jQuery(document).ready(function(){
   var $textareas = jQuery('textarea');

   // store init (default) state   
   $textareas.data('x', $textareas.outerWidth());
   $textareas.data('y', $textareas.outerHeight()); 

   $textareas.mouseup(function(){

      var $this = jQuery(this);

      if (  $this.outerWidth()  != $this.data('x') 
         || $this.outerHeight() != $this.data('y') )
      {
          // Resize Action Here
          alert( $this.outerWidth()  + ' - ' + $this.data('x') + '\n' 
               + $this.outerHeight() + ' - ' + $this.data('y')
               );
      }
  
      // store new height/width
      $this.data('x', $this.outerWidth());
      $this.data('y', $this.outerHeight()); 
   });

});

HTML

<textarea></textarea>
<textarea></textarea>

You can test on JSFiddle

Note:

1. You could attach your own resizable as Hussein has done, but if you want the original one, you can use the above code
2. As Bryan Downing mentions, this works when you mouseup while your mouse is on top of a textarea; however, there are instances where that might not happen like when a browser is not maximized and you continue to drag beyond the scope of the browser, or use resize:vertical to lock movement.

For something more advanced you'd need to add other listeners, possibly a queue and interval scanners; or to use mousemove, as I believe jQuery resizable does -- the question then becomes how much do you value performance vs polish?

---

Update: There's since been a change to Browsers' UI. Now double-clicking the corner may contract the textbox to its default size. So you also may need to capture changes before/after this event as well.

A standard way to handle element's resizing is the Resize Observer api, available in all modern web browser versions.

function outputsize() {
 width.value = textbox.offsetWidth
 height.value = textbox.offsetHeight
}
outputsize()

new ResizeObserver(outputsize).observe(textbox)

Width: <output id="width">0</output><br>
Height: <output id="height">0</output><br>
<textarea id="textbox">Resize me.</textarea>

If you need to deal with old versions of Chrome and Firefox (others untested), Mutation Observer can be used to detect the change of the style attribute.

function outputsize() {
 width.value = textbox.offsetWidth
 height.value = textbox.offsetHeight
}
outputsize()

new MutationObserver(outputsize).observe(textbox, {
 attributes: true, attributeFilter: [ "style" ]
})

Width: <output id="width">0</output><br>
Height: <output id="height">0</output><br>
<textarea id="textbox">Resize me.</textarea>

Resize Observer

Documentation: https://developer.mozilla.org/en-US/docs/Web/API/Resize_Observer_API

Spec: https://wicg.github.io/ResizeObserver

Current Support: http://caniuse.com/#feat=resizeobserver

Polyfills: https://github.com/pelotoncycle/resize-observer https://github.com/que-etc/resize-observer-polyfill https://github.com/juggle/resize-observer

I mixed vol7ron's answer up a bit, and just replaced the "Resize Action Here" with a simple trigger of the normal "resize" event, so you can attach whatever you want to happen to the resize event "as usual":

$(document).ready(function(){
	$('textarea').bind('mouseup mousemove',function(){
		if(this.oldwidth  === null){this.oldwidth  = this.style.width;}
		if(this.oldheight === null){this.oldheight = this.style.height;}
		if(this.style.width != this.oldwidth || this.style.height != this.oldheight){
			$(this).resize();
			this.oldwidth  = this.style.width;
			this.oldheight = this.style.height;
		}
	});
});

I added the mousemove event so the resizing also fires while dragging the mouse around while resizing, but keep in mind that it fires very often when you move the mouse around.

in this case you might want to put a little delay in actually triggering or handling the resizing event, e.g. replace the above:

$(this).resize();

with:

if(this.resize_timeout){clearTimeout(this.resize_timeout);}
this.resize_timeout = setTimeout(function(){$(this).resize();},100);

example usage, make 2nd textarea grow and shrink with the first one:

$('textarea').eq(0).resize(function(){
	var $ta2 = $('textarea').eq(1);
	$('textarea').eq(1).css('width',$ta2.css('width')).css('height',$ta2.css('height'));
});

another way to do it is by binding to the mouseup event on the textarea. then you can check if size changed.

Resize event doesn't exist for textarea.

The resizeable jQueryPlugin doesn't look native, so we must use alternative.

One way to emulate it is to use the mousedown/click event.
If you want real-time event triggering, you can do it like this:

Updated november 11, 2013:

// This fiddle shows how to simulate a resize event on a
// textarea
// Tested with Firefox 16-25 Linux / Windows
// Chrome 24-30 Linux / Windows

var textareaResize = function(source, dest) {
    var resizeInt = null;
    
    // the handler function
    var resizeEvent = function() {
        dest.outerWidth( source.outerWidth() );
        dest.outerHeight(source.outerHeight());
    };

    // This provides a "real-time" (actually 15 fps)
    // event, while resizing.
    // Unfortunately, mousedown is not fired on Chrome when
    // clicking on the resize area, so the real-time effect
    // does not work under Chrome.
    source.on("mousedown", function(e) {
        resizeInt = setInterval(resizeEvent, 1000/15);
    });

    // The mouseup event stops the interval,
    // then call the resize event one last time.
    // We listen for the whole window because in some cases,
    // the mouse pointer may be on the outside of the textarea.
    $(window).on("mouseup", function(e) {
        if (resizeInt !== null) {
            clearInterval(resizeInt);
        }
        resizeEvent();
    });
};
    
textareaResize($("#input"), $("#output"));

Demo : http://jsfiddle.net/gbouthenot/D2bZd/

I wrote this answer to another version of the same question. looks like it's old news in here. I like to stick to vanilla js for whatever reason, so here's a tidy little solution in vanilla:

<textarea
  onmousedown="storeDimensions(this)"
  onmouseup="onresizeMaybe(this)"
></textarea>

<script>
  function storeDimensions(element){
    element.textWidth = element.offsetWidth;
    element.textHeight = element.offsetHeight;
    element.value = "is it gonna change? we don't know yet...";
  }
  
  function onresizeMaybe(element){
    if (element.textWidth===element.offsetWidth
     && element.textHeight===element.offsetHeight) 
      element.value = "no change.\n";
    else element.value ="RESIZED!\n";
    
    element.value +=
       `width: ${element.textWidth}\n`
      +`height: ${element.textHeight}`;
  }
</script>

and for homework, use onmousemove to trigger the resize event instead of onmouseup (I didn't need that in my particular case).

if you want to add this to every textarea in the DOM (not really tested):

let elementArray = document.getElementsByTagName("textarea");
for(var i=0; i<elementArray.length; i++){
  elementArray[i].setAttribute("onmousedown", "storeDimensions(this)");
  elementArray[i].setAttribute("onmouseup", "onresizeMaybe(this)");
}

:) hope it helps someone someday... seeing as how this question is now 9 years old.

NOTE: if you're going to want to trigger this on mousemove, the new fangled ResizeObserver(callback).observe(element) approach is great!

I find that a mousemove event and a setTimeout combined work nicely for this.

let el = document.querySelector('textarea')
let resizeFn = ()=>{}
let timeout = null

el.addEventListener('mousemove',()=>{
    timeout && clearTimeout(timeout)
    timeout = setTimeout(resizeFn,250)
 })

thanks to MoonLite - Your script is working fine, but sometimes, if You do a quick increasing-resize the mouse pointer is outside the textarea on mouseup and the wished function is not triggered. So I added a mouseup event on the containing element to make it work reliable.

.

$('textarea_container').bind('mouseup', function()
{ YourCode ; } ) ;

'

FireFox now supports MutationObserver events on textareas and this seems to work quite well. Chrome sadly still needs a workaround.

Based on the other answers on this page, here's a refactored and updated version, that triggers a window resize event when a textarea is resized.

I've also added an event listener for the mouse leaving the window which is needed in an iFrame to detect when the textarea becomes larger than the frame.

(function(textAreaChanged){
	function store(){
		this.x = this.offsetWidth;
		this.y = this.offsetHeight;
	}

	function textAreaEvent(){
		if (this.offsetWidth !== this.x || this.offsetHeight !== this.y) {
			textAreaChanged();
			store.call(this);
		}
	}

	$('textarea').each(store).on('mouseup mouseout',textAreaEvent);

	$(window).on('mouseup',textAreaEvent);

})(function(){
	$(window).trigger('resize');
});

In IE9 and above we can do the same without jQuery.

(function(textAreaChanged){
	function store(){
		this.x = this.offsetWidth;
		this.y = this.offsetHeight;
	}

	function textAreaEvent(){
		if (this.offsetWidth !== this.x || this.offsetHeight !== this.y) {
			textAreaChanged();
			store.call(this);
		}
	}

	Array.prototype.forEach.call(
		document.querySelectorAll('textarea'),
		function (el){
			el.addEventListener('mouseup',   textAreaEvent);
			el.addEventListener('mouseout',  textAreaEvent);
		}
	);

	window.addEventListener('mouseup',textAreaEvent)

})(function(){
	//trigger window resize
	var event = document.createEvent('Events');
	event.initEvent('resize', true, false);
	window.dispatchEvent(event);
});

Not as beautiful and dynamic but it works as expected.

$('.classname').mouseup(function(){
    $('.classname').css('height', $(this).height());
});

You need to first make the textarea resizable before issuing the resize event. You can do that by using jQuery UI resizable() and inside it you can call the resize event.

$("textarea").resizable({
    resize: function() {
        $("body").append("<pre>resized!</pre>");
    }
});

Check working example at http://jsfiddle.net/HhSYG/1/