UIZE JavaScript Framework

GUIDES Overview Of Features

1. Introduction

This document provides an overview of the comprehensive feature set of the UIZE JavaScript Framework, with examples and links to further guides.

2. FREE and Open Source

UIZE is free to use and all the source is available for all to view and fork on GitHub.

Free to Use - UIZE is absolutely free to use - no catches, no one time purchase fees, no per seat developer licenses.
Dual License - The UIZE JavaScript Framework - including all code and examples - is available under either the MIT License or the GNU General Public License - you choose. Dual licensing means you get to choose the licensing terms that are right for your project or application. There is nothing special for you to do - simply download the UIZE JavaScript Framework, and start using it under the licensing terms of your choice. Go ahead and use UIZE with complete peace of mind.
Open Source = UIZE is proudly contributed to the OpenSource community and is available for forking on GitHub. Being on GitHub means that you can conveniently fork the project and control your destiny by adapting things when needed.

For more information, consult the license page.

3. Modules & Dependency Resolution

UIZE implements an elegant and clean system for defining JavaScript modules of many different varieties.

Defining a module in UIZE is as simple as calling the Uize.module method, as follows...

Uize.module ({
  builder:function () {
    var myModule;

    // do stuff to initialize myModule
    // ... ... ... ... ... ... ...
    // ... ... ... ... ... ... ...

    return myModule

3.1. Dependency Resolution

The way that the module system works, any modules that are declared as direct dependencies in the required property of the module definition are loaded first.

The builder function for the module is called only once all dependencies - direct or indirect - are loaded. This means that you never have to worry about dependencies of other modules and figuring out comprehensive lists of all the code that a page might need. If you follow the practice of always declaring just your own direct dependencies for the module you're working on, then UIZE does all the recursive dependency tracing for you and the module loader takes care of loading what's still needed (not already loaded because something else had needed it).

3.2. Built Into the Base Module

The system for loading module dependencies is built into the base Uize.js file, so all that's needed to bootstrap a page for basic development is to add a script tag to load that file.

<script src="http://www.uize.com/js/Uize.js"></script>

<script type="text/javascript">
  Uize.require (
    function () {Uize.Widgets.Calculator.Widget ().insertUi ()}

If you copy-and-paste the above code into some HTML page (maybe you've got one you're working on), you will see a glorious calculator widget added to the page. Because of the highly modular nature of the UIZE codebase, there's actually a bunch of individual modules that will be loaded. All this is taken care of for you.

3.3. Packaging

Rest assured, when it comes time to get a project ready for production, UIZE provides ways to build JavaScript packages using the same dependency resolution system so that you can reduce the number of HTTP requests made by your application and thereby improve its load time.

You can either rely on the built-in UIZE support for building JavaScript library files, or you can craft your own more sophisticated packager using the raw build methods for tracing dependencies of modules. And, because UIZE supports all kinds of modules, you can even build your HTML templates and CSS templates for UI widgets into the same JavaScript package as your JavaScript logic.

3.4. All Kinds of Modules

Because UIZE's module mechanism is very generic in nature (you can define anything in your builder function), it lends itself to being used as a wrapper for all types of content.

In the UIZE widgets, for example, JavaScript modules are used to wrap HTML templates and CSS templates, allowing all the materials needed by a widget to be packaged into the same file (even the images if you implement base64 encoding for inlining of images in the wrapped CSS modules).

Different flavors of JavaScript modules include...

class modules
package modules
JSON / data modules
CSS template modules
HTML template modules
JavaScript library modules

What's more, using the powerful build system and the development server, you can create your own URL handlers for new types of source files that should be ultimately wrapped in the form of JavaScript modules.

4. Basic Utility Belt Features

UIZE provides a bunch of utility belt features right in the Uize base module, so you get that in addition to the modules & dependency resolution system.

Utility belt features include...

value testing methods, like Uize.isArray, Uize.isList, Uize.isPlainObject, Uize.isPrimitive, Uize.inRange, and many more...
basic data utility methods, like Uize.clone, Uize.copy, Uize.copyList, Uize.indexIn, Uize.isIn, Uize.keys, Uize.lookup, Uize.merge, Uize.reverseLookup, Uize.value, and many more...
iterator methods, like Uize.forEach and Uize.callOn
value transformer methods, like Uize.capFirstChar, Uize.constrain, Uize.substituteInto, and more...
dummy functions, like Uize.nop, Uize.returnFalse, Uize.returnTrue, and Uize.returnX
general utility methods, like Uize.eval, Uize.global, Uize.noNew, Uize.now, Uize.quarantine, etc.

4.1. Avoiding Bloat

While it's nice to have some of these types of utility methods always close at hand, we don't want the Uize base module to become bloatware and so we haven't added some of the more esoteric utilities that you might find in some other popular toolbelt JavaScript libraries.

The utility methods that make their way into the Uize base module are given careful consideration, and are often given the greenlight because they are needed by other core modules that are very likely to be used, so why not make them public for all to use.

4.2. Util Namespaces

Instead of throwing everything including the kitchen sink into the Uize base module, utilities for other kinds of situations are organized into other namespaces in the framework, such as the Uize.Util, Uize.Dom.Util, Uize.Color.xUtil, Uize.Build.Util, and Uize.Array.Util namespaces.

5. Classes, Inheritance, OOP

UIZE makes it dead easy to create classes that come with support for events (thanks to a built-in event infrastructure) and state properties and binding.

5.1. Creating a Class

Making a class in UIZE is as easy as calling the subclass static method of a class that you want to extend, as follows...

var MyWidgetClass = Uize.Widget.V2.subclass ();

In the above example, MyWidgetClass is now a subclass of UIZE's V2 (version 2) widget base class. The new MyWidgetClass class inherits all of the instance methods and property, state properties, and inheritable static methods and properties from the Uize.Widget.V2 base class.

5.2. Declaring Features

Declaring features for a newly created class can be done in a number of different ways, but by far the simplest and most elegant is to declare all the new features or overridden features in an optional features declaration object that is passed to the subclass method, as follows...

var MyClass = Uize.Class.subclass ({
    someInstanceMethod1:function () {
      // do some stuff
    someInstanceMethod2:function () {
      // do some stuff
    someStaticMethod1:function () {
      // do some stuff
    someStaticMethod2:function () {
      // do some stuff

For a more detailed discussion of the UIZE approach to OOP, consult the Classes and Inheritance guide.

6. State Properties and Binding

UIZE offers a mature and powerful state properties system so that classes can expose a state interface for their instances.

The state properties system goes beyond regular object properties, and even beyond the newer properties capabilities of ECMAScript 5, providing powerful constructs like conformers, optimized onChange handlers, aliases (for deprecating old names), and value changed events using the built-in event infrastructure.


function calculateVolume () {
  this.set ({volume:this.get ('width') * this.get ('depth') * this.get ('height')});

var Room = Uize.Class.subclass ({
      conformer:function (newValue) {return Uize.constrain (newValue,10,50)},
      conformer:function (newValue) {return Uize.constrain (newValue,10,50)},
      conformer:function (newValue) {return Uize.constrain (newValue,9,25)},
      onChange:function () {
        // code to display volume info in UI

In this example we're creating a Room class with the state properties width, depth, height, and volume.

6.1. Range Type Conformers

The width and depth properties both have a conformer that constrains their value to a range of 10 to 50, while the height property has a conformer that constrains its value to a range of 9 to 25.

6.2. Optimized onChange Handler

All three of these properties share the same reference to the calculateVolume function, which gets called only once during a set if any or all of the properties change value during the set (this is a smart optimization of UIZE).

The calculateVolume function gets called as though an instance method (ie. with the instance as context), so it can use the this keyword. It uses the get instance method to obtain the current values of the three dimension properties to calculate the volume of the room and then sets a new value on the volume state property, making this property effectively a derived property.

6.3. Looking at Some Outcomes

Now let's take a look at what happens when we try setting the values of the state properties in a few different situations.

var livingRoom = Room ({width:15,depth:20,height:19}); // initialized with values for properties
alert (livingRoom.get ('volume'));              // alerts 5700

livingRoom.set ({width:15,depth:20,height:19}); // no change in properties, volume unchanged
alert (livingRoom.get ('volume'));              // alerts 5700

livingRoom.set ({width:18,depth:18,height:22}); // volume is only calculated once
alert (livingRoom.get ('volume'));              // alerts 7128

livingRoom.set ({width:55,depth:60,height:30}); // property values are constrained at upper bounds
alert (livingRoom.get ('width'));               // alerts 50
alert (livingRoom.get ('depth'));               // alerts 50
alert (livingRoom.get ('height'));              // alerts 25
alert (livingRoom.get ('volume'));              // alerts 62500

livingRoom.set ({width:99,depth:99,height:99}); // properties remain constrained, volume unchanged
alert (livingRoom.get ('width'));               // alerts 50
alert (livingRoom.get ('depth'));               // alerts 50
alert (livingRoom.get ('height'));              // alerts 25
alert (livingRoom.get ('volume'));              // alerts 62500

There are effectively five different places where we're setting values for the state properties: once as part of instance creation, and then on four subsequent occasions...

1.  Immediately after the livingRoom instance is created, the value of the volume state property is 5700, being calculated during construction of the instance from the values set for the width, depth, and height properties.
2.  Next, the set method is called in an attempt to set the values of the dimension properties to their exact current values. This results in no change in the dimension property values, the calculateVolume function is not called for any of the onChange handlers, and the value of the volume property remains unchanged.
3.  Next, the set method is called and different values are specified for each of the dimension properties. This results in the shared calculateVolume change handler function being called only once, and the value of the volume property is now set to 7128.
4.  Next, the set method is called and values are specified for the dimension properties that are all outside of the range bounds enforced by their conformer functions. This results in the values being constrained at the upper limits of the ranges and there is a change in the values of all the properties. The shared calculateVolume change handler function is still called only once, and the value of the volume property is now set to 62500.
5.  Finally, the set method is called once again in an attempt to set values for the dimension properties that are above the upper range bounds enforced by their conformer functions. This results in the values being constrained at the upper limits of the ranges, but this time there is no change in the values of the properties because they were already constrained at their upper limits. The shared calculateVolume change handler function is not called (none of the properties' values have changed), and the value of the volume property remains unchanged at 62500.

6.4. Changed Events

Every state property that is declared for a class gets the benefit of changed events that fire automatically when the value of the state property changes.


var MyClass = Uize.Class.subclass ({

var myClassInstance = MyClass ();

myClassInstance.wire (
  function () {alert (myClassInstance.get ('foo'))}

myClassInstance.set ({foo:'qux'});

In this example, we've created the class MyClass and declared that it has a state property named foo with an initial value of 'bar'. After creating an instance of this class, myClassInstance, we wire a handler for the Changed.foo event, which is an event that will automatically be fired by UIZE whenever the value of the foo state property changes. After wiring the handler, we use the set method to set the foo property to the new value 'qux'. This causes the Changed.foo event to be fired and the alert statement is hit, which alerts the new value 'qux'.

6.5. Binding Properties Together

UIZE providers numerous utility modules for conveniently binding state properties together in straightforward or more elaborate ways.

Property binding utility modules include...

Uize.Util.Coupler - lets you couple two or more instances (of any class) together, synchronizing a set of any number of their state properties between all instances (eg. synchronizing the width, depth, and height properties across any number of different Room instances)
Uize.Util.PropertyAdapter - lets you connect any two properties of any two instance so that they remain synchronized bi-directionally, with an optional value transformer that can allows for the value to be transformed in different ways for each direction (eg. synchronizing two color properties where the color is stored in different formats in each of the properties)

For a more detailed discussion of the state properties system, consult the State Properties guide.

7. Event Infrastructure

The JavaScript language does not provide a built-in system for event-driven programming, so UIZE provides an event system.

Such events can be fired (aka published, dispatched, triggered, emitted, etc.) from anywhere in the code in an ad hoc fashion, and listenable events do not need to be registered formally. Multiple handlers can be registered for the same event. Handlers can be registered for events that are never fired, without ill effects. Conversely, events can be dispatched that are never listened for, without ill effects.


var myWidget = Uize.Widget ();
myWidget.wire (
  'My Arbitrary Event',
  function (event) {alert (event.message)}
myWidget.fire ({name:'My Arbitrary Event',message:'Hello, world!'});

In the above example, an instance of the Uize.Widget class is created, a handler is registered on an arbitrarily named event ('My Arbitrary Event'), and then the fire instance method is called on the widget in order to fire that event. The event object contains an additional message property, whose value is alerted in the handler that was registered for the event.

The event system implemented by the UIZE JavaScript Framework is orthogonal to the event model of Web browsers that is provided as part of the standardized Document Object Model, and can be used outside of the context of Web browsers and other host environments for the JavaScript language that may implement their own proprietary event systems. As an example of this, the framework's event system can be utilized within Windows Script Host by scripts that use the Uize.Class base class.

The Uize.Class base class provides a convenient infrastructure for supporting both static and instance events. Events can conveniently be fired for a class or an instance of a class, and methods are provided to every class that subclasses the Uize.Class base class to allow code to manage the wiring and unwiring of event handlers for static and instance events. This provides all Uize.Class subclasses with a consistent event model.

For a more in-depth discussion on events, consult the guide JavaScript Event System.

8. Conditions, Barriers, Needs

UIZE implements the useful programming constructs of conditions, barriers, and needs.

conditions - define conditions that are derived from one or more state properties using a properties derivation, and register code that is to be executed once a condition is met, each time a condition is met, or whenever a condition changes state
barriers - register code that is to be executed once a condition is met, or immediately if the condition is already met - this can help with code that might be vulnerable to race conditions because of unpredictable asynchronous processes
needs - register provider code that is to be executed the first time something is needed and that will provide that need, and register code that has a need and that should invoke an associated provider to be executed - register needs and providers optionally and in any order - this can help to manage loosely coupled code that needs to cooperate but can't agree on timing

The conditions, barriers, and needs / providers mechanisms make it possible to manage tricky timing situations in applications where code is distributed and where it may not be feasible to enforce / orchestrate the desired sequencing. These mechanisms make it possible to explicitly define the state dependencies.

9. Ajax / Asynchronous Processes

UIZE provides features to enable Web applications to more easily perform asynchronous communication with a Web server, a technique that is often referred to broadly as Ajax.

The Uize.Comm base class provides a foundation for supporting asynchronous communication regardless of the mechanism employed, which could be a hidden iframe, the XMLHttpRequest object, or script tags (see AJAST). This base class provides a caching mechanism for requests, a queueing mechanism in order to sequence successive asynchronous requests through a single communication object, and a standard interface for issuing requests. Various subclasses of the Uize.Comm base class implement support for different communication mechanisms.


Uize.Comm.Ajax ().request ({
  callback:function (searchResults) {
    // do something with the search results

In the above example, an instance of the Uize.Comm.Ajax class is created and immediately used to perform an asynchronous request to a hypothetical search service using the XMLHttpRequest object. The anonymous function specified for the callback property is executed once the request has successfully executed, and the result from the server is passed as a parameter to the callback function as a JSON object.

For a more in-depth discussion of AJAX programming, consult the reference for the Uize.Comm base class.

10. DOM Manipulation

While a design goal of the UIZE JavaScript Framework is to support multiple different host environments that support the JavaScript language, a key application of the framework is to facilitate the development of Rich Internet Applications that run with a web browser as the host environment for client-side functionality.

As such, there exist a number of modules designed specifically to assist with inspection of and manipulation of a Web page's Document Object Model. Among other things, these modules provide static methods for: iterating across a range HTML elements and performing operations on each, finding a set of HTML elements by means of a match expression, getting and setting Cascading Style Sheet (CSS) style properties, insertion of HTML markup, management of DOM event listeners, and querying and modifying coordinates.


Uize.Node.setStyle (

The above example demonstrates how the Uize.Node.setStyle static method of the Uize.Node module is used to set the width, height, backgroundColor, and fontFamily CSS style properties for the three nodes with the ids "myNode1", "myNode2", and "myNode3".

For a more in-depth discussion of DOM manipulation, consult the reference for the Uize.Node module.

11. Widgets Framework

UIZE provides a system to facilitate the development of widgets that can be embedded in HTML pages.

Functionality that can be inherited by widget classes is implemented in the Uize.Widget base class. The framework's widget system allows widgets to be arranged in a hierarchical tree structure, where each widget can have one parent widget and any number of child widgets. In this relationship, parent widgets can provide services to child widgets on their tree, and child widgets can inherit state from widgets higher up in the parent chain.

Examples of widgets include: buttons, sliders for selecting continuous values, progress bars, calendar / date pickers, color pickers, sortable collections, tabbed interfaces, modal dialogs, slide shows, data table sorters, tree list controls, and hierarchical menus.

For a more in-depth discussion of UIZE's widget framework, consult the guide JavaScript Widgets.

12. HTML & CSS Templating

The versatile templating system employed by UIZE is relied upon heavily for the HTML templates and CSS templates that are used by encapsulated widgets.

12.1. HTML Templates

HTML templates are JST templates (.js.jst files) that are compiled to efficient JavaScript functions and wrapped in JavaScript modules so that they can be required as dependencies.

HTML template functions are called as instance methods of widget instances and can, therefore, call the widget's public instance methods as part of process of generating the HTML string for a widget. For instance, a widget's template can call the childHtml instance method on the widget in order to get the HTML for a child widget so that it can be added to the HTML in the desired place.

Below is an example of an HTML template taken from the progress bar widget...


<div id="<%= this.nodeId () %>" class="<%= this.rootNodeCssClasses () %>">
  <div id="<%= this.nodeId ('track') %>" class="<%= this.cssClass ('track') %>">
    <div class="<%= this.cssClass ('trackBg') %>"></div>
    <div id="<%= this.nodeId ('full') %>" class="<%= this.cssClass ('trackFull') %>"></div>
    <div id="<%= this.nodeId ('empty') %>" class="<%= this.cssClass ('trackEmpty') %>"></div>
    <div id="<%= this.nodeId ('statusText') %>" class="<%= this.cssClass ('statusText') %>"></div>

12.2. CSS Templates

CSS templates are JavaScript templates that are compiled to CSS files by the build system, and additionally wrapped as CSS modules that can be required as dependencies of widget modules.

CSS templates can require JavaScript modules through use of the @required directive. This allows CSS templates to declare dependencies on modules that define shared values for styles that are to be common across multiple different CSS files, as well as functions from CSS utility modules. While not the same as systems like LESS and SASS, UIZE's CSS templates system can be used to accomplish a lot of the same objectives of factoring out shared theme-wide styles and creating reusable functions for simplifying the creation of more complex style rules.

Below is an example of a CSS template taken from the color swatch widget...


<%@ required ('Uize.Widgets.CssUtil'); %>
    _cssUtil = Uize.Widgets.CssUtil,
    _borderWidth = _cssUtil.box.border.width
.`` {
  display: inline-block;
  border-width: <%= _borderWidth %>px;
  border-style: solid;
  border-color: #ccc #999 #999 #ccc;
  width: 20px;
  height: 20px;

/*** different sizes ***/
  var _sizes = _cssUtil.sizes;
  function _sizeStyleProperties (_sizeName,_horizontalPadding) {
      _size = _sizes [_sizeName],
      _widthHeight = _size.outer - _borderWidth * 2
    width: <%= _widthHeight %>px;
    height: <%= _widthHeight %>px;
  .`tiny` {
    <% _sizeStyleProperties ('tiny') %>

  .`small` {
    <% _sizeStyleProperties ('small') %>

  .`medium` {
    <% _sizeStyleProperties ('medium') %>

  .`large` {
    <% _sizeStyleProperties ('large') %>

13. Lots of Built-in Widgets

To help you get started with Web app development, UIZE comes bundled with lots of built-in widgets.

Included in the built-in widgets are: auto suggest, tooltip, slider, progress bar, various buttons, calculator, calendar, collection and collection item (for grids and lists), color picker, color info, resizable and draggable dialog / window, egg timer, form and form input, image port, drop list, scrolly, table sorter, tree, toggler button, and more.

The built-in widget modules are divided into two main groups...

widget abstract classes - these are contained under the Uize.Widget namespace and do not have any associated HTML or CSS
encapsulated widgets - these are contained under the Uize.Widgets namespace and are self-contained with their own associated HTML, CSS, and assets (and they usually subclass one of the widget abstract classes)

To preview some of the many built-in widgets, you can take a look at...

Widget Visual Samplers - this provides a way to get a quick sample of some of the features of the encapsulated widgets (the ones with their own HTML and CSS)
Widget Tour - this will take you on a page-by-page tour of many of the widget example pages included as part of the extensive documentation

13.1. Make Your Own

If no built-in widget meets your exact needs you can easily build your own custom widgets - either from scratch by subclassing the Uize.Widget.V2 base class, or by subclassing one of the existing built-in widget classes.

For a detailed discussion of UIZE widgets with guidelines on how to make your own, consult the JavaScript Widgets guide.

14. Internationalization / Localization

UIZE provides facilities (in Uize.Widget) to ease i18n (internationalization) and L10n (localization) of JavaScript code.

The localized state property allows an arbitrary number of localized string templates to be specified in an object hash, and these string templates are then available to the widget and all its child widgets. The localize instance method allows a string template to be retrieved and will process the string, as necessary, to replace substitution tokens with dynamic data.


myWidget = Uize.Widget ({
  localized:{welcomeMessage:'Welcome, {firstName} of {state}, {country}'}
alert (
  myWidget.localize (

In the above example, an instance of the Uize.Widget class is created, specifying a localized hash that contains just one localized string template named welcomeMessage. This string contains the substitution tokens {firstName}, {state}, and {country}. The localize instance method is called on the widget instance, with parameters specifying the name of the localized string to retrieve and dynamic data that should be substituted into its tokens. The result is then displayed to the user with the alert statement. Typically, localization will occur inside the implementation for a widget class, so this example is purely for illustrating the syntax.

TIP: To aid in internationalizing legacy code, a script is provided that can be run in Windows Script Host and that will recurse through the folders of a Web site project in order to compile a report of all the string literals contained inside JavaScript files, using a heuristic algorithm to bucket them according to their likelihood of being internationalizable strings (see JavaScript Build Scripts).

For a more in-depth discussion of internationalization and localization, consult the guide JavaScript Localization.

15. Testing Framework

UIZE provides a robust testing framework to support writing unit tests, functional tests, and performance tests.

The testing framework has the following key benefits...

runs in any JavaScript environment - tests written for the UIZE testing framework can be run in any JavaScript environment, including NodeJS, WSH (Windows Script Host), a Web browser, etc.
synchronous and asynchronous test cases - the testing framework supports both synchronous as well as asynchronous tests, while not adding undue burden in the common case of writing synchronous tests
nesting, arbitrarily deep - any test can contain child tests, so tests can inherently be hierarchical in nature - any test suite can aggregate other test suites, so there's no limit to how you can structure test suites for more complex projects
declarative syntax - for convenience, tests can be defined using a declarative syntax
test run monitoring through events - the running of any test or test suite can be monitored through events that are fired as the test progresses
events for live logging - in addition to monitoring test running using the test events, these events can be used to log output to one or more logging systems
tests are atomic - every test is atomic and is only responsible for returning / reporting a success/fail result - there are no asserts
expectations based - the testing framework was designed from the beginning to be expectations based - some action is performed by a test and there is an expected result, and various methods in the Uize.Test base class provide convenient ways to test for different types of expectations being met
test result retention - after a test tree is run, all the instances created for running the test tree are retained, so the times taken and other information can be evaluated / analyzed afterwards - the data isn't all lost in some cryptic, text-based log file
multi-instantiation - because every test is a class, and every test run is an instance of a test class, an entire test suite can theoretically be multi-instantiated, and test suites like this that include asynchronous tests could even be multi-instantiated and run concurrently (at the very least, results from different runs can be compared from the different instances)

For more information on the testing framework, consult the guide JavaScript Testing Framework.

16. Templating System

UIZE implements a system for templating that allows the JavaScript language to be leveraged within templates, such templates being referred to as JavaScript templates.

This system allows for the use of programmatic logic and JavaScript control structures within a template for the purpose of rendering a result document. It's format and approach will be immediately familiar to anyone who has used the templating systems of other languages, such as Ruby's .erb templates, .NET's .aspx templates, Java's .jsp templates, etc.

The template engine is implemented in the Uize.Template module, which provides a means for compiling a source template into a more performant JavaScript function. Once compiled into JavaScript functions, JavaScript templates can be used to generate text output for a variety of purposes, including, for example, the generation of HTML markup for widgets, the generation of complete HTML documents as part of a Web project build process, and the generation of RSS documents from a data source.


var helloWorldTemplate = Uize.Template.compile (
  '<% for (var i = 0; i < input.repeats; i++) { %>' +
  '<p><% .message %></p>\n' +
  '<% } %>'

var myTemplateOutput = helloWorldTemplate ({repeats:5,message:'Hello World !'});

/* myTemplateOutput will now have the value...

<p>Hello World !</p>
<p>Hello World !</p>
<p>Hello World !</p>
<p>Hello World !</p>
<p>Hello World !</p>


In the above example, a JavaScript template in a string literal is being compiled to a JavaScript function, and then that function is being called with input data that is supplied to the template function. The result is assigned to a variable.

In practice, JavaScript templates are contained inside separate files with the extension .jst in order that the template source not be subject to a further level of escaping within JavaScript string literals.


<% for (var i = 0; i < input.repeats; i++) { %>
<p><% .message %></p>
<% } %>

JavaScript template files can be compiled into JavaScript modules with the use of JavaScript build scripts, and such modules can then be required as dependencies and treated as regular JavaScript modules. Alternatively, JavaScript template source can be embedded in non-visible elements of a Web page, such as a hidden textarea tag or a script tag with a mime type of text/jst, and then retrieved and compiled by client code when the document loads.

For a more in-depth discussion, consult the guide JavaScript Templates.

17. Effects / Animation

UIZE provides powerful features to support slick animation effects, with easing, bounce, elasticity, pulsing, and much more.

Effects and animation in the UIZE JavaScript Framework are achieved through use of a suite of associated modules. The Uize.Fade module provides the underpinnings of time-based animation and compound value interpolation, the Uize.Fade.xFactory extension module extends the Uize.Fade class with factory methods for creating, starting, and managing fades in a fade pool, and the Uize.Fx module provides static methods for initiating fades of CSS style properties.


// fade from thin border/thick padding to thick border/thin padding over 1/4 second
Uize.Fx.fadeStyle ('myNode',{borderWidth:1,padding:20},{borderWidth:20,padding:1},250);

// fade from current colors to white text on black background over two seconds
Uize.Fx.fadeStyle ('myNode',null,{color:'#fff',backgroundColor:'#000'},2000);

// fade font size from 30px back to current size over a half second
Uize.Fx.fadeStyle ('myNode',{fontSize:30},null,500);

To add some pizazz to animations, the UIZE JavaScript Framework provides the Uize.Curve, Uize.Curve.Mod, and Uize.Curve.Rubber modules that let you stray from the bland world of linear animations and into an exotic world of animations driven by arbitrary curve functions, with built-in support for easing curves as well as curves that emulate the complex properties of motion, letting you achieve effects like bounce, springiness, wobble, elasticity, etc. Beyond the built-ins, you have the freedom to roll your own curve functions in order to achieve some of the craziest motion effects you could imagine.

For a more in-depth discussion, consult the guide JavaScript Animation and Effects.

18. Documentation System

UIZE implements a system for building HTML from documentation that is written in a Wikitext like format called Simple Doc.

Document structure in this format is controlled through indentation, much like program structure can be governed by indentation in the Python programming language. A documentation builder script is provided that can run in Windows Script Host. This build script can recurse through all the folders of a Web site project, building HTML files from all Simple Doc files it finds, and extracting Simple Doc formatted documentation from specially flagged comments inside JavaScript module files and synthesizing these Simple Doc fragments together into Simple Doc documents for conversion into HTML documentation files.

The following example shows the documentation for the to instance method of the Uize.Color module. Notice how the documentation comment is indicated with the question mark immediately following the comment begin characters /*.


  Instance Methods
      Returns the current color of the instance, encoded to the specified format.

      encodedColor = colorOBJ.to (encodingSTR);

      The =encodingSTR= parameter supports a wide variety of different `color encodings`.

      var fuchsia = Uize.Color ('fuchsia');
      fuchsia.to ('color');       // produces a new Uize.Color object
      fuchsia.to ('hex');         // produces 'ff00ff'
      fuchsia.to ('#hex');        // produces '#ff00ff'
      fuchsia.to ('name');        // produces 'fuchsia'
      fuchsia.to ('RGB array');   // produces [255,0,255]
      fuchsia.to ('RGB int');     // produces 16711935
      fuchsia.to ('RGB object');  // produces {red:255,green:0,blue:255}
      fuchsia.to ('RGB string');  // produces 'rgb(255,0,255)'
      fuchsia.to ('HSL array');   // produces [300,100,50]
      fuchsia.to ('HSL object');  // produces {hue:300,saturation:100,lightness:50}
      fuchsia.to ('HSL string');  // produces 'hsl(300,100,50)'

      - see the related =Uize.Color.to= static method

For a more in-depth discussion of this documentation system, consult the guide JavaScript Documentation System.

19. Powerful Build System

UIZE provides a robust and extremely versatile and configurable build system that allows multi-level build relationships to be set up.

19.1. Responsibilities of the Build System

The build system takes care of the following responsibilities...

compiling from source - the build system can be configured to support any number of different source file formats, including UIZE source file formats like .js.jst (JavaScript templates), .csst (CSS templates), .simple (SimpleDoc), along with popular Open Source formats like .less for which JavaScript based processing code is available
compressing code - the build system can be configured to compress any number of different types of files (such as JavaScript and CSS), using any compressors that are implemented in JavaScript (such as UIZE's built-in JavaScript Scruncher, or other Open Source minifiers like UglifyJS)
gzipping code - along with compressing code, the build system can also be configured to create gzipped versions of any number of different types of files
building packages - the build system can be configured to create packages in order to bundle multiple files into a single file to reduce HTTP requests when you deploy a project to production
lots of other crazy stuff - that you make it do, since you can configure and extend the build system to do just about anything (it might even brew coffee for you, if you are a powerful enough JavaScript ninja)

19.2. Key Features of the Build System

The build system has the following compelling features...

integrated with development server - the build system integrates with the development server that runs in NodeJS and takes care of automatically rebuilding any files that have become invalidated by changes made to any source files from which they may be derived - directly or indirectly
builds incrementally - the build system can build files incrementally as needed and based upon changes that may invalidate one or more built files
dependency based - the build system is entirely dependency based, so there's no more worries about things being out-of-date because you couldn't remember the right set of build steps - all the dependencies for a build product are known and can be traced recursively, so all build steps necessary to update a file are performed in the correct order, and only as much work as is necessary is done
one-to-many, many-to-one - the build system supports one-to-many and many-to-one build relationships, so one file can be involved as a dependency in building many other files (eg. a source JavaScript file is used for building a compressed JavaScript file, a reference documentation file, a source code viewer HTML file, etc.), and many files can be used in building a single file (eg. a JavaScript source file and a documentation template file are involved in building a reference documentation HTML file)
entirely written in JS - the build system is written entirely in JavaScript, which means you can leverage all your JavaScript skills in configuring and extending it. It also means that any of the UIZE modules or modules from your own project can be loaded during the build process so you can use them in writing your build processes
works in NodeJS as well as WSH (Windows Script Host) - because the build system uses a file system service that abstracts the environment's file system API, the build system can be run in NodeJS, WSH (Windows Script Host), or any environment for which an adapter has been written for the file system service
blazingly fast - the build system is written from the ground up to be highly efficient and blazingly fast, and its incremental build characteristic means you don't waste time rebuilding stuff that's entirely unrelated to what you've modified or stuff that may already be completely current

For more information on the build system, consult the JavaScript Build Scripts guide.

20. Code Compression

UIZE provides a system for scrunching (minifying) JavaScript code - primarily to reduce its size, but also to obfuscate it.

While the network bandwidth that is used to transfer JavaScript code to the client can be reduced in order to reduce transfer time through the use of HTTP compression methods such as gzip, further code size reduction as well as a degree of code obfuscation can be achieved with the use of the Scruncher, a code minification utility that is provided as part of the UIZE JavaScript Framework. This utility can be accessed for individual use through a Web page interface, but can be more conveniently utilized as part of a build script that recurses through the folders of a Web site project and generates compressed and obfuscated code from all the JavaScript files it encounters.

Among the operations that are performed by the Scruncher are:

remove unnecessary whitespace, such as line indentation, unnecessary whitespace between tokens, and linebreaks
remove comments, including documentation comments
rename private identifiers to shortened, cryptic forms

Obfuscation that is provided by the Scruncher is an artifact of the code compression process, and the Scruncher is not designed to provide robust obfuscation.

The two examples below show first an extract of JavaScript code, and second the compressed and obfuscated form of that code. Notice how, in the compressed version of the code, private identifiers that were prefixed with an underscore in the source code have been reduced down to enumerated forms (eg. _a, _b, _c). For the sake of readability in this example, the LineCompacting setting is turned off for the compressed code.


/*ScruncherSettings Mappings="=" LineCompacting="FALSE"*/

_package.toAbsolute = function (_baseUrl,_url) {
  if (_package.from (_url).fullDomain) return _url;
    // return early with URL to resolve against base, if URL is absolute

  var _result = _baseUrl.slice (0,_baseUrl.search (/[\/\\][^\/\\]*$/) + 1);
    // remove everything after the last slash, but keep the last slash
  while (_url) {
      _slashPos = (_url.search (/[\/\\]/) + 1 || _url.length + 1) - 1,
      _folderName = _url.slice (0,_slashPos)
    _result = _folderName == '..'
      ? _result.slice (0,_result.search (/[\/\\][^\/\\]*[\/\\]$/) + 1) // remove end folder
      : _result + _folderName + _url.charAt (_slashPos)
    _url = _url.slice (_slashPos + 1);
  return _result;


if(_a.from(_c).fullDomain)return _c;
var _d=_b.slice(0,_b.search(/[\/\\][^\/\\]*$/)+1);
return _d;};

For a more in-depth discussion of the Scruncher code compression system, consult the guide All About Scrunching.

21. Dev Server (NodeJS)

UIZE provides a NodeJS based development server that allows a project that involves many different types of built files to be developed without having to constantly run build scripts between changes.

The development server utilizes the powerful build system to build derived files whenever they are requested and are not current (ie. some of their dependencies have been modified since the last time they were built). The development server is used in the development of the UIZE framework, itself, and it can be used for any project for which static files will be generated as part of a build process.

With the right configuration of your application server, you can pull all the static files that would be built as part of your build process from the development server running on your localhost. That way, you get the best of both worlds - you can keep using your existing server platform while using the UIZE development server for pre-processing of source code for static files.

22. Extensive Documentation

UIZE comes with extensive documentation, thanks in large parts to the built-in SimpleDoc documentation system and the powerful build system.

The UIZE documentation includes...

reference documentation for every module, containing at least generated implementation informtion and top quality hand written documentation in many of the more important / critical modules
in-depth guides on numerous topics, such as modules, inheritance, the state properties system, the event system, widgets, localization, templating, animation and effects, build scripts, the testing framework, etc.
new announcements for almost every new feature that is introduced
tons of examples that demonstrate how to use UIZE, and that are available in tours and are linked to from reference documentation
numerous tools to aid in development
UIZE unit tests runner so the unit tests can be run in a browser
widget visual samplers to allow widgets to be browsed and sampled by namespace
widget visual tests to allow visual tests for widgets to be run in a browser
and, of course, more good stuff

For more info, consule the guide Using the Documentation.

23. Cross-compatibility and Browser Abstraction

A number of compatibility issues arise when developing applications that must run on a variety of different Web browsers.

UIZE implements some abstractions to help with cross-browser development, such as abstracting the differences between how DOM events are implemented, or how opacity is supported in CSS. Most of these abstractions are implemented in the Uize.Node module.


Uize.Node.wire ('myNode','click',function () {alert ('You clicked me')});

The above example shows how the Uize.Node.wire static method of the Uize.Node module is used to wire a handler function to the click event of a DOM node with the id "myNode". The Uize.Node.wire method abstracts differences between the event systems of different browsers so that application developers don't need to conditionalize their code.

24. Progressive Enhancement / Unobtrusive JavaScript

UIZE offers its fair share of features that can be "stitched on" to a page's markup, without the page's knowledge or deliberate consent.

In the world of Web application development, there is a legitimate place for features that are implemented through the technique of progressive enhancement (sometimes referred to as unobtrusive JavaScript, or graceful degradation). Making tables sortable is a great example of how one can "stitch on" an enhanced user experience, without requiring much cooperation from the application development side of things. Other examples of progressive enhancement features provided in the framework are the lightweight image preview user interaction provided by the Uize.Widget.ThumbZoom widget class, and the ability of the Uize.Widget.Tree.Menu widget (and other subclasses of the Uize.Widget.Tree base class) to extract a hierarchical tree data structure from nested lists.

25. More Features

25.1. Working with JSON

UIZE provides functionality for serializing data to the JSON format, and deserializing from the JSON format.

JSON (JavaScript Object Notation) is a useful format for representing arbitrary data structures. JSON is often used as a format of choice for delivering responses to Ajax requests back to the client, since the response data can be easily deserialized in this format using a simple eval statement.

Static methods are provided in the Uize.Json module for encoding to and decoding from the JSON format. The versatile Uize.Json.to method allows data to be encoded to JSON format with a variety of formatting options, allowing everything from compact output to pretty-print output, where you can govern indentation, optional key sorting behavior, key padding and alignment, quote character for string literals and keys, key quoting rules, etc.

For a more in-depth discussion, consult the reference for the Uize.Json module.

25.2. Working with Strings

UIZE provides utility methods for working with strings in various modules under the Uize.Str namespace.

Modules under the Uize.Str namespace offer utilities for trimming whitespace padding, repeating substrings, joining strings in various ways, splitting strings, creating lookup based substring replacers, creating performant string builder objects, testing for the presence of prefixes or suffixes, working with multi-line strings, and more.

In the interests of code interoperability, extending native objects is not part of the design philosophy of the UIZE JavaScript Framework, so the string methods provided in the various modules under the Uize.Str namespace are not added to the prototype of JavaScript's String object. You're encouraged to use the native methods of JavaScript's String object as much as possible, and look to the static methods in the Uize.Str namespace modules for other capabilities.


alert (
  Uize.Str.Repeat.repeat ('-',70) + '\n' +
  Uize.Str.Repeat.repeat ('Hello, world! ',5) + '\n' +
  Uize.Str.Repeat.repeat ('=',70)

The above example will display an alert dialog with the output...

Hello, world! Hello, world! Hello, world! Hello, world! Hello, world!

For a more in-depth discussion, consult the references for the various modules under the Uize.Str namespace.

25.3. Working with URLs

UIZE provides utility methods for working with URLs in the Uize.Url module.

URLs are highly relevant to browser based applications, but URLs also have value outside of this context. Therefore, utilities for working with URLs shouldn't be tied to the browser. The Uize.Url module can be used in other contexts, such as Windows Script Host, where one might want to use build scripts to build HTML pages for a Web site project, and you might need to manipulate URLs for generating HTML for links and the like. The URL utilities inside this module make it easier to: serialize a params object to a params / query string, parse params from a params / query string into an object hash, resolve a path and params object into a URL string, absolutize URLs, split URLs up into all their component pieces, etc.

For a more in-depth discussion, consult the reference for the Uize.Url module.

25.4. Working with Dates

UIZE provides utility methods for working with dates in the Uize.Date module.

In the interests of code interoperability, extending native objects is not part of the design philosophy of the UIZE JavaScript Framework, so the methods of the Uize.Date module are not added to the prototype of JavaScript's Date object. You're encouraged to use the native methods of JavaScript's Date object as much as possible, and look to the static methods of the Uize.Date module for other capabilities. The date utilities inside this module make it easier to: encode dates to the ISO 8601 format (YYYY-MM-DD), decode dates from the ISO 8601 format, test if a date is recent, determine the number of days in a specific month of a specific year, convert a length of time from one unit to another, etc.

For a more in-depth discussion, consult the reference for the Uize.Date module.

25.5. Working with Colors

UIZE provides a comprehensive framework for working with colors, with support for color spaces, a wide variety of color encodings, a framework for named colors, extension modules that define additional color spaces and named colors, and extensions that provide utilities for manipulating colors.

Support for colors is provided in the Uize.Color module and its various extension modules, which offer the following functionality...

Color Encodings - A framework is provided for defining color encodings, offering a consistent and seemless way to convert from one encoding to another - even if those encodings are associated with different color spaces. A wide variety of built-in color encodings provide many convenient ways to express color values. Additional color encodings can be defined in extension modules.
Color Spaces - A framework is provided for defining color spaces and automatically handles conversion across color spaces. The sRGB and HSL color spaces are built into the Uize.Color module, and additional color spaces are defined in extension modules, such as the Uize.Color.xHsv module that defines the HSV color space.
Named Colors - A framework is provided for defining named colors. Once named colors are defined, color values can be specified using these names in all the methods of the Uize.Color object, its various extension modules, and any other modules that rely on the Uize.Color module for resolving color values. The seventeen named colors of the CSS 2.1 specification are built into the Uize.Color object, and the over one hundred named colors of the SVG 1.0 and CSS 3 specifications are defined in the Uize.Color.xSvgColors extension module.
Color Manipulation - Besides just being able to convert colors across encodings and color spaces, utilities are provided for blending two colors, mixing many colors, sorting colors, generating combination colors, generating random colors, testing for color equality, etc. These various color related utilities are provided in the Uize.Color.xUtil extension module.


Uize.Fx.fadeStyle (
  {borderColor:Uize.Color.random (),backgroundColor:'hsv(300,100%,100%)'}

In the above example, the Uize.Fx.fadeStyle static method of the Uize.Fx module is being used to initiate a fade of the border and background colors for the node with the id of "myNodeId". The starting border color is specified using a named color that is defined in the Uize.Color.xSvgColors extension. The starting background color is specified using the RGB array encoding that is built into the Uize.Color module. The ending border color is a random color generated using the Uize.Color.random static method implemented in the Uize.Color.xUtil extension, and the ending background color is specified using the HSV string encoding defined inside the Uize.Color.xHsv color space extension module. Color values can be specified with this flexibility in the Uize.Fx.fadeStyle method because the Uize.Fx module uses the Uize.Color module for resolving color values.

For a more in-depth discussion, consult the reference for the Uize.Color module.

25.6. Working with Data Structures

UIZE provides utility methods for working with various types of data structures in the Uize.Data module.

In the interests of code interoperability, extending native objects is not part of the design philosophy of the UIZE JavaScript Framework, so the methods of the Uize.Data module are not added to the prototypes of JavaScript's native objects (such as the Array and Object natives). You're encouraged to use the methods of JavaScript's built-in object as much as possible, and look to the static methods of the Uize.Data module for other capabilities.

Among other things, the data manipulation utilities inside this module make it easier to...

test if two arbitrarily complex data structures are identical
find a record from an array of record objects that matches specified criteria
create lookup and reverse lookup objects from a specified object
get the values for a specific property from an array of record objects
get an array of the keys of an object's properties
get an array of the values of an object's properties
test if an object is empty
get the min or max values from an array of numbers
reorder the elements of an array (eg. reverse, inside out, jumbled, etc.)

For a more in-depth discussion, consult the reference for the Uize.Data module.