/* Copyright (c) 2010, Yahoo! Inc. All rights reserved. Code licensed under the BSD License: http://developer.yahoo.com/yui/license.html version: 3.3.0 build: 3167 */ YUI.add('history-base', function(Y) { /** * Provides browser history management functionality using a simple * add/replace/get paradigm. This can be used to ensure that the browser's back * and forward buttons work as the user expects and to provide bookmarkable URLs * that return the user to the current application state, even in an Ajax * application that doesn't perform full-page refreshes. * * @module history * @since 3.2.0 */ /** * Provides global state management backed by an object, but with no browser * history integration. For actual browser history integration and back/forward * support, use the history-html5 or history-hash modules. * * @module history * @submodule history-base * @class HistoryBase * @uses EventTarget * @constructor * @param {Object} config (optional) configuration object, which may contain * zero or more of the following properties: * *
*
initialState (Object)
*
* Initial state to set, as an object hash of key/value pairs. This will be * merged into the current global state. *
*
*/ var Lang = Y.Lang, Obj = Y.Object, GlobalEnv = YUI.namespace('Env.History'), YArray = Y.Array, doc = Y.config.doc, docMode = doc.documentMode, win = Y.config.win, DEFAULT_OPTIONS = {merge: true}, EVT_CHANGE = 'change', SRC_ADD = 'add', SRC_REPLACE = 'replace'; function HistoryBase() { this._init.apply(this, arguments); } Y.augment(HistoryBase, Y.EventTarget, null, null, { emitFacade : true, prefix : 'history', preventable: false, queueable : true }); if (!GlobalEnv._state) { GlobalEnv._state = {}; } // -- Private Methods ---------------------------------------------------------- /** * Returns true if value is a simple object and not a * function or an array. * * @method _isSimpleObject * @param {mixed} value * @return {Boolean} * @private */ function _isSimpleObject(value) { return Lang.type(value) === 'object'; } // -- Public Static Properties ------------------------------------------------- /** * Name of this component. * * @property NAME * @type String * @static */ HistoryBase.NAME = 'historyBase'; /** * Constant used to identify state changes originating from the * add() method. * * @property SRC_ADD * @type String * @static * @final */ HistoryBase.SRC_ADD = SRC_ADD; /** * Constant used to identify state changes originating from the * replace() method. * * @property SRC_REPLACE * @type String * @static * @final */ HistoryBase.SRC_REPLACE = SRC_REPLACE; /** * Whether or not this browser supports the HTML5 History API. * * @property html5 * @type Boolean * @static */ // All HTML5-capable browsers except Gecko 2+ (Firefox 4+) correctly return // true for 'onpopstate' in win. In order to support Gecko 2, we fall back to a // UA sniff for now. (current as of Firefox 4.0b2) HistoryBase.html5 = !!(win.history && win.history.pushState && win.history.replaceState && ('onpopstate' in win || Y.UA.gecko >= 2)); /** * Whether or not this browser supports the window.onhashchange * event natively. Note that even if this is true, you may * still want to use HistoryHash's synthetic hashchange event * since it normalizes implementation differences and fixes spec violations * across various browsers. * * @property nativeHashChange * @type Boolean * @static */ // Most browsers that support hashchange expose it on the window. Opera 10.6+ // exposes it on the document (but you can still attach to it on the window). // // IE8 supports the hashchange event, but only in IE8 Standards // Mode. However, IE8 in IE7 compatibility mode still defines the // event but never fires it, so we can't just detect the event. We also can't // just UA sniff for IE8, since other browsers support this event as well. HistoryBase.nativeHashChange = ('onhashchange' in win || 'onhashchange' in doc) && (!docMode || docMode > 7); Y.mix(HistoryBase.prototype, { // -- Initialization ------------------------------------------------------- /** * Initializes this HistoryBase instance. This method is called by the * constructor. * * @method _init * @param {Object} config configuration object * @protected */ _init: function (config) { var initialState; /** * Configuration object provided by the user on instantiation, or an * empty object if one wasn't provided. * * @property _config * @type Object * @default {} * @protected */ config = this._config = config || {}; /** * Resolved initial state: a merge of the user-supplied initial state * (if any) and any initial state provided by a subclass. This may * differ from _config.initialState. If neither the config * nor a subclass supplies an initial state, this property will be * null. * * @property _initialState * @type Object|null * @default {} * @protected */ initialState = this._initialState = this._initialState || config.initialState || null; /** * Fired when the state changes. To be notified of all state changes * regardless of the History or YUI instance that generated them, * subscribe to this event on Y.Global. If you would rather * be notified only about changes generated by this specific History * instance, subscribe to this event on the instance. * * @event history:change * @param {EventFacade} e Event facade with the following additional * properties: * *
*
changed (Object)
*
* Object hash of state items that have been added or changed. The * key is the item key, and the value is an object containing * newVal and prevVal properties * representing the values of the item both before and after the * change. If the item was newly added, prevVal will be * undefined. *
* *
newVal (Object)
*
* Object hash of key/value pairs of all state items after the * change. *
* *
prevVal (Object)
*
* Object hash of key/value pairs of all state items before the * change. *
* *
removed (Object)
*
* Object hash of key/value pairs of state items that have been * removed. Values are the old values prior to removal. *
* *
src (String)
*
* The source of the event. This can be used to selectively ignore * events generated by certain sources. *
*
*/ this.publish(EVT_CHANGE, { broadcast: 2, defaultFn: this._defChangeFn }); // If initialState was provided, merge it into the current state. if (initialState) { this.add(initialState); } }, // -- Public Methods ------------------------------------------------------- /** * Adds a state entry with new values for the specified keys. By default, * the new state will be merged into the existing state, and new values will * override existing values. Specifying a null or * undefined value will cause that key to be removed from the * new state entry. * * @method add * @param {Object} state Object hash of key/value pairs. * @param {Object} options (optional) Zero or more of the following options: *
*
merge (Boolean)
*
*

* If true (the default), the new state will be merged * into the existing state. New values will override existing values, * and null or undefined values will be * removed from the state. *

* *

* If false, the existing state will be discarded as a * whole and the new state will take its place. *

*
*
* @chainable */ add: function () { var args = YArray(arguments, 0, true); args.unshift(SRC_ADD); return this._change.apply(this, args); }, /** * Adds a state entry with a new value for a single key. By default, the new * value will be merged into the existing state values, and will override an * existing value with the same key if there is one. Specifying a * null or undefined value will cause the key to * be removed from the new state entry. * * @method addValue * @param {String} key State parameter key. * @param {String} value New value. * @param {Object} options (optional) Zero or more options. See * add() for a list of supported options. * @chainable */ addValue: function (key, value, options) { var state = {}; state[key] = value; return this._change(SRC_ADD, state, options); }, /** * Returns the current value of the state parameter specified by key, * or an object hash of key/value pairs for all current state parameters if * no key is specified. * * @method get * @param {String} key (optional) State parameter key. * @return {Object|String} Value of the specified state parameter, or an * object hash of key/value pairs for all current state parameters. */ get: function (key) { var state = GlobalEnv._state, isObject = _isSimpleObject(state); if (key) { return isObject && Obj.owns(state, key) ? state[key] : undefined; } else { return isObject ? Y.mix({}, state, true) : state; // mix provides a fast shallow clone. } }, /** * Same as add() except that a new browser history entry will * not be created. Instead, the current history entry will be replaced with * the new state. * * @method replace * @param {Object} state Object hash of key/value pairs. * @param {Object} options (optional) Zero or more options. See * add() for a list of supported options. * @chainable */ replace: function () { var args = YArray(arguments, 0, true); args.unshift(SRC_REPLACE); return this._change.apply(this, args); }, /** * Same as addValue() except that a new browser history entry * will not be created. Instead, the current history entry will be replaced * with the new state. * * @method replaceValue * @param {String} key State parameter key. * @param {String} value New value. * @param {Object} options (optional) Zero or more options. See * add() for a list of supported options. * @chainable */ replaceValue: function (key, value, options) { var state = {}; state[key] = value; return this._change(SRC_REPLACE, state, options); }, // -- Protected Methods ---------------------------------------------------- /** * Changes the state. This method provides a common implementation shared by * the public methods for changing state. * * @method _change * @param {String} src Source of the change, for inclusion in event facades * to facilitate filtering. * @param {Object} state Object hash of key/value pairs. * @param {Object} options (optional) Zero or more options. See * add() for a list of supported options. * @protected * @chainable */ _change: function (src, state, options) { options = options ? Y.merge(DEFAULT_OPTIONS, options) : DEFAULT_OPTIONS; if (options.merge && _isSimpleObject(state) && _isSimpleObject(GlobalEnv._state)) { state = Y.merge(GlobalEnv._state, state); } this._resolveChanges(src, state, options); return this; }, /** * Called by _resolveChanges() when the state has changed. This method takes * care of actually firing the necessary events. * * @method _fireEvents * @param {String} src Source of the changes, for inclusion in event facades * to facilitate filtering. * @param {Object} changes Resolved changes. * @param {Object} options Zero or more options. See add() for * a list of supported options. * @protected */ _fireEvents: function (src, changes, options) { // Fire the global change event. this.fire(EVT_CHANGE, { _options: options, changed : changes.changed, newVal : changes.newState, prevVal : changes.prevState, removed : changes.removed, src : src }); // Fire change/remove events for individual items. Obj.each(changes.changed, function (value, key) { this._fireChangeEvent(src, key, value); }, this); Obj.each(changes.removed, function (value, key) { this._fireRemoveEvent(src, key, value); }, this); }, /** * Fires a dynamic "[key]Change" event. * * @method _fireChangeEvent * @param {String} src source of the change, for inclusion in event facades * to facilitate filtering * @param {String} key key of the item that was changed * @param {Object} value object hash containing newVal and * prevVal properties for the changed item * @protected */ _fireChangeEvent: function (src, key, value) { /** *

* Dynamic event fired when an individual history item is added or * changed. The name of this event depends on the name of the key that * changed. To listen to change events for a key named "foo", subscribe * to the fooChange event; for a key named "bar", subscribe * to barChange, etc. *

* *

* Key-specific events are only fired for instance-level changes; that * is, changes that were made via the same History instance on which the * event is subscribed. To be notified of changes made by other History * instances, subscribe to the global history:change event. *

* * @event [key]Change * @param {EventFacade} e Event facade with the following additional * properties: * *
*
newVal (mixed)
*
* The new value of the item after the change. *
* *
prevVal (mixed)
*
* The previous value of the item before the change, or * undefined if the item was just added and has no * previous value. *
* *
src (String)
*
* The source of the event. This can be used to selectively ignore * events generated by certain sources. *
*
*/ this.fire(key + 'Change', { newVal : value.newVal, prevVal: value.prevVal, src : src }); }, /** * Fires a dynamic "[key]Remove" event. * * @method _fireRemoveEvent * @param {String} src source of the change, for inclusion in event facades * to facilitate filtering * @param {String} key key of the item that was removed * @param {mixed} value value of the item prior to its removal * @protected */ _fireRemoveEvent: function (src, key, value) { /** *

* Dynamic event fired when an individual history item is removed. The * name of this event depends on the name of the key that was removed. * To listen to remove events for a key named "foo", subscribe to the * fooRemove event; for a key named "bar", subscribe to * barRemove, etc. *

* *

* Key-specific events are only fired for instance-level changes; that * is, changes that were made via the same History instance on which the * event is subscribed. To be notified of changes made by other History * instances, subscribe to the global history:change event. *

* * @event [key]Remove * @param {EventFacade} e Event facade with the following additional * properties: * *
*
prevVal (mixed)
*
* The value of the item before it was removed. *
* *
src (String)
*
* The source of the event. This can be used to selectively ignore * events generated by certain sources. *
*
*/ this.fire(key + 'Remove', { prevVal: value, src : src }); }, /** * Resolves the changes (if any) between newState and the current * state and fires appropriate events if things have changed. * * @method _resolveChanges * @param {String} src source of the changes, for inclusion in event facades * to facilitate filtering * @param {Object} newState object hash of key/value pairs representing the * new state * @param {Object} options Zero or more options. See add() for * a list of supported options. * @protected */ _resolveChanges: function (src, newState, options) { var changed = {}, isChanged, prevState = GlobalEnv._state, removed = {}; if (!newState) { newState = {}; } if (!options) { options = {}; } if (_isSimpleObject(newState) && _isSimpleObject(prevState)) { // Figure out what was added or changed. Obj.each(newState, function (newVal, key) { var prevVal = prevState[key]; if (newVal !== prevVal) { changed[key] = { newVal : newVal, prevVal: prevVal }; isChanged = true; } }, this); // Figure out what was removed. Obj.each(prevState, function (prevVal, key) { if (!Obj.owns(newState, key) || newState[key] === null) { delete newState[key]; removed[key] = prevVal; isChanged = true; } }, this); } else { isChanged = newState !== prevState; } if (isChanged) { this._fireEvents(src, { changed : changed, newState : newState, prevState: prevState, removed : removed }, options); } }, /** * Stores the specified state. Don't call this method directly; go through * _resolveChanges() to ensure that changes are resolved and all events are * fired properly. * * @method _storeState * @param {String} src source of the changes * @param {Object} newState new state to store * @param {Object} options Zero or more options. See add() for * a list of supported options. * @protected */ _storeState: function (src, newState) { // Note: the src and options params aren't used here, but they are used // by subclasses. GlobalEnv._state = newState || {}; }, // -- Protected Event Handlers --------------------------------------------- /** * Default history:change event handler. * * @method _defChangeFn * @param {EventFacade} e state change event facade * @protected */ _defChangeFn: function (e) { this._storeState(e.src, e.newVal, e._options); } }, true); Y.HistoryBase = HistoryBase; }, '3.3.0' ,{requires:['event-custom-complex']}); YUI.add('history-hash', function(Y) { /** * Provides browser history management backed by * window.location.hash, as well as convenience methods for working * with the location hash and a synthetic hashchange event that * normalizes differences across browsers. * * @module history * @submodule history-hash * @since 3.2.0 * @class HistoryHash * @extends HistoryBase * @constructor * @param {Object} config (optional) Configuration object. See the HistoryBase * documentation for details. */ var HistoryBase = Y.HistoryBase, Lang = Y.Lang, YArray = Y.Array, YObject = Y.Object, GlobalEnv = YUI.namespace('Env.HistoryHash'), SRC_HASH = 'hash', hashNotifiers, oldHash, oldUrl, win = Y.config.win, location = win.location, useHistoryHTML5 = Y.config.useHistoryHTML5; function HistoryHash() { HistoryHash.superclass.constructor.apply(this, arguments); } Y.extend(HistoryHash, HistoryBase, { // -- Initialization ------------------------------------------------------- _init: function (config) { var bookmarkedState = HistoryHash.parseHash(); // If an initialState was provided, merge the bookmarked state into it // (the bookmarked state wins). config = config || {}; this._initialState = config.initialState ? Y.merge(config.initialState, bookmarkedState) : bookmarkedState; // Subscribe to the synthetic hashchange event (defined below) to handle // changes. Y.after('hashchange', Y.bind(this._afterHashChange, this), win); HistoryHash.superclass._init.apply(this, arguments); }, // -- Protected Methods ---------------------------------------------------- _change: function (src, state, options) { // Stringify all values to ensure that comparisons don't fail after // they're coerced to strings in the location hash. YObject.each(state, function (value, key) { if (Lang.isValue(value)) { state[key] = value.toString(); } }); return HistoryHash.superclass._change.call(this, src, state, options); }, _storeState: function (src, newState) { var decode = HistoryHash.decode, newHash = HistoryHash.createHash(newState); HistoryHash.superclass._storeState.apply(this, arguments); // Update the location hash with the changes, but only if the new hash // actually differs from the current hash (this avoids creating multiple // history entries for a single state). // // We always compare decoded hashes, since it's possible that the hash // could be set incorrectly to a non-encoded value outside of // HistoryHash. if (src !== SRC_HASH && decode(HistoryHash.getHash()) !== decode(newHash)) { HistoryHash[src === HistoryBase.SRC_REPLACE ? 'replaceHash' : 'setHash'](newHash); } }, // -- Protected Event Handlers --------------------------------------------- /** * Handler for hashchange events. * * @method _afterHashChange * @param {Event} e * @protected */ _afterHashChange: function (e) { this._resolveChanges(SRC_HASH, HistoryHash.parseHash(e.newHash), {}); } }, { // -- Public Static Properties --------------------------------------------- NAME: 'historyHash', /** * Constant used to identify state changes originating from * hashchange events. * * @property SRC_HASH * @type String * @static * @final */ SRC_HASH: SRC_HASH, /** *

* Prefix to prepend when setting the hash fragment. For example, if the * prefix is ! and the hash fragment is set to * #foo=bar&baz=quux, the final hash fragment in the URL will * become #!foo=bar&baz=quux. This can be used to help make an * Ajax application crawlable in accordance with Google's guidelines at * http://code.google.com/web/ajaxcrawling/. *

* *

* Note that this prefix applies to all HistoryHash instances. It's not * possible for individual instances to use their own prefixes since they * all operate on the same URL. *

* * @property hashPrefix * @type String * @default '' * @static */ hashPrefix: '', // -- Protected Static Properties ------------------------------------------ /** * Regular expression used to parse location hash/query strings. * * @property _REGEX_HASH * @type RegExp * @protected * @static * @final */ _REGEX_HASH: /([^\?#&]+)=([^&]+)/g, // -- Public Static Methods ------------------------------------------------ /** * Creates a location hash string from the specified object of key/value * pairs. * * @method createHash * @param {Object} params object of key/value parameter pairs * @return {String} location hash string * @static */ createHash: function (params) { var encode = HistoryHash.encode, hash = []; YObject.each(params, function (value, key) { if (Lang.isValue(value)) { hash.push(encode(key) + '=' + encode(value)); } }); return hash.join('&'); }, /** * Wrapper around decodeURIComponent() that also converts + * chars into spaces. * * @method decode * @param {String} string string to decode * @return {String} decoded string * @static */ decode: function (string) { return decodeURIComponent(string.replace(/\+/g, ' ')); }, /** * Wrapper around encodeURIComponent() that converts spaces to * + chars. * * @method encode * @param {String} string string to encode * @return {String} encoded string * @static */ encode: function (string) { return encodeURIComponent(string).replace(/%20/g, '+'); }, /** * Gets the raw (not decoded) current location hash, minus the preceding '#' * character and the hashPrefix (if one is set). * * @method getHash * @return {String} current location hash * @static */ getHash: (Y.UA.gecko ? function () { // Gecko's window.location.hash returns a decoded string and we want all // encoding untouched, so we need to get the hash value from // window.location.href instead. We have to use UA sniffing rather than // feature detection, since the only way to detect this would be to // actually change the hash. var matches = /#(.*)$/.exec(location.href), hash = matches && matches[1] || '', prefix = HistoryHash.hashPrefix; return prefix && hash.indexOf(prefix) === 0 ? hash.replace(prefix, '') : hash; } : function () { var hash = location.hash.substr(1), prefix = HistoryHash.hashPrefix; // Slight code duplication here, but execution speed is of the essence // since getHash() is called every 50ms to poll for changes in browsers // that don't support native onhashchange. An additional function call // would add unnecessary overhead. return prefix && hash.indexOf(prefix) === 0 ? hash.replace(prefix, '') : hash; }), /** * Gets the current bookmarkable URL. * * @method getUrl * @return {String} current bookmarkable URL * @static */ getUrl: function () { return location.href; }, /** * Parses a location hash string into an object of key/value parameter * pairs. If hash is not specified, the current location hash will * be used. * * @method parseHash * @param {String} hash (optional) location hash string * @return {Object} object of parsed key/value parameter pairs * @static */ parseHash: function (hash) { var decode = HistoryHash.decode, i, len, matches, param, params = {}, prefix = HistoryHash.hashPrefix, prefixIndex; hash = Lang.isValue(hash) ? hash : HistoryHash.getHash(); if (prefix) { prefixIndex = hash.indexOf(prefix); if (prefixIndex === 0 || (prefixIndex === 1 && hash.charAt(0) === '#')) { hash = hash.replace(prefix, ''); } } matches = hash.match(HistoryHash._REGEX_HASH) || []; for (i = 0, len = matches.length; i < len; ++i) { param = matches[i].split('='); params[decode(param[0])] = decode(param[1]); } return params; }, /** * Replaces the browser's current location hash with the specified hash * and removes all forward navigation states, without creating a new browser * history entry. Automatically prepends the hashPrefix if one * is set. * * @method replaceHash * @param {String} hash new location hash * @static */ replaceHash: function (hash) { if (hash.charAt(0) === '#') { hash = hash.substr(1); } location.replace('#' + (HistoryHash.hashPrefix || '') + hash); }, /** * Sets the browser's location hash to the specified string. Automatically * prepends the hashPrefix if one is set. * * @method setHash * @param {String} hash new location hash * @static */ setHash: function (hash) { if (hash.charAt(0) === '#') { hash = hash.substr(1); } location.hash = (HistoryHash.hashPrefix || '') + hash; } }); // -- Synthetic hashchange Event ----------------------------------------------- // TODO: YUIDoc currently doesn't provide a good way to document synthetic DOM // events. For now, we're just documenting the hashchange event on the YUI // object, which is about the best we can do until enhancements are made to // YUIDoc. /** *

* Synthetic window.onhashchange event that normalizes differences * across browsers and provides support for browsers that don't natively support * onhashchange. *

* *

* This event is provided by the history-hash module. *

* *

* Usage example: *

* *
 * YUI().use('history-hash', function (Y) {
 *   Y.on('hashchange', function (e) {
 *     // Handle hashchange events on the current window.
 *   }, Y.config.win);
 * });
 * 
* * @event hashchange * @param {EventFacade} e Event facade with the following additional * properties: * *
*
oldHash
*
* Previous hash fragment value before the change. *
* *
oldUrl
*
* Previous URL (including the hash fragment) before the change. *
* *
newHash
*
* New hash fragment value after the change. *
* *
newUrl
*
* New URL (including the hash fragment) after the change. *
*
* @for YUI * @since 3.2.0 */ hashNotifiers = GlobalEnv._notifiers; if (!hashNotifiers) { hashNotifiers = GlobalEnv._notifiers = []; } Y.Event.define('hashchange', { on: function (node, subscriber, notifier) { // Ignore this subscription if the node is anything other than the // window or document body, since those are the only elements that // should support the hashchange event. Note that the body could also be // a frameset, but that's okay since framesets support hashchange too. if (node.compareTo(win) || node.compareTo(Y.config.doc.body)) { hashNotifiers.push(notifier); } }, detach: function (node, subscriber, notifier) { var index = YArray.indexOf(hashNotifiers, notifier); if (index !== -1) { hashNotifiers.splice(index, 1); } } }); oldHash = HistoryHash.getHash(); oldUrl = HistoryHash.getUrl(); if (HistoryBase.nativeHashChange) { // Wrap the browser's native hashchange event. Y.Event.attach('hashchange', function (e) { var newHash = HistoryHash.getHash(), newUrl = HistoryHash.getUrl(); // Iterate over a copy of the hashNotifiers array since a subscriber // could detach during iteration and cause the array to be re-indexed. YArray.each(hashNotifiers.concat(), function (notifier) { notifier.fire({ _event : e, oldHash: oldHash, oldUrl : oldUrl, newHash: newHash, newUrl : newUrl }); }); oldHash = newHash; oldUrl = newUrl; }, win); } else { // Begin polling for location hash changes if there's not already a global // poll running. if (!GlobalEnv._hashPoll) { if (Y.UA.webkit && !Y.UA.chrome && navigator.vendor.indexOf('Apple') !== -1) { // Attach a noop unload handler to disable Safari's back/forward // cache. This works around a nasty Safari bug when the back button // is used to return from a page on another domain, but results in // slightly worse performance. This bug is not present in Chrome. // // Unfortunately a UA sniff is unavoidable here, but the // consequences of a false positive are minor. // // Current as of Safari 5.0 (6533.16). // See: https://bugs.webkit.org/show_bug.cgi?id=34679 Y.on('unload', function () {}, win); } GlobalEnv._hashPoll = Y.later(50, null, function () { var newHash = HistoryHash.getHash(), newUrl; if (oldHash !== newHash) { newUrl = HistoryHash.getUrl(); YArray.each(hashNotifiers.concat(), function (notifier) { notifier.fire({ oldHash: oldHash, oldUrl : oldUrl, newHash: newHash, newUrl : newUrl }); }); oldHash = newHash; oldUrl = newUrl; } }, null, true); } } Y.HistoryHash = HistoryHash; // HistoryHash will never win over HistoryHTML5 unless useHistoryHTML5 is false. if (useHistoryHTML5 === false || (!Y.History && useHistoryHTML5 !== true && (!HistoryBase.html5 || !Y.HistoryHTML5))) { Y.History = HistoryHash; } }, '3.3.0' ,{requires:['event-synthetic', 'history-base', 'yui-later']}); YUI.add('history-hash-ie', function(Y) { /** * Improves IE6/7 support in history-hash by using a hidden iframe to create * entries in IE's browser history. This module is only needed if IE6/7 support * is necessary; it's not needed for any other browser. * * @module history * @submodule history-hash-ie * @since 3.2.0 */ // Combination of a UA sniff to ensure this is IE (or a browser that wants us to // treat it like IE) and feature detection for native hashchange support (false // for IE < 8 or IE8/9 in IE7 mode). if (Y.UA.ie && !Y.HistoryBase.nativeHashChange) { var Do = Y.Do, GlobalEnv = YUI.namespace('Env.HistoryHash'), HistoryHash = Y.HistoryHash, iframe = GlobalEnv._iframe, win = Y.config.win, location = win.location, lastUrlHash = ''; /** * Gets the raw (not decoded) current location hash from the IE iframe, * minus the preceding '#' character and the hashPrefix (if one is set). * * @method getIframeHash * @return {String} current iframe hash * @static */ HistoryHash.getIframeHash = function () { if (!iframe || !iframe.contentWindow) { return ''; } var prefix = HistoryHash.hashPrefix, hash = iframe.contentWindow.location.hash.substr(1); return prefix && hash.indexOf(prefix) === 0 ? hash.replace(prefix, '') : hash; }; /** * Updates the history iframe with the specified hash. * * @method _updateIframe * @param {String} hash location hash * @param {Boolean} replace (optional) if true, the current * history state will be replaced without adding a new history entry * @protected * @static * @for HistoryHash */ HistoryHash._updateIframe = function (hash, replace) { var iframeDoc = iframe && iframe.contentWindow && iframe.contentWindow.document, iframeLocation = iframeDoc && iframeDoc.location; if (!iframeDoc || !iframeLocation) { return; } iframeDoc.open().close(); if (replace) { iframeLocation.replace(hash.charAt(0) === '#' ? hash : '#' + hash); } else { iframeLocation.hash = hash; } }; Do.after(HistoryHash._updateIframe, HistoryHash, 'replaceHash', HistoryHash, true); if (!iframe) { Y.on('domready', function () { // Create a hidden iframe to store history state, following the // iframe-hiding recommendations from // http://www.paciellogroup.com/blog/?p=604. // // This iframe will allow history navigation within the current page // context. After navigating to another page, all but the most // recent history state will be lost. // // Earlier versions of the YUI History Utility attempted to work // around this limitation by having the iframe load a static // resource. This workaround was extremely fragile and tended to // break frequently (and silently) since it was entirely dependent // on IE's inconsistent handling of iframe history. // // Since this workaround didn't work much of the time anyway and // added significant complexity, it has been removed, and IE6 and 7 // now get slightly degraded history support. iframe = GlobalEnv._iframe = Y.Node.getDOMNode(Y.Node.create( '