YUI PHP Loader

YUI PHP Loader Home

I have made several PHP loaders for YUI over the years, and it's nice to see this library come about. Taking a look at the examples, I can see that I had the right idea. The PHP Loader is more robust and cleaner than my implementations however.

So, the problem this PHP code solves is loading your scripts or YUI scripts dynamically on page load without having to write any of the YUI loader script.

In my implementations, I setup arrays in php that would be converted to json with json_encode. The constructor would setup all the arguments, and delay the .insert() method so that it can be placed near the bottom of the page. The constructor would then generate the required JavaScript code to be output with a PHP call. This would in turn dynamically load all my scripts in a non-blocking manner. I would also setup my global namespace before the loader call and add any required variables I needed for that page in that namespace. So, and example in the PHP "view" of the constructor may look like

< ? php
$load_these = array('calendar', 'datatable', 'myCustomLib');
$loader = new YUILoader($load_these, array('config' => 'someConfigValue'));
? >


    ...
    < div id="footer">
    
    < script type="text/javascript">
        // Insert the scripts
       yuiloader.insert('js');
    
   ...

  

Your PHP source could pull from a config file to populate the $load_these array, and in that manner you can dynamically set the JavaScript that was loaded on the page.

In the YUI PHP Loader, they have somewhat simplified the insert() calls in providing $loader->css() and $loader->script() methods to print the script I have above.

In the backend libraries that I have created, I have also added my own scripts that I wanted the YUILoader to know about. I accomplished this by setting up arrays in php to hold the information about the scripts the YUILoader expects (name, fullpath, requires array etc). The script then adds the addModule JavaScript code to the loading.

Something that the PHP Loader does that I have not added to my own modules is the combination handler. This is where the backend gathers up all the scripts that you want, and combines them into a single download. This dramtically improves page load performance, and saves bandwidth.

Other advantages to this is that the files are server locally, so your site does not have to rely on a 3rd party domain to serve the files. This is especially usefuly where SSL is required or where you can not use a remote server. This includes combining your own files along side YUI modules. To add your own modules, simply add them to the configuration files in lib/meta

You can also change the default skin in the configs. This comes in handy when your testing things and want to setup an override.

I really have been waiting for something like this, and I am glad it has come into being.

YUI Sparkline Widget « Chicken of the Web

YUI Sparkline Widget « Chicken of the Web

If your into cutting edge, this is a nice example of subclassing YUI 2.7 charts to create sparklines in <canvas> and javascript.

Blogged with the Flock Browser

YUI 3: Design Goals and Architecture -Satyen Desai » Garuna Web Designer

YUI 3: Design Goals and Architecture -Satyen Desai » Garuna Web Designer

Satyen Desai goes over lessones learned from YUI 2.7, and the design goals for YUI3. YUI 2 users have expressed the need for more from YUI3

1. Lighter
1. Finer Granularity
2. Code reuse, common base class, easier to create plugins and extensions
2. Easier
1. Conistant API
   
1. Selector, Widget class, Base
2. Convenience - each, bind, chaining, syntax sugar
3. Faster
1. Opportunity to re-factor performance (drag and drop etc)

These are all valid points. In YUI 2, if I want to use a specific util or widget, I would get alot of code that I really didn't need all the time. In YUI 3 you get the option to only include parts of the components you need. This makes sense when building plugins, and widgets of your own, as well as how the core objects relate. A Tooltip widget for instance does not need all the code for an Overlay or dialog box even though they may use some of the same code for making shims or floating elements.

Satyen also goes over application instances with YUI().use() and how it is protected, and self populating. For exmaple YUI().use("anim") will attach optimal dependencies for the anim library, and attach anim to Y. var $anim = new Y.Anim(). This version of anim is garunteed to be the version of the library you are working with, and will never conflict with other widgets on the page.

The custom event handling in YUI 3 has grown quite mature with Event Facades for Dom events and Custom events. 

Custom Events:

slider.on('valueChange', function(e){
  if(e.newVal < 200) {
     alert("New Value " + e.newVal + " is less than 200");
  } 
});

Over all this is a wonderful introduction in getting developers up to speed with the changes from YUI 2 to YUI 3.

Blogged with the Flock Browser

Using Prototype and YUI

Using prototype and YUI

There are many reasons why you might use prototype.js with yui. You may be moving to Yahoo User Interface, or vice versa, or you may just prefer some flexibility. Whatever the reason, there are some good points to using the two together. I have pointed out several times on this blog and Practical Prototype that I personally prefer this method. I use YUI for the widgets, and use prototype for setting up classes, events, and other low level organization. Let's see a quick example:

MySimpleDialog = Class.create({
  initialize: function($div_id, $options){
    this.defaults = {
      width: "20em",
      fixedcenter: true,
      visible: false,
      draggable: true
    };
    Object.extend(this.defaults, $options || {});
    this.dialog = new YAHOO.widget.SimpleDialog($div_id, this.defaults);
   
  },
 
  render: this.dialog.render,
  show: this.dialog.show,

  setTitle: function($title){ this.dialog.setHeader($title);}
  setBody: function($body){ this.dialog.setBody($body); }
});

To initialize a new MySimpleDialog all we have to do now is:

var $mydialog = new MySimpleDailog('my div id');

Notice we do not have to send any options to the SimpleDialog constructor, and if we had, they would override the defaults. To get Fancy, we could create a Template class to be used by our "overridden" setBody method. Keeping things generic helps you to reuse scripts.

Y.get() != new Element()

While trying to use YUI 3.0, I was attracted to try out the YUI Node feature with the following code

$ele = Y.get('foo');

I was working out some race condition problems, and was hoping the waiting feature (where YUI will wait for the element to be in a ready state) would solve some problems for me.

What I had forgot was that Y.get is not the standard dollar function ( $('foo'), $('#foo'), etc ). This poses some real problems for me. I didn't really used the Dom.get methods, and probably for the same reasons, as I use both YUI and prototype together mostly.

But now I want to integrate the really nice features of YUI 3 into my code, and try and break away from my prototype "crutch". However, since I do use other 3rd party libraries for various things, most of them rely on straight up Dom elements being passed to them.

I hate to say it, but I have found something in YUI that just does not sit well with me.

The code still seemed to work with

Y.get('foo');
$ele = $('foo');

But I can't say for sure, and this seems pretty hacky?

YUI 3.0.0 beta 1

YUI 3.0.0 beta 1 is now available for download from YUILibrary.com.

From the Yahoo! User Interface Blog:

"This release takes YUI 3 out of its preview phase and brings its APIs to a near-final state. For those intending to implement YUI 3, the 3.0.0 beta 1 release is a good place to begin the transition. If you’ve been working with the latest preview release, George Puckett has provided a comprehensive 3.0.0 beta 1 changelog to guide you. We look forward to hearing your feedback as you begin working with 3.0.0 beta 1, and we’ll work hard to address that feedback as we prepare for a GA release in the coming months."


Some very interesting things made this release

"StyleSheet: StyleSheet makes it easy to create and modify CSS rules on the fly, allowing you to dynamically style page elements with fewer repaints."

Add stylesheets dynamically!


"ImageLoader: ImageLoader allows you to defer the loading of images that aren’t in the viewport when the page paints, throttling bandwidth usage and improving performance"

Images won't load until they enter the viewport, for longer pages, or hidden elements this is pretty huge. The bandwidth savings could be worth it.

Technorati Code

9nk6ub5zpc