Jump To …


Copyright 2012, 2013 The Apache Software Foundation

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at


Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.


Module that defines functions used for page initialization. The initialize function is passed an array of initializers; each initializer is itself an array. The first value in the initializer defines the name of the module to invoke. The module name may also indicate the function exported by the module, as a suffix following a colon: e.g., "my/module:myfunc". Any additional values in the initializer are passed to the function. The context of the function (this) is null.

define ["underscore", "./console", "./dom", "./events"],
  (_, console, dom, events) ->
    pathPrefix = null

Borrowed from Prototype:

    isOpera = Object.prototype.toString.call(window.opera) == '[object Opera]'
    isIE = !!window.attachEvent && !isOpera

    rebuildURL = (path) ->
      return path if path.match /^https?:/

See Tapestry.rebuildURL() for an error about the path not starting with a leading '/' We'll assume that doesn't happen.

      if !pathPrefix
        l = window.location
        pathPrefix = "#{l.protocol}//#{l.host}"

      return pathPrefix + path

    rebuildURLOnIE =
      if isIE then rebuildURL else _.identity

    addStylesheets = (newStylesheets) ->
      return unless newStylesheets

Figure out which stylesheets are loaded; adjust for IE, and especially, IE 9 which can report a stylesheet's URL as null (not empty string).

      loaded = _.chain(document.styleSheets)

      insertionPoint = _.find(document.styleSheets, (ss) ->
        parent = ss.ownerNode || ss.owningElement
        parent.rel is "stylesheet t-ajax-insertion-point")

Most browsers support document.head, but older IE doesn't:

      head = document.head or document.getElementsByTagName("head")[0]

      .map((ss) -> { href: rebuildURL(ss.href), media: ss.media })
      .reject((ss) -> loaded.contains(ss.href).value())
      .each((ss) ->
        element = document.createElement "link"
        element.setAttribute "type", "text/css"
        element.setAttribute "rel", "stylesheet"
        element.setAttribute "href", ss.href
        if ss.media
          element.setAttribute "media", ss.media

        if insertionPoint
          head.insertBefore element, insertionPoint.ownerNode
          head.appendChild element

        console.debug "Added stylesheet #{ss.href}"


    invokeInitializer = (tracker, qualifiedName, initArguments) ->
      [moduleName, functionName] = qualifiedName.split ':'

      require [moduleName], (moduleLib) ->

Some modules export nothing but do some full-page initialization, such as adding event handlers to the body.

        if not functionName and
          initArguments.length is 0 and
          not _.isFunction moduleLib
            console.debug "Loaded module #{moduleName}"

        fn = if functionName? then moduleLib[functionName] else moduleLib

        unless fn?
          throw new Error "Could not locate function `#{qualifiedName}'."

        if console.debugEnabled
          argsString = (JSON.stringify arg for arg in initArguments).join(", ")
          console.debug "Invoking #{qualifiedName}(#{argsString})"

        fn.apply null, initArguments


Loads all specified libraries in order (this includes the core stack, other stacks, and any free-standing libraries). It then executes the initializations. Once all initializations have completed (which is usually an asynchronous operation, as initializations may require the loading of further modules), then the data-page-initialized attribute of the <body> element is set to 'true'.

This is the main export of the module; other functions are attached as properties.

    loadLibrariesAndInitialize = (libraries, inits) ->
      console.debug "Loading #{libraries?.length or 0} libraries"
      exports.loadLibraries libraries,
        -> exports.initialize inits,

At this point, all libraries have been loaded, and all inits should have executed. Unless some of the inits triggered Ajax updates (such as a core/ProgressiveDisplay component), then the page should be ready to go. We set a flag, mostly used by test suites, to ensure that all is ready. Later Ajax requests will cause the data-ajax-active attribute to switch between "true" and "false", so some test logic may need to be driven by that instead.

            dom.body.attr "data-page-initialized", "true"

    exports = _.extend loadLibrariesAndInitialize,

Passed a list of initializers, executes each initializer in order. Due to asynchronous loading of modules, the exact order in which initializer functions are invoked is not predictable.

      initialize: (inits = [], callback) ->
        console.debug "Executing #{inits.length} inits"
        callbackCountdown = inits.length + 1

tracker gets invoked once after each require/callback, plus once extra (to handle the case where there are no inits). When the count hits zero, it invokes the callback (if there is one).

        tracker = ->

          if callbackCountdown is 0
            console.debug "All inits executed"
            callback() if callback

First value in each init is the qualified module name; anything after that are arguments to be passed to the identified function. A string is the name of a module to load, or function to invoke, that takes no parameters.

        for init in inits
          if _.isString init
            invokeInitializer tracker, init, []
            [qualifiedName, initArguments...] = init
            invokeInitializer tracker, qualifiedName, initArguments


Pre-loads a number of libraries in order. When the last library is loaded, invokes the callback (with no parameters).

      loadLibraries: (libraries, callback) ->
        reducer = (callback, library) -> ->
          console.debug "Loading library #{library}"
          require [library], callback

        finalCallback = _.reduceRight libraries, reducer, callback

        finalCallback.call null

      evalJavaScript: (js) ->
        console.debug "Evaluating: #{js}"
        eval js

Triggers the focus event on the field, if the field exist. Focus occurs delayed 1/8th of a second, which helps ensure that other initializions on the page are in place.

  • fieldId - element id of field to focus on
      focus: (fieldId) ->
        field = dom fieldId

        if field
          _.delay (-> field.focus()), 125

Passed the response from an Ajax request, when the request is successful. This is used for any request that attaches partial-page-render data to the main JSON object response. If no such data is attached, the callback is simply invoked immediately. Otherwise, Tapestry processes the partial-page-render data. This may involve loading some number of JavaScript libraries and CSS style sheets, and a number of direct updates to the DOM. After DOM updates, the callback is invoked, passed the response (with any Tapestry-specific data removed). After the callback is invoked, page initializations occur. This method returns null.

  • response - the Ajax response object
  • callback - invoked after scripts are loaded, but before page initializations occur (may be null)
      handlePartialPageRenderResponse: (response, callback) ->

Capture the partial page response portion of the overall response, and then remove it so it doesn't interfere elsewhere.

        responseJSON = response.json or {}
        partial = responseJSON._tapestry
        delete responseJSON._tapestry

Extreme case: the data has a redirectURL which forces an immediate redirect to the URL. No other initialization or callback invocation occurs.

        if partial?.redirectURL
          window.location.href = partial.redirectURL

        addStylesheets partial?.stylesheets

Make sure all libraries are loaded

        exports.loadLibraries partial?.libraries, ->

After libraries are loaded, update each zone:

          _(partial?.content).each ([id, content]) ->
            console.debug "Updating content for zone #{id}"

            zone = dom.wrap id

            if zone
              zone.trigger events.zone.update, { content }

Invoke the callback, if present. The callback may do its own content updates.

          callback and callback(response)

Lastly, perform initializations from the partial page render response.

          exports.initialize partial?.inits