I decided to move my plugins from my private svn to Google Code. This means the code being developed is now public and can be viewed and reviewed by anyone.
I'm also trying to automate the building process with a makefile in order to make deploys less tedious (thus more frequent :)).
Everyone's invited to check the code, review it, comment and report bugs. The repository has a few plugins that I actually never released. It doesn't contain non-jQuery scripts yet. I haven't moved them yet and won't do yet.
I never actually posted about 2 tiny plugins I made, once jQuery 1.3 was nearing.
Both are somehow related, they are related to Ajax (jQuery.ajax) and they provide sort of a manager to allow multiple implementations of the same feature.
Needless to say, both plugins only work under jQuery 1.3 or higher. The packages(zips) include jQuery 1.2.7pre because that's the version I used to test them when I made them. You obviously don't need to use that version.
Since jQuery 1.3. The default XHR "factory" function can be overriden by passing an 'xhr' setting to jQuery.ajax with a new function
This tiny plugin provides a simple registry for different xhr implementations to co-exist.
To provide a new implementation, you need to do something like this:
jQuery.xhr.register( 'my_xhr', function( settings ){ return new MyXhrImplementation( settings ); });
The argument settings is the object passed to jQuery.ajax.
To use it, you do:
jQuery.ajax({
url:'...',
transport:'my_xhr',
// ...
});
The built-in implementation is used by default (unless it's overriden with jQuery.ajaxSetup) and it's called 'xhr'.
This plugin lets you store multiple functions to sanitize ajax responses.
If you want to provide a new implementation, you need to do something like this:
jQuery.ajaxFilter.register('js_in_href','html', function( data ){ return data.replace(/href="javascript:[^"]+"/g, ''); });
or
jQuery.ajaxFilter.register('eval','script html json', function( data ){ return data.replace(/eval\(.+?\);?/g, ''); });
Arguments for jQuery.ajaxFilter.register() are:
To use it, you do:
jQuery.ajax({
url:'foo.html',
filter:'js_in_href',
// ...
});
The filter can also parse the response.
That means it can (for example) provide an alternative way of eval'ing json. This is specially useful for Adobe AIR apps.
If the filter returns something else than a string, it's assumed to be the final response.
I've been doing a small Haskell project for the Uni and got really interested in this language and the Functional paradigm in general.
I suddenly felt like porting some of this cool functionality to Javascript.
I started by allowing functions to be curried. Here's a demo showing the script I made.
This is quite a fun way of making functions that derive from other functions.
I then felt like porting Haskell's functions. Seemed doable considering Javascript has Higher Order Functions and we now can curry them.
I ported many Prelude's methods as well as Char methods.
Apart from currying, these functions can also work on strings, the same way as they do for lists (arrays). You don't need to worry about splitting(before) or joining(after). I added this because that's how Haskell's functions work.
These functions also work on maps/object/associative arrays. This might not be true for some functions where this was too complicated. This was the best adaptation of Haskell's Tuples that I could think of. A couple of functions like fst and snd don't have a concrete application for now.
In case I didn't make myself clear on this one, all the functions I made can be automatically curried. They're all contained in one namespace, that is, window.hs. I added a method called: hs.global() that will import all the functions to the global namespace. The magic currying function is available as hs.curry.
Haskell's operators are regular functions. I did imitate this adding most operators as methods. The only problem is that to reference them, you need to use something like hs['+'] instead of hs.+ as one would like.
To defeat this, I made hs a function, it provides a small shortcut for these cases. As an example: hs['+'](1,2) == hs('+',1,2).
I think the second option does look better. These functions can also be curried. hs._ will work the same as hs, but inverting the (2) arguments.
I added the dot operator for function composition, it's quite a powerful function.
That's it, the script is licensed under BSD, check the demo and play with it!
Following Steven Levithan's old post about string trimming.
I decided to give it another try after my first proposal.
I made a trim version, based on my aforementioned first attempt. It seems to be much faster on any browser and with different (string) lengths and whitespaces.
I want to make clear that this version doesn't trim the exact same characters that other versions do.
In my first version, I simply tried to improve Steven's version without really giving it a deep thought.
This time I thought:Are all those characters really relevant?.
After thinking about this for a while I decided that, whatever /\s/ matches, should be trimmed.
Why ? because most major js libraries use the regex version. If their users are content, then those are the needed characters. Also, if my function would actually do better than others, it could go directly to jQuery's core (there's a ticket for that).
So I created a test page. The results weren't equal for all browsers, IE and Safari 3 yielded far less charCodes. I decided these are the ones I want to trim.
So, the basic modification I made to my previous version, was to check whether the charCode is lower than 33 instead of the whole map/object.
This one takes much less code and is quite faster, I humbly named it "myBestTrim", here it is:
// Licensed under BSD function myBestTrim( str ){ var start = -1, end = str.length; while( str.charCodeAt(--end) < 33 ); while( str.charCodeAt(++start) < 33 ); return str.slice( start, end + 1 ); };
If you want to try the benchmark, get in here. The number should you care about (in my opinion) is the minimum. That's probably the one that ran a lower CPU level.
That test uses a string with 10K characters. Sounds like a lot but this blog's homepage has 55K of html. As oposed to a regex-based trim, this one should scale pretty well, because it doesn't need to check all the string.
That's actually why I removed any regex-based approach from this test, because they'd take too long.
If you have Firebug, I'd advice you to turn it off before getting into this test.
I made a similar test with small strings. It uses a string of 30 characters with 3 whitespaces on each side. In this case, the difference was smaller but still noticeable.
The only situation where another function was faster was on IE, with a small string WITH whitespaces. In this situation, jQuery's trim (the typical regex-based trim) was slightly faster, my trim got 2nd place.
Most situations don't really require much trimming and critical situations have very large strings, so I think this function scales well on those 2.
If all goes well, I'll put this function into jQuery's core. I'd like though, to get some results from other users, to verify my trim is really fast and effective.
Here's the ticket requesting a faster trim for jQuery: #2279.
I rewrote the scroll limit calculations part, in order to fix the 2 bugs. If you notice any problem, please report.
This version should be perfectly compatible with the latest versions of SerialScroll and LocalScroll.
I tested this only with jQuery 1.2.6 (from trunk) but it should work well even with pretty old versions of jQuery.
Tested my demos and some iframe experiments on IE 6/7, FF 2/3, Safari 3 and Opera 9.2/5. All worked as expected. Enjoy!
The jQuery team and the UI team have been working very hard lately to bring you these new outstanding releases.
var dumped = jsDump.parse( ... );Instead of '...', you need to put the data that you want to dump.
jsDump.HTML = true;This needs to be done before calling .parse().
jsDump.setParser( 'number', '[number]' ); jsDump.setParser( 'date', function( date ){ return date.toUTCString(); });To see all the data types, check the source, no gain on listing them all here.
$('#pane').serialScroll({ //... });
$('div.container').serialScroll({ //... target:'div.pane', //... });This will allow you to have many divs with class container, which contain a scrollable div with class pane. They don't need to be divs.
$.serialScroll({ //... });If, for some reason, you need to retrieve this implicit element, call:
$.scrollTo.window();
This will return you the element, don't use window or document.
$('div.container').serialScroll({ //... onBefore:function( e, elem, $pane, $items, pos ){ //... }, //... });Note that:
$.fn.foo = function(){ ... }; $.fn.foo.bar = function(){ ... }; $.fn.foo.baz = function(){ ... };And enables you to use it like this:
$(...).foo().bar( ... ); $(...).foo( .... ); $(...).foo().baz( ... ).foo().bar( ... ).foo( ... );As showed above, the method that acts as module, can also be used as function.
$.modularize( 'foo' );If $.fn.foo already exists, it will be used when $(...).foo(...) is called with arguments.
$.modularize( 'foo', function(){ ... } );The given function will be used when $(...).foo(...) is called with arguments.
$.modularize( 'baz', null, $.fn.foo );This allows:
$(...).foo().baz().foobar( ... )
Instead of null, you could send the default method.$.fn.foo.lazy = true;You can set this to true, call the methods, and then reset to false.
(function( $ ){ var OPEN = 1, CLOSE = 2, CLOSED = 3; /* the rest of the code */ })( jQuery );These constants, were compared to a 'mode' attribute of the token. This caused 1 reference to each of them, on every loop in the parse function.
var global = 1; (function(){ var local1 = 1; (function(){ var local2 = 1; (function(){ var local3 = 1; /* here I executed the benchmark */ })(); })(); })();This created 4 variables, 1 global, and 3 local. All of them could be accessed from where the benchmark was being ran, but they belonged to different scope chains. I benchmarked 4 functions, each of them accessed one of these variables 400,000 times with a loop.
Opera is the clear champion, for some reason, the scope doesn't affect the timing at all.Firefox 2
* global: 969ms * local1: 672ms * local2: 359ms * local3: 78msIE 6(=7)
* global: 187ms * local1: 171ms * local2: 125ms * local3: 94msSafari 3
* global: 125ms * local1: 93ms * local2: 78ms * local3: 62msFirefox 3 beta 5
* global: 41ms * local1: 48ms * local2: 48ms * local3: 37msOpera 9
* global: 31ms * local1: 31ms * local2: 31ms * local3: 31ms
$('ul li').fastTrigger('mouseover');//regular $('h1').fastTrigger('click.foo');//with namespace $('li p').fastTrigger('focus!');//exclusive $('ul.list').fastTrigger('collapse');//custom event $('#bar').fastTrigger('click', ['foo']);//data array $.fastTrigger('keypress');//global triggering $('a').fastTrigger('blur',[obj]]);//your event object
Templating var values = { name:'Joe', age:32, surname:'Smith' }; var tokenizer = new Tokenizer([ /<%(\w+)%>/, /\$(\w+)/ ],function( src, real, re ){ return real ? src.replace(re,function(all,name){ return values[name]; }) : src; } ); var tpl = '<%name%> $surname is $age years old.'; var tokens = tokenizer.parse(tpl); document.body.innerHTML = tokens.join('');
CSV parser var rows = [ ], row = rows[0] = [ ]; var csv = new Tokenizer( [',',';'], function( text, isSeparator ){ if( isSeparator ){ if( text == ';' ){//new row row = [ ]; rows.push(row); } }else{ row.push(text); } } ); csv.parse('Joe,Smith,32;Jane,Doe,26;Mike,Bowel,54');
