index.rst

DOMBuilder

DOMBuilder takes some of the pain out of dynamically creating HTML content in JavaScript and supports generating multiple types of output from the same inputs.

core dommode htmlmode news license

Quick Guide

DOMBuilder provides a convenient, declarative API for generating HTML elements, via objects which contain functions named for the HTML element they create:

with(DOMBuilder.dom) {
  var article =
    DIV({'class': 'article'}
    , H2('Article title')
    , P('Paragraph one')
    , P('Paragraph two')
    )
}

Every element function also has a map function attached to it which allows you to easily generate content from a list of items:

var el = DOMBuilder.html
function shoppingList(items) {
  return el.OL(el.LI.map(items))
}

>>> shoppingList(['Cheese', 'Bread', 'Butter'])
<ol><li>Cheese</li><li>Bread</li><li>Butter</li></ol>

You can control map output by passing in a callback function:

function opinionatedShoppingList(items) {
  return el.OL(el.LI.map(function(item, attrs, loop) {
    if (item == 'Cheese') attrs['class'] = 'eww'
    if (item == 'Butter') return el.EM(item)
    return item
  })
}

>>> opinionatedShoppingList(['Cheese', 'Bread', 'Butter'])
<ol><li class="eww">Cheese</li><li>Bread</li><li><em>Butter</em></li></ol>

If you want to use this API to go straight to a particular type of output, you can do so using the functions defined in :jsDOMBuilder.dom and :jsDOMBuilder.html, as demonstrated above.

If you want to be able to switch freely between output modes, or you won't know which kind of output you need until runtime, you can use the same API via :jsDOMBuilder.elements, controlling what it outputs by setting the :jsDOMBuilder.mode flag to 'dom' or 'html', or calling a function which generates content using :jsDOMBuilder.withMode:

var el = DOMBuilder.elements
function shoutThing(thing) {
  return el.STRONG(thing)
}

>>> DOMBuilder.mode = 'html'
>>> shoutThing('Hello!').toString()
<strong>Hello!</strong>
>>> DOMBuilder.withMode('dom', shoutThing, 'Hey there!')
[object HTMLStrongElement]

This is useful for writing libraries which need to support outputting both DOM Elements and HTML Strings, or for unit-testing code which normally generates DOM Elements by flipping the mode in your tests to switch to HTML String output.

DOMBuilder also supports using its output modes with another common means of defining HTML in JavaScript code, using nested lists (representing elements and their contents) and objects (representing attributes), like so:

var article =
  ['div', {'class': 'article'}
  , ['h2', 'Article title']
  , ['p', 'Paragraph one']
  , ['p', 'Paragraph two']
  ]

You can generate output from one of these structures using :jsDOMBuilder.build, specifying the output mode:

>>> DOMBuilder.build(article, 'html').toString()
<div class="article"><h2>Article title</h2><p>Paragraph one</p><p>Paragraph two</p></div>

>>> DOMBuilder.build(article, 'dom').toString()
[object HTMLDivElement]

You can also generate these kinds of structures using the element functions defined in :jsDOMBuilder.array.

This is just a quick guide to what DOMBuilder can do - dive into the rest of the documentation to find out about the rest of its features, such as:

• Registering event-handlers.
• Making it more convenient to work with event-handlers-innerhtml.
• Populating document-fragments with content in a single call.
• Being able to use fragments in HTML mode via mock-dom-objects.
• html-escaping in HTML mode.

Installation

Browsers

DOMBuilder is a modular library, which supports adding new output modes and feature modes as plugins.

The available components are:

DOMBuilder.js

Core library

DOMBuilder.dom.js

DOM output mode - adds DOMBuilder.dom

DOMBuilder.html.js

HTML output mode - adds DOMBuilder.html

Compressed Builds

Multiple preconfigured, compressed builds of DOMBuilder are available to suit various needs:

DOM and HTML

For creation of mixed content, with dommode as the default output format.

DOM only

For creation of DOM Elements, with dommode as the default output format.

HTML only

For creation of HTML Strings, with htmlmode as the default output format.

Dependencies

There are no required dependencies, but if jQuery (>= 1.4) is available, DOMBuilder will make use of it when creating DOM Elements and setting up their attributes and event handlers.

If not, DOMBuilder will fall back to using some less comprehensive workarounds for cross-browser DOM issues and use the traditional event registration model for compatibility.

1.4 jQuery was made optional, with the caveat that cross-browser support will be less robust.

Node.js

1.4.1

DOMBuilder can be installed as a Node.js module using Node Package Manager. The Node.js build includes htmlmode and has HTML as the default output format.

Install:

npm install DOMBuilder

Import:

var DOMBuilder = require('DOMBuilder')