{text}
*
* Output:
*
* the text
* the text
*/
'dirAttr': function (chunk, context, bodies, params) {
if (!params || !params.hasOwnProperty('text')) {
return chunk.setError('@dirAttr helper called without required parameter "text"');
}
return chunk.write('dir="' + (rtl.isRtl(dust.helpers.tap(params.text, chunk, context))? 'rtl' : 'ltr') + '"');
},
/**
* A helper to conditionally render content.
* If the given text is considered right-to-left
* render if block, otherwise render else block.
* The method will log a message if no body block
* is provided.
*
* Example:
*
* {@isRtl text=ugc}yes{:else}no{/isRtl}
* {@isRtl text=ugc}foo{/isRtl}
*
* Output:
*
* yes
* no
*/
'isRtl': function (chunk, context, bodies, params) {
var body = bodies.block,
skip = bodies['else'];
if (!params || !params.hasOwnProperty('text')) {
return chunk.setError('@isRtl helper called without required parameter "text"');
}
if(rtl.isRtl(dust.helpers.tap(params.text, chunk, context))) {
if (body) {
chunk.render(body, context);
} else {
dust.log( 'Missing body block in the isRtl helper!', 'INFO' );
}
} else {
if (skip) {
chunk.render(skip, context);
}
}
return chunk;
}
};
var key;
for (key in dustVars) {
dust[key] = dustVars[key];
}
for (key in helpers) {
dust.helpers[key] = helpers[key];
}
}));
// Monkey patch Dust.log
(function (root, dust) {
var oldDustLog;
if (dust.log) {
oldDustLog = dust.log;
dust.log = function dustErrorReportToJet(message, type) {
try {
if (root.jet && (type === 'ERROR' || type === 'WARN')) {
if (message instanceof Error) {
jet.error(message);
} else if (typeof message === 'string') {
try {
throw new Error(message);
} catch (err) {
jet.error(err);
}
}
}
} finally {
return oldDustLog.apply(dust, arguments);
}
};
} else if (root.jet) {
jet.error(new Error("The function dust.log doesn't exist in this version."));
}
}(this, dust));
(function(root) {
"use strict";
root.play = root.play || {};
root.sc = root.sc || {};
sc.hashes = sc.hashes || {};
})(this);
/**
* Utility JavaScript functions that are not related to dust, Play, or LinkedIn. Many of these exist in jQuery or
* underscore, but we don't want the Play code to bring in these dependencies and have to deal with all sorts of
* conflicts.
*/
(function (play, root) {
"use strict";
play.EVENTS = {};
play.EVENTS.DUST_READY = 'playDustReady';
play.Utils = {};
var Utils = play.Utils;
// Establish the object that gets returned to break out of a loop iteration.
var breaker = {};
// continue to polyfill startsWith and endsWith for play-urls and play apps
// it was removed https://gitli.corp.linkedin.com/formatters/formatters-js/commit/786795508bf4af26b0a010fa78bd06686bc12328
/* IE doesn't have startsWith for String: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String/startsWith */
if (!String.prototype.startsWith) {
String.prototype.startsWith = function (searchString, position) {
position = position || 0;
return this.indexOf(searchString, position) === position;
};
}
/**
* Add endsWith to Strings: http://stackoverflow.com/questions/280634/endswith-in-javascript
*/
if (!String.prototype.endsWith) {
String.prototype.endsWith = function (suffix) {
return this.indexOf(suffix, this.length - suffix.length) !== -1;
};
}
// The ECMAScript 5 native function implementation
// of filter
var ArrayProto = Array.prototype,
ObjProto = Object.prototype,
nativeFilter = ArrayProto.filter,
nativeForEach = ArrayProto.forEach,
nativeMap = ArrayProto.map,
nativeSome = ArrayProto.some,
toString = ObjProto.toString,
hasOwnProperty = ObjProto.hasOwnProperty,
playEventsHash = {};
/**
* Shortcut function for checking if an object has a given property directly on itself (in other words, not on a prototype).
* @param obj
* @param key
*/
Utils.has = function (obj, key) {
return hasOwnProperty.call(obj, key);
};
/**
* Retrieve all the names of the object's properties.
* @param obj
*/
Utils.keys = function (obj) {
if (obj !== Object(obj)) {
throw new TypeError('Invalid object');
}
var keys = [];
for (var key in obj) {
if (Utils.has(obj, key)) {
keys.push(key);
}
}
return keys;
};
/**
* Produces a new array of values by executing a function on each value in list and
* returning the value if the function returns true.
* If the native filter method exists, it will be used instead. If list is a JavaScript object, iterator's arguments will be (value, key, list).
* @param obj
* @param iterator
* @param context
*/
Utils.filter = function (obj, iterator, context) {
var results = [];
if (obj == null) {
return results;
}
if (nativeFilter && obj.filter === nativeFilter) {
return obj.filter(iterator, context);
}
Utils.each(obj, function (value, index, list) {
if (iterator.call(context, value, index, list)) {
results.push(value);
}
});
return results;
};
/**
* Assert that condition is true and throw an Error with message if it's not.
* @param condition
* @param message
*/
Utils.assert = function (condition, message) {
if (!condition) {
throw new Error(message);
}
};
/**
* Iterates over a list of elements, yielding each in turn to an iterator function.
* @param obj
* @param iterator
* @param context
*/
Utils.each = function (obj, iterator, context) {
if (obj == null) return;
if (nativeForEach && obj.forEach === nativeForEach) {
obj.forEach(iterator, context);
} else if (obj.length === +obj.length) {
for (var i = 0, length = obj.length; i < length; i++) {
if (iterator.call(context, obj[i], i, obj) === breaker) return;
}
} else {
var keys = Utils.keys(obj);
for (var i = 0, length = keys.length; i < length; i++) {
if (iterator.call(context, obj[keys[i]], keys[i], obj) === breaker) return;
}
}
};
/**
* Returns the same value that is used as the argument. In math: f(x) = x
* @param value
*/
Utils.identity = function (value) {
return value;
};
/**
* Returns true if any of the values in the list pass the iterator truth test.
* Short-circuits and stops traversing the list if a true element is found.
* @param obj
* @param iterator
* @param context
*/
Utils.any = Utils.some = function (obj, iterator, context) {
iterator || (iterator = Utils.identity);
var result = false;
if (obj == null) return result;
if (nativeSome && obj.some === nativeSome) return obj.some(iterator, context);
Utils.each(obj, function (value, index, list) {
if (result || (result = iterator.call(context, value, index, list))) return breaker;
});
return !!result;
};
/**
* Returns true if value is undefined.
* @param obj
* @returns {boolean}
*/
Utils.isUndefined = function (obj) {
return obj === void 0;
};
/**
* Check that obj is not undefined/null
* @param obj
* @returns {boolean}
*/
Utils.isDefined = function (obj) {
return !Utils.isUndefined(obj) && !Utils.isNull(obj);
};
/**
* Returns true if the value of object is null.
* @param obj
*/
Utils.isNull = function (obj) {
return obj === null;
};
/**
* Assert that the given value is not undefined/null and throw an Error with message if it is
* @param value
* @param message
*/
Utils.assertDefined = function (value, message) {
Utils.assert(Utils.isDefined(value), message);
};
/**
* Produces a new array of values by mapping each value in list through a transformation function (iterator).
* If the native map method exists, it will be used instead. If list is a JavaScript object, iterator's arguments will be (value, key, list).
* @param obj
* @param iterator
* @param context
*/
Utils.map = function (obj, iterator, context) {
var results = [];
if (obj == null) return results;
if (nativeMap && obj.map === nativeMap) return obj.map(iterator, context);
Utils.each(obj, function (value, index, list) {
results.push(iterator.call(context, value, index, list));
});
return results;
};
/**
* Copy all of the properties in the source objects over to the destination object, and return the destination object.
* It's in-order, so the last source will override properties of the same name in previous arguments.
* @param obj
*/
Utils.extend = function (obj) {
Utils.each(ArrayProto.slice.call(arguments, 1), function (source) {
if (source) {
for (var prop in source) {
obj[prop] = source[prop];
}
}
});
return obj;
};
/**
* Returns true if object is an Array.
* @param object
*/
Utils.isArray = function (obj) {
return toString.call(obj) == '[object Array]';
};
/**
* IE doesn't have indexOf for Array: https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/Array/IndexOf
*
*/
if (!Array.prototype.indexOf) {
Array.prototype.indexOf = function (searchElement /*, fromIndex */) {
if (this === null) {
throw new TypeError();
}
var t = Object(this);
var len = t.length >>> 0;
if (len === 0) {
return -1;
}
var n = 0;
if (arguments.length > 1) {
n = Number(arguments[1]);
if (n !== n) { // shortcut for verifying if it's NaN
n = 0;
} else if (n !== 0 && n !== Infinity && n !== -Infinity) {
n = (n > 0 || -1) * Math.floor(Math.abs(n));
}
}
if (n >= len) {
return -1;
}
var k = n >= 0 ? n : Math.max(len - Math.abs(n), 0);
for (; k < len; k++) {
if (k in t && t[k] === searchElement) {
return k;
}
}
return -1;
};
}
/**
* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray
*/
if (!Array.isArray) {
Array.isArray = function (vArg) {
return Object.prototype.toString.call(vArg) === "[object Array]";
};
}
/**
* Download and execute the script at the given url. Fire callback when done.
*
* @param url
* @param callback
*/
play.getScript = function (url, callback) {
Utils.assert(url, "getScript called with null url");
var script = document.createElement("script");
script.src = url;
play.executeScript(script, callback);
};
/**
* Execute the JavaScript in script, which should be a DOM script node. Fire callback when done.
*
* Stolen from: https://github.com/jquery/jquery/blob/master/src/ajax/script.js
*
* @param script
* @param callback
*/
play.executeScript = function (script, callback) {
Utils.assert(play.isClient, "executeScript should only be used for client-side rendering!");
Utils.assert(script, "executeScript called with null script");
var head = document.head || document.getElementsByTagName("head")[0] || document.documentElement;
script.async = "async";
var cleanup = function () {
if (head && script.parentNode) {
head.removeChild(script);
}
script = undefined;
};
if (script.src) {
script.onload = script.onreadystatechange = function (_, isAbort) {
if (isAbort || !script.readyState || /loaded|complete/.test(script.readyState)) {
script.onload = script.onreadystatechange = null;
cleanup();
if (!isAbort && callback) {
callback();
}
}
};
}
/* We have to keep a reference to the inserted HTMLScriptElement from insertBefore return value as
IE may trigger the onload/onreadystatechange callback before returning control if the script source
file is already cached by the browser, and our cleanup function declared above would render the
script variable undefined. */
script = head.insertBefore(script, head.firstChild);
if (typeof(script) !== 'undefined' && !script.src) {
cleanup();
if (callback) {
callback();
}
}
};
/**
* Given a path like "A.B.C", safely traverse obj and return the value obj["A"]["B"]["C"]. If at any point an
* intermediate value is null (e.g. obj["A"]["B"] is null before getting to ["C"]), return null, unless required is
* set to true, in which case, throw an exception.
*
* @param obj
* @param path
* @param required
* @return {*}
*/
play.traverseObject = function (obj, path, required) {
Utils.assert(path, "traverseObject called with null path");
Utils.assert(obj || !required, "traverseObject called with a null object, but required is set to true");
var parts = path.split(".");
for (var i = 0; i < parts.length; i++) {
obj = obj ? obj[parts[i]] : obj;
if (!obj) {
Utils.assert(!required, "traverseObject could not find required path " + path);
return null;
}
}
return obj;
};
/**
* Utility function to print a log. Can be used in both normal browsers and Rhino envrionment. Noop if not in either
* environment.
*
* @param msg
*/
play.log = function (msg) {
if (root.console && root.console.log) {
// Normal browsers
root.console.log(msg);
} else if (root.java && root.java.lang && root.java.lang.System && root.java.lang.System.out && root.java.lang.System.out.println) {
// Rhino: http://stackoverflow.com/questions/12399462/rhino-print-function
root.java.lang.System.out.println(msg);
}
};
/**
* Utility function for creating dust template alias. This function is primarily used by DustPlugin when performing
* client side rendering
*
* @param templatePath
* @param alias
*/
play.templateAlias = function (templatePath, alias) {
if (dust && dust.cache) {
if (templatePath in dust.cache) {
dust.cache[alias] = dust.cache[templatePath];
} else {
dust.log("Unable to find template '" + templatePath + '" to create alias "' + alias + "'", 'ERROR');
}
} else {
play.log("Unable to find dust or dust.cache. Please ensure dust js is included in your base page.")
}
}
/**
* a namespace for utility functions inspired by underscore/lodash
*/
play._ = {};
/**
* A specialized verson of some for arrays without support for callback shorthands and `this` binding
* @see lodash.js arraySome
*/
play._.some = function (array, predicate) {
var index = -1,
length = array.length;
while (++index < length) {
if (predicate(array[index], index, array)) {
return true;
}
}
return false;
};
/**
* a simplified underscore.omit where we just support a flat object and a flat array
*/
play._.omit = function (obj, arrayKeysToOmit) {
var result = {};
// loop through the object and copy every key/value that isn't being omitted
for (var prop in obj) {
if (obj.hasOwnProperty(prop) && arrayKeysToOmit.indexOf(prop) === -1) {
result[prop] = obj[prop];
}
}
return result;
};
/**
* A specialized verson of reduce for arrays without support for callbacks and this binding
* @see lodash.js arrayReduce
*/
play._.reduce = function (array, iteraree, accumulator, initFromArray) {
var index = -1,
length = array.length;
if (initFromArray && length) {
accumulator = array[++index];
}
while (++index < length) {
accumulator = iteraree(accumulator, array[index], index, array);
}
return accumulator;
};
/**
* copied from underscore
*/
play._.result = function (object, property) {
if (object === null) {
return null;
}
var value = object[property];
return typeof value === 'function' ? value.call(object) : value;
};
/**
* Allows subscribing to events generated by Play
* @param event
* @param callback
*/
play.on = function (event, callback) {
if (typeof playEventsHash[event] === 'undefined') {
playEventsHash[event] = [];
}
playEventsHash[event].push(callback);
};
/**
* Allows unsubscribing from events generated by Play
* @param event
* @param callback
*/
play.off = function (event, callback) {
var callbacks = playEventsHash[event];
if (typeof callbacks === 'undefined') {
return;
}
for (var i = 0, len = callbacks.length; i < len; i++) {
if (callbacks[i] === callback) {
callbacks.splice(i, 1);
break;
}
}
};
/**
* Triggers Play events
* @param event
* @param params
*/
play.trigger = function (event, params) {
if (typeof playEventsHash[event] !== 'undefined') {
for (var i = 0, len = playEventsHash[event].length; i < len; i++) {
playEventsHash[event][i].apply(this, params);
}
}
}
})(play, this);
/**
* This file is copied from util-i18n-js/src/dust/html-utils.js
*
* Utility functions for creating HTML markup
*/
(function(play, LI, dust) {
"use strict";
var HtmlUtils = LI.HtmlUtils = {};
var Utils = play.Utils;
/**
* Convenient wrapper extracts filter options from a params object
* and uses dust.filter() to filter a string.
*
* Example:
*
* dustFilter(str, 's|j')
*
* Returns:
*
* str with HTML unescaped and Javascript escaped
*
* @param str string to filter
* @param params
* @return {String}
*/
HtmlUtils.dustFilter = function(str, params) {
var filters = [];
if (params && params.filters) {
filters = Utils.map(params.filters.split('|'), function(elem) { return elem.trim(); });
}
return dust.filter(str, 'h', filters);
};
/**
* Create an HTML tag with the given name, attributes, and body. Properly handles escaping characters for display as
* HTML. Correctly handles closing tags, including scripts. Note: this function does NOT HTML escape the (optional)
* body parameter. As the body may contain arbitrary markup, you must ensure that your own code handles escaping for
* it.
*
* Examples:
*
* createHtmlTag("div", {id: "foo"}, "bar")
*
* Returns: bar
*
* createHtmlTag("script", {src: "foo.js"})
*
* Returns:
*
* @param tagName
* @param attributes
* @param body
* @return {String}
*/
HtmlUtils.createHtmlTag = function(tagName, attributes, body) {
Utils.assert(tagName, "createHtmlTag called with null or undefined tagName");
var tagNameEscaped = dust.escapeHtml(tagName);
var out = "<" + tagNameEscaped;
if (attributes) {
var htmlAttributes = HtmlUtils.objectToHtmlAttributes(attributes);
if (htmlAttributes && htmlAttributes.length > 0) {
out += " " + htmlAttributes;
}
}
var closedTag = "";
if (body) {
out += ">" + body + closedTag;
} else if (tagNameEscaped === "script") {
out += ">" + closedTag;
} else {
out += "/>";
}
return out;
};
/**
* Converts the key/value pairs in obj to key/value pairs for HTML attributes. Handles escaping correctly.
*
* Example:
*
* objectToHtmlAttributes({id: "foo", class: "bar"})
*
* Returns: id="foo" class="bar"
*
* @param obj
* @return {*}
*/
HtmlUtils.objectToHtmlAttributes = function(obj) {
var attrs = [];
Utils.map(obj, function(value, key) {
if (Utils.isDefined(key) && Utils.isDefined(value)) {
attrs.push(dust.escapeHtml(key) + '="' + dust.escapeHtml(value) + '"');
}
});
return attrs.join(' ');
};
})(play, LI, dust);
/**
* Helpers that extend dust functionality in a non Play/LinkedIn manner. In fact, after some testing in Play apps, if
* these prove to be generally useful helpers, they should be ported into the dust or dust-helpers open source
* repositories.
*/
(function(play, dust) {
"use strict";
var Utils = play.Utils;
/**
* True iff this script is executing in a browser environment.
*
* TODO: USSR should set a flag instead of this hacky check
*
* @type {Boolean}
*/
play.isClient = typeof window !== 'undefined' && typeof document !== 'undefined';
play.isDustReady = false;
/**
* Returns the current dust debug level.
*
* @returns {*}
*/
play.getDustDebugLevel = function() {
return play.getPageContextValue("dustDebug", false);
};
var resourcesInProgress = {};
/**
* Support lazy-loading of dust templates and partials. Dust will call dust.onLoad if you try to render a template
* that is not in dust.cache. This method fetches it asynchronously from play.templateUrl.
*
* NOTE: We skip invocation of this when javadust is defined in order to keep the existing dust.onLoad behaviour of throwing an error.
* This is to prevent errors during asynchronous operations (such as nextTick() calls) being lost when dust.onLoad is overwritten.
*
* @param name
* @param callback
*/
if (typeof javadust !== undefined) {
dust.onLoad = function(name, callback) {
Utils.assert(play.isClient, "Could not find template " + name + ". Lazy loading for dust templates is only available for client-side rendering!");
var callbacks = resourcesInProgress[name];
if (callbacks) { // someone is already fetching this template in the background, add myself as a callback
callbacks.push(callback);
} else {
resourcesInProgress[name] = [callback];
play.getScript(play.templateUrl(name), function() {
// notify everyone who was waiting on this template that it's ready
var toNotify = resourcesInProgress[name];
while (toNotify && toNotify.length > 0) {
var cb = toNotify.pop();
cb();
}
});
}
};
}
/**
* Tap all values from given dust params object. Returns an object with the same key and tapped values.
*
* @param params
* @param chunk
* @param context
* @returns {{}}
*/
dust.helpers.tapAll = function(params, chunk, context) {
Utils.assert(params, "tapAll called with null params");
var tappedParams = {};
Utils.each(params, function(value, key) {
tappedParams[key] = dust.helpers.tap(value, chunk, context);
});
return tappedParams;
};
/**
* Add a variable to the current context with a key equal to the 'name' parameter and value equal to the body of this
* tag.
*
* Example:
*
* {@addToContext name="myVariable"}This text is now available in the context{/addToContext}
*
* Now I can use the new variable: {myVariable}
* * Output: * *Now I can use the new variable: This text is now available in the context
* * @param chunk * @param context * @param bodies * @param params * @return {*} */ dust.helpers.addToContext = function(chunk, context, bodies, params) { Utils.assert(params.name, "@addToContext called with null params.name"); params = dust.helpers.tapAll(params, chunk, context); return chunk.capture(bodies.block, context, function(out, chunk) { context.current()[params.name] = out; return chunk.end(''); }); }; /** * Writes the body of this tag iff this is the first iteration in a loop. This is the opposite of dust's built in * @sep helper. * * Example: * * people = ["Jim", "Dean", "Kunal"] * * {#people} * tag. The play.embeddedJsonTag function and the @embedJSON helper can
* safely store JSON in the body of an HTML document. This method can safely read it back out. This is useful for
* exposing JSON assembled server-side to client-side JavaScript. Note that this method does not do any caching;
* since JSON.parse can be expensive, you should locally cache the data yourself (e.g. in a backbone model) if you're
* going to be accessing this data more than once for an id.
*
* This code is largely copied from fz.js: I'd prefer to use fs.payload, but it only works of fs.embed was called
* previously, which does not apply to all embedded JSON use cases.
*
* @param id
*/
play.getEmbeddedContent = function(id) {
Utils.assert(id, "getEmbeddedContent called with null id");
var contentElem = document.getElementById(id);
Utils.assert(contentElem, "Could not find DOM node with id " + id);
Utils.assert(contentElem.firstChild, "DOM node with id " + id + " did not have a child comment node");
var innerContent = contentElem.firstChild.nodeValue;
Utils.assert(innerContent !== null && innerContent.length > 0, "No inner contents found for DOM node with id " + id);
contentElem.parentNode.removeChild(contentElem);
return JSON.parse(innerContent);
};
/**
* Include this in a base page to setup client-side rendering of a template. This is useful if your pages are simple,
* or you already fetched all the JSON you need for the base page, or you don't want to incur an extra roundtrip from
* Fizzy and setting up an extra endpoint for an embed.
*
* Supported parameters:
*
* 1. template: the template to render. Should be the name the template registers in dust.cache. Required.
*
* 2. data: the JSON payload that will be passed into the template during rendering. It will be embedded in the
* HTML as a tag. Optional.
*
* 3. templateId: the id to use for the template script tag and the embedded JSON payload (the latter will have
* -content appended). Optional. Uses the template name if not provided. If you're calling @render
* multiple times for the same payload, make sure to give each one a unique id.
*
* 4. templateUrl: the URL for the template. Optional. Tries to guess URL using play.templateUrl if not provided.
*
* 5. skipTemplateUrl: if set to true, does not include a script tag to fetch the template, with the assumption that
* the template is _already_ in dust.cache. Optional. Default is false.
*
* 6. containerId: the ID of the DOM element which the rendered template will be inserted into. Note, this DOM node
* must already be in the DOM; during initial page load, this usually means the DOM comes before this
* @render call. Optional. If no ID is given then the embed will be inserted just before the DOM
* element with id templateId.
*
* Example:
*
* {@render template="/templates/home" data=contextData /}
*
* Output:
*
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.render = function(chunk, context, bodies, params) {
Utils.assert(!play.isClient, "The @render helper is only used in a server-side rendered base page to setup client-side rendering. Perhaps you want fs.embed() instead?");
Utils.assert(params.template, "@render called with null params.template");
params = dust.helpers.tapAll(params, chunk, context);
var template = params.template;
var data = params.data || {};
var templateId = params.templateId || template;
var templateUrl = params.templateUrl || play.templateUrl(template);
var skipTemplateUrl = params.skipTemplateUrl;
var containerId = params.containerId;
var scriptTagParams = {src: templateUrl, id: templateId};
var fetchTemplateScriptTag = skipTemplateUrl ? "" : HtmlUtils.createHtmlTag("script", scriptTagParams);
var embeddedJsonTag = play.embeddedJsonTag(data, templateId + "-content");
var asJsString = function(str) {
if (Utils.isDefined(str)) {
return '"' + dust.escapeJs(str) + '"';
} else {
return "undefined";
}
};
var fsEmbedParams = Utils.map([templateId, template, undefined, containerId], asJsString);
var fsEmbedBody = 'fs.embed(' + fsEmbedParams.join(', ') + ');';
var fsEmbedTag = HtmlUtils.createHtmlTag("script", {}, fsEmbedBody);
return chunk.write(fetchTemplateScriptTag + embeddedJsonTag + fsEmbedTag);
};
/**
* Embed the JSON specified in by the data parameter in a code tag with the id in the id parameter. This can be used
* to take JSON assembled server-side and safely embed it in the HTML document. Use play.getEmbeddedContent to read
* it back out later.
*
* Example: {@embedJSON id="my-data" data=someJsonInContext /}
*
* Output:
*
* @param chunk
* @param context
* @param bodies
* @param params
* @returns {*}
*/
dust.helpers.embedJSON = function(chunk, context, bodies, params) {
Utils.assert(params.id, "@embedJSON called with null id");
Utils.assert(params.data, "@embedJSON called with null data");
params = dust.helpers.tapAll(params, chunk, context);
return chunk.write(play.embeddedJsonTag(params.data, params.id));
};
/**
* Use this helper in your base pages to setup the page context for client-side rendering. Most helpers in dust-utils
* will not work if this helper is not included.
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.initContext = function(chunk) {
Utils.assert(!play.isClient, "The @initContext helper is only used in a server-side rendered base page to setup the page context for server and client-side rendering.");
// Embed the page context JSON in the DOM so it is available to dust-utils for client-side rendering
var embeddedJsonCodeTag = play.embeddedJsonTag(play.getPageContext(), play.EMBEDDED_CONTEXT_ID);
dust.debugLevel = play.getDustDebugLevel();
// Inject sc-hashes_xx_XX.js if useScHashesJs
// TODO: Find a way to inject dust-utils.js and sc-hashes_xx_XX.js in a more performant manner (e.g. let users customize in their concat group)
var scHashesScriptTag = play.useScHashesJs() ? HtmlUtils.createHtmlTag("script", {src: play.getPageContextValue("scHashesUrl", true)}) : '';
// Inject dust-utils.js
var dustUtilJSUrl = play.getPageContextValue("dustUtilsUrl", true),
dustUtilScriptTag = HtmlUtils.createHtmlTag("script", {
src: dustUtilJSUrl
});
// When JavaScript reverse routers are included in DustOptions, a URL to fetch them is included in the response to
// Fizzy/USSR. The URL will return JavaScript with the JavaScript reverse routers so they are usable during server
// side rendering. It also returns a play.jsRoutesString that we put into a script tag so the same routes are
// available for client side rendering.
var jsRoutesScriptTag = play.jsRoutesString ? HtmlUtils.createHtmlTag("script", {}, play.jsRoutesString.replace(/__NEW_LINE__/g, "\n")) : '';
return chunk.write(embeddedJsonCodeTag + scHashesScriptTag + dustUtilScriptTag + jsRoutesScriptTag);
};
// When rendering server-side, hijack (monkey patch) the dust.render method so we can access the page context
if (!play.isClient && !play.contextReady) {
// Prevent the context from being initialized multiple times
play.contextReady = true;
var originalRenderFunction = dust.render;
dust.render = function(name, context, callback) {
var pageContext = context[play.EMBEDDED_CONTEXT_ID];
Utils.assert(pageContext, "No page context found!");
play.setPageContext(pageContext);
dust.debugLevel = play.getDustDebugLevel();
dust.render = originalRenderFunction;
originalRenderFunction(name, context, callback);
};
}
})(play, LI, dust);
/**
* Helpers for rendering forms in dust. Experimental.
*/
(function(play, LI, dust) {
"use strict";
var Utils = play.Utils;
var HtmlUtils = LI.HtmlUtils;
/**
* Writes this tag's body surrounded by form tags. Includes a hidden CSRF input in the form. You can specify an
* 'alias' parameter and corresponding arg0, arg1, etc. parameters to fill in the form's action attribute with a URL.
* You can also specify a 'formData' parameter to provide "form data" for the @input helper.
*
* Any parameter other than 'alias' and 'formData' will be passed unchanged to the form tag.
*
* Example:
*
* {@form alias="controllers.Forms.submit" id="myForm"}
*
*
* {/form}
*
* Output:
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.form = function(chunk, context, bodies, params) {
params = params || {};
params = dust.helpers.tapAll(params, chunk, context);
if (params.formData) {
var formData = this.tap(params.formData, chunk, context);
context = context.push({formData: formData});
}
var attrs = {method: "POST"};
var body = play.createCsrfInput();
if (params.alias) {
attrs.action = play.url(params);
}
attrs = Utils.extend({}, attrs, play._.omit(params, ['alias', 'formData']));
if (bodies && bodies.block) {
return chunk.capture(bodies.block, context, function(out, chunk) {
body += out;
return chunk.end(HtmlUtils.createHtmlTag("form", attrs, body));
});
} else {
return chunk.write(HtmlUtils.createHtmlTag("form", attrs, body));
}
};
// TODO: handle enums as drop downs or radio buttons
// TODO: handle booleans as check boxes
/**
* Write a form input based on JSON form data produced by PegasusFormPlugin.recordTemplateAsFormJson. Specify the
* field to render via the 'field' param and the form data for the fields via the `formData` param. Alternatively, if
* this is inside of a @form tag, you can add the `formData` to the @form tag and it'll apply to all @input calls
* inside of it.
*
* The input will use the field's id as its id and name attributes. It will also include a label and a div for
* displaying errors.
*
* You can customize behavior using the following parameters:
*
* 1. label: custom label text (default: field name)
* 2. noLabel: don't include a label
* 3. error: error text to display (default: none)
* 4. noError: don't include an error div
* 5. arrayIndex: will append [arrayIndex] to the id and name of the field. Useful for submitting lists.
*
* Examples:
*
* {@input field="name" formData="myFormData"/}
*
* {@form alias="controllers.Forms.submit" formData="myFormData"}
* {@input field="name"/}
* {@input field="age" noLabel="true" noError="true" id="custom-id"/}
* {@input field="preferences" type="checkbox" arrayIndex="0" noLabel="true" noError="true"/}
* {@input field="preferences" type="checkbox" arrayIndex="1" noLabel="true" noError="true"/}
* {/form}
*
* Output:
*
*
*
*
*
*
*
* {@input fiel
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.input = function(chunk, context, bodies, params) {
Utils.assert(params, "@input called with null params");
params = dust.helpers.tapAll(params, chunk, context);
var formData = context.get("formData") || params.formData;
Utils.assert(formData, "@input called with null formData");
var field = play.getFormField(formData, params.field);
Utils.assert(field, "@input did not find field " + params.field + " in the formData");
Utils.assert(field.id, "@input did not find an id in field " + params.field);
Utils.assert(field.name, "@input did not find a name in field " + params.field);
var id = field.id;
if (params.arrayIndex) {
id += "[" + params.arrayIndex + "]";
}
var defaultAttrs = {type: "text", id: id, name: id};
var value = field.value || field['default'];
if (value) {
defaultAttrs.value = value;
}
var attrs = Utils.extend({}, defaultAttrs, play._.omit(params, ['field', 'label', 'noLabel', 'noError', 'error', 'formData', 'field', 'arrayIndex']));
var out = '';
if (!params.noLabel) {
var label = params.label || field.name;
var labelAttrs = {"for": attrs.id};
if (!field.optional) {
labelAttrs['class'] = 'required';
}
out += HtmlUtils.createHtmlTag("label", labelAttrs, label);
}
if (!params.noError) {
var error = params.error || field.error || '';
var divAttrs = {
id: attrs.id + "-error",
"class": "error"
};
out += HtmlUtils.createHtmlTag("div", divAttrs, error);
}
out += HtmlUtils.createHtmlTag("input", attrs);
return chunk.write(out);
};
/**
* Traverses a pegasus form object to find a field. The fieldName will be of the format "A.B.C".
*
* @param formData
* @param fieldName
* @return {*}
*/
play.getFormField = function(formData, fieldName) {
Utils.assert(formData, "getFormField called with null formData");
Utils.assert(fieldName, "getFormField called with null fieldName");
var field = formData;
var parts = fieldName.split(".");
for (var i = 0; i < parts.length; i++) {
field = field.fields[parts[i]];
Utils.assert(field, "Could not find field " + fieldName + " in form data");
}
return field;
};
})(play, LI, dust);
/**
* Helpers for programmatically generating HTML markup. In most cases, you should use a dust template to render markup,
* but the functions in this file are more convenient for rendering markup from a helper, where the ratio of logic to
* markup is very high.
*/
(function(play, LI) {
"use strict";
var Utils = play.Utils;
var HtmlUtils = LI.HtmlUtils;
/**
* Create a
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.linkedInDustScriptTag = function(chunk, context, bodies, params) {
var liDustJSURL = play.getPageContextValue('serveT8WithDust', true) ?
play.getPageContextValue('linkedInDustI18nJsUrl', true) : play.getPageContextValue('linkedInDustJsUrl', true);
return chunk.write(play.createScriptTag({src: liDustJSURL}, params || {}));
};
/**
* Writes a script tag with the URL for the dust template path(s) under public/templates. If more than one path is
* specified, the URL will be for a dynamically concatenated resource.
*
* The .js extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the script tag.
*
* Examples:
*
* {@template path="foo"/}
* {@template paths="bar, a/b/c" id="bar"/}
*
* Output:
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.template = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatJs(paths, play.templateUrl, params));
};
/**
* Writes a link tag with the URL for the build-time concatenated css path(s) under public/concat. If more than one
* path is specified, the URL will be for a dynamically concatenated resource.
*
* The .css extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the script tag. The URLs will automatically include the proper locale.
*
* Examples:
*
* {@concatCss path="foo"/}
*
* Output:
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.concatCss = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatCss(paths, play.concatCssUrl, params));
};
/**
* Writes a script tag with the URL for the build-time concatenated js path(s) under public/concat. If more than one
* path is specified, the URL will be for a dynamically concatenated resource.
*
* The .js extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the script tag. The URLs will automatically include the proper locale.
*
* Examples:
*
* {@concatJs path="foo"/}
*
* Output:
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.concatJs = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatJs(paths, play.concatJsUrl, params));
};
/**
* Writes a script tag with the URL for the JS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified, the URL will be for a dynamically concatenated resource. If the path contains placeholders,
* they will be replaced by the current locale. This is useful if you only want some of the js be localized.
* All paths are assumed to be relative to /public/javascripts.
*
* The .js extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the script tag.
*
* Examples:
*
* {@js path="jquery"/}
* {@js paths="dust, controllers/foo" id="bar"/}
* {@js paths="dust, lib/t8//t8.js" id="bar"/}
*
* Output:
*
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.js = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.replaceWithLocale(play.getPathList(params));
return chunk.write(maybeDynamicConcatJs(paths, play.jsUrl, params));
};
/**
* Writes a script tag with the URL for the JS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified the URL will be for a dynamically concatenated resource. The URL will include the current
* locale. All paths are assumed to be relative to /public/javascripts.
*
* The .js extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the script tag.
*
* Examples:
*
* {@jsLocalized path="jquery"/}
* {@jsLocalized paths="dust, controllers/foo" id="bar"/}
*
* Output:
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.jsLocalized = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatJs(paths, play.localizedJsAssetUrl, params));
};
/**
* Writes a script tag with the URL for the JS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified, the URL will be for a dynamically concatenated resource. If the path contains placeholders,
* they will be replaced by the current locale. This is useful if you only want some of the js be localized. Unlike @js,
* all paths are assumed to be relative to /public/ (ie, the /javascripts path is NOT assumed).
*
* The .js extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the script tag.
*
* Examples:
*
* {@jsAsset path="foo"/}
* {@jsAsset paths="bar, /home/dashboard/charts" id="bar"/}
* {@jsAsset paths="lib/t8//t8.js, /home/dashboard/charts" id="bar"/}
*
* Output:
*
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.jsAsset = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.replaceWithLocale(play.getPathList(params));
var jsPaths = Utils.map(paths, function(path) { return play.addExtension(path, '.js'); });
return chunk.write(maybeDynamicConcatJs(jsPaths, play.assetUrl, params));
};
/**
* Writes a script tag with the URL for the JS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified, the URL will be to a dynamically concatenated resource. The URL will include the the current locale.
* Unlike @jsLocalized, all paths are assumed to be relative to /public/ (ie, the /javascripts path is NOT assumed).
*
* The .js extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the script tag.
*
* Examples:
*
* {@jsAssetLocalized path="foo"/}
* {@jsAssetLocalized paths="bar, /home/dashboard/charts" id="bar"/}
*
* Output:
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.jsAssetLocalized = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatJs(paths, play.localizedJsAssetUrl, params));
};
/**
* Writes a link tag with the URL for the CSS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified, the URL will be to a dynamically concatenated resource. All paths are assumed to be relative to
* /public/stylesheets.
*
* The .css extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the link tag.
*
* Examples:
*
* {@css path="main"/}
* {@css paths="common, pages/home" media="screen"/}
*
* Output:
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.css = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatCss(paths, play.cssUrl, params));
};
/**
* Writes a link tag with the URL for the SCSS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified, the URL will be to a dynamically concatenated resource. All paths are assumed to be relative to
* /public/scss.
*
* The .scss extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the link tag.
*
* Examples:
*
* {@scss path="main"/}
* {@scss paths="common, pages/home" media="screen"/}
*
* Output:
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.scss = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatCss(paths, play.scssUrl, params));
};
/**
* Writes a link tag with the URL for the CSS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified, the URL will be to a dynamically concatenated resource. Unlike @css, all paths are assumed to
* be relative to /public/ (ie, the /css path is NOT assumed).
*
* The .css extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the link tag.
*
* Examples:
*
* {@cssAsset path="home/main"/}
* {@cssAsset paths="common, pages/dashboard/home" media="screen"/}
*
* Output:
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.cssAsset = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
var cssPaths = Utils.map(paths, function(path) { return play.addExtension(path, '.css'); });
return chunk.write(maybeDynamicConcatCss(cssPaths, play.assetUrl, params));
};
/**
* Writes a link tag with the URL for the CSS path(s) specified in the 'path' or 'paths' parameter. If more than one
* path is specified, the URL will be to a dynamically concatenated resource. The URL will include the current locale
* appended. Unlike @css, all paths are assumed to be relative to /public/ (ie, the /css path is NOT assumed).
*
* The .css extension is optional: the helper will add it for you. Any parameter other than 'path' and 'paths' will be
* passed unchanged to the link tag.
*
* Examples:
*
* {@cssAssetLocalized path="home/main"/}
* {@cssAssetLocalized paths="common, pages/dashboard/home" media="screen"/}
*
* Output:
*
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.cssAssetLocalized = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var paths = play.getPathList(params);
return chunk.write(maybeDynamicConcatCss(paths, play.localizedCssAssetUrl, params));
};
/**
* Writes an img tag with the URL specified in the 'path' parameter. The path is assumed to be relative to
* /public/images. Any parameter other than 'path' will be passed unchanged to the img tag.
*
* Examples:
*
* {@img path="logo.png"/}
* {@img path="icons/like.gif" alt="Like"/}
*
* Output:
*
* 
* 
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.img = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var attrs = Utils.extend({src: play.imgUrl(params.path)}, play._.omit(params, ['path']));
return chunk.write(HtmlUtils.createHtmlTag('img', attrs, null));
};
/**
* Writes an img tag for an image hosted on scds with path 'path'. The image comes from SCDS's "unversioned" URLs.
* Any parameter other than 'path' will be passed unchanged to the img tag.
*
* Example:
*
* {@scdsImg path="img/foo/bar.png" class="baz"/}
*
* Output:
*
* 
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.scdsImg = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var attrs = Utils.extend({src: play.scdsDirectUnversionedUrl(params.path)}, play._.omit(params, ['path']));
return chunk.write(HtmlUtils.createHtmlTag('img', attrs, null));
};
/**
* Writes a script tag for JS hosted on scds with path 'path'. The JS comes from SCDS's "unversioned" URLs.
* Any parameter other than 'path' will be passed unchanged to the script tag.
*
* Example:
*
* {@scdsJs path="lib/foo/bar"/}
*
* Output:
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.scdsJs = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
return chunk.write(play.createScriptTag({src: play.scdsDirectUnversionedUrl(play.addExtension(params.path, '.js'))}, params));
};
/**
* Builds a SCDS "unversioned" URL with the passed in 'path'.
*
* Example:
*
* {@scdsUrl path="lib/foo/bar.js"/}
*
* Output:
*
* /scds/common/u/lib/foo/bar.js
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.scdsUrl = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
return chunk.write(dust.escapeHtml(play.scdsDirectUnversionedUrl(params.path)));
};
/**
* Writes a link tag for CSS hosted on scds with path 'path'. The CSS comes from SCDS's "unversioned" URLs.
* Any parameter other than 'path' will be passed unchanged to the link tag.
*
* Example:
*
* {@scdsCss path="foo/bar"/}
*
* Output:
*
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.scdsCss = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
return chunk.write(play.createCssTag({href: play.scdsDirectUnversionedUrl(play.addExtension(params.path, '.css'))}, params));
};
/**
* Endpoint for dynamic JS concatenation.
* @type {string}
*/
var SCDS_CONCAT_JS_URL = play.combineUrlPieces('concat/common', 'js');
/**
* Writes out a script tag with its src pointing to a dynamic concat group of
* JS files.
*
* All params other than paths are applied directly to the generated script
* tag.
*
* Example:
* {@scdsJsConcat paths="one, two, three"/}
*
* Output:
*
*
* @param chunk
* @param context
* @param bodies
* @param params
* @returns {*}
*/
dust.helpers.scdsJsConcat = function(chunk, context, bodies, params) {
var paths,
date = new Date(),
versionDate = '&_v=' + date.getFullYear() + date.getMonth() + Math.ceil(date.getDate() / 7); // used for cache busting (busts ~weekly)
Utils.assert(params, '@scdsJsConcatUrl called without params');
Utils.assert(params.paths, '@scdsJsConcatUrl called without paths param');
if (params.cacheBuster && params.cacheBuster.length) {
versionDate = '&_v=' + params.cacheBuster;
params = play._.omit(params, 'cacheBuster');
}
paths = play.getPathList(params);
return chunk.write(play.createScriptTag({ src: play.scdsDirectUrl(play.buildUrl(SCDS_CONCAT_JS_URL, { 'f': paths })) + versionDate }, params));
};
/**
* Writes an img tag with for the mpr image specified by the 'mediaId' or 'urn' params (if both are specified, mediaId
* will be used). The size of the image is determined by the 'size' or 'width' and 'height' params (if both are
* specified, size will be used). All other parameters will be passed unchanged to the img tag.
*
* Example:
*
* {@mprImg mediaId="/p/000/001/profile-photo.png" width="200" height="100" alt="My profile photo"/}
* {@mprImg urn="urn:li:media:/p/1/000/000/1b4/1305a66.png" width="100" height="60" class="logo" /}
*
* Output:
*
* 
* 
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.mprImg = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var imageWidth = params.size || params.width,
imageHeight = params.size || params.height,
mprWidth = params.mprSize || params.mprWidth || imageWidth,
mprHeight = params.mprSize || params.mprHeight || imageHeight,
mprWithoutPadding = params.withoutPadding === 'true',
attrs = play._.omit(params,
['mediaId', 'urn', 'size', 'width', 'height', 'imageWidth', 'imageHeight', 'mprHeight', 'mprWidth', 'mprSize', 'withoutPadding']);
attrs[params.lazyLoad === 'true' ? 'data-delayed-url':'src'] = play.mprUrl(play.getMediaIdFromParams(params), mprWidth, mprHeight, mprWithoutPadding);
if(imageWidth) {
attrs.width = parseInt(imageWidth, 10) + '';
}
if(imageHeight) {
attrs.height = parseInt(imageHeight, 10) + '';
}
return chunk.write(HtmlUtils.createHtmlTag('img', attrs, null));
};
/**
* Writes an img tag with for the profile photo specified by the 'mediaId' or 'urn' params (if both are specified,
* mediaId will be used). If neither 'mediaId' nor 'urn' can be found, shows the 'no-photo' silhouette instead. The
* size of the image is determined by the 'size' or 'width' and 'height' params (if both are specified, size will be
* used). All other parameters will be passed unchanged to the img tag.
*
* Examples:
*
* {@profileImg mediaId="/p/000/001/profile-photo.png" width="80" height="80" alt="My profile photo"/}
* {@profileImg urn="urn:li:media:/p/1/000/000/2cc/004eb3a.jpg" width="100" height="100"/}
* {@profileImg mediaId=undefinedVariable width="40" height="40" alt="Should show no photo"/}
*
* Output:
*
* 
* 
* 
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.profileImg = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var imageWidth = params.size || params.width,
imageHeight = params.size || params.height,
mprWidth = params.mprSize || params.mprWidth || imageWidth,
mprHeight = params.mprSize || params.mprHeight || imageHeight,
mprWithoutPadding = params.withoutPadding === 'true',
mediaId = play.getMediaIdFromParams(params),
src = mediaId ? play.mprUrl(mediaId, mprWidth, mprHeight, mprWithoutPadding) : play.noPhotoUrl(imageWidth, imageHeight),
attrs = Utils.extend({src: src}, play._.omit(params,
['mediaId', 'urn', 'size', 'width', 'height', 'mprHeight', 'mprWidth', 'mprSize']));
if(imageWidth) {
attrs.width = parseInt(imageWidth, 10) + '';
}
if(imageHeight) {
attrs.height = parseInt(imageHeight, 10) + '';
}
return chunk.write(HtmlUtils.createHtmlTag('img', attrs, null));
};
/**
* Writes an img tag for the image specified by the urn or mediaId directly from /media (not from /mpr).
*
* Examples:
*
* {@mediaImg mediaId="/p/000/001/profile-photo.png" alt="My profile photo"/}
* {@mediaImg urn="urn:li:media:/p/1/000/000/196/3283598.png" class="logo" /}
*
* Output:
*
* 
* 
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.mediaImg = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
var attrs = Utils.extend({src: play.mediaUrl(play.getMediaIdFromParams(params))}, play._.omit(params, ['mediaId', 'urn']));
return chunk.write(HtmlUtils.createHtmlTag('img', attrs, null));
};
/**
* Builds a URL for the image specified by the urn or mediaId directly from /media (not from /mpr).
*
* Examples:
*
* {@mediaUrl mediaId="/p/000/001/profile-photo.png" /}
* {@mediaUrl urn="urn:li:media:/p/1/000/000/196/3283598.png" /}
*
* Output:
*
* "/media/p/000/001/profile-photo.png"
* "/media/p/1/000/000/196/3283598.png"
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.mediaUrl = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
return chunk.write(dust.escapeHtml(play.mediaUrl(play.getMediaIdFromParams(params))));
};
/**
* Write the URL specified by the 'alias' and (optional) 'arg0', 'arg1', etc. parameters.
*
* Examples:
*
* {@url alias="controllers.HelloWorld.index"/}
* {@url alias="controllers.Helpers.threeParams" arg0=firstName arg1=lastName arg2=age/}
* {@url alias="controllers.Helpers.index" track="some-track"/}
*
* Output:
*
* /dust-sample
* /dust-sample/helpers/threeParams?firstName=Jim&lastName=Brikman&age=28
* /dust-sample?trk=some-track
*
* @param chunk
* @param context
* @param bodies
* @param params
* @return {*}
*/
dust.helpers.url = function(chunk, context, bodies, params) {
params = dust.helpers.tapAll(params, chunk, context);
return chunk.write(dust.escapeHtml(play.url(params, params.absolute === 'true')));
};
/**
* Adds a key-value pair to the querystring of a URL, overwriting the
* existing value if one by that name already exists.
*
* Examples:
* {@addQueryParameter url="/foo" key="bar" value="baz"/}
* {@addQueryParameter url="/foo?bar=baz" key="biz" value="buzz"/}
* {@addQueryParameter url="/foo?bar=baz" key="bar" value="biz"/}
*
* Output:
* /foo?bar=baz
* /foo?bar=baz&biz=buzz
* /foo?bar=biz
*
* @param chunk
* @param context
* @param bodies
* @param params
* @returns {*}
*/
dust.helpers.addQueryParameter = function(chunk, context, bodies, params) {
Utils.assert(params.url, '@addQueryParameter called without URL param');
Utils.assert(params.key, '@addQueryParameter called without key name');
Utils.assert(params.value, '@addQueryParameter called without value for key');
params = dust.helpers.tapAll(params, chunk, context);
return chunk.write(dust.escapeHtml(play.addQueryParameter(params.url, params.key, params.value)));
};
/**
* Adds a tracking code to a URL.
*
* Example:
* {@addTrackingCode url="/bar" code="some-track-code"/}
*
* Output:
* /bar?trk=some-track-code
*
* @param chunk
* @param context
* @param bodies
* @param params
* @returns {*}
*/
dust.helpers.addTrackingCode = function(chunk, context, bodies, params) {
Utils.assert(params.url, '@addTracking called without url');
Utils.assert(params.code, '@addTracking called without tracking code');
params = dust.helpers.tapAll(params, chunk, context);
return dust.helpers.addQueryParameter(chunk, context, bodies, {
key: 'trk',
value: params.code,
url: params.url
});
};
})(play, LI, dust, sc);
(function() {var require = function(moduleName) { return this[moduleName];}
function exportAsGlobal(exports, require) {'use strict';
var t8 = require('t8');
t8 = ('default' in t8 ? t8['default'] : t8);
"use strict";
var xmessage_reader__CHAR_BACK_SLASH = "\\";
/**
* A simple string reader, similar to an iterator or input stream. Allows the
* character-by-character traversal of a string until there is not more input.
*
* @constructs Reader
* @param {String} input - the string to traverse
*/
function Reader(input) {
this._input = input;
this._index = 0;
this._last = null;
this.next = this.next.bind(this);
this.consume = this.consume.bind(this);
}
/**
* Returns the next character in the traversal. Does not advance the cursor.
* When there are no more characters to be read this returns Reader.END_TOKEN.
*
* @see Reader.prototype.consume
* @return {String|Null} a single character value or null if at the end
*/
Reader.prototype.next = function () {
if (this._index < this._input.length) {
return this._input[this._index];
}
return null;
};
/**
* Consumes the current charcter and advances the Reader's iterator forward by
* one character.
*/
Reader.prototype.consume = function () {
this._last = this._input[this._index];
this._index++;
};
/**
* Returns whether the current character is escaped or not.
*
* @return {Boolean}
*/
Reader.prototype.isEscaped = function () {
return this._last === xmessage_reader__CHAR_BACK_SLASH;
};
Reader.prototype.constructor = Reader;
var xmessage_reader = Reader;
"use strict";
var CHAR_LEFT_BRACE = "{",
CHAR_RIGHT_BRACE = "}",
CHAR_COMMA = ",",
CHAR_COLON = ":",
CHAR_PIPE = "|",
CHAR_ZERO = "0",
CHAR_SINGLE_QUOTE = "'",
parser__CHAR_BACK_SLASH = "\\",
EMPTY_STRING = "",
REGEX_LETTERS = /[a-zA-Z]/,
REGEX_NUMBERS_LEADING = /[1-9]/,
REGEX_NUMBERS_TRAILING = /[0-9]/,
REGEX_LETTERS_OR_NUMBERS = /[a-zA-Z0-9]/,
REGEX_KEYWORD_ALLOWED_CHARS = /[a-zA-Z0-9_\-~.|\[\]\/]/,
REGEX_STYLE_DELIMITER_DEFAULT = /[#]/,
REGEX_STYLE_DELIMITER_CHOICE = /[#+<]/,
SPECIAL_STYLE_PARSERS = {},
SPECIAL_DELIMITER_PATTERNS = {},
KEEP_DELIMITER_FLAGS = {},
KEEP_STYLE_ORDER_FLAGS = {};
SPECIAL_DELIMITER_PATTERNS.choice = REGEX_STYLE_DELIMITER_CHOICE;
KEEP_DELIMITER_FLAGS.choice = true;
KEEP_STYLE_ORDER_FLAGS.choice = true;
/**
* Throws an error. Convenience method to save bytes.
*/
function throwError(message) {
throw new Error(message);
}
/**
* Given an input string, extracts the segments of simple text as well as placeholders.
* Text segments are returned as plain Strings. Placeholders are returned as Objects with
* a `text` property containing the unparsed placeholder text. The validity of placeholders
* is not checked.
*
* Throws exceptions if unexpected or unmatched "{" or "}" characters are found.
*
* Example:
* extractMessage("Hello, {:name}!") => ["Hello, ", { text: ":name" }]
*
* @param {String} input
* @return {Object[]}
*/
function extractMessage(input) {
var segments = [],
curlyStack = [],
isInsideQuote = false,
buffer = [],
reader = new xmessage_reader(input),
currentFn = reader.next,
nextFn = reader.consume;
while (currentFn()) {
// SPECIAL CASE: Skip over back slashes unless they're escaped.
if (currentFn() === parser__CHAR_BACK_SLASH && !reader.isEscaped()) {
nextFn();
continue;
}
// SPECIAL CASE: If a character is escaped push it in the buffer and move on to the next one.
if (reader.isEscaped()) {
buffer.push(currentFn());
nextFn();
continue;
}
// Check for single-quoted ranges of text.
if (curlyStack.length === 0) {
if (currentFn() === CHAR_SINGLE_QUOTE) {
isInsideQuote = !isInsideQuote;
nextFn();
// Flush buffer into a segment.
if (buffer.length > 0) {
segments.push(buffer.join(EMPTY_STRING));
buffer.length = 0;
}
}
}
if (!isInsideQuote) {
// SPECIAL CASE: Found a closing curly but not inside a placeholder
if (currentFn() === CHAR_RIGHT_BRACE && !reader.isEscaped() && curlyStack.length === 0) {
throwError("Unexpected \"}\"");
} else if (currentFn() === CHAR_LEFT_BRACE) {
// Handle nested messages.
// If we just found the beginning of a message...
if (curlyStack.length === 0) {
// Flush buffer into a segment.
if (buffer.length > 0) {
segments.push(buffer.join(EMPTY_STRING));
buffer.length = 0;
}
} else {
// Only push curlies into the buffer if they're nested.
buffer.push(currentFn());
}
curlyStack.push(currentFn());
nextFn();
} else if (currentFn() === CHAR_RIGHT_BRACE) {
curlyStack.pop();
// If we just found the end of a message...
if (curlyStack.length === 0) {
// Flush buffer into a segment.
if (buffer.length > 0) {
segments.push({
text: buffer.join(EMPTY_STRING)
});
buffer.length = 0;
} else {
throwError("Unexpected end of placeholder (found no content)");
}
} else {
// Only push curlies into the buffer if they're nested.
buffer.push(currentFn());
}
nextFn();
} else {
// When inside a quoted range we just collect all text.
if (currentFn()) {
buffer.push(currentFn());
}
nextFn();
}
} else {
// When outside a quoted range we just collect all text.
if (currentFn()) {
buffer.push(currentFn());
}
nextFn();
}
}
if (curlyStack.length !== 0) {
throwError("Unexpected end of placeholder (unmatched \"{\")");
}
if (buffer.length > 0) {
segments.push(buffer.join(EMPTY_STRING));
buffer.length = 0;
}
return segments;
}
/**
* Expects to find and index at the beginning of the Reader. Reads until
* it finds the end of an index or the Reader is done.
*
* Throws if an index could not be parsed.
*
* @return {Object} an object describing the index
*/
function expectIndex(currentFn, nextFn) {
var indexBuffer = [],
keywordBuffer = [];
// The regexp /^((0|[1-9][0-9]*)|:([a-zA-Z]+)|((0|[1-9][0-9]*)(:([a-zA-Z]+))))$/
// could potentially replace this code. Needs more investigation.
if (currentFn() === CHAR_ZERO) {
indexBuffer.push(currentFn());
nextFn();
if (currentFn() && (currentFn() !== CHAR_COMMA && currentFn() !== CHAR_COLON)) {
throwError("Could not parse index; expected \":\" or end of identifier but found \"" + currentFn() + "\"");
}
} else if (currentFn() && REGEX_NUMBERS_LEADING.test(currentFn())) {
while (currentFn() && REGEX_NUMBERS_TRAILING.test(currentFn())) {
indexBuffer.push(currentFn());
nextFn();
}
}
if (currentFn() === CHAR_COLON) {
nextFn(); // Consume the ":"
// First character of a keyword has to be a letter or a number
if (currentFn() && REGEX_LETTERS_OR_NUMBERS.test(currentFn())) {
keywordBuffer.push(currentFn());
nextFn();
} else {
throwError("Expected letter (a-zA-Z) or number (0-9) but found \"" + currentFn() + "\"");
}
// Parse keyword
while (currentFn() && REGEX_KEYWORD_ALLOWED_CHARS.test(currentFn())) {
keywordBuffer.push(currentFn());
nextFn();
}
} else {
if (indexBuffer.length === 0 && currentFn()) {
throwError("Unexpected character; expected \":\" but found \"" + currentFn() + "\"");
}
}
if (currentFn() === CHAR_COMMA || !currentFn()) {
indexBuffer = parseInt(indexBuffer.join(EMPTY_STRING), 10);
if (isNaN(indexBuffer)) {
indexBuffer = null;
}
keywordBuffer = keywordBuffer.join(EMPTY_STRING) || null; // If there was no keyword make sure it's null
} else {
throwError("Unexpected character; expected \",\" or end of identifier but found \"" + currentFn() + "\"");
}
return {
number: indexBuffer,
keyword: keywordBuffer
};
}
/**
* Expects to find a placeholder type. Throws if invalid characters are found.
*/
function expectType(currentFn, nextFn) {
var buffer = [];
if (!currentFn()) {
throwError("Unable to parse type. Expected letter (a-zA-Z) but found end of identifier after \",\"");
} else {
while (currentFn() && REGEX_LETTERS.test(currentFn())) {
buffer.push(currentFn());
nextFn();
}
}
return buffer.join(EMPTY_STRING);
}
/**
* Expects to find a style. A style may be a key only, or a key/value
* pair. For key/value pairs the delimiter is captured as well.
*/
function expectStyleTuple(currentFn, nextFn, parseMode) {
var DELIMITER_PATTERN = SPECIAL_DELIMITER_PATTERNS[parseMode] || REGEX_STYLE_DELIMITER_DEFAULT,
KEEP_DELIMITER = KEEP_DELIMITER_FLAGS[parseMode] || false;
var buffer = [],
delimiter = null,
key = null,
value = undefined,
result = {};
while (currentFn()) {
if (DELIMITER_PATTERN.test(currentFn())) {
// We found the delimiter. If they key hasn't been discovered
// yet then this is an error.
if (buffer.length === 0) {
throwError("Error parsing style key/value. Found delimiter \"" + currentFn() + "\" but expected key.");
} else {
if (key === null) {
key = buffer.join(EMPTY_STRING);
buffer.length = 0;
delimiter = currentFn();
nextFn(); // Eat the delimiter.
}
}
}
buffer.push(currentFn());
nextFn();
}
if (delimiter === null) {
// This means we never found a delimiter, so the buffer is filled
// with a key.
key = buffer.join(EMPTY_STRING);
buffer.length = 0;
} else {
// Since we found a delimiter, anything remaining in the buffer
// must be the value.
value = buffer.join(EMPTY_STRING);
buffer.length = 0;
}
result.key = key || null;
result.value = value || null;
// Choice is really the only placeholder that needs delimiter, so we omit it
// unless configured to preserve it.
if (KEEP_DELIMITER) {
result.delimiter = delimiter || null;
}
return result;
}
function expectDelimitedStyleList(currentFn, nextFn, parseMode, styleIndexOffset) {
var KEEP_STYLE_ORDER = KEEP_STYLE_ORDER_FLAGS[parseMode] || false;
var curlyStack = [],
// A stack to keep track of nested xmessages
parsedStyles = {},
unprocessedStyles = [],
buffer = [];
styleIndexOffset = styleIndexOffset || 0;
// Break the stream into chunks based on the style delimiter. We'll make a
// second pass later to determine if they're simple or complex styles.
while (currentFn()) {
if (currentFn() === CHAR_LEFT_BRACE) {
curlyStack.push(currentFn());
} else if (currentFn() === CHAR_RIGHT_BRACE) {
curlyStack.pop();
}
if (curlyStack.length === 0 && currentFn() === CHAR_PIPE) {
// If we found a pipe that should mean that at least a style name has been
// pushed into the buffer. If the buffer is empty then something is wrong.
if (buffer.length === 0) {
throwError("Unexpected \"" + CHAR_PIPE + "\" in style list.");
}
// Push watever is in the buffer into the style buffer as a string. We'll
// try and work out if it is a key/value or just a straight value later.
unprocessedStyles.push(buffer.join(EMPTY_STRING));
// Clear the buffer.
buffer.length = 0;
// Eat the delimiter character.
nextFn();
} else {
// Consume the character and push it into the buffer because it's either
// a style name or key/value pair.
buffer.push(currentFn());
nextFn();
}
}
// Take care of the last style or a singleton style.
if (buffer.length > 0) {
unprocessedStyles.push(buffer.join(EMPTY_STRING));
buffer.length = 0;
}
// Now we take a second pass and parse each style individually.
// First we map each item into a style object, then we merge them
// into a map and include their order (index).
unprocessedStyles.map(function (style) {
var reader = new xmessage_reader(style);
return expectStyleTuple(reader.next, reader.consume, parseMode);
}).forEach(function (style, index) {
// Most placeholders don't need to know the order of the styles. Only
// "choice" really cares, so omit it for unless configured to keep it.
if (KEEP_STYLE_ORDER) {
style.order = index + styleIndexOffset;
}
if (!parsedStyles.hasOwnProperty(style.key)) {
parsedStyles[style.key] = style;
} else {
throwError("Found duplicate style key \"" + style.key + "\". Styles must have unique names.");
}
});
return parsedStyles;
}
function expectRemainderAsStyle(currentFn, nextFn /* , parseMode */) {
var buffer = [],
value = undefined,
result = {};
while (currentFn()) {
buffer.push(currentFn());
nextFn();
}
value = buffer.join(EMPTY_STRING);
result[value] = {
key: value,
value: null
/* It's unlikely that delimiter or order will be useful, so omit them. */
/*
delimiter: null,
order: 0
*/
};
return result;
}
SPECIAL_STYLE_PARSERS.choice = function expectChoiceStyleList(currentFn, nextFn, parseMode) {
return expectDelimitedStyleList(currentFn, nextFn, parseMode);
};
SPECIAL_STYLE_PARSERS.date = function expectDateStyleList(currentFn, nextFn, parseMode) {
return expectRemainderAsStyle(currentFn, nextFn, parseMode);
};
SPECIAL_STYLE_PARSERS.number = function expectDateStyleList(currentFn, nextFn, parseMode) {
return expectRemainderAsStyle(currentFn, nextFn, parseMode);
};
SPECIAL_STYLE_PARSERS.list = function expectListStyleList(currentFn, nextFn, parseMode) {
var remainder = [],
remainderText,
parameters,
styleParameters,
styleIterator,
key;
while (currentFn()) {
remainder.push(currentFn());
nextFn();
}
remainderText = remainder.join(EMPTY_STRING);
if (/^(name$|name\,)/.test(remainderText)) {
parameters = {
name: {
key: "name",
value: "name"
/* It's unlikely that delimiter or order will be useful, so omit them. */
/*
delimiter: null,
order: -1
*/
}
};
styleIterator = new xmessage_reader(remainderText.substr("name".length));
} else if (/^(text$|text\,)/.test(remainderText)) {
parameters = {
text: {
key: "text",
value: "text"
/* It's unlikely that delimiter or order will be useful, so omit them. */
/*
delimiter: null,
order: -1
*/
}
};
styleIterator = new xmessage_reader(remainderText.substr("text".length));
} else {
throwError("Invalid style list for List placeholder.");
}
// If there is anything left to do, we'll parse the styles as normal.
// Then we merge them.
if (styleIterator) {
// Eat any comma and parse the rest of the string.
if (styleIterator.next() === CHAR_COMMA) {
styleIterator.consume();
styleParameters = expectDelimitedStyleList(styleIterator.next, styleIterator.consume, parseMode);
for (key in styleParameters) {
if (styleParameters.hasOwnProperty(key)) {
// Only copy keys that don't replace the list type.
if (!/^(name$|name\,)/.test(key) && !/^(text$|text\,)/.test(key)) {
parameters[key] = styleParameters[key];
}
}
}
}
}
return parameters;
};
function expectParameters(currentFn, nextFn, parseMode) {
if (SPECIAL_STYLE_PARSERS[parseMode]) {
return SPECIAL_STYLE_PARSERS[parseMode](currentFn, nextFn, parseMode);
}
return expectDelimitedStyleList(currentFn, nextFn, parseMode);
}
function expectPlaceholder(currentFn, nextFn) {
var index = null,
type = null,
parameters = null;
if (currentFn()) {
index = expectIndex(currentFn, nextFn);
if (currentFn() === CHAR_COMMA) {
nextFn(); // Consume the "," and extract the type
type = expectType(currentFn, nextFn);
if (currentFn() === CHAR_COMMA) {
nextFn(); // Consume the "," and extract the parameters
parameters = expectParameters(currentFn, nextFn, type);
}
} else {
type = "simple";
}
} else {
throwError("Error parsing placeholder. Unexpected end of input.");
}
if (currentFn()) {
throwError("Unexpected character \"" + currentFn() + "\".");
}
return {
index: index,
type: type,
parameters: parameters
};
}
function parsePlaceholder(str) {
var reader = new xmessage_reader(str);
return expectPlaceholder(reader.next, reader.consume);
}
/**
* Recursively parses a string into a message. Handles nested messages and segments of text.
*/
function parseMessage(str) {
return extractMessage(str).map(function (textOrPlaceholder) {
if (typeof textOrPlaceholder === "string") {
return textOrPlaceholder;
} else {
return parsePlaceholder(textOrPlaceholder.text);
}
}).map(function parseSubexpressions(textOrPlaceholder) {
if (typeof textOrPlaceholder === "string") {
return textOrPlaceholder;
} else {
if (typeof textOrPlaceholder.parameters === "object") {
var key = undefined,
value = undefined;
for (key in textOrPlaceholder.parameters) {
if (textOrPlaceholder.parameters.hasOwnProperty(key)) {
value = textOrPlaceholder.parameters[key];
if (value.value) {
value.value = parseMessage(value.value);
}
}
}
}
return textOrPlaceholder;
}
});
}
var parser = parseMessage;
"use strict";
var locale = "default",
ruleSets = {
"default": {
list: {
start: "{0}, {1}",
middle: "{0}, {1}",
end: "{0}, {1}",
"2": "{0}, {1}"
},
number: {
percent: "{0}%",
integer: {
separator: ","
}
},
suffix: {}
} , 'en_US': {"date":{"long":"LL","medium":"ll","short":"M/D/YY","full":"EEEE, MMMM D, YYYY"},"list":{"2":"{0} and {1}","start":"{0}, {1}","middle":"{0}, {1}","end":"{0}, and {1}"},"number":{"percent":"{0}%"},"possessive":{"fallback":"’s","rules":{".*[Ss]$":"’",".*[A-RT-Z]$":"’S",".*[a-rt-z]$":"’s"}},"time":{"short":"h:mm a","medium":"h:mm:ss a","long":"h:mm:ss a ZZ","full":"h:mm:ss a ZZ"}}
},
placeholder_placeholder__evaluator = function evaluator() {};
/**
* Sets the placeholder evaluator function. This function will be used to
* evaluate placeholders, converting them into string values.
*
* This is structured this way in order to prevent circular references. The
* default evaluator is a no-op function.
*
* @param {Function} fn - the function to use for evaluation
*/
function setEvaluator(fn) {
placeholder_placeholder__evaluator = fn;
}
function getRules(locale, type) {
var ruleSet = ruleSets[locale];
if (type && ruleSet) {
return ruleSet[type];
}
return ruleSet;
}
function addRuleSet(locale, rules) {
ruleSets[locale] = rules; // TODO: Consider something like _.extend() here instead.
}
/**
* Gets the value of the style with the name `key` in the specified placeholder,
* or `undefined` if the style could not be found.
*
* @param {Object} placeholder - a well-formed placeholder object
* @param {String} key - the name of the style to get
* @return {String|Array}
*/
function getStyle(placeholder, key) {
var result;
if (placeholder.parameters) {
result = placeholder.parameters[key];
}
if (result) {
return result.value;
}
return undefined;
}
/**
* Gets the style with the index `index` in the specified placeholder,
* or `undefined` if the style could not be found.
*
* This function returns the entire style object, not just the value.
*
* @param {Object} placeholder - a well-formed placeholder object
* @param {Number} index - the 0-based index of the style to get
* @return {Object}
*/
function getStyleByIndex(placeholder, index) {
var styles = placeholder.parameters,
name;
if (styles) {
for (name in styles) {
if (styles.hasOwnProperty(name)) {
if (styles[name].order === index) {
return styles[name];
}
}
}
}
return undefined;
}
/**
* Evaluates a particular style, specified by `key`, from the given placeholder
* using the specified locale. Styles may contain entire XMessages, that is,
* nested placeholders. Those will be evaluated using the `evaluator` function.
*
* If no style is found with the name specified by `key`, `undefined` is the
* return value.
*
* @param {Object} placeholder - a well-formed placeholder object
* @param {String} key - the name of the style to evaluate
* @param {Array} context - an array of values, may be primitives or objects
* @param {String} locale - the locale
* @return {String}
* @see setEvaluator
*/
function evaluateStyle(placeholder, key, context, locale) {
var maybeStyle = getStyle(placeholder, key),
result;
if (maybeStyle) {
result = maybeStyle.map(function (segment) {
if (segment instanceof Object) {
return placeholder_placeholder__evaluator(segment, context, locale);
}
return segment.toString();
}).join("");
}
return result;
}
/**
* Tries to resolve the value of a placeholder's index from the supplied
* context. For example, an index may be {1}, {:name}, {1:name}, etc. If the
* index doesn't specify a number, 0 will be used.
*
* @param {Object} placeholder - a well-formed placeholder object
* @param {Array} context - an array of values, may be primitives or objects
* @return {*}
*/
function resolveIndex(placeholder, context) {
var result = null;
if (placeholder && placeholder.index && context) {
var index = placeholder.index;
if (typeof index.number === "number") {
result = context[index.number];
} else if (index.number === null) {
result = context[0]; // Default to the 0th element if no number is specified.
}
if (result !== undefined && result !== null) {
if (typeof index.keyword === "string") {
result = result[index.keyword];
}
} else {
result = undefined;
}
}
return result;
}
"use strict";
var anchor_placeholder = evaluateAnchorPlaceholder;
var anchor_placeholder__STRING_TEXT = "text",
anchor_placeholder__STRING_TITLE = "title",
STRING_ID = "id",
STRING_CLASS = "class";
function evaluateAnchorPlaceholder(placeholderAst, context, locale) {
var resolved = resolveIndex(placeholderAst, context),
isMap = resolved && typeof resolved === "object",
hrefAttr = isMap ? resolved.href : resolved,
idAttr = isMap ? resolved.id : null,
classAttr = isMap ? resolved["class"] : null,
textStyle = evaluateStyle(placeholderAst, anchor_placeholder__STRING_TEXT, context, locale),
titleStyle = evaluateStyle(placeholderAst, anchor_placeholder__STRING_TITLE, context, locale),
result = "";
return result;
}
"use strict";
var boolean_placeholder = evaluateBooleanPlaceholder;
var boolean_placeholder__STRING_TRUE = "true",
boolean_placeholder__STRING_FALSE = "false";
function evaluateBooleanPlaceholder(placeholderAst, context, locale) {
var indexValue = resolveIndex(placeholderAst, context),
result = "";
if (indexValue === true || indexValue === boolean_placeholder__STRING_TRUE) {
result = evaluateStyle(placeholderAst, boolean_placeholder__STRING_TRUE, context, locale);
} else if (indexValue === false || indexValue === boolean_placeholder__STRING_FALSE) {
result = evaluateStyle(placeholderAst, boolean_placeholder__STRING_FALSE, context, locale);
} else {
// This is an error. Truthy values are not supported.
throw new Error("Invalid argument for BooleanPlaceholder. Expected boolean or \"true\" or \"false\" but found \"" + indexValue + "\"");
}
return result;
}
"use strict";
var choice_placeholder = evaluateChoicePlaceholder;
var choice_placeholder__REGEX_NUMBERS = /-?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/,
choice_placeholder__REGEX_CATEGORIES = /^(zero|singular|dual|few|many|plural|other)$/;
function evaluateChoicePlaceholder(placeholderAst, context, locale) {
var indexValue = resolveIndex(placeholderAst, context),
result = "",
stylesAsRules,
styleToRender,
chooserResult,
styles,
params = placeholderAst.parameters,
currentStyle,
key;
styles = [];
for (key in params) {
if (params.hasOwnProperty(key)) {
currentStyle = params[key];
styles[currentStyle.order] = currentStyle;
}
}
if (!choice_placeholder__REGEX_NUMBERS.test(indexValue)) {
throw new Error("Invalid context value for ChoicePlaceholder. \"" + indexValue + "\" is not a valid number.");
}
stylesAsRules = styles.map(function (style, index) {
var result = {};
if (choice_placeholder__REGEX_CATEGORIES.test(style.key)) {
result.category = style.key;
result.comparison = "eq";
result.text = index.toString();
} else {
// Assume number
result.arg = parseFloat(style.key);
switch (style.delimiter) {
case "<":
result.comparison = "gt";
break;
case "+":
result.comparison = "gte";
break;
case "#":
result.comparison = "gte";
break;
default:
result.comparison = "eq";
break;
}
result.text = index.toString();
}
return result;
});
chooserResult = new t8.Chooser().format(parseFloat(indexValue), stylesAsRules, locale);
if (chooserResult !== undefined) {
styleToRender = styles[parseInt(chooserResult, 10)];
result = evaluateStyle(placeholderAst, styleToRender.key, context, locale);
}
return result;
}
"use strict";
var map_placeholder = evaluateMapPlaceholder;
var DEFAULT_TEXT = "DEFAULT_TEXT";
function evaluateMapPlaceholder(placeholderAst, context, locale) {
var indexValue = resolveIndex(placeholderAst, context),
style,
result = "";
if (indexValue !== undefined) {
indexValue = indexValue.toString();
style = getStyle(placeholderAst, indexValue);
if (style) {
result = evaluateStyle(placeholderAst, indexValue, context, locale);
} else {
result = evaluateStyle(placeholderAst, DEFAULT_TEXT, context, locale);
}
} else {
result = evaluateStyle(placeholderAst, DEFAULT_TEXT, context, locale);
}
return result;
}
"use strict";
function formatPossessive(value, locale) {
var result = "",
key = undefined;
if (value !== undefined) {
var possessiveRules = getRules(locale, "possessive");
if (possessiveRules) {
var suffixFromRules = undefined;
if (possessiveRules.rules) {
for (key in possessiveRules.rules) {
if (possessiveRules.rules.hasOwnProperty(key)) {
var suffixValue = possessiveRules.rules[key];
var regex = new RegExp(key);
if (regex.test(value)) {
suffixFromRules = suffixValue;
}
}
}
}
if (suffixFromRules !== undefined) {
result = suffixFromRules;
} else if (possessiveRules.fallback) {
result = possessiveRules.fallback;
}
}
}
return result;
}
"use strict";
var possessive_placeholder = evaluatePossessivePlaceholder;
function evaluatePossessivePlaceholder(placeholderAst, context, locale) {
var resolvedValue = resolveIndex(placeholderAst, context),
result = "";
if (resolvedValue !== undefined) {
result = formatPossessive(resolvedValue, locale);
}
return result;
}
"use strict";
var simple_placeholder = evaluateSimplePlaceholder;
function evaluateSimplePlaceholder(placeholderAst, context /* , locale */) {
var resolvedValue = resolveIndex(placeholderAst, context),
output;
if (resolvedValue === undefined) {
output = "{" + (placeholderAst.index.number !== null ? placeholderAst.index.number : "") + (placeholderAst.index.keyword !== null ? ":" + placeholderAst.index.keyword : "") + "}";
} else {
output = resolvedValue;
}
return output;
}
/**
* Formats a value with a prefix or suffix provided by a set of styles.
* @param {Object} styles - a placeholder's style map
* @param {String} value - the value to decorate
*/
"use strict";
var prefix_suffix_formatter = formatPrefixOrSuffix;
var STYLE_PREFIX = "prefix",
STYLE_SUFFIX = "suffix";
function formatPrefixOrSuffix(styles, value) {
if (styles) {
var maybePrefix = styles[STYLE_PREFIX];
var maybeSuffix = styles[STYLE_SUFFIX];
// TODO: Could prefix or suffix ever be a placeholder, or only values allowed?
if (maybePrefix) {
value = maybePrefix.value + value;
}
if (maybeSuffix) {
value = value + maybeSuffix.value;
}
}
return value;
}
"use strict";
var text_placeholder = evaluateTextPlaceholder;
function evaluateTextPlaceholder(placeholderAst, context /* , locale */) {
var resolvedValue = resolveIndex(placeholderAst, context),
output;
if (resolvedValue === undefined) {
output = "{" + (placeholderAst.index.number !== null ? placeholderAst.index.number : "") + (placeholderAst.index.keyword !== null ? ":" + placeholderAst.index.keyword : "") + "}";
} else {
output = resolvedValue;
}
output = prefix_suffix_formatter(placeholderAst.parameters, output);
return output;
}
/**
* Applies placeholder substitution on a string template.
* @param {String} template - the template containing placeholders {0} and {1}, etc.
* @return {String} an interpolated template
*/
"use strict";
function stringFormat(template /* , args... */) {
// Shamelessly copied from: http://stackoverflow.com/questions/610406/javascript-equivalent-to-printf-string-format/4673436#4673436
var args = Array.prototype.slice.call(arguments, 1);
return template.replace(/{(\d+)}/g, function (match, number) {
return typeof args[number] !== "undefined" ? args[number] : match;
});
}
function findFirstProperty(properties, object) {
var length, index;
for (index = 0, length = properties.length; index < length; ++index) {
var key = properties[index];
if (object.hasOwnProperty(key)) {
return object[key];
}
}
return null;
}
function defaults(target, source) {
var key;
if (target && source) {
for (key in source) {
if (source.hasOwnProperty(key)) {
if (!target.hasOwnProperty(key)) {
target[key] = source[key];
}
}
}
}
return target;
}
"use strict";
var number_placeholder = evaluateNumberPlaceholder;
function formatPercentage(template, value) {
value = Math.floor(value * 100);
return stringFormat(template, value);
}
/**
* Gets the set of locale-specific rules to use for number formatting.
*/
function getFormattingRules(locale) {
return defaults(defaults({}, getRules(locale, "number")), getRules("default", "number"));
}
function evaluateNumberPlaceholder(placeholderAst, context, locale) {
var resolvedValue = resolveIndex(placeholderAst, context),
styles = placeholderAst.parameters,
rules = getFormattingRules(locale),
output;
if (resolvedValue !== undefined) {
if (styles) {
if (styles.integer) {
output = new t8.NumberFormatter().format(Math.floor(resolvedValue), locale);
} else if (styles.currency) {
output = new t8.CurrencyFormatter().format(resolvedValue, undefined, locale);
} else if (styles.percent) {
output = formatPercentage(rules.percent, resolvedValue);
}
} else {
output = new t8.NumberFormatter().format(resolvedValue, locale);
}
}
return output;
}
"use strict";
var date_placeholder = evaluateDatePlaceholder;
function evaluateDatePlaceholder(placeholderAst, context, locale) {
var resolvedValue = resolveIndex(placeholderAst, context),
output = "",
style,
pattern,
t8Impl,
rules = getRules(locale, "date");
style = getStyleByIndex(placeholderAst, 0);
if (!style) {
style = "medium";
} else {
style = style.key;
}
pattern = rules[style];
if (!pattern) {
// Might be a custom format...
pattern = style; // Need to replace single quotes with square brackets for Moment.
if (pattern) {
// It's a custom pattern for sure, so we need to do some doctoring on the pattern.
pattern = pattern.replace(/Z/, "ZZ"); // Since moment.js renders "Z" as XX:XX and "ZZ" as XXXX
}
}
if (pattern) {
t8Impl = new t8.DateFormatter();
output = t8Impl.format(new Date(resolvedValue), locale, pattern, false);
}
return output;
}
"use strict";
var time_placeholder = evaluateTimePlaceholder;
function evaluateTimePlaceholder(placeholderAst, context, locale) {
var resolvedValue = resolveIndex(placeholderAst, context),
output = "",
style,
pattern,
t8Impl,
rules = getRules(locale, "time");
style = getStyleByIndex(placeholderAst, 0);
if (!style) {
style = "medium";
} else {
style = style.key;
}
pattern = rules[style];
if (!pattern) {
// Might be a custom format...
pattern = style;
}
if (pattern) {
t8Impl = new t8.DateFormatter();
output = t8Impl.format(new Date(resolvedValue), locale, pattern, false);
}
return output;
}
"use strict";
var suffix_placeholder = evaluateSuffixPlaceholder;
var CHAR_SPACE = " ",
CHAR_TAB = "\t",
suffix_placeholder__STRING_SEP = "sep",
STRATEGY_REVERSE_SEARCH_FOR_VOWEL = "reverseSearchForVowel";
function evaluateSuffixPlaceholder(placeholderAst, context, locale) {
var resolvedValue = resolveIndex(placeholderAst, context),
result = "",
addSeparator = false,
rules,
key,
value,
regex,
suffixFromRules,
currentChar,
i,
lastIndex,
vowels,
endsWithVowel,
params = placeholderAst.parameters;
if (resolvedValue !== undefined) {
if (params) {
addSeparator = !!params[suffix_placeholder__STRING_SEP];
}
rules = getRules(locale, "suffix");
if (rules) {
vowels = (rules.hardVowels || "") + (rules.softVowels || "");
switch (rules.strategy) {
case STRATEGY_REVERSE_SEARCH_FOR_VOWEL:
if (resolvedValue.length > 0) {
lastIndex = resolvedValue.length - 1;
for (i = lastIndex; i >= 0 && currentChar !== CHAR_SPACE && currentChar !== CHAR_TAB; i--) {
currentChar = resolvedValue.charAt(i);
if (vowels.indexOf(currentChar) !== -1) {
endsWithVowel = i === lastIndex;
suffixFromRules = rules.hardVowels && rules.hardVowels.indexOf(currentChar) > -1 ? rules.hardVowelSuffix : rules.fallbackSuffix;
result = "" + (endsWithVowel ? rules.bufferChar : "") + suffixFromRules;
return addSeparator ? rules.separator + result : result;
}
}
// Fall back to check if it ends with a consonant.
for (key in rules.nonVowelToSuffix) {
if (rules.nonVowelToSuffix.hasOwnProperty(key)) {
value = rules.nonVowelToSuffix[key];
regex = new RegExp(key);
if (regex.test(resolvedValue.charAt(lastIndex))) {
suffixFromRules = value;
break;
}
}
}
if (!suffixFromRules) {
suffixFromRules = rules.defaultBufferChar;
}
result = addSeparator ? rules.separator + suffixFromRules : suffixFromRules;
break;
}
break;
default:
break;
}
}
}
return result;
}
/**
* Formats a value as a name according to a set of styles.
* @param {Object} styles - a placeholder's style map
* @param {Object} value - the value to decorate
*/
"use strict";
var name_formatter = formatName;
var DEFAULT_NAME_STYLE = "FULL_NAME",
NAME_STYLES = ["familiar", "family", "full", "given", "list", "maiden"];
function formatName(styles, value, locale) {
var output,
nameAdapter = {},
formatAdapter,
formatStyle,
hasMicroformat = false,
t8Impl;
if (value !== undefined) {
nameAdapter.firstName = value.givenName;
nameAdapter.lastName = value.familyName;
nameAdapter.maidenName = value.maidenName;
formatStyle = findFirstProperty(NAME_STYLES, styles);
if (formatStyle) {
formatStyle = formatStyle.key;
} else {
formatStyle = "familiar";
}
hasMicroformat = !!styles.micro;
if (formatStyle) {
switch (formatStyle) {
case "given":
output = value.givenName || "";
if (hasMicroformat) {
output = "" + output + "";
}
break;
case "family":
output = value.familyName || "";
if (hasMicroformat) {
output = "" + output + "";
}
break;
case "maiden":
output = value.maidenName || "";
if (hasMicroformat) {
output = "" + output + "";
}
break;
default:
formatAdapter = formatStyle === "full" || formatStyle === "given" || formatStyle === "family" || formatStyle === "maiden" ? "FULL_NAME" : formatStyle === "familiar" ? "FAMILIAR_NAME" : formatStyle === "list" ? "LIST_VIEW" : DEFAULT_NAME_STYLE;
if (hasMicroformat) {
formatAdapter = [formatAdapter, "MICROFORMAT"];
}
t8Impl = new t8.NameFormatter();
output = t8Impl.format(nameAdapter, formatAdapter, locale);
break;
}
}
}
return output;
}
"use strict";
var name_placeholder = evaluateNamePlaceholder;
function evaluateNamePlaceholder(placeholderAst, context, locale) {
var resolvedValue = resolveIndex(placeholderAst, context),
output = undefined;
output = name_formatter(placeholderAst.parameters, resolvedValue, locale);
if (placeholderAst.parameters.possessive) {
output += formatPossessive(output, locale);
}
output = prefix_suffix_formatter(placeholderAst.parameters, output);
return output;
}
"use strict";
var list_placeholder = evaluateListPlaceholder;
var TYPE_NAME = "name",
RULE_START = "start",
RULE_MIDDLE = "middle",
RULE_END = "end",
RULE_2 = "2";
function applyValueFormatting(styles, value, locale) {
if (styles) {
if (styles[TYPE_NAME]) {
value = name_formatter(styles, value, locale);
}
// Then apply prefix/suffix
value = prefix_suffix_formatter(styles, value);
}
return value;
}
function evaluateListPlaceholder(placeholderAst, context, locale) {
var resolvedValue = resolveIndex(placeholderAst, context),
result = "",
collectionSize,
lastIndex,
rules = getRules(locale, "list") || getRules("default", "list"),
listRule,
firstPosition,
secondPosition;
// Blank output for falsy and non-list values.
if (resolvedValue && resolvedValue instanceof Array) {
collectionSize = resolvedValue.length;
lastIndex = collectionSize - 1;
if (collectionSize > 0) {
switch (collectionSize) {
case 1:
result = applyValueFormatting(placeholderAst.parameters, resolvedValue[0], locale);
break;
case 2:
result = stringFormat(rules[RULE_2], applyValueFormatting(placeholderAst.parameters, resolvedValue[0], locale), applyValueFormatting(placeholderAst.parameters, resolvedValue[1], locale));
break;
default:
// 3 or more
firstPosition = 0;
secondPosition = 1;
do {
listRule = firstPosition === 0 ? RULE_START : secondPosition < lastIndex ? RULE_MIDDLE : RULE_END;
if (listRule === RULE_START) {
result = stringFormat(rules[listRule], applyValueFormatting(placeholderAst.parameters, resolvedValue[firstPosition], locale), applyValueFormatting(placeholderAst.parameters, resolvedValue[secondPosition], locale));
} else {
result = stringFormat(rules[listRule], result, applyValueFormatting(placeholderAst.parameters, resolvedValue[secondPosition], locale));
}
firstPosition++;
secondPosition++;
} while (listRule !== RULE_END);
break;
}
} // else { return ''; }
} // else { return ''; }
return result;
}
/**
* Validate if an given AST is well-formed. Returns a string if there was a
* validation error; otherwise returns undefined.
* @param {Object} ast - the AST of a placeholder
* @return {String|Undefined}
*/
"use strict";
var validatePlaceholder = validatePlaceholder__validate;
function validatePlaceholder__validate(ast) {
if (!ast) {
return "Placeholder is invalid.";
}
if (!ast.index) {
return "Placeholder must have an index.";
}
return undefined;
}
"use strict";
function allowOnlyTheseStyleKeys(ast, allowedStylesRegexp) {
var hasValidationError, styles, name;
if (ast.parameters) {
styles = ast.parameters;
for (name in styles) {
if (styles.hasOwnProperty(name)) {
if (!allowedStylesRegexp.test(name)) {
hasValidationError = "Invalid style \"" + name + "\"";
break;
}
}
}
}
return hasValidationError;
}
function mustHaveTheseStyleKeys(ast, requiredStyleKeys) {
var hasValidationError, styles, name, index, length;
if (ast.parameters) {
styles = ast.parameters;
for (index = 0, length = requiredStyleKeys.length; index < length; ++index) {
name = requiredStyleKeys[index];
if (!styles.hasOwnProperty(name)) {
hasValidationError = "Missing required style key \"" + name + "\"";
}
}
} else {
hasValidationError = "Placeholder must have styles";
}
return hasValidationError;
}
function checkStyleCount(ast, styleLimit, mode) {
var hasValidationError,
messageZero = "Placeholder must have styles",
messageEq = "Placeholder must have exactly " + styleLimit + " style(s)",
messageLte = "Placeholder must have at least " + styleLimit + " style(s)",
styleCount = 0,
key;
// This would be way nicer if we could just use Object.keys().length here.
if (ast.parameters) {
for (key in ast.parameters) {
if (ast.parameters.hasOwnProperty(key)) {
styleCount++;
}
}
if (mode === "eq" && styleCount !== styleLimit) {
hasValidationError = messageEq;
} else if (mode === "gte" && styleCount < styleLimit) {
hasValidationError = messageLte;
}
} else {
if (styleLimit > 0) {
hasValidationError = messageZero;
}
// else case: we expect 0 and there are none -- no error here.
}
return hasValidationError;
}
function mustHaveAtLeastNStyles(ast, styleLimit) {
return checkStyleCount(ast, styleLimit, "gte");
}
function mustHaveExactlyNStyles(ast, styleLimit) {
return checkStyleCount(ast, styleLimit, "eq");
}
function checkStyleValue(ast, styles, mode) {
var style, index, length, hasValidationError;
if (ast.parameters) {
for (index = 0, length = styles.length; index < length; ++index) {
style = ast.parameters[styles[index]];
if ("without" === mode) {
if (style && style.value) {
hasValidationError = "Invalid value for style \"" + style.key + "\"";
}
} else if ("with" === mode) {
if (style) {
if (!style.value) {
hasValidationError = "Style \"" + style.key + "\" must have a value";
}
}
}
}
}
return hasValidationError;
}
function stylesMustHaveAValue(ast, styles) {
return checkStyleValue(ast, styles, "with");
}
function stylesMustHaveNoValue(ast, styles) {
return checkStyleValue(ast, styles, "without");
}
"use strict";
var validateAnchor = validateAnchor__validate;
var validateAnchor__STRING_TEXT = "text",
validateAnchor__STRING_TITLE = "title",
REQUIRED_STYLES = [validateAnchor__STRING_TEXT],
validateAnchor__SUPPORTED_STYLES_REGEXP = new RegExp("^(" + [validateAnchor__STRING_TEXT, validateAnchor__STRING_TITLE].join("|") + ")$");
function validateAnchor__validate(ast) {
var result = mustHaveTheseStyleKeys(ast, REQUIRED_STYLES);
if (!result) {
result = allowOnlyTheseStyleKeys(validateAnchor__SUPPORTED_STYLES_REGEXP);
}
return result;
}
"use strict";
var validateBoolean = validateBoolean__validate;
var validateBoolean__STRING_TRUE = "true",
validateBoolean__STRING_FALSE = "false",
validateBoolean__SUPPORTED_STYLES_REGEXP = new RegExp("^(" + [validateBoolean__STRING_TRUE, validateBoolean__STRING_FALSE].join("|") + ")$");
function validateBoolean__validate(ast) {
var result = mustHaveAtLeastNStyles(ast, 1);
if (!result) {
result = allowOnlyTheseStyleKeys(ast, validateBoolean__SUPPORTED_STYLES_REGEXP);
}
return result;
}
"use strict";
var validateChoice = validateChoice__validate;
var validateChoice__REGEX_NUMBERS = /-?(?:0|[1-9]\d*)(?:\.\d*)?(?:[eE][+\-]?\d+)?/,
validateChoice__REGEX_CATEGORIES = /^(zero|singular|dual|few|many|plural|other)$/;
function validateChoice__validate(ast) {
var result,
lastNumber,
currentNumber,
i,
length,
styles,
params = ast.parameters,
currentStyle,
key,
hasCategories = false;
styles = [];
for (key in params) {
if (params.hasOwnProperty(key)) {
currentStyle = params[key];
styles[currentStyle.order] = currentStyle;
if (validateChoice__REGEX_CATEGORIES.test(key)) {
hasCategories = true;
}
}
}
currentStyle = undefined;
// Loop through the styles and check if numeric ones are ascending.
for (i = 0, length = styles.length; i < length; ++i) {
currentStyle = styles[i];
if (validateChoice__REGEX_NUMBERS.test(currentStyle.key)) {
currentNumber = parseInt(currentStyle.key, 10);
if (lastNumber === undefined) {
lastNumber = currentNumber;
} else {
if (lastNumber < currentNumber) {
lastNumber = currentNumber;
} else {
result = "Invalid number order. Cannot list " + currentNumber + " after " + lastNumber + ". Numbers must be ascending.";
break;
}
}
} else if (validateChoice__REGEX_CATEGORIES.test(currentStyle.key)) {
hasCategories = true;
} else {
result = "Invalid category key \"" + currentStyle.key + "\".";
break;
}
}
if (hasCategories) {
// It must have singular and plural categories if it has categories.
if (!params.singular) {
result = "Missing required category \"singular\"";
} else if (!params.plural) {
result = "Missing required category \"plural\"";
}
}
return result;
}
"use strict";
var validateMap = validateMap__validate;
function validateMap__validate(ast) {
var result, styles, name, hasStyle;
if (!ast.parameters) {
result = "MapPlaceholder must have parameters.";
} else {
styles = ast.parameters;
for (name in styles) {
if (styles.hasOwnProperty(name)) {
hasStyle = true; // If there's at least one this should be true.
if (!styles[name].value) {
result = "MapPlaceholder cannot have keys without values.";
break;
}
}
}
if (!hasStyle) {
result = "MapPlaceholder must have at least one style argument.";
}
}
return result;
}
"use strict";
var validateName = validateName__validate;
var validateName__STRING_PREFIX = "prefix",
validateName__STRING_SUFFIX = "suffix",
validateName__STYLES_THAT_REQUIRE_VALUES = [validateName__STRING_PREFIX, validateName__STRING_SUFFIX],
validateName__SUPPORTED_STYLES_REGEXP = /^(familiar|family|full|given|list|maiden|micro|possessive|salutation|prefix|suffix)$/;
function validateName__validate(ast) {
var result = allowOnlyTheseStyleKeys(ast, validateName__SUPPORTED_STYLES_REGEXP);
if (!result) {
result = stylesMustHaveAValue(ast, validateName__STYLES_THAT_REQUIRE_VALUES);
}
return result;
}
"use strict";
var validateList = validateList__validate;
var validateList__STRING_PREFIX = "prefix",
validateList__STRING_SUFFIX = "suffix",
validateList__STYLES_THAT_REQUIRE_VALUES = [validateList__STRING_PREFIX, validateList__STRING_SUFFIX],
validateList__SUPPORTED_STYLES_REGEXP = /^(text|name|familiar|family|full|given|list|maiden|micro|possessive|salutation|prefix|suffix)$/;
function validateList__validate(ast) {
var result = allowOnlyTheseStyleKeys(ast, validateList__SUPPORTED_STYLES_REGEXP);
if (!result) {
result = stylesMustHaveAValue(ast, validateList__STYLES_THAT_REQUIRE_VALUES);
}
return result;
}
"use strict";
var validatePossessive = validatePossessive__validate;
function validatePossessive__validate(ast) {
return mustHaveExactlyNStyles(ast, 0);
}
"use strict";
var validateSuffix = validateSuffix__validate;
var validateSuffix__STRING_SEP = "sep",
STRING_NOSEP = "nosep",
EMPTY_STYLES = [validateSuffix__STRING_SEP, STRING_NOSEP],
validateSuffix__SUPPORTED_STYLES_REGEXP = new RegExp("^(" + [validateSuffix__STRING_SEP, STRING_NOSEP].join("|") + ")$");
function validateSuffix__validate(ast) {
var result = mustHaveExactlyNStyles(ast, 1);
if (!result) {
result = allowOnlyTheseStyleKeys(ast, validateSuffix__SUPPORTED_STYLES_REGEXP);
}
if (!result) {
result = stylesMustHaveNoValue(ast, EMPTY_STYLES);
}
return result;
}
"use strict";
var validateText = validateText__validate;
var validateText__STRING_PREFIX = "prefix",
validateText__STRING_SUFFIX = "suffix",
validateText__SUPPORTED_STYLES_REGEXP = new RegExp([validateText__STRING_SUFFIX, validateText__STRING_PREFIX].join("|"));
function validateText__validate(ast) {
return allowOnlyTheseStyleKeys(ast, validateText__SUPPORTED_STYLES_REGEXP);
}
"use strict";
var Validator = Validator__validate;
var specializedValidators = {
anchor: validateAnchor,
boolean: validateBoolean,
choice: validateChoice,
list: validateList,
map: validateMap,
name: validateName,
possessive: validatePossessive,
suffix: validateSuffix,
text: validateText
};
function Validator__validate(ast) {
var key, value, hasValidationError;
if (typeof ast === "string") {
return;
}
hasValidationError = validatePlaceholder(ast);
if (!hasValidationError) {
if (specializedValidators.hasOwnProperty(ast.type)) {
hasValidationError = specializedValidators[ast.type](ast);
}
}
if (hasValidationError) {
throw new Error(hasValidationError);
} else {
// Check styles (if they are also placeholders)
if (ast && ast.parameters instanceof Object) {
for (key in ast.parameters) {
if (ast.parameters.hasOwnProperty(key)) {
value = ast.parameters[key];
if (value.value && value.value instanceof Array) {
// Calls itself recursively.
value.value.forEach(Validator__validate);
}
}
}
}
}
}
/**
* Converts an XMessage-compliant string into an AST by parsing it.
*
* @param {[type]} xmessage [description]
* @return {[type]} [description]
*/
"use strict";
var EVALUATORS = {
anchor: anchor_placeholder,
boolean: boolean_placeholder,
choice: choice_placeholder,
date: date_placeholder,
list: list_placeholder,
map: map_placeholder,
name: name_placeholder,
number: number_placeholder,
possessive: possessive_placeholder,
simple: simple_placeholder,
suffix: suffix_placeholder,
text: text_placeholder,
time: time_placeholder
};
/**
* A facade/proxy function that delegates to various placeholder functions.
* This function maps a placeholder to its resolved value. Passes `context`
* and `locale` to the underlying implementations.
*
* @param {Object} placeholderAst - a well-formed placeholder AST object
* @param {Array} context - an array of values, may be primitives or objects
* @param {String} locale - the locale
* @return {String}
*/
function message_builder__evaluator(placeholderAst, context, locale) {
var result = "",
evaluatorFunction;
if (placeholderAst && context && locale) {
evaluatorFunction = EVALUATORS[placeholderAst.type];
if (evaluatorFunction) {
result = evaluatorFunction(placeholderAst, context, locale);
}
}
return result;
}
// Use the above evaluator function for evaluating placeholders and styles.
setEvaluator(message_builder__evaluator);
function toAst(xmessage) {
var protoMessage = parser(xmessage);
// Perform validation. This could be omitted for PROD.
protoMessage.forEach(Validator);
return protoMessage;
}
function makeInterpolator(ast, locale) {
return function evaluate(context) {
return ast.map(function (placeholder) {
if (typeof placeholder === "string") {
return placeholder;
} else {
return message_builder__evaluator(placeholder, context, locale);
}
}).join("");
};
}
function fromString(xmessage, locale) {
return makeInterpolator(toAst(xmessage), locale);
}
exports.toAst = toAst;
exports.makeInterpolator = makeInterpolator;
exports.fromString = fromString;
}exportAsGlobal((this.xmessage = {}), require);})();
/**
* Override the get method in t8 to support xmsg syntax in dust templates.
*
* Created by xxiao on 5/15/15.
*/
(function(play, t8, LI) {
var oldResourceGet = t8.Resources.prototype.get;
t8.Resources.prototype.get = function(key, namespace, context, callback) {
var useNativeXmsg = false;
var useJavaXmsg = false;
if (play.hasPageContext()) {
useNativeXmsg = play.getPageContextValue("useNativeXmsg", true);
useJavaXmsg = !play.isClient && play.getPageContextValue("useJavaXmsg", false);
}
if (useNativeXmsg || useJavaXmsg) {
play.Utils.assert(callback, "get called with null callback");
play.Utils.assert(key, "get called with null or empty key");
play.Utils.assert(namespace, "get called with null or empty namespace");
//No dynamic string if xmsg syntax is enabled
evalXmsg(callback, key, namespace, context, useJavaXmsg, this.i18nCacheStatic);
} else {
oldResourceGet.call(this, key, namespace, context, callback);
}
};
function evalXmsg(callback, key, namespace, context, useJavaXmsg, i18nCacheStatic) {
if (useJavaXmsg) {
try {
callback(null, com.linkedin.playplugins.dust.plugin.I18nPropertiesRenderer.getProperty(namespace, LI.i18n.getLocale().value, key, context));
} catch (e) {
callback(e.getMessage());
}
} else {
if (i18nCacheStatic && i18nCacheStatic.cache && i18nCacheStatic.cache[namespace] && i18nCacheStatic.cache[namespace][key]) {
var xmsgString = i18nCacheStatic.cache[namespace][key];
var ast = xmessage.toAst(xmsgString);
var messageFn = xmessage.makeInterpolator(ast, LI.i18n.getLocale().value);
callback(null, messageFn(getData(ast, context)));
} else {
callback("Could not find xmsg key " + key + " in static i18n cache.");
}
}
}
// Construct the argument array. Since dust does not use the number based index, the array length should always be 1.
function getData(ast, context) {
var result = [];
var data = {};
ast.map(function (placeholder) {
if (typeof placeholder === "object") {
var argName = placeholder.index.keyword;
data[argName] = context.get(argName);
}
});
result[0] = data;
return result;
}
})(play, t8, LI);