Commit b4778891 authored by Kevin Abel's avatar Kevin Abel
Browse files

Add js source needed for minimal embed scripts

parent c12398b3
/* global define: false */
define(['jquery'], function($) {
"use strict";
var wdnProp = 'UA-3203435-1';
var unlDomain = '.unl.edu';
var Plugin;
var thisURL = String(window.location);
var gaWdnName = 'wdn';
var gaWdn = gaWdnName + '.';
// ga.js method for getting default tracker (with set account)
var getDefaultGATracker = function() {
var tracker = _gat._getTrackerByName();
if (tracker._getAccount() !== 'UA-XXXXX-X') {
return tracker;
}
return undefined;
};
// analytics.js method for getting default tracker
var getDefaultAnalyticsTracker = function() {
return ga.getByName('t0');
};
Plugin = {
initialize : function() {
ga('create', wdnProp, {
name: gaWdnName,
cookieDomain: unlDomain,
allowLinker: true
});
},
callTrackPageview: function(thePage, trackInWDNAccount){
var action = 'pageview', method = 'send', legacyMethod = '_trackPageview';
if (!thePage) {
ga(gaWdn+method, action);
return;
}
if (trackInWDNAccount !== false) {
trackInWDNAccount = true;
}
// First, track in the wdn analytics
if (trackInWDNAccount) {
ga(gaWdn+method, action, thePage);
}
// Second, track in local site analytics
try {
_gaq.push(function() {
var tracker = getDefaultGATracker();
if (tracker) {
tracker[legacyMethod](thePage);
}
});
ga(function() {
var tracker = getDefaultAnalyticsTracker();
if (tracker) {
tracker[method](action, thePage);
}
});
} catch(e) {}
},
callTrackEvent: function(category, evtaction, label, value, noninteraction) {
var action = 'event', method = 'send', legacyMethod = '_trackEvent', evtOpt;
if (noninteraction !== true) {
noninteraction = false;
}
evtOpt = {
eventCategory: category,
eventAction: evtaction,
eventLabel: label,
eventValue: value,
nonInteraction: noninteraction
};
ga(gaWdn+method, action, evtOpt);
try {
_gaq.push(function() {
var tracker = getDefaultGATracker(), legacyValue = value;
if (tracker) {
if (typeof value !== "undefined") {
legacyValue = Math.floor(value);
}
tracker[legacyMethod](category, evtaction, label, legacyValue, noninteraction);
}
});
ga(function() {
var tracker = getDefaultAnalyticsTracker();
if (tracker) {
tracker[method](action, evtOpt);
}
});
} catch(e) {}
},
callTrackTiming: function(category, variable, value, label, sampleRate) {
var action = 'timing', method = 'send', legacyMethod = '_trackTiming';
ga(gaWdn+method, action, category, variable, value, label);
try {
_gaq.push(function() {
var tracker = getDefaultGATracker();
if (tracker) {
tracker[legacyMethod](category, variable, value, label, sampleRate);
}
});
ga(function() {
var tracker = getDefaultAnalyticsTracker();
if (tracker) {
tracker[method](action, category, variable, value, label);
}
});
} catch (e) {}
}
};
return Plugin;
});
This diff is collapsed.
requirejs.config({
map: {
"*": {
css: 'require-css/css'
}
}
});
MIT License
-----------
Copyright (C) 2013 Guy Bedford
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
define(['require', './normalize'], function(req, normalize) {
var cssAPI = {};
var isWindows = !!process.platform.match(/^win/);
function compress(css) {
if (config.optimizeCss == 'none') {
return css;
}
if (typeof process !== "undefined" && process.versions && !!process.versions.node && require.nodeRequire) {
var csso;
try {
csso = require.nodeRequire('csso');
}
catch(e) {
console.log('Compression module not installed. Use "npm install csso -g" to enable.');
return css;
}
var csslen = css.length;
try {
css = (csso.minify || csso.justDoIt)(css);
}
catch(e) {
console.log('Compression failed due to a CSS syntax error.');
return css;
}
console.log('Compressed CSS output to ' + Math.round(css.length / csslen * 100) + '%.');
return css;
}
console.log('Compression not supported outside of nodejs environments.');
return css;
}
//load file code - stolen from text plugin
function loadFile(path) {
var file;
if (typeof process !== "undefined" && process.versions && !!process.versions.node && require.nodeRequire) {
var fs = require.nodeRequire('fs');
file = fs.readFileSync(path, 'utf8');
if (file.indexOf('\uFEFF') === 0)
return file.substring(1);
return file;
}
else {
file = new java.io.File(path);
var lineSeparator = java.lang.System.getProperty("line.separator"),
input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), 'utf-8')),
stringBuffer, line;
try {
stringBuffer = new java.lang.StringBuffer();
line = input.readLine();
if (line && line.length() && line.charAt(0) === 0xfeff)
line = line.substring(1);
stringBuffer.append(line);
while ((line = input.readLine()) !== null) {
stringBuffer.append(lineSeparator).append(line);
}
return String(stringBuffer.toString());
}
finally {
input.close();
}
}
}
function saveFile(path, data) {
if (typeof process !== "undefined" && process.versions && !!process.versions.node && require.nodeRequire) {
var fs = require.nodeRequire('fs');
fs.writeFileSync(path, data, 'utf8');
}
else {
var content = new java.lang.String(data);
var output = new java.io.BufferedWriter(new java.io.OutputStreamWriter(new java.io.FileOutputStream(path), 'utf-8'));
try {
output.write(content, 0, content.length());
output.flush();
}
finally {
output.close();
}
}
}
//when adding to the link buffer, paths are normalised to the baseUrl
//when removing from the link buffer, paths are normalised to the output file path
function escape(content) {
return content.replace(/(["'\\])/g, '\\$1')
.replace(/[\f]/g, "\\f")
.replace(/[\b]/g, "\\b")
.replace(/[\n]/g, "\\n")
.replace(/[\t]/g, "\\t")
.replace(/[\r]/g, "\\r");
}
// NB add @media query support for media imports
var importRegEx = /@import\s*(url)?\s*(('([^']*)'|"([^"]*)")|\(('([^']*)'|"([^"]*)"|([^\)]*))\))\s*;?/g;
var absUrlRegEx = /^([^\:\/]+:\/)?\//;
// Write Css module definition
var writeCSSDefinition = "define('@writecss', function() {return function writeCss(c) {var d=document,a='appendChild',i='styleSheet',s=d.createElement('style');s.type='text/css';d.getElementsByTagName('head')[0][a](s);s[i]?s[i].cssText=c:s[a](d.createTextNode(c));};});";
var siteRoot;
var baseParts = req.toUrl('base_url').split('/');
baseParts[baseParts.length - 1] = '';
var baseUrl = baseParts.join('/');
var curModule = 0;
var config;
var writeCSSForLayer = true;
var layerBuffer = [];
var cssBuffer = {};
cssAPI.load = function(name, req, load, _config) {
//store config
config = config || _config;
if (!siteRoot) {
siteRoot = (path.resolve(config.dir || path.dirname(config.out), config.siteRoot || '.') + '/').substr(1);
if (isWindows)
siteRoot = siteRoot.replace(/\\/g, '/');
}
//external URLS don't get added (just like JS requires)
if (name.match(absUrlRegEx))
return load();
var fileUrl = req.toUrl(name + '.css');
if (isWindows)
fileUrl = fileUrl.replace(/\\/g, '/');
// rebase to the output directory if based on the source directory;
// baseUrl points always to the output directory, fileUrl only if
// it is not prefixed by a computed path (relative too)
var fileSiteUrl = fileUrl;
if (fileSiteUrl.indexOf(baseUrl) < 0) {
var appRoot = req.toUrl(config.appDir);
if (isWindows)
appRoot = appRoot.replace(/\\/g, '/');
if (fileSiteUrl.indexOf(appRoot) === 0)
fileSiteUrl = siteRoot + fileSiteUrl.substring(appRoot.length);
} else if (config.deployRoot) {
siteRoot = '/';
fileSiteUrl = config.deployRoot + fileSiteUrl.substring(baseUrl.length);
} else {
fileSiteUrl = fileSiteUrl.substr(1);
}
//add to the buffer
cssBuffer[name] = normalize(loadFile(fileUrl), fileSiteUrl, siteRoot);
load();
};
cssAPI.normalize = function(name, normalize) {
if (name.substr(name.length - 4, 4) == '.css')
name = name.substr(0, name.length - 4);
return normalize(name);
};
cssAPI.write = function(pluginName, moduleName, write, parse) {
var cssModule;
//external URLS don't get added (just like JS requires)
if (moduleName.match(absUrlRegEx))
return;
layerBuffer.push(cssBuffer[moduleName]);
if (!global._requirejsCssData) {
global._requirejsCssData = {
usedBy: {css: true},
css: ''
};
} else {
global._requirejsCssData.usedBy.css = true;
}
if (config.buildCSS !== false) {
var style = cssBuffer[moduleName];
if (config.writeCSSModule && style) {
if (writeCSSForLayer) {
writeCSSForLayer = false;
write(writeCSSDefinition);
}
cssModule = 'define(["@writecss"], function(writeCss){\n writeCss("'+ escape(compress(style)) +'");\n})';
}
else {
cssModule = 'define(function(){})';
}
write.asModule(pluginName + '!' + moduleName, cssModule);
}
};
cssAPI.onLayerEnd = function(write, data) {
if (config.separateCSS && config.IESelectorLimit)
throw 'RequireCSS: separateCSS option is not compatible with ensuring the IE selector limit';
if (config.separateCSS) {
var outPath = data.path.replace(/(\.js)?$/, '.css');
console.log('Writing CSS! file: ' + outPath + '\n');
var css = layerBuffer.join('');
process.nextTick(function() {
if (global._requirejsCssData) {
css = global._requirejsCssData.css = css + global._requirejsCssData.css;
delete global._requirejsCssData.usedBy.css;
if (Object.keys(global._requirejsCssData.usedBy).length === 0) {
delete global._requirejsCssData;
}
}
saveFile(outPath, compress(css));
});
}
else if (config.buildCSS !== false && config.writeCSSModule !== true) {
var styles = config.IESelectorLimit ? layerBuffer : [layerBuffer.join('')];
for (var i = 0; i < styles.length; i++) {
if (styles[i] === '')
return;
write(
"(function(c){var d=document,a='appendChild',i='styleSheet',s=d.createElement('style');s.type='text/css';d.getElementsByTagName('head')[0][a](s);s[i]?s[i].cssText=c:s[a](d.createTextNode(c));})\n" +
"('" + escape(compress(styles[i])) + "');\n"
);
}
}
//clear layer buffer for next layer
layerBuffer = [];
writeCSSForLayer = true;
};
return cssAPI;
});
/*
* Require-CSS RequireJS css! loader plugin
* 0.1.8
* Guy Bedford 2014
* MIT
*/
/*
*
* Usage:
* require(['css!./mycssFile']);
*
* Tested and working in (up to latest versions as of March 2013):
* Android
* iOS 6
* IE 6 - 10
* Chome 3 - 26
* Firefox 3.5 - 19
* Opera 10 - 12
*
* browserling.com used for virtual testing environment
*
* Credit to B Cavalier & J Hann for the IE 6 - 9 method,
* refined with help from Martin Cermak
*
* Sources that helped along the way:
* - https://developer.mozilla.org/en-US/docs/Browser_detection_using_the_user_agent
* - http://www.phpied.com/when-is-a-stylesheet-really-loaded/
* - https://github.com/cujojs/curl/blob/master/src/curl/plugin/css.js
*
*/
define(function() {
//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
if (typeof window == 'undefined')
return { load: function(n, r, load){ load() } };
var head = document.getElementsByTagName('head')[0];
var engine = window.navigator.userAgent.match(/Trident\/([^ ;]*)|AppleWebKit\/([^ ;]*)|Opera\/([^ ;]*)|rv\:([^ ;]*)(.*?)Gecko\/([^ ;]*)|MSIE\s([^ ;]*)|AndroidWebKit\/([^ ;]*)/) || 0;
// use <style> @import load method (IE < 9, Firefox < 18)
var useImportLoad = false;
// set to false for explicit <link> load checking when onload doesn't work perfectly (webkit)
var useOnload = true;
// trident / msie
if (engine[1] || engine[7])
useImportLoad = parseInt(engine[1]) < 6 || parseInt(engine[7]) <= 9;
// webkit
else if (engine[2] || engine[8])
useOnload = false;
// gecko
else if (engine[4])
useImportLoad = parseInt(engine[4]) < 18;
//>>excludeEnd('excludeRequireCss')
//main api object
var cssAPI = {};
//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
cssAPI.pluginBuilder = './css-builder';
// <style> @import load method
var curStyle, curSheet;
var createStyle = function () {
curStyle = document.createElement('style');
head.appendChild(curStyle);
curSheet = curStyle.styleSheet || curStyle.sheet;
}
var ieCnt = 0;
var ieLoads = [];
var ieCurCallback;
var createIeLoad = function(url) {
curSheet.addImport(url);
curStyle.onload = function(){ processIeLoad() };
ieCnt++;
if (ieCnt == 31) {
createStyle();
ieCnt = 0;
}
}
var processIeLoad = function() {
ieCurCallback();
var nextLoad = ieLoads.shift();
if (!nextLoad) {
ieCurCallback = null;
return;
}
ieCurCallback = nextLoad[1];
createIeLoad(nextLoad[0]);
}
var importLoad = function(url, callback) {
if (!curSheet || !curSheet.addImport)
createStyle();
if (curSheet && curSheet.addImport) {
// old IE
if (ieCurCallback) {
ieLoads.push([url, callback]);
}
else {
createIeLoad(url);
ieCurCallback = callback;
}
}
else {
// old Firefox
curStyle.textContent = '@import "' + url + '";';
var loadInterval = setInterval(function() {
try {
curStyle.sheet.cssRules;
clearInterval(loadInterval);
callback();
} catch(e) {}
}, 10);
}
}
// <link> load method
var linkLoad = function(url, callback) {
var link = document.createElement('link');
link.type = 'text/css';
link.rel = 'stylesheet';
if (useOnload)
link.onload = function() {
link.onload = function() {};
// for style dimensions queries, a short delay can still be necessary
setTimeout(callback, 7);
}
else
var loadInterval = setInterval(function() {
for (var i = 0; i < document.styleSheets.length; i++) {
var sheet = document.styleSheets[i];
if (sheet.href == link.href) {
clearInterval(loadInterval);
return callback();
}
}
}, 10);
link.href = url;
head.appendChild(link);
}
//>>excludeEnd('excludeRequireCss')
cssAPI.normalize = function(name, normalize) {
if (name.substr(name.length - 4, 4) == '.css')
name = name.substr(0, name.length - 4);
return normalize(name);
}
//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
cssAPI.load = function(cssId, req, load, config) {
(useImportLoad ? importLoad : linkLoad)(req.toUrl(cssId + '.css'), load);
}
//>>excludeEnd('excludeRequireCss')
return cssAPI;
});
//>>excludeStart('excludeRequireCss', pragmas.excludeRequireCss)
/*
* css.normalize.js
*
* CSS Normalization
*
* CSS paths are normalized based on an optional basePath and the RequireJS config
*
* Usage:
* normalize(css, fromBasePath, toBasePath);
*
* css: the stylesheet content to normalize
* fromBasePath: the absolute base path of the css relative to any root (but without ../ backtracking)
* toBasePath: the absolute new base path of the css relative to the same root
*
* Absolute dependencies are left untouched.
*
* Urls in the CSS are picked up by regular expressions.
* These will catch all statements of the form:
*
* url(*)
* url('*')
* url("*")
*
* @import '*'
* @import "*"
*