code
stringlengths 2
1.05M
|
|---|
// circuits by lionel ringenbach @ ucodia.space
// display parameters
var scaling = 40;
var nodeSize = scaling * 0.45;
var linkSize = nodeSize * 0.1;
var offset = { x: scaling / 2, y: scaling / 2 };
// theming
var themes;
var currentTheme;
// data
var currentModel;
function setup() {
createCanvas(window.innerWidth, window.innerHeight);
// defaults
themes = {
dark: { backColor: color(0) },
light: { backColor: color(255) }
}
currentTheme = themes.dark;
// ui
var themeSel = createSelect();
themeSel.option('dark');
themeSel.option('light');
themeSel.changed(themeChanged);
var panel = select('#panel');
panel.child(themeSel);
currentModel = generateModel();
drawModel(currentModel);
}
function generateModel() {
// generate color palette
var nColors = randomInt(2, 4);
var colorOffset = random(0, 1);
var palette = createPalette(nColors, colorOffset);
// generate pad styles
var padStyles = [regularPadStyle, padWithHoleStyle];
// generate circuit
var cols = Math.ceil(width / scaling);
var rows = Math.ceil(height / scaling);
var circuit = createCircuit(cols, rows, palette.length, padStyles.length);
return {
circuit: circuit,
palette: palette,
padStyles: padStyles
}
}
///////////////////////
// drawing functions //
///////////////////////
function drawModel(model) {
background(currentTheme.backColor);
for (var i = 0; i < model.circuit.paths.length; i++) {
var path = model.circuit.paths[i];
// pick path color and pad style
var color = model.palette[path.color];
var padStyle = model.padStyles[path.padStyle];
drawPath(path, color, padStyle);
}
}
function drawPath(path, color, padStyle) {
drawTrace(path.nodes, color);
drawPad(path.nodes[0], color, padStyle);
if (path.nodes.length > 1)
drawPad(path.nodes[path.nodes.length - 1], color, padStyle);
}
function drawTrace(nodes, color) {
for (var i = 0; i < nodes.length - 1; i++) {
stroke(color);
strokeWeight(linkSize);
var lPos = getPosition(nodes[i], scaling, offset);
var rPos = getPosition(nodes[i + 1], scaling, offset);
line(lPos.x, lPos.y, rPos.x, rPos.y);
}
}
function drawPad(node, color, style) {
var pos = getPosition(node, scaling, offset);
// apply style and draw pad
style(color);
ellipse(pos.x, pos.y, nodeSize, nodeSize);
}
// pad styles
function regularPadStyle(color) {
noStroke();
fill(color);
}
function padWithHoleStyle(color) {
stroke(color);
strokeWeight(linkSize);
fill(currentTheme.backColor);
}
//////////////////////
// model generation //
//////////////////////
function createCircuit(cols, rows, nColors, nStyles) {
// create reference grid
var grid = [];
for (var i = 0; i < cols; i++) {
if (!grid[i]) grid[i] = [];
for (var j = 0; j < rows; j++) {
grid[i][j] = null;
}
}
// initialize paths
var paths = [];
// generate circuit
for (var i = 0; i < cols; i++) {
for (var j = 0; j < rows; j++) {
// skip if node is already defined
if (grid[i][j]) continue;
// roll a dice for empty node
var empty = rollDice(4);
if (!empty) {
// generate new path length
var pathLength = randomInt(1, cols);
// start new path with new node
var current = createNode(i, j);
var path = createPath(nColors, nStyles);
path.nodes.push(current);
paths.push(path);
// update referennce grid
grid[i][j] = current;
// generate path
while (path.nodes.length < pathLength) {
var last = path.nodes[path.nodes.length - 1];
var nextX = last.x;
var nextY = last.y;
var dir = randomInt(0, 1);
// dir = 0 -> navigate to right
if (dir === 0) {
nextX++;
}
// dir = 1 -> navigate to bottom right
else if (dir === 1) {
nextX++;
nextY++;
}
// exit prematurely in case
// next position is outside boundaries
// or already has a node
if ((nextX >= cols || nextY >= rows) || grid[nextX][nextY])
break;
// initialize next node
var next = createNode(nextX, nextY);
path.nodes.push(next);
// update reference grid
grid[nextX][nextY] = next;
}
}
}
}
return {
cols: cols,
rows: rows,
paths: paths
}
}
function createNode(x, y) {
return {
x: x,
y: y
}
}
function createPath(nColors, nSytles) {
var nodes = [];
var color = randomInt(0, nColors - 1);
var padStyle = randomInt(0, nSytles - 1);
return {
nodes: nodes,
color: color,
padStyle: padStyle
}
}
function createPalette(n, offset) {
if (!offset) offset = 0;
var palette = []
push();
colorMode(HSB, n, 100, 100);
for (var i = 0; i < n; i++) {
var hue = (i + offset) % n;
palette[i] = color(hue, 70, 90);
}
pop();
return palette;
}
///////////////////
// event hookups //
///////////////////
function windowResized() {
resizeCanvas(window.innerWidth, window.innerHeight);
currentModel = generateModel();
drawModel(currentModel);
}
function mousePressed() {
if (mouseButton == RIGHT) return;
currentModel = generateModel();
drawModel(currentModel);
}
function keyPressed() {
if (key === ' ') {
currentTheme = currentTheme === themes.dark ? themes.light : themes.dark;
drawModel(currentModel);
}
}
function themeChanged(evt) {
evt.preventDefault();
if (evt && evt.target) {
currentTheme = themes[evt.target.value];
drawModel(currentModel);
}
}
///////////////
// utilities //
///////////////
function getPosition(pos, scale, offset) {
if (!scale) scale = 1;
if (!offset) offset = { x: 0, y: 0 };
return {
x: (pos.x * scale) + offset.x,
y: (pos.y * scale) + offset.y
}
}
function randomInt(min, max) {
return Math.floor(Math.random() * (max - min + 1)) + min;
}
function rollDice(faces) {
return randomInt(1, faces) === 1;
}
|
exports = module.exports = {
"title": "1"
};
|
var parsers = {
'dom' : function(value, opts) {
opts = opts || {};
// should default to this
// opts.parser = markdownDOMParser;
return html2markdown(value, opts);
},
'html' : function(value, opts) {
opts = opts || {};
opts.parser = markdownHTMLParser;
return html2markdown(value, opts);
}
};
for(var key in parsers) {
var markdown = parsers[key];
describe("With " + key + " parser", function() {
it("should be able to convert '<h1>H1</h1>' to '# H1\\n\\n'", function() {
var md = markdown("<h1>H1</h1>");
expect(md).toMatch(/\# H1\n\n/);
});
it("should be able to convert '<h2>H2</h2>' to '## H2\\n\\n'", function() {
var md = markdown("<h2>H2</h2>");
expect(md).toMatch(/\#{2} H2\n\n/);
});
it("should be able to convert '<h3>H3</h3>' to '### H3\\n\\n'", function() {
var md = markdown("<h3>H3</h3>");
expect(md).toMatch(/\#{3} H3\n\n/);
});
it("should be able to convert '<h4>H4</h4>' to '#### H4\\n\\n'", function() {
var md = markdown("<h4>H4</h4>");
expect(md).toMatch(/\#{4} H4\n\n/);
});
it("should be able to convert '<h5>H5</h5>' to '##### H5\\n\\n'", function() {
var md = markdown("<h5>H5</h5>");
expect(md).toMatch(/\#{5} H5\n\n/);
});
it("should be able to convert '<h6>H6</h6>' to '###### H6\\n\\n'", function() {
var md = markdown("<h6>H6</h6>");
expect(md).toMatch(/\#{6} H6\n\n/);
});
it("should be able to convert '<strong>Bold</strong>' to '**Bold**'", function() {
var md = markdown("<strong>Bold</strong>");
expect(md).toMatch(/\*{2}Bold\*{2}/);
});
it("should be able to convert '<b>Bold</b>' to '**Bold**'", function() {
var md = markdown("<b>Bold</b>");
expect(md).toMatch(/\*{2}Bold\*{2}/);
});
it("should be able to convert '<em>Italic</em>' to '_Italic_'", function() {
var md = markdown("<em>Italic</em>");
expect(md).toMatch(/\_Italic\_/);
});
it("should be able to convert '<i>Italic</i>' to '_Italic_'", function() {
var md = markdown("<i>Italic</i>");
expect(md).toMatch(/\_Italic\_/);
});
it("should be able to convert '<title>This is document Title</title>' to '# This is document Title\\n\\n'", function() {
var md = markdown("<title>This is document Title</title>");
expect(md).toMatch(/\# This is document Title\n\n/);
});
it("should be able trim text inside inline elements", function() {
var md = markdown("<strong> String </strong>");
expect(md).toMatch(/\*{2}String\*{2}/);
});
it("should be able to convert 'This has a <strong>block</strong> word' to 'This has a **block** word'", function() {
var md = markdown("This has a <strong>block</strong> word");
expect(md).toMatch(/This has a \*{2}block\*{2} word/);
});
it("should be able to convert '<hr />' to '- - -\\n\\n'", function() {
var md = markdown("<hr />");
expect(md).toEqual("- - -\n\n");
});
it("should be able to convert '<br/>' to ' \\n'", function() {
var md = markdown("this is text before break<br/>this is text after break");
expect(md).toMatch(" \n");
});
it("should be able to convert 'This has <strong>blocked and <em>italicized</em></strong> texts.' to 'This has **blocked and _italicized_** texts.'", function() {
var md = markdown("This has <strong>blocked and <em>italicized</em></strong> texts.");
expect(md).toMatch(/This has \*{2}blocked and \_italicized\_\*{2} texts\./);
});
it("should be able to convert 'this is text before hr<hr/>this is text after hr' to 'this is text before hr \\nthis is text after hr'", function() {
var md = markdown("this is text before hr<hr/>this is text after hr");
expect(md).toMatch("this is text before hr\n\n- - -\n\nthis is text after hr");
});
it("should be able to convert 'this is text before break<br/>this is text after break' to 'this is text before break \\nthis is text after break'", function() {
var md = markdown("this is text before break<br/>this is text after break");
expect(md).toMatch("this is text before break \nthis is text after break");
});
it("should be able to convert '<p>This is a paragraph. This is the second sentence.</p>' to 'This is a paragraph. This is the second sentence.\\n\\n'", function() {
var md = markdown("<p>This is a paragraph. This is the second sentence.</p>");
expect(md).toEqual("This is a paragraph. This is the second sentence.\n\n");
});
it("should be able to convert 'this is text before paragraph<p>This is a paragraph</p>this is text after paragraph' to 'this is text before paragraph\nThis is a paragraph\n\nthis is text after paragraph'", function() {
var md = markdown("this is text before paragraph<p>This is a paragraph</p>this is text after paragraph");
expect(md).toEqual("this is text before paragraph\n\nThis is a paragraph\n\nthis is text after paragraph");
});
it("should be able to convert span element", function() {
var md = markdown("<span>this is span element</span>");
expect(md).toEqual(" this is span element ");
md = markdown("before<span>this is span element</span>after");
expect(md).toEqual("before this is span element after");
md = markdown("before <span>this is span element</span> after");
expect(md).toEqual("before this is span element after");
});
it("should be able to convert '<blockquote>This is blockquoted</blockquote>' to '> This is blockquoted'", function() {
var md = markdown("<blockquote>This is blockquoted</blockquote>");
expect(md).toMatch("> This is blockquoted");
});
it("should be able to convert nested blockquotes", function() {
var md = markdown("<blockquote>This is blockquoted<blockquote>This is nested blockquoted</blockquote></blockquote>");
expect(md).toMatch("> This is blockquoted\n\n> > This is nested blockquoted");
});
//enable when wordwrap ie enabled
// var html = "<p>This is a paragraph. Followed by a blockquote.</p><blockquote><p>This is a blockquote which will be truncated at 75 characters width. It will be somewhere around here.</p></blockquote>";
// html += "<p>Some list for you:</p><ul><li>item a</li><li>item b</li></ul><p>So which one do you choose?</p>";
// it("should be able to convert a block of html", function() {
// var md = markdown(html);
// var md_str = "This is a paragraph\. Followed by a blockquote\.\n\n\> \nThis is a blockquote which will be truncated at 75 characters width\. It \nwill be somewhere around here\.\n\nSome list for you:\n\n\* item a\n\* item b\n\nSo which one do you choose\?\n\n";
// expect(md).toEqual(md_str);
// });
it("should be able to convert unordered list", function() {
var md = markdown("<ul><li>item a</li><li>item b</li></ul>");
expect(md).toMatch(/\* item a\n\* item b\n/);
});
it("should be able to convert ordered list", function() {
var md = markdown("<ol><li>item 1</li><li>item 2</li></ol>");
expect(md).toMatch(/1\. item 1\n1\. item 2\n/);
});
it("should be able to convert nested lists", function() {
var md = markdown("<ul><li>item a<ul><li>item aa</li><li>item bb</li></ul></li><li>item b</li></ul>");
expect(md).toMatch(/\* item a\n \* item aa\n \* item bb\n\* item b\n/);
});
it("should not convert empty list items", function() {
var md = markdown("<ol><li>item 1</li><li/></ol>");
expect(md).toMatch(/1\. item 1\n/);
md = markdown("<ul><li>item 1</li><li></li></ol>");
expect(md).toMatch(/\* item 1\n/);
});
it("should be able to convert images inline style", function() {
var md = markdown("<img alt=\"Example Image\" title=\"Free example image\" src=\"/img/62838.jpg\"/>", {"inlineStyle": true});
var expected = "![Example Image](/img/62838.jpg \"Free example image\")\n\n";
expect(md).toEqual(expected);
});
it("should be able to convert images reference style", function() {
var md = markdown("<img alt=\"Example Image\" title=\"Free example image\" src=\"/img/62838.jpg\"/>");
var expected = "![Example Image][0]\n\n[0]: /img/62838.jpg";
expect(md).toEqual(expected);
//if alt is empty then title should be used
md = markdown("<img title=\"Free example image title\" src=\"/img/62838.jpg\">");
var expected = "![Free example image title][0]\n\n[0]: /img/62838.jpg";
expect(md).toEqual(expected);
});
it("should be able to convert images as block elements", function() {
var md = markdown("before<img alt=\"Example Image\" title=\"Free example image\" src=\"/img/62838.jpg\"/>after");
var expected = "before\n\n![Example Image][0]\n\nafter\n\n[0]: /img/62838.jpg";
expect(md).toEqual(expected);
var md = markdown("before<img alt=\"Example Image\" title=\"Free example image\" src=\"/img/62838.jpg\"/>after", {"inlineStyle": true});
var expected = "before\n\n![Example Image](/img/62838.jpg \"Free example image\")\n\nafter";
expect(md).toEqual(expected);
});
it("should not convert images if url is empty", function() {
var md = markdown("<img alt=\"Example Image\" title=\"Free example image\">");
expect(md).toEqual("");
});
it("should be able to properly convert links reference style", function() {
var html = "<a href=\"http://www.example.com\" title=\"Example\">Visit Example</a>";
html += "text1";
html += "<a href=\"http://www.example1.com\" title=\"Example\">Visit Example1</a>";
html += "text2";
html += "<a href=\"http://www.example.com\" title=\"Example\">Visit Example</a>";
//urls should not be duplicated in reference style
var expected = "[Visit Example][0]text1[Visit Example1][1]text2[Visit Example][0]";
expected += "\n\n";
expected += "[0]: http://www.example.com\n";
expected += "[1]: http://www.example1.com";
var md = markdown(html);
expect(md).toEqual(expected);
});
it("should be able to convert links inline style", function() {
var md = markdown("<a href=\"http://www.example.com\" title=\"Example\">Visit Example</a>", {"inlineStyle": true});
expect(md).toEqual("[Visit Example](http://www.example.com \"Example\")");
});
it("should not convert if link has no text to display", function() {
var html = "<a href='/'/>";
md = markdown(html);
expect(md).toEqual("");
html = "<div class='logo'>\n";
html += " <a href='/'/>\n";
html += "</div>";
md = markdown(html);
expect(md).toEqual("");
});
it("should convert elements with child elements surrounded by whitespace", function() {
var html = "<div>\n\t<h2>\n\t\t<a href='http://finance.yahoo.com'>Yahoo! Finance</a>\n\t</h2>\n</div>";
md = markdown(html);
expect(md).toEqual("## [Yahoo! Finance][0]\n\n[0]: http://finance.yahoo.com");
html = "<span>\n\t<b>Hello</b>\n\t</span>";
md = markdown(html);
expect(md).toEqual(" **Hello** ");
});
it("should convert image wrapped in anchor to markdown that can be rendered using showdown - inline style parsing", function() {
var md = markdown("<a href=\"/exec/j/4/?pid=62838&lno=1&afsrc=1\"><img alt=\"Example Image\" title=\"Free example image\" src=\"/img/62838.jpg\"></a>", {"inlineStyle": true});
var expected = "[![Example Image](/img/62838.jpg \"Free example image\")](/exec/j/4/?pid=62838&lno=1&afsrc=1)";
expect(md).toEqual(expected);
});
it("should convert image wrapped in anchor to markdown that can be rendered using showdown - reference style parsing", function() {
var md = markdown("<a href='/exec/j/4/?pid=62838&lno=1&afsrc=1'><img alt='Example Image' title='Free example image' src='/img/62838.jpg'></a>", {"inlineStyle": false});
var expected = "[![Example Image](/img/62838.jpg \"Free example image\")](/exec/j/4/?pid=62838&lno=1&afsrc=1)";
var html = "<a href='/exec/j/4/?pid=62838&lno=1&afsrc=1'>\n\t<img alt='Example Image' title='Free example image' src='/img/62838.jpg'>\n\t</a>";
md = markdown(html, {"inlineStyle": false});
expect(md).toEqual(expected);
});
it("should output only text of empty links", function() {
var md = markdown("<a href=''>Empty Link Text</a>", {"inlineStyle": true});
var expected = "Empty Link Text";
expect(md).toEqual(expected);
});
//tags that have no parsing rules e.g. form elements 'head', 'style', script', 'link' 'option', 'noscript', 'noframes', 'input', 'button', 'select', 'textarea', and 'label'
it("should not convert any elements that have no parsing rules. ", function() {
var html = "<head><link rel='openid.delegate' href='http://jeresig.livejournal.com/'/>";
html += "<script src='http://ejohn.org/files/retweet.js'></script></head>";
var md = markdown(html);
expect(md).toEqual("");
});
//tables
it("should be able to convert tables", function() {
var html = "<table border=\"1\">";
html += "<tr><td>Row 1 Cell 1</td><td>Row 1 Cell 2</td></tr>";
html += "<tr><td>Row 2 Cell 1</td><td>Row 2 Cell 2</td></tr>";
html += "</table>";
var md = markdown(html);
var expected = "Row 1 Cell 1\n\n";
expected += "Row 1 Cell 2\n\n";
expected += "Row 2 Cell 1\n\n";
expected += "Row 2 Cell 2\n\n";
expect(md).toEqual(expected);
});
it("should be able to convert tables with lists", function() {
var html = "<table border=\"1\">";
html += "<tr><td width=\"50%\"><ul><li>List Item 1</li><li>List Item 2</li></ul></td>";
html += "<td><ul><li>List Item 3</li><li>List Item 4</li></ul></td></tr>";
html += "</table>";
var md = markdown(html);
var expected = "* List Item 1\n* List Item 2\n\n* List Item 3\n* List Item 4\n\n";
expect(md).toEqual(expected);
});
//test empty block element
it("should not convert emptyt tags", function() {
var md = markdown("<div> </div>");
expect(md).toEqual("");
md = markdown("<h1> </h1>");
expect(md).toEqual("");
md = markdown("<b> </b>");
expect(md).toEqual("");
});
it("should collape whitespace to single space for text nodes", function() {
var md = markdown("<div> a b c\n d </div>");
expect(md).toEqual(" a b c d \n\n");
md = markdown("<div></div><div> a b c\n d </div>");
expect(md).toEqual(" a b c d \n\n");
md = markdown("<div>1</div><div> a b c\n d </div>");
expect(md).toEqual("1\n\na b c d \n\n");
md = markdown("<h1> a b c\n d </h1>");
expect(md).toEqual("# a b c d \n\n");
});
it("should trim anchor title and text", function() {
var md = markdown("<a href=\"http://www.example.com\" title=\" Example \"> Visit Example </a>", {"inlineStyle": true});
expect(md).toEqual("[Visit Example](http://www.example.com \"Example\")");
md = markdown("<a href=\"http://www.example.com\" title=\" Example \"> Visit Example </a>", {"inlineStyle": false});
expect(md).toEqual("[Visit Example][0]\n\n[0]: http://www.example.com");
var html ="<a href='/blog/line-length-readability#comments'>\n";
html += "<span itemprop='interactionCount'>32</span>\n";
html += "comments\n</a>";
md = markdown(html);
expect(md).toEqual("[32 comments][0]\n\n[0]: /blog/line-length-readability#comments");
});
it("should trim image alt and title", function() {
var html = "<img alt=\" Example Image \" title=\" Free example image \" src=\"/img/62838.jpg\">";
var md = markdown(html, {"inlineStyle": true});
var expected = "![Example Image](/img/62838.jpg \"Free example image\")\n\n";
expect(md).toEqual(expected);
md = markdown(html);
expected = "![Example Image][0]\n\n[0]: /img/62838.jpg";
expect(md).toEqual(expected);
});
it("should be able to convert image followed by link to markdown that can be renderd using showdown", function() {
var html = "<p>\n";
html += " <img alt='Feed' class='icon' src='http://mementodb.com/images/logo.png'/>\n";
html += " <a href='http://mementodb.com'>Memento</a>\n";
html += "</p>";
var md = markdown(html);
var expected = "![Feed][0]\n\n[Memento][1]\n\n";
expected += "[0]: http://mementodb.com/images/logo.png\n";
expected += "[1]: http://mementodb.com";
expect(md).toEqual(expected);
});
it("should be able to convert list items with linked images as only linked images", function() {
var html = "before list";
html += "<ul>\n";
html += " <li><div class='curve-down'><a href='/ipad/#video'><img src='http://images.apple.com/home/images/promo_video_ipad_launch.png' alt='Watch the new iPad video' width='237' height='155' /><span class='play'></span></a></div></li>";
html += " <li><div class='curve-down'><a href='/iphone/videos/#tv-ads-datenight'><img src='http://images.apple.com/home/images/promo_video_iphone4s_ad.png' alt='Watch the new iPhone TV Ad' width='237' height='155' /><span class='play'></span></a></div></li>";
html += "</ul>\n";
var md = markdown(html);
var expected = "before list\n\n";
expected += "[](/ipad/#video)\n\n";
expected += "[](/iphone/videos/#tv-ads-datenight)\n\n";
expect(md).toEqual(expected);
});
it("should be able to convert title", function() {
var html = "<hgroup>\n";
html += "\t<h1><a href='http://www.google.com'>Nathen Harvey</a></h1>\n";
html += "\t<h2>a blog</h2>\n";
html += "</hgroup>";
var md = markdown(html);
var expected = "# [Nathen Harvey][0]\n\n## a blog\n\n\n\n[0]: http://www.google.com";
expect(md).toEqual(expected);
});
it("should be able to convert paragrphs in blocquotes", function() {
var html="<blockquote>\n";
html+="\t<p>Lorem ipsum</p>\n";
html+="\t<p>Lorem ipsum</p>\n";
html+="</blockquote>";
var md = markdown(html);
var expected = "> Lorem ipsum\n\n> Lorem ipsum\n\n";
expect(md).toEqual(expected);
html = "<blockquote>\n";
html+="\t<p>Lorem ipsum</p>\n";
html+="</blockquote>\n";
html+="<blockquote>\n";
html+="\t<p>Lorem ipsum</p>\n";
html+="</blockquote>"
md = markdown(html);
expect(md).toEqual(expected);
});
it("should be able to convert pre block", function() {
var html = "<pre>";
html += " void main(String[] args) {\n";
html += " System.out.println(\"Hello Markdown\");\n";
html += " }";
html += "</pre>";
var expected = " " + " void main(String[] args) {\n";
expected += " " + " System.out.println(\"Hello Markdown\");\n";
expected += " " + " }";
expected += "\n\n";
var md = markdown(html);
expect(md).toEqual(expected);
});
it("should be able to convert pre block with html tags", function() {
var html = "<pre>\n";
html += "<div a=\"b\">\n";
html += " <span>this is span inside pre block</span>\n";
html += " this is paragraph inside pre block\n";
html += "</div>";
html += "</pre>";
var expected = " " + "\n\n\n";
expected += " " + " this is span inside pre block\n";
expected += " " + " this is paragraph inside pre block\n";
expected += " " + "\n";
expected += "\n";
var md = markdown(html);
expect(md).toEqual(expected);
});
it("should be able to convert <pre><code>...</code></pre> blocks", function() {
var html= "<pre><code>{% blockquote [author[, source]] [link] [source_link_title] %}";
html+= "\nQuote string";
html+= "\n{% endblockquote %}";
html+= "\n</code></pre>";
var md = markdown(html);
expected=" {% blockquote [author[, source]] [link] [source_link_title] %}";
expected+="\n Quote string";
expected+="\n {% endblockquote %}";
expected+="\n ";
expected+="\n\n";
expect(md).toEqual(expected);
});
});
}
describe("markdownDOMParser", function() {
it("parser function should be able to echo input html", function() {
var html = "<div><span id=\"test-id\"> Hmm <br/> Hello markdown converter </span><!-- this is comment --></div>";
var result ="";
markdownHTMLParser(html, {
start: function(tag, attrs, unary) {
result+="<"+tag.toLowerCase();
for ( var i = 0; i < attrs.length; i++ ) {
result += " " + attrs[i].name + '="' + attrs[i].value + '"';
}
result += (unary ? "/" : "") + ">";
},
chars: function(text) {
result += text;
},
end: function(tag) {
result+="</"+tag.toLowerCase()+">";
},
comment: function(text) {
result += "<!--" + text + "-->";
}
});
expect(html).toEqual(result);
});
});
//TODO add test for block function
//TODO test bookmarklet links
//TODO add test for xss protection
//TODO test parsing of iframe/frame element
//TODO add tests to verify hidden nodes are not parsed
//TODO add more unit tests based on official markdown syntax
//TODO improve formatting of pre/code tags
|
import {route} from 'part:@vega/core/router'
import Main from './Main'
import routerParams from '@vega/utils/routerParams'
export default {
name: 'communicator-testbed',
title: 'Communicator test',
icon: () => null,
router: route(':viewOptions', {
transform: {
viewOptions: {
toState: routerParams.decode,
toPath: routerParams.encode
}
}
}),
component: Main
}
|
import test from 'tape';
import buildConsoleReplay, { consoleReplay } from '../src/buildConsoleReplay';
test('consoleReplay does not crash if no console.history object', (assert) => {
assert.plan(1);
assert.doesNotThrow(() => consoleReplay(), /Error/,
'consoleReplay should not throw an exception if no console.history object');
});
test('consoleReplay returns empty string if no console.history object', (assert) => {
assert.plan(1);
const actual = consoleReplay();
const expected = '';
assert.equals(actual, expected,
'consoleReplay should return an empty string if no console.history');
});
test('consoleReplay does not crash if no console.history.length is 0', (assert) => {
assert.plan(1);
console.history = [];
assert.doesNotThrow(() => consoleReplay(), /Error/,
'consoleReplay should not throw an exception if console.history.length is zero');
});
test('consoleReplay returns empty string if no console.history object', (assert) => {
assert.plan(1);
console.history = [];
const actual = consoleReplay();
const expected = '';
assert.equals(actual, expected,
'consoleReplay should return an empty string if console.history is an empty array');
});
test('consoleReplay replays multiple history messages', (assert) => {
assert.plan(1);
console.history = [
{ arguments: ['a', 'b'], level: 'log' },
{ arguments: ['c', 'd'], level: 'warn' },
];
const actual = consoleReplay();
const expected =
'console.log.apply(console, ["a","b"]);\nconsole.warn.apply(console, ["c","d"]);';
assert.equals(actual, expected,
'Unexpected value for console replay history');
});
test('consoleReplay replays converts console param objects to JSON', (assert) => {
assert.plan(1);
console.history = [
{ arguments: ['some message', { a: 1, b: 2 }], level: 'log' },
{ arguments: ['other message', { c: 3, d: 4 }], level: 'warn' },
];
const actual = consoleReplay();
const expected = `console.log.apply(console, ["some message","{\\"a\\":1,\\"b\\":2}"]);
console.warn.apply(console, ["other message","{\\"c\\":3,\\"d\\":4}"]);`;
assert.equals(actual, expected, 'Unexpected value for console replay history');
});
test('consoleReplay replays converts script tag inside of object string to be safe ', (assert) => {
assert.plan(1);
console.history = [
{ arguments: ['some message </script><script>alert(\'WTF\')</script>',
{ a: 'Wow</script><script>alert(\'WTF\')</script>', b: 2 }],
level: 'log',
},
{ arguments: ['other message', { c: 3, d: 4 }], level: 'warn' },
];
const actual = consoleReplay();
const expected = `console.log.apply(console, ["some message (/script><script>alert('WTF')\
(/script>","{\\"a\\":\\"Wow(/script><script>alert('WTF')(/script>\\",\\"b\\":2}"]);
console.warn.apply(console, ["other message","{\\"c\\":3,\\"d\\":4}"]);`;
assert.equals(actual, expected, 'Unexpected value for console replay history');
});
test('buildConsoleReplay wraps console replay in a script tag', (assert) => {
assert.plan(1);
console.history = [
{ arguments: ['some message', { a: 1, b: 2 }], level: 'log' },
{ arguments: ['other message', { c: 3, d: 4 }], level: 'warn' },
];
const actual = buildConsoleReplay();
const expected = `
<script id="consoleReplayLog">
console.log.apply(console, ["some message","{\\"a\\":1,\\"b\\":2}"]);
console.warn.apply(console, ["other message","{\\"c\\":3,\\"d\\":4}"]);
</script>`;
assert.equals(actual, expected, 'Unexpected value for console replay history');
});
|
var mainAdmin = function () {
var init = function init() {
$(app).append('<iframe id="adminIframe0" src="http://editthispost.com:9002/p/index"></iframe><iframe id="adminIframe1" src="http://editthispost.com:9001"></iframe>');
};
return {
init: init
};
}();
|
// nombreVariable:tipoVariable
/*
let numero:number = 2;
// numero = "Adrian"; //No se puede guardar tipos de dato string en numbers
+numero = 18;
let verdad:boolean = true;
// verdad = 0;// No podemos igualar a un elemento que no sea un booleano
verdad = null;
verdad = undefined;
verdad = false;
let nombre:string = "Adrian";
nombre = `Yo no soy ${verdad}`;
let arregloNumeros1:number[] = [1,2];
let arregloNumeros2:Array <number> = [1,2];
interface UsuarioInt{
nombre:string,
apellido:string,
nota?:number,
id:number
}
let adrian:UsuarioInt = {
nombre:"Adrian",
apellido:"Eguez",
id:21
};
var juego = {};
juego = 2;
juego = "string";
let juego = 2;
//juego = "Nombre"; //Error
//juego = {}; // Error
let juego:any = 2;
juego = "Nombre";
juego = {};
const amigo = "Amigo";
const numero = 2;
//numero = 25;
//amigo = "Referendum";
*/
|
'use strict';
/* Controllers */
var app = angular.module('AngularFlask');
app.controller('IndexController', ['$scope', '$http', '$window', function ($scope, $http, $window) {
console.log("loggedin at index: " + $window.sessionStorage.logged_in);
if($window.sessionStorage.logged_in_status === 'true') {
$scope.logged_in = true;
} else {
$scope.logged_in = false;
}
}])
.controller('HomeController', ['$scope', '$location', '$window', function ($scope, $location, $window) {
console.log("controllers.js - HomeController: phoning home...");
if($window.sessionStorage.logged_in_status === 'true') {
var userType = JSON.parse($window.sessionStorage.logged_in).userType;
if(userType === 'admin') {
$location.path('/admin');
} else if(userType === 'student') {
$location.path('/course');
} else if(userType === 'supervisor') {
$location.path('/students');
} else if(userType ==='sponsor') {
$location.path('/project');
}
} else {
$location.path('/login');
}
}])
.controller('ProfileRedirectController', ['$scope', '$location', '$window', function($scope, $location, $window) {
if($window.sessionStorage.logged_in_status === 'true') {
var user = JSON.parse($window.sessionStorage.logged_in);
if(user.userType === 'admin') {
$location.path('/admin');
} else if(user.userType === 'student') {
$http.get('/api/user/'+user.UserID+'/student')
.then(function(success) {
$location.path('/student/'+success.data.StudentID);
}, function(error) {
console.log(error);
});
} else if(user.userType === 'supervisor') {
$location.path('/students');
} else if(user.userType ==='sponsor') {
$location.path('/project');
}
} else {
$location.path('/login');
}
}])
.controller('SponsorHomeController', ['$scope', '$location', '$window', function ($scope, $location, $window) {
console.log("controllers.js - SponsorHomeController: phoning home...");
$scope.isShowingNew = false;
$scope.sponsor = JSON.parse($window.sessionStorage.logged_in);
$scope.currentTab = 1;
$scope.switch = function(tab) {
$scope.currentTab = tab;
}
$scope.showNew = function() {
console.log("SHOW NEW");
$scope.isShowingNew = true;
}
$scope.hideNew = function() {
console.log("HIDE NEW");
$scope.isShowingNew = false;
}
}])
.controller('CreateProjectController', ['$scope', '$http', '$location', '$window', function ($scope, $http, $location, $window) {
$scope.create_project = function() {
var title = $scope.title;
var description = $scope.description;
var category = $scope.category;
var deliverables = $scope.deliverables;
var requirements = $scope.requirements;
var payment = $scope.payment;
var thumbnail = $scope.thumbnail;
console.log("PAYMENT: "+payment);
//http post
$http.post('/api/project/create', {'title': title, 'description': description, 'category': category, 'deliverables': deliverables, 'requirements': requirements, 'payment': payment, 'thumbnail': thumbnail})
.then(function(success) {
$location.path("/home");
}, function(error) {
console.log(error);
});
}
}])
.controller('StudentHomeController', ['$scope', '$location', '$window', function ($scope, $location, $window) {
console.log("controllers.js - StudentHomeController: phoning home...");
$scope.student = JSON.parse($window.sessionStorage.logged_in);
$scope.currentTab = 1;
$scope.switch = function(tab) {
$scope.currentTab = tab;
}
}])
.controller('SupervisorHomeController', ['$scope', '$location', '$window', function($scope, $location, $window) {
console.log("controllers.js - SupervisorHomeController: phoning home...");
$scope.isShowingNew = false;
$scope.supervisor = JSON.parse($window.sessionStorage.logged_in);
$scope.showNew = function() {
console.log("SHOW NEW");
$scope.isShowingNew = true;
}
$scope.hideNew = function() {
console.log("HIDE NEW");
$scope.isShowingNew = false;
}
}])
.controller('RegisterController', ['$scope', '$http', '$location', '$window', '$rootScope', function($scope, $http, $location, $window, $rootScope) {
$scope.register = function() {
var username = $scope.username;
var email = $scope.email;
var password = $scope.password;
//http post
$http.post('/api/user/create', {'username': username, 'email': email, 'password': password, 'userType': 'sponsor'})
.then(function(success) {
$http.post('/api/login', {'username': username, 'password': password})
.then(function(success) {
$window.sessionStorage.setItem("logged_in", JSON.stringify(success.data.user));
$window.sessionStorage.setItem("logged_in_status", true)
$rootScope.$broadcast('login-change');
$location.path('/home')
}, function(error) {
console.log(error);
})
}, function(error) {
console.log(error);
});
}
}])
.controller('LoginController', ['$scope', '$http', '$location', '$window', '$rootScope', function ($scope, $http, $location, $window, $rootScope) {
if($window.sessionStorage.logged_in_status === 'true') {
$location.path('/home');
}
$scope.login = function() {
console.log("ANGULAR LOGIN");
var username = $scope.username;
var password = $scope.password;
$http.post('/api/login', {'username': username, 'password': password})
.then(function(success) {
if(success.data != 'failed') {
$window.sessionStorage.setItem("logged_in", JSON.stringify(success.data.user));
console.log("controllers.js - LoginController: Setting localstorage user: " + $window.sessionStorage.logged_in);
$window.sessionStorage.setItem("logged_in_status", true)
$rootScope.$broadcast('login-change');
$location.path('/home')
} else {
console.log("failed");
alert("Invalid login.");
}
}, function(error) {
console.log(error);
})
}
}])
.controller('LogoutController', ['$scope', '$location', '$window', '$route', '$rootScope', function ($scope, $location, $window, $route, $rootScope) {
console.log("controller.js - LogoutController");
if($window.sessionStorage.logged_in_status === 'true') {
$window.sessionStorage.setItem("logged_in_status", false);
$window.sessionStorage.setItem("logged_in", null);
}
$rootScope.$broadcast('login-change');
$location.path('/');
}])
.controller('CreateStudentController', ['$scope', '$http', '$location', '$window', function ($scope, $http, $location, $window) {
if($window.sessionStorage.logged_in_status === 'true' && JSON.parse($window.sessionStorage.logged_in).userType === 'supervisor') {
console.log("Accessing create_student as supervisor");
} else {
console.log("Accessing create_student as non-supervisor");
$location.path('/home');
}
$scope.create_student = function() {
console.log("CREATE STUDENT");
var username = $scope.username;
var FirstName = $scope.FirstName;
var LastName = $scope.LastName;
var password = $scope.password;
$http.post('/api/user/create', {'username': username, 'FirstName': FirstName, 'LastName': LastName, 'password': password, 'userType': 'student'})
.then(function(success) {
console.log("controllers.js - CreateUserController create_user: then");
$location.path('/home');
}, function(error) {
console.log(error);
});
}
}])
.controller('CreateUserController', ['$scope', '$http', '$location', '$window', function ($scope, $http, $location, $window) {
console.log("controller.js - CreateUserController");
if($window.sessionStorage.logged_in_status === 'true' && JSON.parse($window.sessionStorage.logged_in).userType === 'admin') {
console.log("Accessing create_user as admin");
} else {
console.log("Accessing create_user as non-admin");
$location.path('/home');
}
$scope.create_user = function() {
var username = $scope.username;
var password = $scope.password;
var userType = $scope.userType;
$http.post('/api/user/create', {'username': username, 'password': password, 'userType': userType})
.then(function(success) {
console.log("controllers.js - CreateUserController create_user: then");
$location.path('/home');
}, function(error) {
console.log(error);
});
}
}])
.controller('UserListController', ['$scope', '$http', '$window', function ($scope, $http, $window) {
$http.get('/api/user')
.then(function(success) {
$scope.users = success.data;
}, function(error) {
console.log(error);
console.log("controllers.js - UserListController: failed to get User list");
});
}])
.controller('StudentListController', ['$scope', '$http', '$window', function ($scope, $http, $window) {
var endpoint = '/api/supervisor/' + JSON.parse($window.sessionStorage.logged_in).UserID + '/student'
$http.get(endpoint)
.then(function(success) {
console.log("students");
console.log(success);
$scope.students = [];
for(var i = success.data.length - 1; i >= 0; i--) {
console.log(i);
var current_student = success.data[i];
get_enrolled_courses(current_student);
console.log(current_student);
$scope.students.push(current_student);
}
}, function(error) {
console.log(error);
});
var get_enrolled_courses = function(current_student) {
$http.get('/api/user/' + current_student.UserID + '/course')
.then(function(success) {
console.log("enroleld courses for: " + current_student.login);
console.log(success.data);
current_student.enrolled_courses = success.data[0];
}, function(error) {
console.log(error);
});
}
}])
.controller('StudentProfileController', ['$scope', '$routeParams', '$http', '$window', function ($scope, $routeParams, $http, $window) {
var endpoint ='/api/students/' + $routeParams.StudentID;
$http.get(endpoint)
.then(function(success) {
$scope.student = success.data;
}, function(error) {
console.log(error);
});
$scope.go_back = function() {
$window.history.back();
}
}]);
|
'use strict';
var express = require('express');
var logger = require('morgan');
var path = require('path');
var responseTime = require('response-time');
var methodOverride = require('method-override');
var multer = require('multer');
var compression = require('compression');
var cors = require('cors');
var favicon = require('serve-favicon');
var bodyParser = require('body-parser');
var cookieParser = require('cookie-parser');
var session = require('express-session');
var RedisStore = require('connect-redis')(session);
var errorHandler = require('errorhandler');
var flash = require('express-flash');
var _ = require('lodash');
var _app = null;
var _server = null;
function _configure() {
var env = _app.config.get('server.env');
var root = _app.root;
var paths = _app.config.get('paths');
_server
.set('views', path.join(_app.root, paths.server, 'templates'))
.set('view engine', 'jade')
.enable('trust proxy')
.disable('x-powered-by');
// Express middleware
_server
.use(favicon(path.join(_app.root, paths.public, 'favicon.png')))
.use(bodyParser.json())
.use(bodyParser.urlencoded({
extended: true
}))
// .use(multer())
.use(methodOverride());
if (_app.config.get('server.allowCrossDomain')) {
_server.use(cors());
}
_server.use(cookieParser(_app.config.get('app.secret')));
_server.use(session({
secret: _app.config.get('app.secret'),
saveUninitialized: true,
resave: true,
store: new RedisStore()
}));
_server.use(_app.passport.initialize());
_server.use(_app.passport.session({
maxAge: new Date(Date.now() + 86400000)
}));
_server.use(express.static(path.join(_app.root, paths.dist)));
_server.use(function (req, res, next) {
res.locals.NODE_ENV = env;
res.locals.auth = {};
res.locals.auth.local = _app.config.get('auth.local.enabled');
res.locals.auth.twitter = _app.config.get('auth.twitter.enabled');
res.locals.auth.facebook = _app.config.get('auth.facebook.enabled');
res.locals.auth.google = _app.config.get('auth.google.enabled');
res.locals.app = {};
res.locals.app.name = _app.config.get('app.name');
res.locals.app.keywords = _app.config.get('app.keywords');
res.locals.app.description = _app.config.get('app.description');
if(_.isObject(req.user)) {
res.locals.User = req.user;
}
next();
});
/*
* res.cRender() searches for the template in the component templates directory
* it requires the syntax res.cRender('component/view', locals, cb);
*/
_server.use(function(req, res, next) {
res.cRender = function(view, locals, cb) {
var viewArr = view.split('/');
var tpl = path.join(_app.root, paths.server, 'components', viewArr[0], 'templates', viewArr[1]);
return res.render(tpl, locals, cb);
};
next();
});
_server.use(flash());
_server.use(require(path.join(_app.root, paths.server, 'routes'))(_app));
if (env === 'development') {
require('express-debug')(_server);
}
// development error handler
// will print stacktrace
if (env === 'development') {
_server
.use(logger('dev'))
.use(errorHandler())
.use(responseTime());
_server.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('500', {
message: err.message,
error: err
});
});
} else {
_server.use(logger());
_server.use(compression({
filter: function (req, res) {
return (/json|text|javascript|css/).test(res.getHeader('Content-Type'));
},
level: 9
}));
// error handlers
// 404
_server.use(function(req, res, next) {
var err = new Error('Not Found');
res.status(404).render('404', {
url: req.protocol + '://' + req.headers.host + req.originalUrl,
error: 'Page not found!'
});
});
// 500
_server.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('500', {
message: err.message,
error: {}
});
});
}
}
function getServer() {
return _server;
}
function init(app) {
_app = app;
_app.servers.express = exports;
_server = express();
_configure();
}
// Public API
module.exports.getServer = getServer;
module.exports = init;
|
'use strict';
import React from 'react';
import { Router, Route, IndexRoute} from 'react-router';
import createBrowserHistory from 'history/lib/createBrowserHistory';
let history = createBrowserHistory();
// import useScroll from 'scroll-behavior/lib/useStandardScroll'
import CurrentUserStore from './stores/CurrentUserStore';
import {AuthApiActions} from './api/AuthAPI';
import App from './App';
import LandingPage from './viewControllers/LandingPage';
import SearchPage from './viewControllers/SearchPage';
import AboutPage from './viewControllers/infoPages/AboutPage';
import MembershipPage from './viewControllers/infoPages/MembershipPage';
import BuyingClubPage from './viewControllers/infoPages/BuyingClubPage';
import NewsletterPage from './viewControllers/infoPages/NewsletterPage';
import NotFoundPage from './viewControllers/NotFoundPage';
import LoginPage from './viewControllers/Auth/LoginPage';
import Logout from './viewControllers/Auth/Logout';
import SendPasswordResetPage from './viewControllers/Auth/SendPasswordResetPage';
import ConfirmPasswordResetPage from './viewControllers/Auth/ConfirmPasswordResetPage';
import UserRegistrationPage from './viewControllers/Auth/UserRegistrationPage';
import Admin from './viewControllers/admin/Index';
import Dashboard from './viewControllers/admin/Dashboard';
import Blog from './viewControllers/admin/Blog';
import NewPost from './viewControllers/admin/NewPost';
import Blurbs from './viewControllers/admin/Blurbs';
import BuyingClub from './viewControllers/admin/BuyingClub';
import Account from './viewControllers/admin/Account';
import Settings from './viewControllers/admin/Settings';
function requireAuth(nextState, replaceState) {
if (!CurrentUserStore.authenticated()) {
let location = {pathname: '/login'};
let state;
if(nextState && nextState.location){
state = {nextPathname: nextState.location.pathname};
}
replaceState(state, location);
}
}
function logoutUser(nextState, replaceState) {
AuthApiActions.logout();
if (!CurrentUserStore.authenticated()) {
let location = {pathname: '/login'};
replaceState(null, location);
}
}
export default(
<Router history={history}>
<Route path="/" component={App}>
<IndexRoute component={LandingPage}/>
<Route path="/" component={LandingPage}/>
<Route path="/search" component={SearchPage}/>
<Route path="/about" component={AboutPage}/>
<Route path="/membership" component={MembershipPage}/>
<Route path="/buying-club" component={BuyingClubPage}/>
<Route path="/newsletter" component={NewsletterPage}/>
<Route path="/login" component={LoginPage}/>
<Route path="/send-password-reset" component={SendPasswordResetPage}/>
<Route path="/confirm-password-reset" component={ConfirmPasswordResetPage}/>
<Route path="/registration" component={UserRegistrationPage}/>
<Route path="/admin" component={Admin} onEnter={requireAuth}>
<IndexRoute component={Dashboard}/>
<Route path="/" component={Dashboard}/>
<Route path="blog" component={Blog}/>
<Route path="new-post" component={NewPost}/>
<Route path="blurbs" component={Blurbs}/>
<Route path="buying-club" component={BuyingClub}/>
<Route path="account" component={Account}/>
<Route path="settings" component={Settings}/>
</Route>
<Route path="/logout" component={Logout} onEnter={logoutUser}/>
<Route path="*" component={NotFoundPage}/>
</Route>
</Router>
);
|
import React from "react";
import RenderParameter from "../helpers/RenderParameter";
const Rain = ({ data }) => {
const parameter = data.RainHourly;
return (
<div className="Rain">
<div className="row align-items-center">
<div className="col-4">
<RenderParameter parameter={parameter} type="min" />
</div>
<div className="col-4">
<RenderParameter parameter={parameter} />
</div>
<div className="col-4">
<RenderParameter parameter={parameter} type="max" />
</div>
</div>
<div className="row align-items-center justify-content-center">
<div className="col-4">
<RenderParameter
parameter={data.RainDaily}
small
label="Cumulative (last 24 hours)"
/>
</div>
</div>
</div>
);
};
export default Rain;
|
(function() {
'use strict';
angular
.module('animations')
.factory('dpResource', dpResource);
dpResource.$inject = [
'$rootScope', 'Restangular', '$localStorage', '$sessionStorage', '$q', 'AnimsConfig', 'dpObjectData',
'$interval'
];
/* @ngInject */
function dpResource($rootScope, Restangular, $localStorage, $sessionStorage, $q, AnimsConfig, dpObjectData,
$interval) {
var me
, _ = $rootScope;
$sessionStorage.anims = $sessionStorage.anims || {};
$sessionStorage.users = $sessionStorage.users || {};
me = {
'get' : get,
'set' : set,
add : add,
getFrames : getFrames,
clear : clear
};
init();
return me;
////////////////
function init() {
$interval(function() {
$sessionStorage.users = {};
}, 900000); // Wipe users cache every 15 minutes
}
function get(id, type) {
type = type || 'anims';
var item = $sessionStorage[type][id];
if (type === 'anims' && item) {
var deferred = $q.defer();
item = Restangular.restangularizeElement(null, item, type);
deferred.resolve(item);
return _.extend(deferred.promise, {$object : item});
}
item = Restangular.one(type, id).get();
$sessionStorage[type][id] = item.$object;
return item;
}
function add(items, type) {
items = _.isArray(items) ? items : [items];
_.merge($sessionStorage[type || 'anims'], _.indexBy(items, '_id'));
}
function set(items, type) {
$sessionStorage[type || 'anims'] = _.indexBy(items, '_id');
}
function getFrames(anim, edit) {
var frames = {}
, promises = []
, allPromises
, pageSize = AnimsConfig.framesPageSize
, route = edit ? 'edit/frames' : 'frames';
$localStorage.frames = $localStorage.frames || {};
_.times(Math.ceil(anim.framesCount / pageSize), function(n) {
var promise = anim.getList(route, {offset : n * pageSize});
promise.then(function(loadedFrames) {
_.extend(frames, _.indexBy(loadedFrames, 'order'));
return dpObjectData.unpackFrames(loadedFrames, frames);
});
promises.push(promise);
});
allPromises = $q.all(promises);
allPromises.then(function() {
_.each(frames, function(frame, key) {
if (!frame.objectData) {
frames[key].objectData = frames[frame.order - 1].objectData;
}
return frame;
});
dpObjectData.rasterize(frames);
});
allPromises.$object = frames;
return allPromises;
}
function clear() {
$sessionStorage.anims = {};
$sessionStorage.users = {};
}
}
})();
|
/*! qpaste 2013-11-23 */
function respond(a,b){b.send("hello "+a.params.name)}var restify=require("restify"),db=require("riak-js").getClient({host:"127.0.0.1",port:"8098",debug:!0}),server=restify.createServer({name:"qPaste"});server.pre(restify.pre.userAgentConnection()),server.get("/hia/:name",respond),server.head("/hia/:name",respond),server.listen(8080,function(){console.log("%s listening at %s",server.name,server.url)});
|
import sqlFormatter from './../src';
import behavesLikeSqlFormatter from './behavesLikeSqlFormatter';
describe('Db2Formatter', () => {
behavesLikeSqlFormatter('db2');
it('formats FETCH FIRST like LIMIT', () => {
expect(
sqlFormatter.format(
'SELECT col1 FROM tbl ORDER BY col2 DESC FETCH FIRST 20 ROWS ONLY;',
{ language: 'db2' }
)
).toBe(
'SELECT\n' +
' col1\n' +
'FROM\n' +
' tbl\n' +
'ORDER BY\n' +
' col2 DESC\n' +
'FETCH FIRST\n' +
' 20 ROWS ONLY;'
);
});
it('formats only -- as a line comment', () => {
const result = sqlFormatter.format(
'SELECT col FROM\n' + '-- This is a comment\n' + 'MyTable;\n',
{ language: 'db2' }
);
expect(result).toBe(
'SELECT\n' +
' col\n' +
'FROM\n' +
' -- This is a comment\n' +
' MyTable;'
);
});
it('recognizes @ and # as part of identifiers', () => {
const result = sqlFormatter.format('SELECT col#1, @col2 FROM tbl\n', {
language: 'db2'
});
expect(result).toBe(
'SELECT\n' + ' col#1,\n' + ' @col2\n' + 'FROM\n' + ' tbl'
);
});
it('recognizes :variables', () => {
expect(sqlFormatter.format('SELECT :variable;', { language: 'db2' })).toBe(
'SELECT\n' + ' :variable;'
);
});
it('replaces :variables with param values', () => {
const result = sqlFormatter.format('SELECT :variable', {
language: 'db2',
params: { variable: '"variable value"' }
});
expect(result).toBe('SELECT\n' + ' "variable value"');
});
});
|
version https://git-lfs.github.com/spec/v1
oid sha256:fe53691b455530080b33c21ed8e6aec1f690cf560d2baf0461ae96c9e4887065
size 6087
|
module.exports = {
name: 'GoogleFontsSelector',
type: 'select',
default: '0',
section: 'general',
title: 'Interface Font',
description: 'Select a font from the Google Fonts library.',
options: [
{ name: 'Default', value: '0' },
{ name: 'Open Sans', value: '1' },
{ name: 'Roboto', value: '2' },
{ name: 'Roboto Condensed', value: '3' },
{ name: 'Droid Sans', value: '4' }
]
};
|
import babel from 'rollup-plugin-babel';
import resolve from 'rollup-plugin-node-resolve';
import commonjs from 'rollup-plugin-commonjs';
import replace from 'rollup-plugin-replace';
import uglify from 'rollup-plugin-uglify';
export default {
input: 'src/index.js',
output:
{
file: 'lib/rxcc-es5-umd-rollup.js',
name: 'rxcc',
format: 'umd',
sourcemap: true,
},
plugins: [
resolve({
module: true,
jsnext: true,
main: true,
browser: true,
modulesOnly: true,
}),
commonjs({
include: 'node_modules/**',
}),
babel({
babelrc: false,
exclude: 'node_modules/**',
}),
replace({
ENV: JSON.stringify(process.env.NODE_ENV || 'development'),
}),
(process.env.NODE_ENV === 'production' && uglify())
]
}
|
/* eslint global-require:0 */
import { createStore as _createStore, applyMiddleware, compose } from 'redux';
import { routerMiddleware } from 'react-router-redux';
import reduxThunk from 'redux-thunk';
import reduxCatch from 'redux-catch';
import reducer from 'App/reducer';
import actionLogger from './middleware/actionLogger';
function middlewareHandler(error) {
console.log(error);
}
export default function createStore(history, data) {
// Sync dispatched route actions to the history
const reduxRouterMiddleware = routerMiddleware(history);
const middleware = [
reduxCatch(middlewareHandler),
reduxThunk,
reduxRouterMiddleware,
actionLogger
];
let finalCreateStore;
if (__CLIENT__ && window.devToolsExtension) {
finalCreateStore = compose(
applyMiddleware(...middleware),
// The devtools extension is injecting this function into the document
// so we can call it. It returns a middleware definition that allows
// it to hook into events right before they enter the root reducer
window.devToolsExtension()
)(_createStore);
} else {
finalCreateStore = applyMiddleware(...middleware)(_createStore);
}
const store = finalCreateStore(reducer, data);
if (__DEVELOPMENT__ && module.hot) {
module.hot.accept('App/reducer', () => {
store.replaceReducer(require('App/reducer').default);
});
}
return store;
}
|
export default {
props: {
titles: [{ name: 'a' }, { name: 'b' }, { name: 'c' }]
},
html: `
<p>a</p>
<p>b</p>
<p>c</p>
`,
test({ assert, component, target }) {
component.titles = [{ name: 'b' }, { name: 'c' }];
assert.htmlEqual(target.innerHTML, `
<p>b</p>
<p>c</p>
`);
component.titles = [{ name: 'c' }];
assert.htmlEqual(target.innerHTML, `
<p>c</p>
`);
}
};
|
var express = require("express");
var logfmt = require("logfmt");
var app = express();
app.use(logfmt.requestLogger());
app.use(express.static(__dirname));
app.get('/', function(req, res) {
res.render('index.html');
});
var port = Number(process.env.PORT || 5000);
app.listen(port, function() {
console.log("Listening on " + port);
});
|
'use strict';
const name = getName(__filename),
tpl = hbs.compile('{{ truncate str len }}'),
tplSuffix = hbs.compile('{{ truncate str len suffix=" TBC" }}');
describe(name, function () {
it('returns emptystring if undefined', function () {
expect(tpl()).to.equal('');
expect(tpl({})).to.equal('');
});
it('does not change strings shorter than given length', function () {
expect(tpl({str: 'foo', len: 5})).to.equal('foo');
});
it('does not change strings equal to given length', function () {
expect(tpl({str: 'fooba', len: 5})).to.equal('fooba');
});
it('shortens strings longer than given length', function () {
expect(tpl({str: 'foo bar bar', len: 5})).to.equal('foo b…');
});
it('trims whitespace when entire string is shorter than given length', function () {
expect(tpl({str: ' fo ', len: 5})).to.equal('fo');
});
it('trims whitespace when non-whitespace string is shorter than given length', function () {
expect(tpl({str: ' foo ', len: 5})).to.equal('foo');
});
it('trims whitespace where non-whitespace string is longer than given length', function () {
expect(tpl({str: ' foo bar bar ', len: 5})).to.equal('foo b…');
});
it('trims whitespace after truncating', function () {
expect(tpl({str: 'foo bar bar', len: 4})).to.equal('foo…');
});
it('accepts a suffix to append', function () {
expect(tplSuffix({str: 'foo bar bar', len: 5})).to.equal('foo b TBC');
});
});
|
var EvernoteMail = require('../lib/EvernoteMail');
var config = require('../config/config');
describe('Send a mail to Evernote', function() {
var evernoteMail;
before(function() {
config.evernote.mailUser = 'sample.example@gmail.com';
config.evernote.mailPass = 'u2Uqu7XBhQEDbBxA';
config.evernote.mailFrom = 'todoist2evernote <writer@todoist2evernote.herokuapp.com>';
config.evernote.AddNoteEmailAddress = 'fdkfjaslkfad.82272@m.evernote.com';
var that = this;
that.calledCount = 0;
evernoteMail = new EvernoteMail("<my-fake-userid>");
// ドライバ
evernoteMail.transporter.sendMail = function(mail, cb) {
that.calledCount++;
that.calledArgs = mail;
cb();
};
});
it('config is ok', function() {
expect(evernoteMail.transporter.transporter.options.auth.user).is.equals('sample.example@gmail.com');
expect(evernoteMail.transporter.transporter.options.auth.pass).is.equals('u2Uqu7XBhQEDbBxA');
expect(evernoteMail.mailTo).is.equals('fdkfjaslkfad.82272@m.evernote.com');
expect(evernoteMail.mailFrom).is.equals('todoist2evernote <writer@todoist2evernote.herokuapp.com>');
});
it('sends a mail', function(done) {
var that = this;
var mail = {
subject: 'サンプル2',
html: '<h1>文字化けしている？</h1>'
};
return evernoteMail.sendAsync(mail).then(function() {
expect(that.calledCount).is.equals(1);
expect(that.calledArgs).is.deep.equals({
subject: 'サンプル2',
html: '<h1>文字化けしている？</h1>',
from: config.evernote.mailFrom,
to: config.evernote.AddNoteEmailAddress
});
done();
}, done);
})
});
|
Pending = require('../models').Pending;
var winston = require('winston');
var MongoDB = require('winston-mongodb')//.MongoDB;
var logger = new (winston.Logger)({
transports: [
new (winston.transports.Console)(),
new (winston.transports.File)({ filename: 'requests.log', json:false })
]
});
var researchLogger = new (winston.Logger)({
transports: [
new (winston.transports.Console)()
]
});
researchLogger.add(winston.transports.MongoDB, { db: 'log', collection: 'log'});
function updateHandler(req, res){
var tID=req.body.transferID;
var status=req.body.status;
var newHash=req.body.newHash;
var uploaderMac = req.body.uploader;
User.find({ 'ip': req.ip }, function (error, users) {
console.log("tid " + tID + " status " + status + " newHash " + newHash + " result " + users);
if (users == undefined || users.length == 0) {
logger.error('update.js-updatingHandler: Update request not completed. Reason - Cannot find user with IP ' + req.ip);
//console.log('Cannot find user with IP ' + req.ip);
res.send({ 'status': 'Error', 'text': 'Cannot find user with IP ' + req.ip });
return;
}
var mac = users[0].mac
var nick = users[0].nick
if (status == 'missing') {
var missingFile = newHash;
var missingUser = mac;
File.find({ 'hash': missingFile }, function (error, files) {
if (files == undefined || files.length == 0) {
logger.error('update.js-updateHandler: Missing - File with hash ', missingFile, ' could not be found' );
res.send({ 'status': 'OK', 'text': 'Missing Update complete' });
return;
}
if (files[0].users.length == 1) {
File.find({ 'hash': missingFile }).remove();
logger.info('update.js-updateHandler: Missing - Successful. Removed File with hash ', missingFile, '.' );
}
var file = files[0];
for (i = 0; i < file.users.length; i++) {
if (file.users[i] === missingUser) {
file.users.splice(i, 1);
file.save();
logger.info('update.js-updateHandler: Missing - Successful. Removed user with mac ', missingUser, ' from file with hash ', missingFile, '.' );
break;
}
}
res.send({ 'status': 'OK', 'text': 'Missing Update complete' });
});
return;
}
Pending.find({ 'transferID': parseFloat(tID), 'downloader': mac, 'uploader': uploaderMac }, { 'type': 1 }, function (error, relevantPending) {
if (relevantPending == undefined || relevantPending.length == 0) {
logger.error('Update request not completed. Reason - Cannot find pending to update. IP', req.ip);
res.send({ 'status': 'Error', 'text': 'Unable to find pending' });
return;
}
var type = relevantPending[0].type;
var updateLog = {}
if (type == 'secondleg')
updateLog["friend"] = uploaderMac;
var replications = 0;
console.log(type);
if (type == 'direct' || type == 'secondleg') {
Pending.find({ 'transferID': tID }, { 'uploader': 1, 'fileHash': 1, 'type': 1, 'downloader': 1 }, function (error, requests) {
Pending.remove({ "transferID": tID }, function (err, removed) { // removes all pending transfer with id tID from pending
//logger.info("Update type " + type + removed);
console.log(removed);
for (var i = 0; i < requests.length; i++) {
if (requests[i].type == 'secondleg') { // adds entries to pending for deletion of replicated files.
var newPending = new Pending();
replications++;
newPending.fileHash = requests[i].fileHash;
newPending.downloader = requests[i].uploader;
newPending.uploader = "0000000000000000";
newPending.transferID = tID;
newPending.type = 'delete';
newPending.save();
console.log("Pending to delete file added");
//logger.info("Update type "+ type + newPending + " added");
console.log(newPending);
}
}
var downloader = requests[0].downloader;
if (type == 'direct')
if (status == 'done') {
updateLog["type"] = "update";
updateLog["transferID"] = tID;
updateLog["complete"] = true;
updateLog["replications"] = replications;
researchLogger.info(updateLog);
logger.info('update.js-updateHandler: Update request completed. File transfer for direct, ' + downloader + ' has received file, made changes to pending')
}
else {
updateLog["type"] = "update";
updateLog["transferID"] = tID;
updateLog["complete"] = false;
updateLog["replications"] = replications;
researchLogger.info(updateLog);
logger.info('update.js-updateHandler: Update request completed. File transfer for direct, ' + downloader + ' has cancelled file, made changes to pending')
}
else
if (status == 'done') {
updateLog["type"] = "update";
updateLog["transferID"] = tID;
updateLog["complete"] = true;
updateLog["replications"] = replications;
researchLogger.info(updateLog);
logger.info('update.js-updateHandler: Update request completed. File transfer for secondleg, ' + downloader + ' has received file, made changes to pending')
}
/*else {
updateLog["type"] = "Update";
updateLog["transferID"] = tID;
updateLog["complete"] = false;
updateLog["replications"] = replications;
researchLogger.info(updateLog);
logger.info('update.js-updateHandler: Update request completed. File transfer for secondleg, ' + downloader + ' has cancelled file, made changes to pending')
}*/
res.send({ 'status': 'OK', 'text': 'Update Complete' });
});
});
}
if (type == 'firstleg') {
if (status == 'done') {
Pending.find({ 'transferID': tID, 'type': 'direct' }, function (error, request) {
if(error || request.length == 0){
res.send({ 'status': 'OK', 'text': 'Update Complete' });
return;
}
var newPending = new Pending();
newPending.fileHash = newHash;
newPending.downloader = request[0].downloader;
newPending.uploader = mac;
newPending.fileName = request[0].fileName;
newPending.fileName = request[0].fileName;
newPending.transferID = tID;
newPending.type = 'secondleg';
newPending.fileSize = request[0].fileSize;
newPending.symKey = request[0].symKey;
newPending.uploaderIP = request[0].uploaderIP;
newPending.nick = request[0].nick;
newPending.save();
//logger.info('update.js-updateHandler: Update request completed. File transfer for firstleg, ' + nick + ' has received file, added secondleg transfers to pending')
console.log(newPending);
Pending.remove({ "transferID": tID, 'downloader': mac, 'type': 'firstleg' }, function (err, removed) {
console.log(removed);
logger.info('update.js-updateHandler: Update request completed. File transfer for firstleg, ' + nick + ' has received file, added secondleg transfers to pending')
res.send({ 'status': 'OK', 'text': 'Update Complete' });
});
});
}
else {
Pending.remove({ "transferID": tID, 'downloader': mac, 'type': 'firstleg' }, function (err, removed) {
console.log(removed);
logger.info('update.js-updateHandler: Update request completed. File trasnsfer for firstleg, ' + mac + 'could not recieve file');
res.send({ 'status': 'OK', 'text': 'Update Complete' });
});
}
}
if (type == 'delete') {
Pending.remove({ "transferID": tID, 'downloader': mac, 'type': 'delete' }, function (err, removed) {
console.log(removed);
logger.info('update.js-updateHandler: Update request completed. ' + mac + ' has deleted file.');
res.send({ 'status': 'OK', 'text': 'Update Complete' });
});
}
});
});
}
exports.updateHandler = updateHandler;
|
var express = require('express'),
http = require('http'),
https = require('https'),
fs = require('fs'),
config = require('./config.json'),
routes = require('./src/routes.js'),
httpsApp = express(),
httpApp = express(),
favicon = require('serve-favicon');
//CORS
var allowCrossDomain = function(req, res, next) {
"use strict";
res.header('Access-Control-Allow-Origin', "*");
res.header('Access-Control-Allow-Methods', 'GET,PUT,POST,DELETE');
res.header('Access-Control-Allow-Headers', 'content-type, authorization, content-length, x-requested-with');
next();
};
httpApp.use(favicon(__dirname + '/images/favicon.png'));
httpApp.use(allowCrossDomain); //allow CORS requests
httpApp.use('/images', express.static(__dirname +'/images'));
routes.setup(httpApp);
httpApp.set('port', process.env.PORT || config.http.port);
//CREATE SERVER HTTP
http.createServer(httpApp).listen(httpApp.get('port'), function(){
"use strict";
console.log("http is listening on port", httpApp.get('port'));
});
if(config.https != null) {
//MIDDLEWARE
httpsApp.use(allowCrossDomain); //allow CORS requests
routes.setup(httpsApp);
//SSL MANAGEMENT
var sslOptions = {},
key = config.https.key,
cert = config.https.cert,
ca = config.https.ca;
if(typeof key !== "undefined") {
sslOptions.key = fs.readFileSync(key, 'utf8');
}
if(typeof cert !== "undefined") {
sslOptions.cert = fs.readFileSync(cert, 'utf8');
}
if(typeof ca !== "undefined") {
sslOptions.ca = [];
for(var ci = 0; ci < ca.length; ci++) {
var caFile = ca[ci];
sslOptions.ca.push(fs.readFileSync(caFile, 'utf8'));
}
}
//CREATE SERVER HTTPS
https.createServer(sslOptions, httpsApp).listen(config.https.port, function(){
"use strict";
console.log("http is listening on port", config.https.port);
});
}
|
function showElement(name) {
var x = document.getElementById(name);
if (x.style.display === 'none') {
x.style.display = 'block';
} else {
x.style.display = 'none';
}
}
|
module.exports = function (gulp, glob, genericTask, runSequence) {
// build custom tasks for i18n
glob.sync('./temp/README-*.md').map(function(file){
return file.replace(/.*README\-|\.md$/g, '');
}).concat(['all', 'eng']).forEach(function(lang){
genericTask(lang);
gulp.task('doc:pdf:'+lang, function(cb){
runSequence('clean', ['copy:images', 'copy:md'], 'generate:pdf:'+lang, cb);
});
});
};
|
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
var Filters = {
Scale: function Scale() {
var inmin = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];
var inmax = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];
var outmin = arguments.length <= 2 || arguments[2] === undefined ? -1 : arguments[2];
var outmax = arguments.length <= 3 || arguments[3] === undefined ? 1 : arguments[3];
var inrange = inmax - inmin,
outrange = outmax - outmin,
rangeRatio = outrange / inrange;
return function (input) {
return outmin + input * rangeRatio;
};
}
};
exports.default = Filters;
|
/**
* DevExtreme (data/utils.js)
* Version: 16.2.5
* Build date: Mon Feb 27 2017
*
* Copyright (c) 2012 - 2017 Developer Express Inc. ALL RIGHTS RESERVED
* EULA: https://www.devexpress.com/Support/EULAs/DevExtreme.xml
*/
"use strict";
var $ = require("jquery"),
toComparable = require("../core/utils/data").toComparable;
var normalizeBinaryCriterion = function(crit) {
return [crit[0], crit.length < 3 ? "=" : String(crit[1]).toLowerCase(), crit.length < 2 ? true : crit[crit.length - 1]]
};
var normalizeSortingInfo = function(info) {
if (!$.isArray(info)) {
info = [info]
}
return $.map(info, function(i) {
return {
selector: $.isFunction(i) || "string" === typeof i ? i : i.getter || i.field || i.selector,
desc: !!(i.desc || "d" === String(i.dir).charAt(0).toLowerCase())
}
})
};
var errorMessageFromXhr = function() {
var textStatusMessages = {
timeout: "Network connection timeout",
error: "Unspecified network error",
parsererror: "Unexpected server response"
};
var explainTextStatus = function(textStatus) {
var result = textStatusMessages[textStatus];
if (!result) {
return textStatus
}
return result
};
return function(xhr, textStatus) {
if (xhr.status < 400) {
return explainTextStatus(textStatus)
}
return xhr.statusText
}
}();
var aggregators = {
count: {
seed: 0,
step: function(count) {
return 1 + count
}
},
sum: {
seed: 0,
step: function(sum, item) {
return sum + item
}
},
min: {
step: function(min, item) {
return item < min ? item : min
}
},
max: {
step: function(max, item) {
return item > max ? item : max
}
},
avg: {
seed: [0, 0],
step: function(pair, value) {
return [pair[0] + value, pair[1] + 1]
},
finalize: function(pair) {
return pair[1] ? pair[0] / pair[1] : NaN
}
}
};
var processRequestResultLock = function() {
var lockDeferred, lockCount = 0;
var obtain = function() {
if (0 === lockCount) {
lockDeferred = $.Deferred()
}
lockCount++
};
var release = function() {
lockCount--;
if (lockCount < 1) {
lockDeferred.resolve()
}
};
var promise = function() {
var deferred = 0 === lockCount ? $.Deferred().resolve() : lockDeferred;
return deferred.promise()
};
var reset = function() {
lockCount = 0;
if (lockDeferred) {
lockDeferred.resolve()
}
};
return {
obtain: obtain,
release: release,
promise: promise,
reset: reset
}
}();
function isDisjunctiveOperator(condition) {
return /^(or|\|\||\|)$/i.test(condition)
}
function isConjunctiveOperator(condition) {
return /^(and|\&\&|\&)$/i.test(condition)
}
var keysEqual = function(keyExpr, key1, key2) {
if ($.isArray(keyExpr)) {
var name, names = $.map(key1, function(v, k) {
return k
});
for (var i = 0; i < names.length; i++) {
name = names[i];
if (toComparable(key1[name], true) != toComparable(key2[name], true)) {
return false
}
}
return true
}
return toComparable(key1, true) == toComparable(key2, true)
};
var BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
var base64_encode = function(input) {
if (!$.isArray(input)) {
input = stringToByteArray(String(input))
}
var result = "";
function getBase64Char(index) {
return BASE64_CHARS.charAt(index)
}
for (var i = 0; i < input.length; i += 3) {
var octet1 = input[i],
octet2 = input[i + 1],
octet3 = input[i + 2];
result += $.map([octet1 >> 2, (3 & octet1) << 4 | octet2 >> 4, isNaN(octet2) ? 64 : (15 & octet2) << 2 | octet3 >> 6, isNaN(octet3) ? 64 : 63 & octet3], getBase64Char).join("")
}
return result
};
var stringToByteArray = function(str) {
var code, i, bytes = [];
for (i = 0; i < str.length; i++) {
code = str.charCodeAt(i);
if (code < 128) {
bytes.push(code)
} else {
if (code < 2048) {
bytes.push(192 + (code >> 6), 128 + (63 & code))
} else {
if (code < 65536) {
bytes.push(224 + (code >> 12), 128 + (code >> 6 & 63), 128 + (63 & code))
} else {
if (code < 2097152) {
bytes.push(240 + (code >> 18), 128 + (code >> 12 & 63), 128 + (code >> 6 & 63), 128 + (63 & code))
}
}
}
}
}
return bytes
};
var isUnaryOperation = function(crit) {
return "!" === crit[0] && $.isArray(crit[1])
};
var utils = {
normalizeBinaryCriterion: normalizeBinaryCriterion,
normalizeSortingInfo: normalizeSortingInfo,
errorMessageFromXhr: errorMessageFromXhr,
aggregators: aggregators,
keysEqual: keysEqual,
isDisjunctiveOperator: isDisjunctiveOperator,
isConjunctiveOperator: isConjunctiveOperator,
processRequestResultLock: processRequestResultLock,
isUnaryOperation: isUnaryOperation,
base64_encode: base64_encode
};
module.exports = utils;
|
//var service_url = 'http://2048.semantics3.com';
//var service_url = 'http://localhost:2048';
var service_url = 'http://ring:2048';
var session_id = "";
var interval = 0;
var stop = false;
var score;
function view(obj) {
for (var i = 0; i < 4; i++) {
for (var j = 0; j < 4; j++) {
var num = obj.grid[i][j];
if (num != 0) {
$('#tb'+i+j).html("<p class='c2048'><span id='sp"+i+j+"'>"+num+"</span></p>");
$('#sp'+i+j).css('color',tx_colors[num]);
$('#sp'+i+j).css('font-size',tx_sizes[num]+'px');
$('#tb'+i+j).css('background-color',colors[num]);
} else {
$('#tb'+i+j).html("");
$('#tb'+i+j).css('background-color',"#FFF");
}
}
}
$('#score').html(obj.score);
score = obj.score;
}
function run() {
var xhr = new XMLHttpRequest();
xhr.open('GET', service_url+'/hi/start/json');
xhr.onreadystatechange = function() {
if (xhr.readyState === 4 && xhr.status === 200) {
data = xhr.responseText;
obj = JSON.parse(data);
view(obj);
session_id = obj.session_id;
//console.log(session_id);
setTimeout(function() {
ai_run(obj.grid);
},interval);
}
};
xhr.send(null);
}
function dump(grid){
var str = "[";
for (var i = 0; i < 4; i++) {
if (i) str += ", ";
str += "[";
for (var j = 0; j < 4; j++) {
if (j) str += ", ";
str += grid[i][j];
}
str += "]";
}
str += "]";
return str;
}
function rotate(grid, direction) {
for (var i = 0; i < direction; i++) {
var new_grid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]];
for (var j = 0; j < 4; j++) {
for (var k = 0; k < 4; k++) {
new_grid[j][k] = grid[k][4 - j - 1];
}
}
grid = new_grid;
}
return grid;
}
function move_impl(ary) {
var joined = false;
var point = 0;
var moved = false;
for (var i = 0; i < 4; i++) {
if (ary[i] == 0) continue;
var hit = false;
for (var j = i - 1; j >= 0; j--) {
if (ary[j] == 0) continue;
if (ary[j] == ary[i] && !joined) {
ary[j] *= 2;
ary[i] = 0;
joined = true;
moved = true;
point += ary[j];
} else {
if (j+1 != i) {
ary[j+1] = ary[i];
ary[i] = 0;
moved = true;
}
joined = false;
}
hit = true;
break;
}
if (i != 0 && !hit) {
ary[0] = ary[i];
ary[i] = 0;
moved = true;
joined = false;
}
}
return {point:point,ary:ary,movable:moved};
}
function moveUp(grid) {
var newgrid = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]];
var point = 0;
var movable = false;
for (var i = 0; i < 4; i++) {
var ary = [0,0,0,0];
for (var j = 0; j < 4; j++) {
ary[j] = grid[j][i];
}
var ret = move_impl(ary);
point += ret.point;
if (ret.movable) movable = true;
for (var j = 0; j < 4; j++) {
newgrid[j][i] = ret.ary[j];
}
}
return {point:point,grid:newgrid,movable:movable};
}
function move(grid, direction) {
var newgrid = rotate(grid, direction);
var ret = moveUp(newgrid);
newgrid = rotate(ret.grid, 4 - direction - 1);
return {point:ret.point,grid:newgrid,movable:ret.movable};
}
// || ||
// \||/ \||/
// \/ \/
function moveput(grid, dir) {
var ret = move(grid, dir);
var flag = 0;
for (var i = 0; i < 4; i++)
for (var j = 0; j < 4; j++)
if (ret.grid[i][j] == 0) ret.grid[i][j] = 2;
return ret;
}
function evaluate(grid) {
var value1 = [[80,40,40,40],[30,10,10,10],[3,1,1,3],[1,1,1,1]];
var value2 = [[40,40,40,80],[10,10,10,30],[3,1,1,3],[1,1,1,1]];
//var slope1 = [[10,20,30,40],[80,70,50,40],[33,34,35,36],[100,99,98,95]];
//var slope2 = [[40,30,20,10],[50,60,70,80],[36,35,34,33],[95,98,99,100]];
var slope1 = [[10,11,12,13],[32,31,30,20],[33,34,35,36],[100,99,98,95]];
var slope2 = [[13,12,11,10],[20,30,31,32],[36,35,34,33],[95,98,99,100]];
//var slope1 = [[10,11,12,13],[50,40,30,20],[60,70,80,90],[100,99,98,95]];
//var slope2 = [[13,12,11,10],[20,30,40,50],[90,80,70,60],[95,98,99,100]];
//var slope2 = [[13,12,11,10],[],[],[]];
var res1 = -1e10;
var res2 = -1e10;
var dir1 = 1;
var dir2 = 1;
for (var i = 0; i < 4; i++) {
var score = evaluate_impl(grid, value1);
if (res1 < score) {
res1 = score;
dir1 = i;
}
score = evaluate_impl(grid, value2);
if (res2 < score) {
res2 = score;
dir2 = i;
}
value1 = rotate(value1, 1);
value2 = rotate(value2, 1);
}
return Math.max(res1, res2);
for (var i = 0; i < dir1; i++) slope1 = rotate(slope1, 1);
var slopebonus1 = 100;
for (var i = 0; i < 4; i++)
for (var j = 0; j < 4; j++)
for (var k = 0; k < 4; k++)
for (var l = 0; l < 4; l++)
if (slope1[i][j] > slope1[k][l] && grid[i][j] > grid[k][l])
slopebonus1 = Math.min(slopebonus1, slope1[k][l]);
for (var i = 0; i < dir2; i++) slope2 = rotate(slope2, 1);
var slopebonus2 = 100;
for (var i = 0; i < 4; i++)
for (var j = 0; j < 4; j++)
for (var k = 0; k < 4; k++)
for (var l = 0; l < 4; l++)
if (slope2[i][j] > slope2[k][l] && grid[i][j] > grid[k][l])
slopebonus2 = Math.min(slopebonus2, slope2[k][l]);
//console.log(slopebonus);
return Math.max(slopebonus1 * res1, slopebonus2 * res2);
}
function evaluate_sub(grid) {
var value1 = [[80,40,20,20],[40,20,10,20],[20,1,1,3],[1,1,1,1]];
var value2 = [[20,20,40,80],[20,10,20,40],[3,1,1,20],[1,1,1,1]];
//var value1 = [[80,40,40,40],[30,10,10,10],[3,1,1,3],[1,1,1,1]];
//var value2 = [[40,40,40,80],[10,10,10,30],[3,1,1,3],[1,1,1,1]];
var res = -1e10;
for (var i = 0; i < 4; i++) {
var score = evaluate_impl(grid, value1);
if (res < score) res = score;
score = evaluate_impl(grid, value2);
if (res < score) res = score;
value1 = rotate(value1, 1);
value2 = rotate(value2, 1);
}
return 10 * res;
}
function evaluate_impl(value, grid) {
var res = 0;
var num = 0;
for (var i = 0; i < 4; i++) {
for (var j = 0; j < 4; j++) {
res += Math.pow(grid[i][j], 1.5) * value[i][j];
if (grid[i][j] > 1) num++;
}
}
var score = res;
return score / num;
}
function recursive(grid, n) {
if (n <= 0) return {score:0,num:1};
var ret = 0;
var num = 0;
var score = 0;
for (var i = 0; i < 4; i++) {
var new_grid = moveput(grid, i);
if (!new_grid.movable) continue;
var rec = recursive(new_grid.grid, n-1);
score = evaluate(new_grid.grid) + rec.score;
num += rec.num;
if (score > ret) ret = score;
}
return {score:ret,num:num};
}
function calc(grid) {
//console.log("grid_begin: "+dump(grid));
var maxp = -1e10;
var maxi = -1;
var num = 0;
//var dep = depth(grid);
var dep = 3;
for (var i = 0; i < 4; i++) {
var ret = moveput(grid, i);
if (!ret.movable) continue;
rec = recursive(ret.grid, dep);
var dirnum = 1;
var dircnt = 1;
for (var y = 0; y < 4; y++) {
for (var x = 0; x < 4; x++) {
var rett = ret.grid;
if (rett[y][x] == 0) {
rett[y][x] = 2;
dircnt++;
for (var j = 0; j < 4; j++) {
var rettt = move(rett, j);
if (rettt.movable) dirnum++;
}
}
}
}
//var score = rec.score * dirnum / dircnt;
var score = rec.score * (Math.pow(dirnum / dircnt, 0.5) + 1);
num += rec.num;
if (maxp <= score) { maxp = score; maxi = i; }
}
//console.log("grid_end: "+dump(grid));
//console.log("score: %f", maxp);
//document.writeln(maxp+"<br>");
if (maxi == -1) maxi = one;
return maxi;
}
// /\ /\
// /||\ /||\
// || ||
function ai_run(grid) {
var move_dir = calc(grid);
//console.log("moveto: "+move_dir);
var xhr = new XMLHttpRequest();
var url = service_url+'/hi/state/'+session_id+'/move/'+move_dir+'/json';
//console.log(url);
xhr.open('GET', url);
xhr.onreadystatechange = function() {
if (xhr.readyState == 4 && xhr.status == 200) {
var data = xhr.responseText;
obj = JSON.parse(data);
view(obj);
if (!stop && !obj.over) {
ai_run(obj.grid);
}
if (obj.over) {
$('#scorelist').append($('<p>').text(score));
run();
}
}
};
xhr.send(null);
}
|
// import a from 'moduleA.js';
// console.log('Module A loaded.');
// a.update();
// /**
// * Should output:
// *
// * Hi from module B.
// * Hi from module A.
// */
// import c from 'moduleC.js';
// console.log('Module C loaded.');
// c.show();
// /**
// * Should output:
// *
// * Hi from module C.
// */
/**
* Can I replace 'System.import'?
*/
System.import('moduleA.js').then(function (m) {
console.log('Module A loaded using System.import...');
m.update();
// ES6 features for testing Babel transpiler:
console.log('Testing ES6 features...');
const PI = 3.14;
console.log(PI);
let bla = "bla";
console.log(bla);
[0, 1, 2].forEach(n => {
console.log(n);
})
});
|
#!/usr/bin/env node
/*!
* Script to run vnu-jar if Java is available.
* Copyright 2017-2019 The Bootstrap Authors
* Copyright 2017-2019 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
*/
'use strict'
const childProcess = require('child_process')
const vnu = require('vnu-jar')
childProcess.exec('java -version', (error, stdout, stderr) => {
if (error) {
console.error('Skipping vnu-jar test; Java is missing.')
return
}
const is32bitJava = !stderr.match(/64-Bit/)
// vnu-jar accepts multiple ignores joined with a `|`.
// Also note that the ignores are regular expressions.
const ignores = [
// "autocomplete" is included in <button> and checkboxes and radio <input>s due to
// Firefox's non-standard autocomplete behavior - see https://bugzilla.mozilla.org/show_bug.cgi?id=654072
'Attribute “autocomplete” is only allowed when the input type is.*',
'Attribute “autocomplete” not allowed on element “button” at this point.',
// Markup used in Components → Forms → Layout → Form grid → Horizontal form is currently invalid,
// but used this way due to lack of support for flexbox layout on <fieldset> element in most browsers
'Element “legend” not allowed as child of element “div” in this context.*',
// Content → Reboot uses various date/time inputs as a visual example.
// Documentation does not rely on them being usable.
'The “date” input type is not supported in all browsers.*',
'The “week” input type is not supported in all browsers.*',
'The “month” input type is not supported in all browsers.*',
'The “color” input type is not supported in all browsers.*',
'The “datetime-local” input type is not supported in all browsers.*',
'The “time” input type is not supported in all browsers.*',
// IE11 doesn't recognize <main> / give the element an implicit "main" landmark.
// Explicit role="main" is redundant for other modern browsers, but still valid.
'The “main” role is unnecessary for element “main”.'
].join('|')
const args = [
'-jar',
vnu,
'--asciiquotes',
'--skip-non-html',
// Ignore the language code warnings
'--no-langdetect',
'--Werror',
`--filterpattern "${ignores}"`,
'_gh_pages/',
'js/tests/'
]
// For the 32-bit Java we need to pass `-Xss512k`
if (is32bitJava) {
args.splice(0, 0, '-Xss512k')
}
return childProcess.spawn('java', args, {
shell: true,
stdio: 'inherit'
})
.on('exit', process.exit)
})
|
angular.module( 'sample', [
'auth0',
'ngRoute',
'ngSanitize',
'sample.home',
'sample.login',
'angular-storage',
'angular-jwt'
])
.config( function myAppConfig ( $routeProvider, authProvider, $httpProvider, $locationProvider,
jwtInterceptorProvider) {
$routeProvider
.when( '/', {
controller: 'HomeCtrl',
templateUrl: 'home/home.html',
pageTitle: 'Homepage',
requiresLogin: true
})
.when( '/login', {
controller: 'LoginCtrl',
templateUrl: 'login/login.html',
pageTitle: 'Login'
});
authProvider.init({
domain: AUTH0_DOMAIN,
clientID: AUTH0_CLIENT_ID,
loginUrl: '/login'
});
jwtInterceptorProvider.tokenGetter = function(store) {
return store.get('token');
}
// Add a simple interceptor that will fetch all requests and add the jwt token to its authorization header.
// NOTE: in case you are calling APIs which expect a token signed with a different secret, you might
// want to check the delegation-token example
$httpProvider.interceptors.push('jwtInterceptor');
}).run(function($rootScope, auth, store, jwtHelper, $location) {
$rootScope.$on('$locationChangeStart', function() {
if (!auth.isAuthenticated) {
var token = store.get('token');
if (token) {
if (!jwtHelper.isTokenExpired(token)) {
auth.authenticate(store.get('profile'), token);
} else {
$location.path('/login');
}
}
}
});
})
.controller( 'AppCtrl', function AppCtrl ( $scope, $location ) {
$scope.$on('$routeChangeSuccess', function(e, nextRoute){
if ( nextRoute.$$route && angular.isDefined( nextRoute.$$route.pageTitle ) ) {
$scope.pageTitle = nextRoute.$$route.pageTitle + ' | Auth0 Sample' ;
}
});
})
;
|
/*****************************************************************************************
* Gamma:
* The hunter. Takes a moment to strengthen its army, then selects a target unit to track
* down. Ignore everything else en-route.
* Contributed by: Chris Taylor & Matt Wagner
****************************************************************************************/
var msg = [];
var ID;
var targetUnit = -1;
var firstBase = -1;
var nextBase = -1;
onmessage = function ( ev ) {
for( var cmd in ev.data ) {
switch( cmd ) {
case "setID":
//used so I can identify which units the game has classified as 'mine'
ID = ev.data[cmd];
while (msg.length > 0) {
msg.pop();
}
break;
default:
//strategy response
dataResponse( ev );
}
}
};
/*****************************************************************************************
* Utility Functions
****************************************************************************************/
//checks if an enemy unit is in attacking range. If there are multiple, select the
//weakest
enemyInRange = function( me, them ) {
targetLife = 999;
target = -1;
for( var i = 0; i < them.length; i++ ) {
if( them[i].health <= 0 ) {
continue;
}
var x = me.locx - them[i].locx;
var y = me.locy - them[i].locy;
if( x*x + y*y < me.atkRadius*me.atkRadius && them[i].health < targetLife ) {
targetLife = them[i].health;
target = them[i].id;
}
}
return target;
};
distanceToUnit = function(unit1, unit2)
{
return Math.sqrt(Math.pow(unit1.locx - unit2.locx,2) + Math.pow(unit1.locy-unit2.locy,2));
}
closestEnemy = function( me, them, seed ) {
if (them.length==0)
return -1;
var closest=them[0];
var closestDist=seed;
for( var i = 0; i < them.length; i++ ) {
if( them[i].health <= 0 )
continue;
var dist=distanceToUnit(me, them[i]);
if (dist<closestDist)
{
closestDist=dist;
closest=them[i];
}
}
return closest;
}
//identify the direction i should move in to get to a target destination
getDir = function( x1, y1, x2, y2 ) {
var w = x1 - x2;
var h = y1 - y2;
if( Math.abs( w ) > Math.abs( h ) ){
if( w < 0 ) {
return "right";
} else {
return "left";
}
} else {
if( h < 0 ) {
return "down";
} else {
return "up";
}
}
return "";
};
//find a base that I am currently owning
ownedBase = function( bases ) {
for( var i = 0; i < bases.length; i++ ) {
if( bases[i].allegiance == ID ) {
return bases[i];
}
}
return -1;
}
//find nearest unoccupied base, excluding an id
closestOpenBase = function( bases, x, y, exid ) {
var minDist = 9999;
var minBase = -1;
for( var i = 0; i < bases.length; i++ ) {
if( bases[i].allegiance >= 0 || bases[i].id == exid ) {
continue;
}
var dist = Math.abs(bases[i].locx - x) + Math.abs(bases[i].locy - y);
if( dist < minDist ) {
minDist = dist;
minBase = bases[i];
}
}
return minBase;
};
//check if enemies are inside a base
isEnemyInBase = function( b, foes ) {
for( var i = 0; i < foes.length; i++ ) {
if( IsUnitInBase( b, foes[i] ) ) {
return true;
}
}
return false;
};
/*if( homeBase[0] == -1 ) {
homeBase[0] = ownedBase( b );
homeBase[1] = closestOpenBase( b, homeBase[0].locx, homeBase[0].locy );
//split army into 2 troops for later reference
troop[0] = myGuys;
troop[1] = [];
totalUnits = u.length;
}*/
/*
var index = 0;
var closest = 1000000;
for (var x = 0; x < b.length; x++)
{
if(b[x].allegiance == this.ID)
{
continue;
}
var temp = Math.sqrt(Math.pow((b[x].locx - myGuys[i].locx),2) + Math.pow((b[x].locy - myGuys[i].locy),2));
if(closest >= temp)
{
closest = temp;
index = x;
}
}*/
isUnitInBase = function ( base, unit ) {
var x = base.locx - unit.locx;
var y = base.locy - unit.locy;
if ( x*x + y*y < base.R*base.R ) {
return true;
}
return false;
}
getUnitsInBase = function (base, units)
{
var unitsInBase=[];
for (var i=0;i<units.length;i++)
{
if (isUnitInBase(base,units[i]))
unitsInBase.push(units[i]);
}
return unitsInBase;
}
numBases = function( bases ) {
var numBases = 0;
for( var i = 0; i < bases.length; i++ ) {
if( bases[i].allegiance == ID ) {
numBases++;
}
}
return numBases;
}
//create new orders for my units
dataResponse = function ( ev ) {
//sort through given data
orders = [];
myGuys = [];
enemies = [];
u = ev.data["Data"].units;
b = ev.data["Data"].bases;
var baseCount = numBases(b);
for( var i = 0; i < u.length; i++ ) {
if( u[i].allegiance == this.ID ) {
myGuys.push( u[i] );
} else {
enemies.push( u[i] );
}
}
var availableUnits = [];
var farmingUnits = [];
var ownedBasesNeedingMore = [];
for (var baseIndex = 0; baseIndex<b.length; baseIndex++)
{
if (b[baseIndex].allegiance != ID)
continue;
var unitsInBase = getUnitsInBase(b[baseIndex], myGuys);
if (unitsInBase.length<5)
{
ownedBasesNeedingMore.push(b[baseIndex]);
}
for (var i=0;i<Math.min(5,unitsInBase.length);i++)
{
var unit=unitsInBase[i];
farmingUnits.push(unit);
var mark = enemyInRange(unit, enemies);
if(mark>0)
{
orders.push( {"unitID" : unit.id, "move" : "", "dash" : "", "attack" : mark, "farm" : false} );
}
else
{
mark = closestEnemy(unit, enemies, b[0].R);
if(mark>0)
{
var dir = getDir( unit.locx, unit.locy, mark.locx, mark.locy );
orders.push( {"unitID" : unit.id, "move" : dir, "dash" : dir, "attack" : "", "farm" : false} );
}
else
{
orders.push( {"unitID" : unit.id, "move" : "", "dash" : "", "attack" : "", "farm" : true} );
}
}
}
}
for (var i = 0;i<myGuys.length;i++)
{
var unit=myGuys[i];
var unitIsFarming=0;
for (var j = 0; j<farmingUnits.length;j++)
{
var farmingUnit=farmingUnits[j];
if (farmingUnit.id==unit.id)
{
unitIsFarming=1;
break;
}
}
if (unitIsFarming==1)
continue;
var mark = enemyInRange(unit, enemies);
if(mark>0)
{
orders.push( {"unitID" : unit.id, "move" : "", "dash" : "", "attack" : mark, "farm" : false} );
continue;
}
mark = closestEnemy(unit, enemies, b[0].R*2);
if(mark>0)
{
var dir = getDir( unit.locx, unit.locy, mark.locx, mark.locy );
orders.push( {"unitID" : unit.id, "move" : dir, "dash" : dir, "attack" : "", "farm" : false} );
continue;
}
var nextOpenBase = closestOpenBase(b,unit.locx, unit.locy);
if (ownedBasesNeedingMore.length>0)
{
var baseToMoveTo=ownedBasesNeedingMore[0];
var dir = getDir( unit.locx, unit.locy, baseToMoveTo.locx, baseToMoveTo.locy );
orders.push( {"unitID" : unit.id, "move" : dir, "dash" : dir, "attack" : "", "farm" : false} );
}
else if (nextOpenBase != -1)
{
var dir = getDir( unit.locx, unit.locy, nextOpenBase.locx, nextOpenBase.locy );
orders.push( {"unitID" : unit.id, "move" : dir, "dash" : dir, "attack" : "", "farm" : false} );
}
else//attack!
{
var mark = closestEnemy(unit, enemies, 1000000000);
if (mark!=-1)
{
var dir = getDir( unit.locx, unit.locy, mark.locx, mark.locy );
orders.push( {"unitID" : unit.id, "move" : dir, "dash" : dir, "attack" : "", "farm" : false} );
}
}
}
//post message back to AI Manager
postMessage( { "Orders" : orders } );
}
|
'use strict';
angular.module('newsApp')
.controller('profileCtrl', ['$http', '$scope', 'baseUrl', function($http, $scope, baseUrl){
$scope.model = [];
$http.get(baseUrl + '/api/v1/users/me/').success(function(response){
$scope.userData = response.users;
sessionStorage.setItem('email', response.user.email);
});
$http.get(baseUrl + '/api/v1/categories/').success(function(response){
$scope.Categories = response.categories;
$scope.model = (new Array($scope.Categories.length)).fill(false);
});
$scope.editEmail = function(new_email){
if(sessionStorage.getItem('email')!==new_email){
$http.put(baseUrl + '/api/v1/users/me/',{
user: {
email: new_email
}
}).success(function(){
swal("Success!", "You successfull change your email adress", "success");
}).error(function(){
swal("Some Error!", "You need fix your mistake", "error");
});
}
else{
swal("Error!", "You choose the same email!" , "error");
};
};
$scope.editPassword = function(current, new_password, new_passwordRepeat){
if(current!==new_password){
$http.post(baseUrl + '/api/v1/users/me/password/',{
user: {
original_password: current,
new_password: new_password, new_passwordRepeat
}
}).success(function(){
swal("Success!", "You successfull change your password", "success");
}).error(function(){
swal("Some Error!", "Problem with communication to the server", "error");
});
}
else{
swal("Error!", "You choose the same password!" , "error");
};
};
$scope.editCategory = function(model){
var zaznaczoneId = [];
$scope.model.forEach(function(v, i) {
if(v) zaznaczoneId.push($scope.Categories[i].id);
});
$http.put(baseUrl + '/api/v1/users/me/', {
user: {
category_ids: zaznaczoneId
}
}).success(function(){
if(zaznaczoneId!=""){
swal("", "Your category have been changed", "success");
}
else{
console.log('zero zmian kategorii');
}
});
};
$scope.isChecked = function(model){
return $scope.model.every(function(e) {
return e === false;
});
};
}]);
|
#!/usr/bin/env node
const colors = require('colors/safe');
const { execSync } = require('child_process');
function log(message) {
console.log(`${colors.yellow('[morto]')} ${message}`);
}
function exec(command, cwd) {
const startTime = new Date();
log(`[exec] running "${command}" in "/${cwd || ''}"...`);
try {
execSync(command, { cwd, stdio: 'inherit', stderr: 'inherit' });
log(`[exec] finished "${command}" in ${((new Date() - startTime) / 1000).toFixed(2)}s...`);
return 0;
} catch (_) {
log(`[exec] ${colors.red('ERROR')} in "${command}" after ${((new Date() - startTime) / 1000).toFixed(2)}s...`);
return 1;
}
}
function copy(object) {
return JSON.parse(JSON.stringify(object));
}
function trap(fn) {
return function(...args) {
try {
return fn(...args);
} catch(e) {
log(`[trap] ERROR: ${e.message}`);
return 1;
}
}
}
function runCommandGroup(project, name, group, env) {
const commandGroup = project[group] || {};
const commands = (commandGroup.common || []).concat(commandGroup[env] || []);
commands.forEach((command, index) => {
log(`[${name}] Running ${group} ${index}...`);
const exitCode = exec(command, project.subDirectory);
if (exitCode !== 0) throw new Error(`Command failed in project ${name}: ${command}`);
});
}
module.exports = { log, exec, copy, trap, runCommandGroup };
|
const winston = require('winston'), //Used for logging to file
fileLog = new(winston.Logger)({ //Creates log transport to log to error.log file
transports: [
new(winston.transports.File)({
filename: 'error.log', //The name of the logging file
showLevel: false,
prettyPrint: true,
json: false
})
]
}),
fs = require('fs');
//Covert string to having just first character uppercase and the rest lowercase
exports.toTitleCase = str => {
//Finds words and replaces the word with a title case word, doesn't matter what it was previously(title case is the first letter of each word is uppercase and rest lowercase)
return str.replace(/\w\S*/g, word => {
return word.charAt(0).toUpperCase() + word.substr(1).toLowerCase();
});
}
//Used to escape regex and prevent errors
function escapeRegExp(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
exports.escapeRegExp = escapeRegExp;
//Thing to sort objects (converts object to array, sorts array then reconverts to object)
exports.sortObj = obj => {
var temp_array = [],
temp_obj = {};
//Converts Object to array
for (var key in obj) {
if (obj.hasOwnProperty(key)) {
temp_array.push(key);
}
}
//Sorts array
temp_array.sort();
//Converts array back to object
for (var i = 0; i < temp_array.length; i++) {
temp_obj[temp_array[i]] = obj[temp_array[i]];
}
return temp_obj;
};
//Splits array into the number size you specify
exports.splitArray = (array, size) => {
var sets = [],
chunks = array.length / size,
i = 0;
//This code creates an array of arrays and its magic don't question it
for (var i = 0, j = 0; i < chunks; i++, j += size) {
sets[i] = array.slice(j, j + size);
}
return sets;
}
//Logs errors to the cconsole as well as the error.log
exports.fileLog = err => {
console.log(errorC(err))
fileLog.error(err)
}
//Try to get a user object from a typed name
exports.getName = (msg, name) => {
//Creates name regex to search by
var nameRegex = new RegExp(escapeRegExp(name), "i");
//If not in a guild make the msg.user the msg.author(msg.user doesn't normally exit but it helps me do some commands easier)
if (!msg.channel.guild) {
msg.user = msg.author;
return msg;
} else if (!name) return msg.channel.guild.members.get(msg.author.id); //If no name passed return the member object of the user
//Check to see if you're able to find the user by nickname or username and return the object if found, if not return the author's member object
else return msg.channel.guild.members.find(member => (member.nick || member.user.username).match(nameRegex)) ? msg.channel.guild.members.find(member => (member.nick || member.user.username).match(nameRegex)) : msg.channel.guild.members.get(msg.author.id);
}
//Deletes the passed message after 5000ms
exports.messageDelete = msg => {
setTimeout(() => {
msg.delete();
}, 5000)
}
exports.saveFile = (file, data) => {
var ext = /(?:\.([^.]+))?$/.exec(file);
fs.writeFile(`${file}-temp${ext}`, data, error => {
if (error) {
console.log(errorC(err))
} else {
fs.stat(`${file}-temp${ext}`, (err, stats) => {
if (err || stats["size"] < 5) {
console.log(errorC(`Did not save ${file} due to error.`))
} else {
fs.renameSync(`${__dirname}/${file}-temp${ext}`, `${__dirname}/${file}${ext}`)
}
});
}
});
}
|
"use strict";
/* Controllers */
var pongAppControllers = angular.module("pongAppControllers", []);
pongAppControllers.controller("dashboardCtrl", ["$scope", "$http", "socket",
function($scope, $http, socket, $routeParams) {
var NUM_RECENT_GAMES = 5;
$scope.dataRefresh = function(refresh) {
if (!refresh) {
$http.get("/api/game/history/" + NUM_RECENT_GAMES)
.success(function(games) {
$scope.mostRecentGame = games.shift();
$scope.recentGames = games;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
}
$http.get("/api/stats/standings/weekly?numResults=4")
.success(function(standing) {
$scope.weeklyStandings = standing;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
$http.get("/api/stats/streak/wins/top")
.success(function(player) {
$scope.winStreak = player;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
$http.get("/api/stats/streak/losses/top")
.success(function(player) {
$scope.losingStreak = player;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
$http.get("/api/stats/largest-score-difference")
.success(function(score) {
$scope.sweepingScore = score;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
$http.get("/api/game/total")
.success(function(total) {
$scope.totalGames = total;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
$http.get("/api/stats/top-rankings")
.success(function(rankings) {
$scope.eloRanking = rankings || $scope.eloRanking;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
};
$scope.mostRecentGame = {};
$scope.recentGames = [{},{},{},{}];
$scope.eloRanking = [{},{},{},{},{}];
$scope.weeklyStandings = [{},{},{},{}];
$scope.winStreak = {};
$scope.losingStreak = {};
$scope.sweepingScore = {};
$scope.totalGames = 0;
socket.on("new-game", function(game) {
$scope.recentGames.unshift($scope.mostRecentGame);
$scope.mostRecentGame = game;
if ($scope.recentGames.length > NUM_RECENT_GAMES - 1){
$scope.recentGames.pop();
}
$scope.dataRefresh(true);
});
}
]);
pongAppControllers.controller("profileCtrl", ["$scope", "$http", "$routeParams",
function($scope, $http, $routeParams) {
$scope.user = {};
$scope.stats = {};
$scope.gameHistory = {};
$scope.init = function() {
if ($routeParams.id) {
$http.get("/api/game/user/" + $routeParams.id)
.success(function(gameHistory){
$scope.gameHistory = gameHistory;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
$http.get("/api/stats/user/" + $routeParams.id)
.success(function(stats){
$scope.stats = stats;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
}
};
}
]);
pongAppControllers.controller("playerStatsCtrl", ["$scope", "$http", "$filter",
function($scope, $http, $filter) {
$scope.filter = "allTime";
$scope.allPlayerStats = [];
$scope.comparedPlayers = [];
$scope.leftCompare = {};
$scope.rightCompare = {};
$scope.init = function() {
$http.get("/api/stats/user/all")
.success(function(stats){
populateData(stats);
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
};
var populateData = function(allPlayerStats){
angular.forEach(allPlayerStats, function(player, index) {
var newPlayer = {
name : player.name,
avatarUrl : player.avatarUrl,
playerSince : player.playerSince,
rank : player.rank,
id: player.userId,
selected : false,
stats : [setAllTimeStats(player), setWeeklyStats(player), setMonthlyStats(player)],
};
$scope.allPlayerStats.push(newPlayer);
});
changeStats(0);
};
// update gameCount, wins, losses, and win rate
// to display either 0: allTime, 1: weekly, 2: monthly
var changeStats = function(statIndex) {
angular.forEach($scope.allPlayerStats, function(player, index) {
angular.extend($scope.allPlayerStats[index], player.stats[statIndex]);
});
};
$scope.$watch("filter", function(value) {
switch (value) {
case "allTime":
changeStats(0);
break;
case "weekly":
changeStats(1);
break;
case "monthly":
changeStats(2);
break;
}
});
$scope.addPlayerToCompare = function(playerId) {
var push = function(id) {
$scope.comparedPlayers.push(id);
};
if ($scope.comparedPlayers.length === 0){
push(playerId);
} else if ($scope.comparedPlayers[0] !== playerId) {
push(playerId);
if ($scope.comparedPlayers.length === 2) {
compare($scope.comparedPlayers[0], $scope.comparedPlayers[1]);
}
} else {
$scope.comparedPlayers = [];
}
};
var compare = function(playerOneId, playerTwoId) {
$http.get("/api/stats/user/"+playerOneId+"/matchup/"+playerTwoId)
.success(function(compareStats) {
computeCompareStats(compareStats, playerOneId, playerTwoId);
});
};
var computeCompareStats = function (compareStats, playerOneId, playerTwoId) {
$scope.compareStats = compareStats;
var totalGames = (compareStats.wins + compareStats.opponentWins);
$scope.leftCompare = $filter("filter")($scope.allPlayerStats, function(player) {return (player.id === playerOneId);})[0];
$scope.rightCompare = $filter("filter")($scope.allPlayerStats, function(player) {return (player.id === playerTwoId);})[0];
$scope.leftCompare.id = playerOneId;
$scope.rightCompare.id = playerTwoId;
$scope.leftCompare.avgPoints = ((compareStats.winningPoints + compareStats.losingPoints) / totalGames).toFixed(1);
$scope.rightCompare.avgPoints = ((compareStats.opponentWinningPoints + compareStats.opponentLosingPoints) / totalGames).toFixed(1);
$scope.leftCompare.winRate = (compareStats.wins / totalGames) * 100;
$scope.rightCompare.winRate = (compareStats.opponentWins / totalGames) * 100;
};
$scope.closeOverlay = function() {
$scope.comparedPlayers = [];
angular.forEach($scope.allPlayerStats, function(player) {
player.selected = false;
});
};
var setAllTimeStats = function(stats) {
return {
"wins": stats.wins,
"losses": stats.losses,
"gameCount": stats.gameCount,
"winRate": stats.winRate,
};
};
var setWeeklyStats = function(stats) {
return {
"wins": stats.weeklyWins,
"losses": stats.weeklyLosses,
"gameCount": stats.weeklyGameCount,
"winRate": stats.weeklyWinRate,
};
};
var setMonthlyStats = function(stats) {
return {
"wins": stats.monthlyWins,
"losses": stats.monthlyLosses,
"gameCount": stats.monthlyGameCount,
"winRate": stats.monthlyWinRate,
};
};
}
]);
pongAppControllers.controller("gameHistoryCtrl", ["$scope", "$http",
function($scope, $http) {
$scope.gameHistory = {};
$scope.init = function() {
$http.get("/api/game/history/99")
.success(function(gameHist) {
$scope.gameHistory = gameHist;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
};
}
]);
pongAppControllers.controller("inputScoreCtrl", ["$scope", "$http", "$routeParams",
function($scope, $http, $routeParams) {
$scope.team = [];
$scope.winner = {};
$scope.loser = {};
$scope.winnerScore = 21;
$scope.loserScore = 15;
$scope.init = function() {
$scope.winner.avatarUrl = $scope.loser.avatarUrl = "https://hipchat.tor.razorfish.com/img/silhouette_125.png";
$http.get("/api/user/list").success(function(data) {
$scope.team = data;
});
};
$scope.submitScoreNow = function($form) {
if ($form.$valid) {
if (angular.isObject($scope.winner) && $scope.winner.userId && angular.isObject($scope.loser) && $scope.loser.userId && $scope.winner !== $scope.loser) {
postScore();
$form.$setPristine();
}
}
};
var postScore = function() {
var game = {
winnerUserId: $scope.winner.userId,
winnerScore: $scope.winnerScore,
loserUserId: $scope.loser.userId,
loserScore: $scope.loserScore
};
$http({
method: "POST",
url:"/api/game",
data: game,
headers: { "Content-type": "application/json"}
})
.success(function(data, status, headers, config) {
$scope.winner = {},
$scope.loser = {};
$scope.winner.avatarUrl = $scope.loser.avatarUrl = "https://hipchat.tor.razorfish.com/img/silhouette_125.png";
$scope.winnerScore = 21;
$scope.loserScore = 15;
})
.error(function(data, status, headers, config) {
console.error(data.error);
});
};
}
]);
|
/**
* http://usejsdoc.org/
*/
define('api/user', ['app/kickStart'], function (app) {
function transformResponse(data, headers) {
return {
data: JSON.parse(data),
token: headers().authentication
};
}
//console.log(app);
app.factory('Register', ['$resource', function($resource) {
return $resource('/api/user/register', {}, {
save: {
method: 'POST',
transformResponse: transformResponse
}
});
}]);
app.factory('Login', ['$resource', function($resource) {
return $resource('/api/user/authenticate', {}, {
save: {
method: 'POST',
transformResponse: transformResponse
}
});
}]);
app.factory('Logout', ['$resource', '$cookies', function($resource, $cookies) {
return $resource('/api/user/logout', {}, {
query: {
method: 'GET',
headers: {'Authorization': $cookies.get('token')}
}
});
}]);
});
|
import { moduleFor, test } from 'ember-qunit';
moduleFor('controller:authorize', {
// Specify the other units that are required for this test.
// needs: ['controller:foo']
});
// Replace this with your real tests.
test('it exists', function(assert) {
var controller = this.subject();
assert.ok(controller);
});
|
// My first try at Gulp, just a bunch och copy-paste-stuff that seems to work...
var gulp = require('gulp');
var concat = require('gulp-concat');
var uglify = require('gulp-uglify');
var paths = {
scripts: ['src/*'],
triggers: ['src/triggers-plugin/*','src/triggers.js']
};
gulp.task('clean', function(cb) {
// You can use multiple globbing patterns as you would with `gulp.src`
del(['build'], cb);
});
//gulp.task('scripts', ['clean'], function() {
gulp.task('tiled-extras-plugin', [], function() {
// Minify and copy all JavaScript
return gulp.src(paths.scripts)
.pipe(concat('phaser-tiled-extras.js'))
.pipe(gulp.dest('build'))
.pipe(uglify())
.pipe(concat('phaser-tiled-extras.min.js'))
.pipe(gulp.dest('build'));
});
gulp.task('triggers-plugin', [], function() {
// Minify and copy all JavaScript
return gulp.src(paths.triggers)
.pipe(concat('phaser-tiled-extras-triggers.js'))
.pipe(gulp.dest('build'))
.pipe(uglify())
.pipe(concat('phaser-tiled-extras-triggers.min.js'))
.pipe(gulp.dest('build'));
});
gulp.task('default', ['tiled-extras-plugin', 'triggers-plugin']);
|
// Generated by CoffeeScript 1.9.3
(function() {
var CompositeDisposable, Panel, PanelElement, callAttachHooks,
extend = function(child, parent) { for (var key in parent) { if (hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; },
hasProp = {}.hasOwnProperty;
CompositeDisposable = require('event-kit').CompositeDisposable;
callAttachHooks = require('./space-pen-extensions').callAttachHooks;
Panel = require('./panel');
PanelElement = (function(superClass) {
extend(PanelElement, superClass);
function PanelElement() {
return PanelElement.__super__.constructor.apply(this, arguments);
}
PanelElement.prototype.createdCallback = function() {
return this.subscriptions = new CompositeDisposable;
};
PanelElement.prototype.initialize = function(model) {
var ref;
this.model = model;
this.appendChild(this.getItemView());
if (this.model.getClassName() != null) {
(ref = this.classList).add.apply(ref, this.model.getClassName().split(' '));
}
this.subscriptions.add(this.model.onDidChangeVisible(this.visibleChanged.bind(this)));
this.subscriptions.add(this.model.onDidDestroy(this.destroyed.bind(this)));
return this;
};
PanelElement.prototype.getModel = function() {
return this.model != null ? this.model : this.model = new Panel;
};
PanelElement.prototype.getItemView = function() {
return atom.views.getView(this.getModel().getItem());
};
PanelElement.prototype.attachedCallback = function() {
callAttachHooks(this.getItemView());
return this.visibleChanged(this.getModel().isVisible());
};
PanelElement.prototype.visibleChanged = function(visible) {
if (visible) {
return this.style.display = null;
} else {
return this.style.display = 'none';
}
};
PanelElement.prototype.destroyed = function() {
var ref;
this.subscriptions.dispose();
return (ref = this.parentNode) != null ? ref.removeChild(this) : void 0;
};
return PanelElement;
})(HTMLElement);
module.exports = PanelElement = document.registerElement('atom-panel', {
prototype: PanelElement.prototype
});
}).call(this);
|
/*jslint node: true */
"use strict";
var passport = require('passport');
module.exports = function (app) {
app.use(passport.initialize());
app.use(passport.session());
passport.serializeUser(function (user, done) {
done(null, user);
});
passport.deserializeUser(function (user, done) {
done(null, user);
});
require('./strategies/local.strategy')();
};
|
// @flow
import type {PrecinctData, StatByParty} from './types';
// Find the key for the larger of the values.
//
// obj should be an object with two keys and numerical values. Returns the key
// corresponding to the larger value, or null if they are equal.
function winner(obj: StatByParty): ?string {
const [k1, k2] = Object.keys(obj);
if (obj[k1] > obj[k2]) {
return k1;
} else if (obj[k2] > obj[k1]) {
return k2;
} else {
return null;
}
}
function parseQs(data: string): {[string]: string} {
if (data[0] === '#' || data[0] === '?') {
data = data.slice(1);
}
const retval = {};
for (let item of data.split('&')) {
let ix = item.indexOf('=');
if (ix !== -1) {
retval[decodeURIComponent(item.slice(0, ix))] = decodeURIComponent(
item.slice(ix + 1));
}
}
return retval;
}
function sum(vals: $ReadOnlyArray<number>): number {
return vals.reduce((a, b) => a + b, 0);
}
function population(precincts: $ReadOnlyArray<PrecinctData>) {
return sum(precincts.map(p => p.dots.length));
}
export {winner, parseQs, sum, population};
|
import React from 'react'
import { Message } from 'semantic-ui-react'
import ComponentExample from 'docs/src/components/ComponentDoc/ComponentExample'
import ExampleSection from 'docs/src/components/ComponentDoc/ExampleSection'
const TextAreaTypesExamples = () => (
<ExampleSection title='Types'>
<ComponentExample
title='TextArea'
description='A default TextArea.'
examplePath='addons/TextArea/Types/TextAreaExampleTextArea'
>
<Message info>
You should always wrap a <code>Textarea</code> with a <code>Form</code>{' '}
component to get styles applied because Semantic UI applies styles for{' '}
<code>.ui.form textarea</code>.
</Message>
</ComponentExample>
</ExampleSection>
)
export default TextAreaTypesExamples
|
'use strict';
var React = require('react');
var PureRenderMixin = require('react-addons-pure-render-mixin');
var SvgIcon = require('../../svg-icon');
var ImageCropRotate = React.createClass({
displayName: 'ImageCropRotate',
mixins: [PureRenderMixin],
render: function render() {
return React.createElement(
SvgIcon,
this.props,
React.createElement('path', { d: 'M7.47 21.49C4.2 19.93 1.86 16.76 1.5 13H0c.51 6.16 5.66 11 11.95 11 .23 0 .44-.02.66-.03L8.8 20.15l-1.33 1.34zM12.05 0c-.23 0-.44.02-.66.04l3.81 3.81 1.33-1.33C19.8 4.07 22.14 7.24 22.5 11H24c-.51-6.16-5.66-11-11.95-11zM16 14h2V8c0-1.11-.9-2-2-2h-6v2h6v6zm-8 2V4H6v2H4v2h2v8c0 1.1.89 2 2 2h8v2h2v-2h2v-2H8z' })
);
}
});
module.exports = ImageCropRotate;
|
pinboard.contextMenus = (function() {
'use strict';
var SAVE_TO_PINBOARD = 'Save to Pinboard';
var SAVE_SELECTION_PINBOARD = 'Save Selection to Pinboard';
var SAVE_URL_TO_PINBOARD = 'Save URL to Pinboard';
var SAVE_IMAGE_URL_TO_PINBOARD = 'Save Image URL to Pinboard';
var SAVE_AUDIO_URL_TO_PINBOARD = 'Save Audio URL to Pinboard';
var SAVE_VIDEO_URL_TO_PINBOARD = 'Save Video URL to Pinboard';
var MENU_ID_PAGE = 'page';
var MENU_ID_SELECTION = 'selection';
var MENU_ID_LINK = 'link';
var MENU_ID_IMAGE = 'image';
var MENU_ID_AUDIO = 'audio';
var MENU_ID_VIDEO = 'video';
var setup = function(onClockCallback) {
chrome.contextMenus.create({
'title': SAVE_TO_PINBOARD,
'id': MENU_ID_PAGE,
'contexts': [MENU_ID_PAGE]
});
chrome.contextMenus.create({
'title': SAVE_SELECTION_PINBOARD,
'id': MENU_ID_SELECTION,
'contexts': [MENU_ID_SELECTION]
});
chrome.contextMenus.create({
'title': SAVE_URL_TO_PINBOARD,
'id': MENU_ID_LINK,
'contexts': [MENU_ID_LINK]
});
chrome.contextMenus.create({
'title': SAVE_IMAGE_URL_TO_PINBOARD,
'id': MENU_ID_IMAGE,
'contexts': [MENU_ID_IMAGE]
});
chrome.contextMenus.create({
'title': SAVE_AUDIO_URL_TO_PINBOARD,
'id': MENU_ID_AUDIO,
'contexts': [MENU_ID_AUDIO]
});
chrome.contextMenus.create({
'title': SAVE_VIDEO_URL_TO_PINBOARD,
'id': MENU_ID_VIDEO,
'contexts': [MENU_ID_VIDEO]
});
chrome.contextMenus.onClicked.addListener(onclick);
callback = onClockCallback;
};
var callback;
var onclick = function(info, tab) {
if (chrome.extension.lastError || chrome.runtime.lastError) {
//console.log(chrome.extension.lastError);
//console.log(chrome.runtime.lastError);
return;
} else {
var config;
if (info.menuItemId === MENU_ID_LINK) {
config = {
url: info.linkUrl,
title: info.linkUrl
};
} else if (info.menuItemId === MENU_ID_IMAGE ||
info.menuItemId === MENU_ID_AUDIO ||
info.menuItemId === MENU_ID_VIDEO) {
config = {
url: info.srcUrl,
title: info.srcUrl
};
} else {
config = {
url: info.pageUrl,
title: tab.title,
description: info.selectionText
};
}
callback(config);
}
};
return {
setup: setup
};
})();
|
/* ************************************************************************
Googly
Copyright:
2010-2011 Deutsche Telekom AG, Germany, http://telekom.com
************************************************************************ */
/**
* Googly appearances
*/
qx.Theme.define("googly.theme.Appearance", {
extend: unify.theme.dark.Appearance,
appearances : {
"button" : {
base : true,
style : function() {
return {
padding: "2px",
margin: "10px 8px",
fontSize: "12px",
backgroundColor: "red",
//properties : {
verticalAlign: "middle"
//}
};
}
},
"label" : {
base : true,
style : function() {
return {
paddingLeft: "10px",
paddingTop: "10px",
paddingRight: "10px",
paddingBottom: "10px"
};
}
}
}
});
|
import App from './build'
const app = new App();
|
/**
* German translation for bootstrap-datepicker
* Sam Zurcher <sam@orelias.ch>
*/
;(function($){
$.fn.datepicker.dates['de'] = {
days: ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"],
daysShort: ["Son", "Mon", "Die", "Mit", "Don", "Fre", "Sam", "Son"],
daysMin: ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"],
months: ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"],
monthsShort: ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"],
today: "Heute",
weekStart: 1,
format: "dd.mm.yyyy"
};
}(jQuery));
|
'use strict';
import $ from 'jquery';
import jQuery from 'jquery';
window.$ = $;
window.jQuery = jQuery;
require('bootstrap');
require('bootstrap-tagsinput');
require('bootstrap-tabcollapse')
const editor = require('./braindump.editor');
const notebooks = require('./braindump.notebooks')
const dates = require('./Dates');
editor.initEditor();
notebooks.init();
dates.initDates();
$('#noteTabs').tabCollapse();
|
/**
*
* Routes
*
* Copyright 2019, Author Name
* Some information on the license.
*
**/
module.exports = {
'/': () => {
// Log it.
window.Helpers.log('Route Loaded: home', '#E19F12')
// Get route controller.
let c = require('./routes/home').default
// Check for an init method.
if (typeof c.init === 'function') c.init()
// Check for an listeners method.
if (typeof c.listeners === 'function') c.listeners()
}
}
|
define(function()
{
"use strict";
var Connector = {};
Connector.ProblemControlsUI =
{
mapStateToProps: function(state, ownProps)
{
return (
{
backCount: state.backCount,
generationCount: state.generationCount,
popSize: state.popSize,
submitFunction: ownProps.submitFunction,
});
}
};
Connector.ProblemResultsUI =
{
mapStateToProps: function(state, ownProps)
{
return (
{
bestGenomes: state.bestGenomes,
message: state.message,
});
}
};
Connector.ProblemTableauUI =
{
mapStateToProps: function(state, ownProps)
{
var problem = state.problem;
var objective = problem.objective();
var genes = problem.genes();
var fitnessCases = problem.fitnessCases();
return (
{
objective: objective,
genes: genes,
fitnessCases: fitnessCases,
});
}
};
if (Object.freeze)
{
Object.freeze(Connector);
}
return Connector;
});
|
(function($) {
/**
* 1. FitText.js 1.2 - (http://sam.zoy.org/wtfpl/)
*-----------------------------------------------------------*/
(function( $ ){
$.fn.fitText = function( kompressor, options ) {
// Setup options
var compressor = kompressor || 1,
settings = $.extend({
'minFontSize' : Number.NEGATIVE_INFINITY,
'maxFontSize' : Number.POSITIVE_INFINITY
}, options);
return this.each(function(){
// Store the object
var $this = $(this);
// Resizer() resizes items based on the object width divided by the compressor * 10
var resizer = function () {
$this.css('font-size', Math.max(Math.min($this.width() / (compressor*10), parseFloat(settings.maxFontSize)), parseFloat(settings.minFontSize)));
};
// Call once to set.
resizer();
// Call on resize. Opera debounces their resize by default.
$(window).on('resize.fittext orientationchange.fittext', resizer);
});
};
})( jQuery );
/**
* 2. CP Responsive - (Required - FitText.js)
*
* Required to call on READY & LOAD
*-----------------------------------------------------------*/
function CPApplyFlatText(s, fs) {
if( s.hasClass('cp-description') || s.hasClass('cp-short-description') || s.hasClass('cp-info-container') ) {
s.fitText(1.7, { minFontSize: '12px', maxFontSize: fs } );
} else {
s.fitText(1.2, { minFontSize: '16px', maxFontSize: fs } );
}
}
function CPAutoResponsiveResize() {
jQuery('.cp_responsive').each(function(index, el) {
var lh = '',
ww = jQuery(window).width(),
s = jQuery(el),
fs = s.css( 'font-size' ),
CKE_FONT = s.attr( 'data-font-size' ),
Def_FONT = s.attr( 'data-font-size-init' ),
CKE_LINE_HEIGHT = s.attr( 'data-line-height' ),
Def_LineHeight = s.attr( 'data-line-height-init' );
if( CKE_FONT ) {
fs = CKE_FONT; // 1. CKEditor font sizes from editor
} else if( Def_FONT ) {
fs = Def_FONT; // 2. Initially stored font size
}
// Initially set empty line height
if( CKE_LINE_HEIGHT ) {
lh = CKE_LINE_HEIGHT; // 1. CKEditor font sizes from editor
} else if( Def_LineHeight ) {
lh = Def_LineHeight; // 2. Initially stored font size
}
if( ww <= 800 ) {
// Apply default line-height - If it does not contain class - `cp_line_height`
s.css({'display':'block', 'line-height':'1.15em'});
CPApplyFlatText(s, fs);
} else {
s.css({'display':'', 'line-height': lh });
check_responsive_font_sizes();
// Apply `fit-text` for all CKEditor elements - ( .cp-title, .cp-description etc. )
s.fitText(1.2, { minFontSize: fs, maxFontSize: fs } );
}
});
}
jQuery(document).ready(function() {
// Set normal values in data attribute to reset these on window resize
setTimeout(function() {
CPResponsiveTypoInit();
//for link color change
cp_color_for_list_tag();
}, 1500 );
// hide image for small devices
hide_image_on_smalldevice();
// box shadow for all form style
apply_boxshaddow();
// function to call CP_slide_in_height() when text area resize
apply_resize_on_textarea();
if(jQuery(".slidein-overlay").length > 0){
var count = 0;
jQuery(".slidein-overlay").each(function(index, el) {
if(!jQuery(this).find(".cp-slidein-content").hasClass('ps-container')){
if( !jQuery(this).find(".cp-slidein-content").hasClass('si-open') ){
count++;
var old_id= jQuery(this).find(".cp-slidein-content").attr('id');
jQuery(this).find(".cp-slidein-content").attr("id",old_id+"-"+count);
}
var id= jQuery(this).find(".cp-slidein-content").attr('id');
Ps.initialize(document.getElementById(id));
}
});
}
setTimeout(function() {
//hide sidebar for slidein
hide_sidebar();
}, 500 );
cp_slidein_social_responsive();
//setTimeout(function() {
cp_slide_in_column_equilize();
// }, 1000 );
});
jQuery(window).resize(function(){
/* = Responsive Typography
*-----------------------------------------------------------*/
CPAutoResponsiveResize();
// hide image for small devices
hide_image_on_smalldevice();
CP_slide_in_height();
cp_slidein_social_responsive();
//setTimeout(function() {
cp_slide_in_column_equilize();
//}, 300 );
});
/**
* This function will hide image on small devices
*/
function hide_image_on_smalldevice(){
jQuery(".slidein-overlay").each(function() {
var vw = jQuery(window).innerWidth();
var flag = jQuery(this).data('image-position');
var hidewidth = jQuery(this).data('hide-img-on-mobile');
if(hidewidth){
if(vw <= hidewidth ){
jQuery(this).find('.cp-image-container').addClass('cp-hide-image');
} else {
jQuery(this).find('.cp-image-container').removeClass('cp-hide-image');
}
}
});
}
})(jQuery);
/**
* Check inner span has set font size
*/
check_responsive_font_sizes();
function check_responsive_font_sizes() {
// Apply font sizes
jQuery(".cp_responsive[data-font-size-init]").each(function(index, el) {
if( jQuery( el ).find('.cp_font').length ) {
// Added class `cp-no-responsive` to over ride the init font size of all - elements i.e. - cp-title, .cp-description etc.
// Add for only parents not inner child's
if( !jQuery( el ).hasClass('.cp_font, .cp_line_height') ) {
jQuery( el ).addClass('cp-no-responsive');
}
} else {
// If child element not found class - `cp_font` then remove class `cp-no-responsive`
jQuery( el ).removeClass('cp-no-responsive');
}
});
}
/**
* Set normal values in data attribute to reset these on window resize
*/
function CPResponsiveTypoInit() {
// 1. Add font size attribute
jQuery('.cp_responsive').each(function(index, el) {
var s = jQuery(el);
// Add attribute `data-line-height-init` for all `cp_responsive` classes. Except `.cp_line_height` which is added from editor.
if( !s.hasClass('cp_line_height') ) {
// Set `init` font size data attribute
var fs = s.css('font-size');
var hasData = s.attr('data-font-size');
if(!hasData) {
s.attr('data-font-size-init', fs);
}
}
// Add attribute `data-line-height-init` for all `cp_responsive` classes. Except `.cp_font` which is added from editor.
if( !s.hasClass('cp_font') ) {
// Set `init` line height data attribute
var lh = s.css('line-height');
var hasData = s.attr('data-line-height');
if(!hasData) {
s.attr('data-line-height-init', lh);
}
}
});
check_responsive_font_sizes();
// Slide In height
CP_slide_in_height();
}
/**
* This function adjust height for Slide In
* Loop for all live Slide In's
*
*/
function CP_slide_in_height() {
setTimeout(function() {
// Loop all live Slide In's
jQuery('.cp-slidein-popup-container').each(function(index, element) {
var slide_in_overlay = jQuery(this).find('.slidein-overlay');
if( slide_in_overlay.hasClass('si-open') ) {
var t = jQuery(element),
slidein = t.find('.cp-slidein'),
cp_slidein = t.find('.cp-slidein'),
slide_overlay = t.find('.slidein-overlay'),
slide_overlay_height = t.find('.cp-slidein').outerHeight(),
slidein_body_height = t.find('.cp-slidein-body').outerHeight(),
ww = jQuery(window).width();
if( ( slidein_body_height > jQuery(window).height() ) ) {
slidein.addClass('cp-slidein-exceed');
slide_overlay.each(function( i, el ) {
if( jQuery(el).hasClass('si-open') ) {
jQuery('html').addClass('cp-exceed-vieport');
}
});
slidein.css('height', slidein_body_height );
} else {
slidein.removeClass('cp-slidein-exceed');
jQuery('html').removeClass('cp-exceed-vieport');
slidein.css('height', '' );
}
}
});
}, 1200);
}
// function to change color for list type according to span color
function cp_color_for_list_tag(){
jQuery(".slidein-overlay").each(function() {
var moadal_style = jQuery(this).find(".cp-slidein-body").attr('class').split(' ')[1];
jQuery(this).find("li").each(function() {
if( (jQuery(this).parents(".cp_social_networks").length == 0) || (jQuery(this).parents(".custom-html-form").length == 0) ){
var is_responsive_cls = jQuery(this).parents(".cp_responsive").length;
if( is_responsive_cls ) {
var parent_li = jQuery(this).parents(".cp_responsive").attr('class').split(' ')[0],
cnt = jQuery(this).index()+1,
font_size = jQuery(this).find(".cp_font").css("font-size"),
color = jQuery(this).find("span").css("color"),
list_type = jQuery(this).parent();
list_type = list_type[0].nodeName.toLowerCase(),
style_type = '',
style_css = '';
if( list_type == 'ul' ){
style_type = jQuery(this).closest('ul').css('list-style-type');
if( style_type == 'none' ){
jQuery(this).closest('ul').css( 'list-style-type', 'disc' );
}
} else {
style_type = jQuery(this).closest('ol').css('list-style-type');
if( style_type == 'none' ){
jQuery(this).closest('ol').css( 'list-style-type', 'decimal' );
}
}
jQuery(this).find("span").each(function(){
var spancolor = jQuery(this).css("color");
if( spancolor.length > 0 ){
color = spancolor;
}
});
var font_style ='';
jQuery(".cp-li-color-css-"+cnt).remove();
jQuery(".cp-li-font-css-"+cnt).remove();
if(font_size){
font_style='font-size:'+font_size;
jQuery('head').append('<style class="cp-li-font-css'+cnt+'">.'+moadal_style+' .'+parent_li+' li:nth-child('+cnt+'){ '+font_style+'}</style>');
}
if(color){
jQuery('head').append('<style class="cp-li-color-css'+cnt+'">.'+moadal_style+' .'+parent_li+' li:nth-child('+cnt+'){ color: '+color+';}</style>');
}
}
}
});
});
}
//function for box shadow for form field
function apply_boxshaddow (data) {
jQuery(".slidein-overlay").each(function() {
var border_color = jQuery(this).find(".cp-form-container").find(".cp-email").css("border-color"),
moadal_style = jQuery(this).find(".cp-slidein-body").attr('class').split(' ')[1],
classname = jQuery(this).data("class"),
cont_class = jQuery(this).data("class");
if( jQuery(this).hasClass('ps-container') ){
cont_class = jQuery(this).data("ps-id");
border_color = data;
classname = 'slidein-overlay';
}
jQuery(".cp-box-shaddow-"+cont_class).remove();
jQuery('head').append('<style class="cp-box-shaddow-'+cont_class+'">.'+classname+' .cp-slidein .'+moadal_style+' input.cp-email:focus, .'+classname+' .cp-slidein .'+moadal_style+' input.cp-name:focus { box-shadow: 0 0 4px '+border_color+';}</style>');
});
}
/*
* for social media responsive icon*
*/
function cp_slidein_social_responsive(){
var wh = jQuery(window).width();
jQuery(".cp_social_networks").each(function() {
if( !jQuery(this).parents('.cp-slidein-body').hasClass('cp-floating-social-bar')){
var column_no = jQuery(this).data('column-no');
var classname ='';
if(wh < 768){
jQuery(this).removeClass('cp_social_networks');
jQuery(this).removeClass(column_no);
classname = jQuery(this).attr('class');
jQuery(this).attr('class', 'cp_social_networks cp_social_autowidth ' + ' ' + classname );
}else{
jQuery(this).removeClass('cp_social_networks');
jQuery(this).removeClass('cp_social_autowidth');
jQuery(this).removeClass(column_no);
classname = jQuery(this).attr('class');
jQuery(this).attr('class', 'cp_social_networks ' + ' ' + column_no + ' ' + classname );
}
}
});
}
/* Toggle Slide In on click of button */
jQuery("body").on( 'click', '.cp-slidein-head .cp-slidein-toggle' , function(e){
e.preventDefault();
jQuery(this).toggleClass('cp-widget-open');
var this_cls = jQuery(this);
toggle_widget(this_cls , 600);
e.stopPropagation();
});
function toggle_widget(this_cls , val ){
var slidein_container = this_cls.closest('.cp-slidein'),
border_width = slidein_container.find('.cp-slidein-content').css("border-bottom-width");
if( this_cls.hasClass('cp-widget-open') ) {
slidein_container.animate({
'bottom' : 0
}, val );
} else {
if(slidein_container.hasClass('cp-slidein-exceed')){
var cp_slidein_body_ht = slidein_container.height();
}else{
var cp_slidein_body_ht = this_cls.closest('.cp-slidein-body').outerHeight();
}
var cp_slidein_header_ht = this_cls.closest('.cp-slidein-head').outerHeight();
var bottomCss = cp_slidein_body_ht - cp_slidein_header_ht + 2;
if(typeof border_width !=='undefined' && border_width !==''){
border_width = border_width.replace('-', 'px');
border_width = parseInt(border_width);
if(slidein_container.hasClass('cp-slidein-exceed')){
bottomCss = bottomCss - border_width ;
}else{
bottomCss = border_width + bottomCss ;
}
}
slidein_container.animate({
'bottom' : '-'+bottomCss + 'px'
}, val );
setTimeout(function() {
slidein_container.parents(".slidein-overlay").removeClass('cp-hide-slide-widget');
},val);
}
}
jQuery(this).on('smile_data_received',function(e,data){
var minimize_widget = data.minimize_widget || null;
if( minimize_widget == 1 ){
var this_cls = jQuery(".cp-slidein-head .cp-slidein-toggle");
jQuery(".cp-slidein-toggle").removeClass('cp-widget-open');
}
set_optin_widget_bottom();
cp_slide_in_column_equilize();
});
function set_optin_widget_bottom(){
setTimeout(function() {
jQuery('.cp-slidein-popup-container').each(function() {
if( jQuery(this).find('.cp-slidein-toggle').length > 0 ) {
var slidein_container = jQuery(this).find('.cp-slidein');
if( jQuery(this).find('.cp-slidein-toggle').hasClass('cp-widget-open') ) {
slidein_container.animate({
'bottom' : 0
}, 600 );
} else {
if(slidein_container.hasClass('cp-slidein-exceed')){
var cp_slidein_body_ht = slidein_container.height();
}else{
var cp_slidein_body_ht = jQuery(this).find('.cp-slidein-body').outerHeight();
}
var cp_slidein_header_ht = jQuery(this).find('.cp-slidein-head').outerHeight();
var bottomCss = cp_slidein_body_ht - cp_slidein_header_ht + 2;
var border_width = slidein_container.find('.cp-slidein-content').css("border-bottom-width");
if(typeof border_width !=='undefined' && border_width !==''){
border_width = border_width.replace('-', 'px');
border_width = parseInt(border_width);
if(slidein_container.hasClass('cp-slidein-exceed')){
bottomCss = bottomCss - border_width ;
}else{
bottomCss = border_width + bottomCss ;
}
}
slidein_container.animate({
'bottom' : '-'+bottomCss + 'px'
}, 600 );
}
}
});
}, 600);
}
function apply_resize_on_textarea(){
jQuery(".slidein-overlay").each(function() {
jQuery(this).find(".cp-textarea").each(function(){
var textareas =jQuery(this);
textareas.mouseup(function () {
CP_slide_in_height();
});
});
});
}
//hide sidebar for social media style
jQuery("body").on( 'click', '.cp_social_hide_sidebar' , function(e){
e.preventDefault();
var btn = jQuery(this);
var slidein_container = jQuery(this).closest('.cp-slidein'),
animate_container = slidein_container.find('.cp-animate-container'),
cp_social_icons_container = slidein_container.find('.cp_social_icons_container'),
entry_animation = animate_container.data('overlay-animation'),
exit_animation = animate_container.data('exit-animation');
slidein_position = slidein_container.attr('class').split(' ')[1];
var width = slidein_container.css("max-width");
jQuery(this).toggleClass('cp_hidden_sidebar');
switch(slidein_position){
case 'slidein-center-right' :
entry_animation = 'smile-slideInRight';
exit_animation = 'smile-slideOutRight';
break;
case 'slidein-center-left' :
entry_animation = 'smile-slideInLeft';
exit_animation = 'smile-slideOutLeft';
break;
}
animate_container.attr('class',"cp-animate-container");
if(jQuery(this).hasClass('cp_hidden_sidebar')){
animate_container.attr('class',"cp-animate-container smile-animated "+ exit_animation);
}else{
animate_container.attr('class',"cp-animate-container smile-animated "+ entry_animation);
}
slidein_container.css('left','');
btn.css('left','');
slidein_container.css('right','');
btn.css('right','');
setTimeout(function() {
if(btn.hasClass('cp_hidden_sidebar')){
if( slidein_position == 'slidein-center-left' ){
slidein_container.css('left',"-"+width);
btn.css('left','+'+width);
}else if( slidein_position == 'slidein-center-right' ){
slidein_container.css('right',"-"+width);
btn.css('right','+'+width);
}
}
},600);
});
function hide_sidebar(){
jQuery(".slidein-overlay").each(function() {
var slidein_overlay = jQuery(this).find(".cp-slidein");
if(jQuery(this).find('.cp_social_networks').hasClass('cp-icon-style-top')){
slidein_overlay.append( '<span class="cp_social_hide_sidebar cp_social_icon">+</span>' );
}
});
}
/**
* This function will apply height to cp-columns-equalized class
*/
function cp_slide_in_column_equilize() {
setTimeout(function() {
jQuery(".cp-columns-equalized").each(function() {
// if modal is open then only apply equalize properties
if( jQuery(this).closest('.slidein-overlay').hasClass('si-open') || jQuery(this).closest('.slidein-overlay').hasClass('cp-slidein-inline') ) {
var wh = jQuery(window).width();
var childClasses = Array();
jQuery(this).children('.cp-column-equalized-center').each(function () {
var contHeight = jQuery(this).outerHeight();
childClasses.push(contHeight);
});
var count = 0;
if(jQuery(this).find('.cp-image-container').length > 0){
jQuery(this).find(".cp-highlight").each(function(index, el) {
count++;
});
}
var pad_top = parseInt(jQuery(this).css('padding-top'));
var pad_bottom = parseInt(jQuery(this).css('padding-top'));
var tot_padding = pad_top + pad_bottom;
var maxHeight = Math.max.apply(Math, childClasses) + tot_padding;
maxHeight = maxHeight-count;
if( wh > 768 ) {
jQuery(this).css( 'height', maxHeight );
} else {
jQuery(this).css( 'height', 'auto' );
}
}
});
}, 200 );
}
|
"use strict";
var express = require('express');
var errors = require('../errors');
var directives = require('../directives');
var schemas = require('../schemas');
var moment = require('moment');
module.exports = function (logger, config, knexClient) {
var router = express.Router();
var tokenService = directives.token(logger, knexClient);
router.post('/login', directives.validation.schema(schemas.users.login), function(req, res, next) {
knexClient.select('id', 'email', 'password').from('users').where({ email: req.body.email }).limit(1)
.then(function(rows) {
if (rows && rows.length > 0) {
return directives.password.comparePassword(req.body.password, rows[0].password)
.then(function(match) {
if (match) {
return tokenService.generate();
}
else {
return next(new errors.EntityNotFoundError('user'));
}
}).then(function(token) {
return [token, knexClient('tokens').count('user_id').where({ user_id: rows[0].id }).limit(1)];
}).spread(function(token, tokenRow) {
if (tokenRow && tokenRow[0] && tokenRow[0].count === '0') {
return [token, knexClient('tokens').insert({
user_id: rows[0].id,
token: token,
expiry: knexClient.raw('to_timestamp(?)', moment(Date.now() + tokenService.defaultExpiry).format('X'))
})];
}
else {
return [token, knexClient('tokens').where({user_id: rows[0].id}).update({
token: token,
expiry: knexClient.raw('to_timestamp(?)', moment(Date.now() + tokenService.defaultExpiry).format('X'))
})];
}
}).spread(function(token, result) {
return res.status(200).send({token: token});
});
}
else {
return next(new errors.EntityNotFoundError('user'));
}
}).catch(function(error) {
logger.error(error);
return next(new errors.InternalError());
});
});
router.post('/register', directives.validation.schema(schemas.users.register), function(req, res, next) {
return knexClient('users').count('email').where({ email: req.body.email })
.then(function(result) {
if (result[0].count === '0') {
return directives.password.encryptPassword(req.body.password)
.then(function(encryptedPassword) {
return knexClient('users').insert({email: req.body.email, password: encryptedPassword});
}).then(function() {
return res.status(200).send();
});
}
else {
return next(new errors.EntityAlreadyExistError('user'));
}
}).catch(function(error) {
logger.error(error);
return next(new errors.InternalError());
});
});
return router;
};
|
import {bindable, customElement, bindingMode, computedFrom} from 'aurelia-framework';
import {resolvedView} from 'aurelia-view-manager';
@resolvedView('spoonx/form', 'form-select')
@customElement('form-select')
export class FormSelect {
@bindable({defaultBindingMode: bindingMode.twoWay}) value;
@bindable name = '';
@bindable classes = '';
@bindable readonly = false;
@bindable disabled = false;
@bindable multiple = false;
@bindable selectOptions = [];
@bindable options = {};
@bindable optionLabel = 'name';
@bindable autofocus;
@bindable required;
@computedFrom('selectOptions', 'optionLabel')
get optionLabels() {
return this.selectOptions.map(option => {
if (typeof option === 'object' && this.optionLabel) {
option.label = option[this.optionLabel] || '';
}
return option;
});
}
getOptionLabel(option) {
if (typeof option === 'object' && this.optionLabel) {
return option[this.optionLabel] || option;
}
return option;
}
}
|
'use strict';
var bufferEqual = require('buffer-equal'),
ipLib = require('ip'),
TWO_PWR_32 = (1 << 16) * 2,
common = require('./common');
/**
* Return the closest floating-point representation to the buffer value. Precision will be
* lost for big numbers.
*/
function fromUInt64 (buf) {
var high = buf.readUInt32BE(0) || 0, // force
low = buf.readUInt32BE(4) || 0,
lowUnsigned = (low >= 0) ? low : TWO_PWR_32 + low;
return high * TWO_PWR_32 + lowUnsigned;
}
function parseUdpRequest (msg, rinfo) {
if (msg.length < 16) {
throw new Error('received packet is too short');
}
var params = {
connectionId: msg.slice(0, 8), // 64-bit
action: msg.readUInt32BE(8),
transactionId: msg.readUInt32BE(12)
};
// TODO: randomize
if (!bufferEqual(params.connectionId, common.CONNECTION_ID)) {
throw new Error('received packet with invalid connection id');
}
if (params.action === common.ACTIONS.CONNECT) {
// No further params
} else if (params.action === common.ACTIONS.ANNOUNCE) {
params.info_hash = msg.slice(16, 36).toString('hex'); // 20 bytes
params.peer_id = msg.slice(36, 56).toString('hex'); // 20 bytes
params.downloaded = fromUInt64(msg.slice(56, 64)); // TODO: track this?
params.left = fromUInt64(msg.slice(64, 72));
params.uploaded = fromUInt64(msg.slice(72, 80)); // TODO: track this?
params.event = common.EVENT_IDS[msg.readUInt32BE(80)];
if (!params.event) {
throw new Error('invalid event'); // early return
}
var ip = msg.readUInt32BE(84); // optional
params.ip = ip ?
ipLib.toString(ip)
: rinfo.address;
params.key = msg.readUInt32BE(88); // TODO: what is this for?
// never send more than MAX_ANNOUNCE_PEERS or else the UDP packet will get bigger than
// 512 bytes which is not safe
params.numwant = Math.min(
msg.readUInt32BE(92) || common.DEFAULT_ANNOUNCE_PEERS, // optional
common.MAX_ANNOUNCE_PEERS
);
params.port = msg.readUInt16BE(96) || rinfo.port; // optional
params.addr = params.ip + ':' + params.port; // TODO: ipv6 brackets
params.compact = 1; // udp is always compact
} else if (params.action === common.ACTIONS.SCRAPE) { // scrape message
if ((msg.length - 16) % 20 !== 0) {
throw new Error('invalid scrape message');
}
params.info_hash = [];
for (var i = 0, len = (msg.length - 16) / 20; i < len; i += 1) {
var infoHash = msg.slice(16 + (i * 20), 36 + (i * 20)).toString('hex'); // 20 bytes
params.info_hash.push(infoHash);
}
} else {
throw new Error('Invalid action in UDP packet: ' + params.action);
}
return params;
}
module.exports = parseUdpRequest;
|
var agent = require('superagent')
,select = require('./default/select');
//TODO: Choose better names
//TODO: Make queries configurable
module.exports = Client = function(options) {
if(!(this instanceof Client)){
return new Client(options);
};
this.options = options?(typeof options === 'string'?{ "token": options }:options):{};
};
Client.prototype._getJson = function(url, qs, fn){
if(!fn){
fn = qs;
qs = {};
};
if(this.options.token) qs.access_token = this.options.token;
// We store the facebook token into the querystring
agent
.get(url)
.query(qs)
.end(function(e, r){
if(e) return fn(e);
try{
var j = JSON.parse(r.text);
}catch(e){
return fn(e);
};
fn(null, j);
});
//TODO: Remove Superagent
};
Client.prototype.query = function(q, fn){
var qs = { "q": typeof q === 'string'? q : JSON.stringify(q) };
// We store the FQL query in the querystring
// We get the response to the FQL query and standarize the format
this._getJson('https://graph.facebook.com/fql', qs, function(e, r){
if(e) return fn(e);
if(r.error) return fn(new Error('(#'+r.error.code+') '+r.error.type+': '+r.error.message));
var j = {}; typeof q !== 'string'?r.data.forEach(function(v){ j[v.name] = v.fql_result_set; }):j = r.data;
fn(null, j);
});
};
Client.prototype.user = function(q, fn){
var where = (+q?'uid':(q.length===27?'third_party_id':'username'))+'="'+q+'"';
// NOTE: Will fail in usernames with 27 characters but ¡oh, well, the life!
this.query('SELECT ' + select.user + ' FROM user WHERE ' + where, function(e, r){
if(e || !r.length) return fn(e);
fn(null, r[0]);
});
// NOTE:
// This is the equivalent of: SELECT * FORM user WHERE...
// BUT security_settings because is broken:
// https://developers.facebook.com/x/bugs/208059456059686/
// 30/01/2014
// You can read about the returned values here
// https://developers.facebook.com/docs/reference/fql/user/
};
Client.prototype.event = function(q, fn){
var where = +q?'eid="'+q+'" OR creator='+q+'':'user="'+q+'"';
this.query('SELECT ' + select.event + ' FROM event WHERE ' + where + ' LIMIT 500', function(e, r){
if(e || !r.length) return fn(e);
fn(null, r);
});
// TODO: Iterate over query to get all events
// NOTE:
// This is the equivalent of: SELECT * FORM event WHERE...
// BUT feed_targeting and creator_cursor because seems broken
// 31/01/2014
// You can read about the returned values here
// https://developers.facebook.com/docs/reference/fql/event/
};
Client.prototype.photo = function(q, fn){
var where = +q?'aid="'+q+'" OR object_id="'+q+'" OR owner="'+q+'"':'pid="'+q+'"';
this.query('SELECT ' + select.photo + ' FROM photo WHERE ' + where + ' LIMIT 500', function(e, r){
if(e || !r.length) return fn(e);
fn(null, r);
});
// TODO: Iterate over query to get all photos
// NOTE:
// This is the equivalent of: SELECT * FORM photo WHERE...
// BUT feed_targeting and creator_cursor because seems broken
// 31/01/2014
// You can read about the returned values here
// https://developers.facebook.com/docs/reference/fql/photo/
};
Client.prototype._video = function(q, fn){
return fn(new Error('Not implemented yet'));
// FIXME: Can't get public videos... I'm not tagged in anyone
var where = (+q?'owner':'vid')+'="'+q+'"';
// TODO: Check if vid is numeric
this.query('SELECT ' + select.video + ' FROM video WHERE ' + where, function(e, r){
if(e || !r.length) return fn(e);
fn(null, +q?r:r[0]);
});
// You can read about the returned values here
// https://developers.facebook.com/docs/reference/fql/video/
};
Client.prototype.pageFeedback = function(q, o, fn){
var client = this
,messages = [];
if(!fn){
fn = o;
o = {};
};
//TODO: Options about range of times
//FIXME: Clean this up
// We iterate over messages until we get a empty query
var query = function(t){
//NOTE: In testing never got more than ~400 comments so 500 seems a number as good as any other
client.query('SELECT actor_id, attachment, created_time, message, permalink, post_id, source_id, target_id FROM stream WHERE source_id IN (SELECT page_id FROM page WHERE username="'+q+'") AND created_time<'+t+' AND actor_id!=source_id LIMIT 500', function(e, r){
if(e || !r.length) return fn(e, messages);
messages = messages.concat(r);
query(Math.min.apply(this,r.map(function(v){return v.created_time;})));
});
};
query(Math.floor((new Date())/1000));
// More fields that could be in this query:
// https://developers.facebook.com/docs/reference/fql/stream/
// Thera are some very cool like tags id, places, action_links, share information, tags etc etc...
// NOTE A dozen FQL bugs should be resolved:
// https://developers.facebook.com/x/bugs/203565426458434/
// filter_key='others' doesnt work well too...
};
Client.prototype._page = function(q, fn){
return fn(new Error('Not implemented yet'));
this.query('SELECT can_post, name, username, pic, pic_crop, pic_small, pic_square,type,url FROM profile WHERE username="'+q+'"', function(e, r){
if(e || !r.length) return fn(e);
//TODO: Finish
//NOTE: Remember to get type and get most information
console.log(r);
});
};
Client.prototype._profile = function(q, fn){
//return fn(new Error('Not implemented yet'));
var client = this;
this.query('SELECT id FROM profile WHERE username="'+q+'"', function(e, r){
if(e || !r.length) return fn(e);
client._getJson('https://graph.facebook.com/'+r[0].id, fn);
//client[r.type](q,fn);
//TODO: Finish this method when user, page etc, etc... gets implemented
});
};
//TODO: Add Mocha tests
//TODO: Think about to remove empty retorned fields
|
/**
* This service creates a modal ,
* properties Of this modal can be set from the controller by injecting this service
*
*/
contactManagerApp.service('ModalService', ['$modal',
function ($modal) {
var modalDefaults = {
backdrop: true,
keyboard: true,
modalFade: true,
templateUrl: 'views/modal.html'
};
var modalOptions = {
closeButtonText: 'Close',
buttons: [{label:'OK'}],
headerText: 'Proceed?',
bodyText: 'Perform this action?'
};
this.showModal = function (customModalDefaults, customModalOptions) {
if (!customModalDefaults)
customModalDefaults = {};
customModalDefaults.backdrop = 'static';
return this.show(customModalDefaults, customModalOptions);
};
this.show = function (customModalDefaults, customModalOptions) {
var tempModalDefaults = {};
var tempModalOptions = {};
angular.extend(tempModalDefaults, modalDefaults, customModalDefaults);
angular.extend(tempModalOptions, modalOptions, customModalOptions);
if (!tempModalDefaults.controller) {
tempModalDefaults.controller = function ($scope, $modalInstance) {
$scope.modalOptions = tempModalOptions;
$scope.modalOptions.ok = function (result) {
$modalInstance.close(result);
if($scope.modalOptions.buttons[0].callBack)
$scope.modalOptions.buttons[0].callBack();
};
$scope.modalOptions.close = function (result) {
$modalInstance.dismiss('cancel');
if($scope.modalOptions.buttons[1].callBack)
$scope.modalOptions.buttons[1].callBack();
};
}
}
return $modal.open(tempModalDefaults).result;
};
}]);
|
module.exports = {
"key": "roggenrola",
"moves": [
{
"learn_type": "tutor",
"name": "earth-power"
},
{
"learn_type": "tutor",
"name": "block"
},
{
"learn_type": "tutor",
"name": "sleep-talk"
},
{
"learn_type": "tutor",
"name": "snore"
},
{
"learn_type": "machine",
"name": "bulldoze"
},
{
"learn_type": "machine",
"name": "round"
},
{
"learn_type": "egg move",
"name": "heavy-slam"
},
{
"learn_type": "level up",
"level": 23,
"name": "smack-down"
},
{
"learn_type": "egg move",
"name": "autotomize"
},
{
"learn_type": "level up",
"level": 30,
"name": "stealth-rock"
},
{
"learn_type": "level up",
"level": 36,
"name": "stone-edge"
},
{
"learn_type": "machine",
"name": "flash-cannon"
},
{
"learn_type": "machine",
"name": "rock-polish"
},
{
"learn_type": "egg move",
"name": "gravity"
},
{
"learn_type": "level up",
"level": 14,
"name": "rock-blast"
},
{
"learn_type": "level up",
"level": 20,
"name": "iron-defense"
},
{
"learn_type": "egg move",
"name": "rock-tomb"
},
{
"learn_type": "machine",
"name": "facade"
},
{
"learn_type": "machine",
"name": "rock-smash"
},
{
"learn_type": "machine",
"name": "hidden-power"
},
{
"learn_type": "egg move",
"name": "magnitude"
},
{
"learn_type": "machine",
"name": "frustration"
},
{
"learn_type": "machine",
"name": "return"
},
{
"learn_type": "machine",
"name": "attract"
},
{
"learn_type": "machine",
"name": "swagger"
},
{
"learn_type": "level up",
"level": 33,
"name": "sandstorm"
},
{
"learn_type": "egg move",
"name": "lock-on"
},
{
"learn_type": "level up",
"level": 17,
"name": "mud-slap"
},
{
"learn_type": "machine",
"name": "protect"
},
{
"learn_type": "egg move",
"name": "curse"
},
{
"learn_type": "machine",
"name": "substitute"
},
{
"learn_type": "level up",
"level": 27,
"name": "rock-slide"
},
{
"learn_type": "machine",
"name": "rest"
},
{
"learn_type": "level up",
"level": 40,
"name": "explosion"
},
{
"learn_type": "level up",
"level": 4,
"name": "harden"
},
{
"learn_type": "machine",
"name": "double-team"
},
{
"learn_type": "machine",
"name": "toxic"
},
{
"learn_type": "machine",
"name": "earthquake"
},
{
"learn_type": "machine",
"name": "strength"
},
{
"learn_type": "egg move",
"name": "take-down"
},
{
"learn_type": "level up",
"level": 1,
"name": "tackle"
},
{
"learn_type": "level up",
"level": 10,
"name": "headbutt"
},
{
"learn_type": "level up",
"level": 7,
"name": "sand-attack"
}
]
};
|
import {WidgetBase} from '../common/widget-base';
import {constants} from '../common/constants';
import {generateBindables} from '../common/decorators';
import {customAttribute, inject} from '../common/common';
@customAttribute(`${constants.attributePrefix}button`)
@generateBindables('ejButton', ['contentType', 'cssClass', 'enabled', 'enableRTL', 'height', 'htmlAttributes', 'imagePosition', 'prefixIcon', 'repeatButton', 'showRoundedCorner', 'size', 'suffixIcon', 'text', 'timeInterval', 'type', 'width'], [], {'enableRTL': ['enableRtl']})
@inject(Element)
export class ejButton extends WidgetBase {
constructor(element) {
super();
this.element = element;
}
}
|
/* graph generator */
module.exports = function(flow){
var content = [];
var nodeCount = flow.files.queue.length;
var edgeCount = 0;
// build graph file content
content.push('digraph graph {');
flow.files.queue.forEach(function(file){
var c = color(file);
if (c)
content.push(name(file) + c);
edgeCount += file.linkTo.length;
file.linkTo.forEach(function(linkTo){
content.push(name(file) + '->' + name(linkTo[0]));
});
});
content.push('}');
// remove all files
flow.result = content.join('\n');
};
module.exports.handlerName = 'Make input graph';
var noFilenameSeed = 0;
function name(file){
if (!file.filename)
{
if (!file.graphName)
file.graphName = file.sourceFilename || '[no filename ' + (noFilenameSeed++) + ']';
return '"' + file.graphName + '"';
}
return '"' + file.relpath + '"';
}
function color(file){
switch (file.type){
case 'html':
return ' [color="1 0 0"]';
case 'script':
return ' [color="0.7 0.8 0.9"]';
case 'style':
return ' [color="1 1 0.8"]';
case 'template':
return ' [color="0.7 1 0.7"]';
case 'l10n':
return ' [color="1 0.9 0.5"]';
case 'image':
return ' [color="0.6 0.9 1"]';
}
return '';
}
|
export default function clone (obj, parent) {
if (obj === null || typeof obj !== 'object') {
return obj;
}
let cloned = new obj.constructor();
for (let i in obj) {
if (!({}.hasOwnProperty.call(obj, i))) {
continue;
}
let value = obj[i];
if (i === 'parent' && typeof value === 'object') {
if (parent) {
cloned[i] = parent;
}
} else if (i === 'source') {
cloned[i] = value;
} else if (value instanceof Array) {
cloned[i] = value.map(j => clone(j, cloned));
} else {
cloned[i] = clone(value, cloned);
}
}
return cloned;
};
|
const Usuario = require('../usuario/Usuario.js')
const createUser = (oUser) => {
return new Promise((resolve, reject) => {
Usuario.create(oUser, function (err, oNewUser) {
if (err) {
reject({
mensage: err
})
} else {
resolve(oNewUser)
}
})
});
}
module.exports.createUser = createUser
|
/**
* Created by diegopc86 on 09/12/15.
*/
Router.route('user/:_id/follow', function () {
var _id = this.params._id;
Meteor.call('followUser', _id);
return this.redirect('/user/' + _id);
}, { name: 'user.follow' });
Router.route('user/:_id/unfollow', function () {
var _id = this.params._id;
Meteor.call('unfollowUser', _id);
return this.redirect('/user/' + _id);
}, { name: 'user.unfollow' });
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _index = require('../../format/index.js');
var _index2 = _interopRequireDefault(_index);
var _index3 = require('../_lib/convertToFP/index.js');
var _index4 = _interopRequireDefault(_index3);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
// This file is generated automatically by `scripts/build/fp.js`. Please, don't change it.
var format = (0, _index4.default)(_index2.default, 2);
exports.default = format;
module.exports = exports['default'];
|
import React from 'react';
import {mount} from 'enzyme';
import ReactDate from '../';
test('defaultValue', () => {
const onChange = jest.fn();
const onValid = jest.fn();
const onInvalid = jest.fn();
const el = mount(
<ReactDate
format="DD/MM/YYYY"
defaultValue="2017-04-18"
onChange={onChange}
onValid={onValid}
onInvalid={onInvalid}
/>
);
const input = el.find('input');
expect(input.props().value).toBe('18/04/2017');
// try changing to a different valid date
input.simulate('change', {target: {value: '10/04/2017'}});
expect(input.props().value).toBe('10/04/2017');
expect(onChange.mock.calls.length).toBe(1);
expect(onChange.mock.calls[0]).toEqual(
[{target: {value: '2017-04-10'}}],
);
// try changing to a different invalid date
input.simulate('change', {target: {value: 'not a date'}});
expect(input.props().value).toBe('not a date');
// onChange does not yet get called
expect(onChange.mock.calls.length).toBe(1);
expect(onValid.mock.calls.length).toBe(0);
expect(onInvalid.mock.calls.length).toBe(1);
});
// TODO: this needs a lot more test cases
|
module.exports = {
default : {
files : [
'<%= buildCfg.srcPath %>/js/**/*.js',
'<%= buildCfg.srcPath %>/stylesheets/**/*.{less,styl,sass,scss}'
],
tasks : ['default']
},
build : {
files : [
'<%= buildCfg.srcPath %>/js/**/*.js',
'<%= buildCfg.srcPath %>/stylesheets/**/*.{less,styl,sass,scss}'
],
tasks : ['build']
}
};
|
/*
* This file has been commented to support Visual Studio Intellisense.
* You should not use this file at runtime inside the browser--it is only
* intended to be used only for design-time IntelliSense. Please use the
* standard jQuery library for all production use.
*
* Comment version: 1.3.2b
*/
/*
* jQuery JavaScript Library v1.3.2
* http://jquery.com/
*
* Copyright (c) 2009 John Resig
*
* 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.
*
* Date: 2009-02-19 17:34:21 -0500 (Thu, 19 Feb 2009)
* Revision: 6246
*/
(function(){
var
// Will speed up references to window, and allows munging its name.
window = this,
// Will speed up references to undefined, and allows munging its name.
undefined,
// Map over jQuery in case of overwrite
_jQuery = window.jQuery,
// Map over the $ in case of overwrite
_$ = window.$,
jQuery = window.jQuery = window.$ = function(selector, context) {
/// <summary>
/// 1: $(expression, context) - This function accepts a string containing a CSS selector which is then used to match a set of elements.
/// 2: $(html) - Create DOM elements on-the-fly from the provided String of raw HTML.
/// 3: $(elements) - Wrap jQuery functionality around a single or multiple DOM Element(s).
/// 4: $(callback) - A shorthand for $(document).ready().
/// </summary>
/// <param name="selector" type="String">
/// 1: expression - An expression to search with.
/// 2: html - A string of HTML to create on the fly.
/// 3: elements - DOM element(s) to be encapsulated by a jQuery object.
/// 4: callback - The function to execute when the DOM is ready.
/// </param>
/// <param name="context" type="jQuery">
/// 1: context - A DOM Element, Document or jQuery to use as context.
/// </param>
/// <field name="selector" Type="Object">
/// The DOM node context originally passed to jQuery() (if none was passed then context will be equal to the document).
/// </field>
/// <field name="context" Type="String">
/// A selector representing selector originally passed to jQuery().
/// </field>
/// <returns type="jQuery" />
// The jQuery object is actually just the init constructor 'enhanced'
return new jQuery.fn.init( selector, context );
},
// A simple way to check for HTML strings or ID strings
// (both of which we optimize for)
quickExpr = /^[^<]*(<(.|\s)+>)[^>]*$|^#([\w-]+)$/,
// Is it a simple selector
isSimple = /^.[^:#\[\.,]*$/;
jQuery.fn = jQuery.prototype = {
init: function( selector, context ) {
/// <summary>
/// 1: $(expression, context) - This function accepts a string containing a CSS selector which is then used to match a set of elements.
/// 2: $(html) - Create DOM elements on-the-fly from the provided String of raw HTML.
/// 3: $(elements) - Wrap jQuery functionality around a single or multiple DOM Element(s).
/// 4: $(callback) - A shorthand for $(document).ready().
/// </summary>
/// <param name="selector" type="String">
/// 1: expression - An expression to search with.
/// 2: html - A string of HTML to create on the fly.
/// 3: elements - DOM element(s) to be encapsulated by a jQuery object.
/// 4: callback - The function to execute when the DOM is ready.
/// </param>
/// <param name="context" type="jQuery">
/// 1: context - A DOM Element, Document or jQuery to use as context.
/// </param>
/// <returns type="jQuery" />
// Make sure that a selection was provided
selector = selector || document;
// Handle $(DOMElement)
if ( selector.nodeType ) {
this[0] = selector;
this.length = 1;
this.context = selector;
return this;
}
// Handle HTML strings
if (typeof selector === "string") {
// Are we dealing with HTML string or an ID?
var match = quickExpr.exec(selector);
// Verify a match, and that no context was specified for #id
if (match && (match[1] || !context)) {
// HANDLE: $(html) -> $(array)
if (match[1])
selector = jQuery.clean([match[1]], context);
// HANDLE: $("#id")
else {
var elem = document.getElementById(match[3]);
// Handle the case where IE and Opera return items
// by name instead of ID
if (elem && elem.id != match[3])
return jQuery().find(selector);
// Otherwise, we inject the element directly into the jQuery object
var ret = jQuery(elem || []);
ret.context = document;
ret.selector = selector;
return ret;
}
// HANDLE: $(expr, [context])
// (which is just equivalent to: $(content).find(expr)
} else
return jQuery(context).find(selector);
// HANDLE: $(function)
// Shortcut for document ready
} else if ( jQuery.isFunction( selector ) )
return jQuery( document ).ready( selector );
// Make sure that old selector state is passed along
if ( selector.selector && selector.context ) {
this.selector = selector.selector;
this.context = selector.context;
}
return this.setArray(jQuery.isArray( selector ) ?
selector :
jQuery.makeArray(selector));
},
// Start with an empty selector
selector: "",
// The current version of jQuery being used
jquery: "1.3.2",
// The number of elements contained in the matched element set
size: function() {
/// <summary>
/// The number of elements currently matched.
/// Part of Core
/// </summary>
/// <returns type="Number" />
return this.length;
},
// Get the Nth element in the matched element set OR
// Get the whole matched element set as a clean array
get: function( num ) {
/// <summary>
/// Access a single matched element. num is used to access the
/// Nth element matched.
/// Part of Core
/// </summary>
/// <returns type="Element" />
/// <param name="num" type="Number">
/// Access the element in the Nth position.
/// </param>
return num == undefined ?
// Return a 'clean' array
Array.prototype.slice.call( this ) :
// Return just the object
this[ num ];
},
// Take an array of elements and push it onto the stack
// (returning the new matched element set)
pushStack: function( elems, name, selector ) {
/// <summary>
/// Set the jQuery object to an array of elements, while maintaining
/// the stack.
/// Part of Core
/// </summary>
/// <returns type="jQuery" />
/// <param name="elems" type="Elements">
/// An array of elements
/// </param>
// Build a new jQuery matched element set
var ret = jQuery( elems );
// Add the old object onto the stack (as a reference)
ret.prevObject = this;
ret.context = this.context;
if ( name === "find" )
ret.selector = this.selector + (this.selector ? " " : "") + selector;
else if ( name )
ret.selector = this.selector + "." + name + "(" + selector + ")";
// Return the newly-formed element set
return ret;
},
// Force the current matched set of elements to become
// the specified array of elements (destroying the stack in the process)
// You should use pushStack() in order to do this, but maintain the stack
setArray: function( elems ) {
/// <summary>
/// Set the jQuery object to an array of elements. This operation is
/// completely destructive - be sure to use .pushStack() if you wish to maintain
/// the jQuery stack.
/// Part of Core
/// </summary>
/// <returns type="jQuery" />
/// <param name="elems" type="Elements">
/// An array of elements
/// </param>
// Resetting the length to 0, then using the native Array push
// is a super-fast way to populate an object with array-like properties
this.length = 0;
Array.prototype.push.apply( this, elems );
return this;
},
// Execute a callback for every element in the matched set.
// (You can seed the arguments with an array of args, but this is
// only used internally.)
each: function( callback, args ) {
/// <summary>
/// Execute a function within the context of every matched element.
/// This means that every time the passed-in function is executed
/// (which is once for every element matched) the 'this' keyword
/// points to the specific element.
/// Additionally, the function, when executed, is passed a single
/// argument representing the position of the element in the matched
/// set.
/// Part of Core
/// </summary>
/// <returns type="jQuery" />
/// <param name="callback" type="Function">
/// A function to execute
/// </param>
return jQuery.each( this, callback, args );
},
// Determine the position of an element within
// the matched set of elements
index: function( elem ) {
/// <summary>
/// Searches every matched element for the object and returns
/// the index of the element, if found, starting with zero.
/// Returns -1 if the object wasn't found.
/// Part of Core
/// </summary>
/// <returns type="Number" />
/// <param name="elem" type="Element">
/// Object to search for
/// </param>
// Locate the position of the desired element
return jQuery.inArray(
// If it receives a jQuery object, the first element is used
elem && elem.jquery ? elem[0] : elem
, this );
},
attr: function( name, value, type ) {
/// <summary>
/// Set a single property to a computed value, on all matched elements.
/// Instead of a value, a function is provided, that computes the value.
/// Part of DOM/Attributes
/// </summary>
/// <returns type="jQuery" />
/// <param name="name" type="String">
/// The name of the property to set.
/// </param>
/// <param name="value" type="Function">
/// A function returning the value to set.
/// </param>
var options = name;
// Look for the case where we're accessing a style value
if ( typeof name === "string" )
if ( value === undefined )
return this[0] && jQuery[ type || "attr" ]( this[0], name );
else {
options = {};
options[ name ] = value;
}
// Check to see if we're setting style values
return this.each(function(i){
// Set all the styles
for ( name in options )
jQuery.attr(
type ?
this.style :
this,
name, jQuery.prop( this, options[ name ], type, i, name )
);
});
},
css: function( key, value ) {
/// <summary>
/// Set a single style property to a value, on all matched elements.
/// If a number is provided, it is automatically converted into a pixel value.
/// Part of CSS
/// </summary>
/// <returns type="jQuery" />
/// <param name="key" type="String">
/// The name of the property to set.
/// </param>
/// <param name="value" type="String">
/// The value to set the property to.
/// </param>
// ignore negative width and height values
if ( (key == 'width' || key == 'height') && parseFloat(value) < 0 )
value = undefined;
return this.attr( key, value, "curCSS" );
},
text: function( text ) {
/// <summary>
/// Set the text contents of all matched elements.
/// Similar to html(), but escapes HTML (replace "<" and ">" with their
/// HTML entities).
/// Part of DOM/Attributes
/// </summary>
/// <returns type="String" />
/// <param name="text" type="String">
/// The text value to set the contents of the element to.
/// </param>
if ( typeof text !== "object" && text != null )
return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
var ret = "";
jQuery.each( text || this, function(){
jQuery.each( this.childNodes, function(){
if ( this.nodeType != 8 )
ret += this.nodeType != 1 ?
this.nodeValue :
jQuery.fn.text( [ this ] );
});
});
return ret;
},
wrapAll: function( html ) {
/// <summary>
/// Wrap all matched elements with a structure of other elements.
/// This wrapping process is most useful for injecting additional
/// stucture into a document, without ruining the original semantic
/// qualities of a document.
/// This works by going through the first element
/// provided and finding the deepest ancestor element within its
/// structure - it is that element that will en-wrap everything else.
/// This does not work with elements that contain text. Any necessary text
/// must be added after the wrapping is done.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="html" type="Element">
/// A DOM element that will be wrapped around the target.
/// </param>
if ( this[0] ) {
// The elements to wrap the target around
var wrap = jQuery( html, this[0].ownerDocument ).clone();
if ( this[0].parentNode )
wrap.insertBefore( this[0] );
wrap.map(function(){
var elem = this;
while ( elem.firstChild )
elem = elem.firstChild;
return elem;
}).append(this);
}
return this;
},
wrapInner: function( html ) {
/// <summary>
/// Wraps the inner child contents of each matched elemenht (including text nodes) with an HTML structure.
/// </summary>
/// <param name="html" type="String">
/// A string of HTML or a DOM element that will be wrapped around the target contents.
/// </param>
/// <returns type="jQuery" />
return this.each(function(){
jQuery( this ).contents().wrapAll( html );
});
},
wrap: function( html ) {
/// <summary>
/// Wrap all matched elements with a structure of other elements.
/// This wrapping process is most useful for injecting additional
/// stucture into a document, without ruining the original semantic
/// qualities of a document.
/// This works by going through the first element
/// provided and finding the deepest ancestor element within its
/// structure - it is that element that will en-wrap everything else.
/// This does not work with elements that contain text. Any necessary text
/// must be added after the wrapping is done.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="html" type="Element">
/// A DOM element that will be wrapped around the target.
/// </param>
return this.each(function(){
jQuery( this ).wrapAll( html );
});
},
append: function() {
/// <summary>
/// Append content to the inside of every matched element.
/// This operation is similar to doing an appendChild to all the
/// specified elements, adding them into the document.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="content" type="Content">
/// Content to append to the target
/// </param>
return this.domManip(arguments, true, function(elem){
if (this.nodeType == 1)
this.appendChild( elem );
});
},
prepend: function() {
/// <summary>
/// Prepend content to the inside of every matched element.
/// This operation is the best way to insert elements
/// inside, at the beginning, of all matched elements.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="" type="Content">
/// Content to prepend to the target.
/// </param>
return this.domManip(arguments, true, function(elem){
if (this.nodeType == 1)
this.insertBefore( elem, this.firstChild );
});
},
before: function() {
/// <summary>
/// Insert content before each of the matched elements.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="" type="Content">
/// Content to insert before each target.
/// </param>
return this.domManip(arguments, false, function(elem){
this.parentNode.insertBefore( elem, this );
});
},
after: function() {
/// <summary>
/// Insert content after each of the matched elements.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="" type="Content">
/// Content to insert after each target.
/// </param>
return this.domManip(arguments, false, function(elem){
this.parentNode.insertBefore( elem, this.nextSibling );
});
},
end: function() {
/// <summary>
/// End the most recent 'destructive' operation, reverting the list of matched elements
/// back to its previous state. After an end operation, the list of matched elements will
/// revert to the last state of matched elements.
/// If there was no destructive operation before, an empty set is returned.
/// Part of DOM/Traversing
/// </summary>
/// <returns type="jQuery" />
return this.prevObject || jQuery( [] );
},
// For internal use only.
// Behaves like an Array's method, not like a jQuery method.
push: [].push,
sort: [].sort,
splice: [].splice,
find: function( selector ) {
/// <summary>
/// Searches for all elements that match the specified expression.
/// This method is a good way to find additional descendant
/// elements with which to process.
/// All searching is done using a jQuery expression. The expression can be
/// written using CSS 1-3 Selector syntax, or basic XPath.
/// Part of DOM/Traversing
/// </summary>
/// <returns type="jQuery" />
/// <param name="selector" type="String">
/// An expression to search with.
/// </param>
/// <returns type="jQuery" />
if ( this.length === 1 ) {
var ret = this.pushStack( [], "find", selector );
ret.length = 0;
jQuery.find( selector, this[0], ret );
return ret;
} else {
return this.pushStack( jQuery.unique(jQuery.map(this, function(elem){
return jQuery.find( selector, elem );
})), "find", selector );
}
},
clone: function( events ) {
/// <summary>
/// Clone matched DOM Elements and select the clones.
/// This is useful for moving copies of the elements to another
/// location in the DOM.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
/// <param name="deep" type="Boolean" optional="true">
/// (Optional) Set to false if you don't want to clone all descendant nodes, in addition to the element itself.
/// </param>
// Do the clone
var ret = this.map(function(){
if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
// IE copies events bound via attachEvent when
// using cloneNode. Calling detachEvent on the
// clone will also remove the events from the orignal
// In order to get around this, we use innerHTML.
// Unfortunately, this means some modifications to
// attributes in IE that are actually only stored
// as properties will not be copied (such as the
// the name attribute on an input).
var html = this.outerHTML;
if ( !html ) {
var div = this.ownerDocument.createElement("div");
div.appendChild( this.cloneNode(true) );
html = div.innerHTML;
}
return jQuery.clean([html.replace(/ jQuery\d+="(?:\d+|null)"/g, "").replace(/^\s*/, "")])[0];
} else
return this.cloneNode(true);
});
// Copy the events from the original to the clone
if ( events === true ) {
var orig = this.find("*").andSelf(), i = 0;
ret.find("*").andSelf().each(function(){
if ( this.nodeName !== orig[i].nodeName )
return;
var events = jQuery.data( orig[i], "events" );
for ( var type in events ) {
for ( var handler in events[ type ] ) {
jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
}
}
i++;
});
}
// Return the cloned set
return ret;
},
filter: function( selector ) {
/// <summary>
/// Removes all elements from the set of matched elements that do not
/// pass the specified filter. This method is used to narrow down
/// the results of a search.
/// })
/// Part of DOM/Traversing
/// </summary>
/// <returns type="jQuery" />
/// <param name="selector" type="Function">
/// A function to use for filtering
/// </param>
/// <returns type="jQuery" />
return this.pushStack(
jQuery.isFunction( selector ) &&
jQuery.grep(this, function(elem, i){
return selector.call( elem, i );
}) ||
jQuery.multiFilter( selector, jQuery.grep(this, function(elem){
return elem.nodeType === 1;
}) ), "filter", selector );
},
closest: function( selector ) {
/// <summary>
/// Get a set of elements containing the closest parent element that matches the specified selector, the starting element included.
/// </summary>
/// <returns type="jQuery" />
/// <param name="selector" type="Function">
/// An expression to filter the elements with.
/// </param>
/// <returns type="jQuery" />
var pos = jQuery.expr.match.POS.test( selector ) ? jQuery(selector) : null,
closer = 0;
return this.map(function(){
var cur = this;
while ( cur && cur.ownerDocument ) {
if ( pos ? pos.index(cur) > -1 : jQuery(cur).is(selector) ) {
jQuery.data(cur, "closest", closer);
return cur;
}
cur = cur.parentNode;
closer++;
}
});
},
not: function( selector ) {
/// <summary>
/// Removes any elements inside the array of elements from the set
/// of matched elements. This method is used to remove one or more
/// elements from a jQuery object.
/// Part of DOM/Traversing
/// </summary>
/// <param name="selector" type="jQuery">
/// A set of elements to remove from the jQuery set of matched elements.
/// </param>
/// <returns type="jQuery" />
if ( typeof selector === "string" )
// test special case where just one selector is passed in
if ( isSimple.test( selector ) )
return this.pushStack( jQuery.multiFilter( selector, this, true ), "not", selector );
else
selector = jQuery.multiFilter( selector, this );
var isArrayLike = selector.length && selector[selector.length - 1] !== undefined && !selector.nodeType;
return this.filter(function() {
return isArrayLike ? jQuery.inArray( this, selector ) < 0 : this != selector;
});
},
add: function( selector ) {
/// <summary>
/// Adds one or more Elements to the set of matched elements.
/// Part of DOM/Traversing
/// </summary>
/// <param name="elements" type="Element">
/// One or more Elements to add
/// </param>
/// <returns type="jQuery" />
return this.pushStack( jQuery.unique( jQuery.merge(
this.get(),
typeof selector === "string" ?
jQuery( selector ) :
jQuery.makeArray( selector )
)));
},
is: function( selector ) {
/// <summary>
/// Checks the current selection against an expression and returns true,
/// if at least one element of the selection fits the given expression.
/// Does return false, if no element fits or the expression is not valid.
/// filter(String) is used internally, therefore all rules that apply there
/// apply here, too.
/// Part of DOM/Traversing
/// </summary>
/// <returns type="Boolean" />
/// <param name="expr" type="String">
/// The expression with which to filter
/// </param>
return !!selector && jQuery.multiFilter( selector, this ).length > 0;
},
hasClass: function( selector ) {
/// <summary>
/// Checks the current selection against a class and returns whether at least one selection has a given class.
/// </summary>
/// <param name="selector" type="String">The class to check against</param>
/// <returns type="Boolean">True if at least one element in the selection has the class, otherwise false.</returns>
return !!selector && this.is( "." + selector );
},
val: function( value ) {
/// <summary>
/// Set the value of every matched element.
/// Part of DOM/Attributes
/// </summary>
/// <returns type="jQuery" />
/// <param name="val" type="String">
/// Set the property to the specified value.
/// </param>
if ( value === undefined ) {
var elem = this[0];
if ( elem ) {
if( jQuery.nodeName( elem, 'option' ) )
return (elem.attributes.value || {}).specified ? elem.value : elem.text;
// We need to handle select boxes special
if ( jQuery.nodeName( elem, "select" ) ) {
var index = elem.selectedIndex,
values = [],
options = elem.options,
one = elem.type == "select-one";
// Nothing was selected
if ( index < 0 )
return null;
// Loop through all the selected options
for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
var option = options[ i ];
if ( option.selected ) {
// Get the specifc value for the option
value = jQuery(option).val();
// We don't need an array for one selects
if ( one )
return value;
// Multi-Selects return an array
values.push( value );
}
}
return values;
}
// Everything else, we just grab the value
return (elem.value || "").replace(/\r/g, "");
}
return undefined;
}
if ( typeof value === "number" )
value += '';
return this.each(function(){
if ( this.nodeType != 1 )
return;
if ( jQuery.isArray(value) && /radio|checkbox/.test( this.type ) )
this.checked = (jQuery.inArray(this.value, value) >= 0 ||
jQuery.inArray(this.name, value) >= 0);
else if ( jQuery.nodeName( this, "select" ) ) {
var values = jQuery.makeArray(value);
jQuery( "option", this ).each(function(){
this.selected = (jQuery.inArray( this.value, values ) >= 0 ||
jQuery.inArray( this.text, values ) >= 0);
});
if ( !values.length )
this.selectedIndex = -1;
} else
this.value = value;
});
},
html: function( value ) {
/// <summary>
/// Set the html contents of every matched element.
/// This property is not available on XML documents.
/// Part of DOM/Attributes
/// </summary>
/// <returns type="jQuery" />
/// <param name="val" type="String">
/// Set the html contents to the specified value.
/// </param>
return value === undefined ?
(this[0] ?
this[0].innerHTML.replace(/ jQuery\d+="(?:\d+|null)"/g, "") :
null) :
this.empty().append( value );
},
replaceWith: function( value ) {
/// <summary>
/// Replaces all matched element with the specified HTML or DOM elements.
/// </summary>
/// <param name="value" type="String">
/// The content with which to replace the matched elements.
/// </param>
/// <returns type="jQuery">The element that was just replaced.</returns>
return this.after( value ).remove();
},
eq: function( i ) {
/// <summary>
/// Reduce the set of matched elements to a single element.
/// The position of the element in the set of matched elements
/// starts at 0 and goes to length - 1.
/// Part of Core
/// </summary>
/// <returns type="jQuery" />
/// <param name="num" type="Number">
/// pos The index of the element that you wish to limit to.
/// </param>
return this.slice( i, +i + 1 );
},
slice: function() {
/// <summary>
/// Selects a subset of the matched elements. Behaves exactly like the built-in Array slice method.
/// </summary>
/// <param name="start" type="Number" integer="true">Where to start the subset (0-based).</param>
/// <param name="end" optional="true" type="Number" integer="true">Where to end the subset (not including the end element itself).
/// If omitted, ends at the end of the selection</param>
/// <returns type="jQuery">The sliced elements</returns>
return this.pushStack( Array.prototype.slice.apply( this, arguments ),
"slice", Array.prototype.slice.call(arguments).join(",") );
},
map: function( callback ) {
/// <summary>
/// This member is internal.
/// </summary>
/// <private />
/// <returns type="jQuery" />
return this.pushStack( jQuery.map(this, function(elem, i){
return callback.call( elem, i, elem );
}));
},
andSelf: function() {
/// <summary>
/// Adds the previous selection to the current selection.
/// </summary>
/// <returns type="jQuery" />
return this.add( this.prevObject );
},
domManip: function( args, table, callback ) {
/// <param name="args" type="Array">
/// Args
/// </param>
/// <param name="table" type="Boolean">
/// Insert TBODY in TABLEs if one is not found.
/// </param>
/// <param name="dir" type="Number">
/// If dir<0, process args in reverse order.
/// </param>
/// <param name="fn" type="Function">
/// The function doing the DOM manipulation.
/// </param>
/// <returns type="jQuery" />
/// <summary>
/// Part of Core
/// </summary>
if ( this[0] ) {
var fragment = (this[0].ownerDocument || this[0]).createDocumentFragment(),
scripts = jQuery.clean( args, (this[0].ownerDocument || this[0]), fragment ),
first = fragment.firstChild;
if ( first )
for ( var i = 0, l = this.length; i < l; i++ )
callback.call( root(this[i], first), this.length > 1 || i > 0 ?
fragment.cloneNode(true) : fragment );
if ( scripts )
jQuery.each( scripts, evalScript );
}
return this;
function root( elem, cur ) {
return table && jQuery.nodeName(elem, "table") && jQuery.nodeName(cur, "tr") ?
(elem.getElementsByTagName("tbody")[0] ||
elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
elem;
}
}
};
// Give the init function the jQuery prototype for later instantiation
jQuery.fn.init.prototype = jQuery.fn;
function evalScript( i, elem ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
if ( elem.src )
jQuery.ajax({
url: elem.src,
async: false,
dataType: "script"
});
else
jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
if ( elem.parentNode )
elem.parentNode.removeChild( elem );
}
function now(){
/// <summary>
/// Gets the current date.
/// </summary>
/// <returns type="Date">The current date.</returns>
return +new Date;
}
jQuery.extend = jQuery.fn.extend = function() {
/// <summary>
/// Extend one object with one or more others, returning the original,
/// modified, object. This is a great utility for simple inheritance.
/// jQuery.extend(settings, options);
/// var settings = jQuery.extend({}, defaults, options);
/// Part of JavaScript
/// </summary>
/// <param name="target" type="Object">
/// The object to extend
/// </param>
/// <param name="prop1" type="Object">
/// The object that will be merged into the first.
/// </param>
/// <param name="propN" type="Object" optional="true" parameterArray="true">
/// (optional) More objects to merge into the first
/// </param>
/// <returns type="Object" />
// copy reference to target object
var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options;
// Handle a deep copy situation
if ( typeof target === "boolean" ) {
deep = target;
target = arguments[1] || {};
// skip the boolean and the target
i = 2;
}
// Handle case when target is a string or something (possible in deep copy)
if ( typeof target !== "object" && !jQuery.isFunction(target) )
target = {};
// extend jQuery itself if only one argument is passed
if ( length == i ) {
target = this;
--i;
}
for ( ; i < length; i++ )
// Only deal with non-null/undefined values
if ( (options = arguments[ i ]) != null )
// Extend the base object
for ( var name in options ) {
var src = target[ name ], copy = options[ name ];
// Prevent never-ending loop
if ( target === copy )
continue;
// Recurse if we're merging object values
if ( deep && copy && typeof copy === "object" && !copy.nodeType )
target[ name ] = jQuery.extend( deep,
// Never move original objects, clone them
src || ( copy.length != null ? [ ] : { } )
, copy );
// Don't bring in undefined values
else if ( copy !== undefined )
target[ name ] = copy;
}
// Return the modified object
return target;
};
// exclude the following css properties to add px
var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i,
// cache defaultView
defaultView = document.defaultView || {},
toString = Object.prototype.toString;
jQuery.extend({
noConflict: function( deep ) {
/// <summary>
/// Run this function to give control of the $ variable back
/// to whichever library first implemented it. This helps to make
/// sure that jQuery doesn't conflict with the $ object
/// of other libraries.
/// By using this function, you will only be able to access jQuery
/// using the 'jQuery' variable. For example, where you used to do
/// $("div p"), you now must do jQuery("div p").
/// Part of Core
/// </summary>
/// <returns type="undefined" />
window.$ = _$;
if ( deep )
window.jQuery = _jQuery;
return jQuery;
},
// See test/unit/core.js for details concerning isFunction.
// Since version 1.3, DOM methods and functions like alert
// aren't supported. They return false on IE (#2968).
isFunction: function( obj ) {
/// <summary>
/// Determines if the parameter passed is a function.
/// </summary>
/// <param name="obj" type="Object">The object to check</param>
/// <returns type="Boolean">True if the parameter is a function; otherwise false.</returns>
return toString.call(obj) === "[object Function]";
},
isArray: function(obj) {
/// <summary>
/// Determine if the parameter passed is an array.
/// </summary>
/// <param name="obj" type="Object">Object to test whether or not it is an array.</param>
/// <returns type="Boolean">True if the parameter is a function; otherwise false.</returns>
return toString.call(obj) === "[object Array]";
},
// check if an element is in a (or is an) XML document
isXMLDoc: function( elem ) {
/// <summary>
/// Determines if the parameter passed is an XML document.
/// </summary>
/// <param name="elem" type="Object">The object to test</param>
/// <returns type="Boolean">True if the parameter is an XML document; otherwise false.</returns>
return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
!!elem.ownerDocument && jQuery.isXMLDoc(elem.ownerDocument);
},
// Evalulates a script in a global context
globalEval: function( data ) {
/// <summary>
/// Internally evaluates a script in a global context.
/// </summary>
/// <private />
if ( data && /\S/.test(data) ) {
// Inspired by code by Andrea Giammarchi
// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
var head = document.getElementsByTagName("head")[0] || document.documentElement,
script = document.createElement("script");
script.type = "text/javascript";
if ( jQuery.support.scriptEval )
script.appendChild( document.createTextNode( data ) );
else
script.text = data;
// Use insertBefore instead of appendChild to circumvent an IE6 bug.
// This arises when a base node is used (#2709).
head.insertBefore( script, head.firstChild );
head.removeChild( script );
}
},
nodeName: function( elem, name ) {
/// <summary>
/// Checks whether the specified element has the specified DOM node name.
/// </summary>
/// <param name="elem" type="Element">The element to examine</param>
/// <param name="name" type="String">The node name to check</param>
/// <returns type="Boolean">True if the specified node name matches the node's DOM node name; otherwise false</returns>
return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();
},
// args is for internal usage only
each: function( object, callback, args ) {
/// <summary>
/// A generic iterator function, which can be used to seemlessly
/// iterate over both objects and arrays. This function is not the same
/// as $().each() - which is used to iterate, exclusively, over a jQuery
/// object. This function can be used to iterate over anything.
/// The callback has two arguments:the key (objects) or index (arrays) as first
/// the first, and the value as the second.
/// Part of JavaScript
/// </summary>
/// <param name="obj" type="Object">
/// The object, or array, to iterate over.
/// </param>
/// <param name="fn" type="Function">
/// The function that will be executed on every object.
/// </param>
/// <returns type="Object" />
var name, i = 0, length = object.length;
if ( args ) {
if ( length === undefined ) {
for ( name in object )
if ( callback.apply( object[ name ], args ) === false )
break;
} else
for ( ; i < length; )
if ( callback.apply( object[ i++ ], args ) === false )
break;
// A special, fast, case for the most common use of each
} else {
if ( length === undefined ) {
for ( name in object )
if ( callback.call( object[ name ], name, object[ name ] ) === false )
break;
} else
for ( var value = object[0];
i < length && callback.call( value, i, value ) !== false; value = object[++i] ){}
}
return object;
},
prop: function( elem, value, type, i, name ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// This member is not documented within the jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.prop
// Handle executable functions
if ( jQuery.isFunction( value ) )
value = value.call( elem, i );
// Handle passing in a number to a CSS property
return typeof value === "number" && type == "curCSS" && !exclude.test( name ) ?
value + "px" :
value;
},
className: {
// internal only, use addClass("class")
add: function( elem, classNames ) {
/// <summary>
/// Internal use only; use addClass('class')
/// </summary>
/// <private />
jQuery.each((classNames || "").split(/\s+/), function(i, className){
if ( elem.nodeType == 1 && !jQuery.className.has( elem.className, className ) )
elem.className += (elem.className ? " " : "") + className;
});
},
// internal only, use removeClass("class")
remove: function( elem, classNames ) {
/// <summary>
/// Internal use only; use removeClass('class')
/// </summary>
/// <private />
if (elem.nodeType == 1)
elem.className = classNames !== undefined ?
jQuery.grep(elem.className.split(/\s+/), function(className){
return !jQuery.className.has( classNames, className );
}).join(" ") :
"";
},
// internal only, use hasClass("class")
has: function( elem, className ) {
/// <summary>
/// Internal use only; use hasClass('class')
/// </summary>
/// <private />
return elem && jQuery.inArray(className, (elem.className || elem).toString().split(/\s+/)) > -1;
}
},
// A method for quickly swapping in/out CSS properties to get correct calculations
swap: function( elem, options, callback ) {
/// <summary>
/// Swap in/out style options.
/// </summary>
var old = {};
// Remember the old values, and insert the new ones
for ( var name in options ) {
old[ name ] = elem.style[ name ];
elem.style[ name ] = options[ name ];
}
callback.call( elem );
// Revert the old values
for ( var name in options )
elem.style[ name ] = old[ name ];
},
css: function( elem, name, force, extra ) {
/// <summary>
/// This method is internal only.
/// </summary>
/// <private />
// This method is undocumented in jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.css
if ( name == "width" || name == "height" ) {
var val, props = { position: "absolute", visibility: "hidden", display:"block" }, which = name == "width" ? [ "Left", "Right" ] : [ "Top", "Bottom" ];
function getWH() {
val = name == "width" ? elem.offsetWidth : elem.offsetHeight;
if ( extra === "border" )
return;
jQuery.each( which, function() {
if ( !extra )
val -= parseFloat(jQuery.curCSS( elem, "padding" + this, true)) || 0;
if ( extra === "margin" )
val += parseFloat(jQuery.curCSS( elem, "margin" + this, true)) || 0;
else
val -= parseFloat(jQuery.curCSS( elem, "border" + this + "Width", true)) || 0;
});
}
if ( elem.offsetWidth !== 0 )
getWH();
else
jQuery.swap( elem, props, getWH );
return Math.max(0, Math.round(val));
}
return jQuery.curCSS( elem, name, force );
},
curCSS: function( elem, name, force ) {
/// <summary>
/// This method is internal only.
/// </summary>
/// <private />
// This method is undocumented in jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.curCSS
var ret, style = elem.style;
// We need to handle opacity special in IE
if ( name == "opacity" && !jQuery.support.opacity ) {
ret = jQuery.attr( style, "opacity" );
return ret == "" ?
"1" :
ret;
}
// Make sure we're using the right name for getting the float value
if ( name.match( /float/i ) )
name = styleFloat;
if ( !force && style && style[ name ] )
ret = style[ name ];
else if ( defaultView.getComputedStyle ) {
// Only "float" is needed here
if ( name.match( /float/i ) )
name = "float";
name = name.replace( /([A-Z])/g, "-$1" ).toLowerCase();
var computedStyle = defaultView.getComputedStyle( elem, null );
if ( computedStyle )
ret = computedStyle.getPropertyValue( name );
// We should always get a number back from opacity
if ( name == "opacity" && ret == "" )
ret = "1";
} else if ( elem.currentStyle ) {
var camelCase = name.replace(/\-(\w)/g, function(all, letter){
return letter.toUpperCase();
});
ret = elem.currentStyle[ name ] || elem.currentStyle[ camelCase ];
// From the awesome hack by Dean Edwards
// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
// If we're not dealing with a regular pixel number
// but a number that has a weird ending, we need to convert it to pixels
if ( !/^\d+(px)?$/i.test( ret ) && /^\d/.test( ret ) ) {
// Remember the original values
var left = style.left, rsLeft = elem.runtimeStyle.left;
// Put in the new values to get a computed value out
elem.runtimeStyle.left = elem.currentStyle.left;
style.left = ret || 0;
ret = style.pixelLeft + "px";
// Revert the changed values
style.left = left;
elem.runtimeStyle.left = rsLeft;
}
}
return ret;
},
clean: function( elems, context, fragment ) {
/// <summary>
/// This method is internal only.
/// </summary>
/// <private />
// This method is undocumented in the jQuery API: http://docs.jquery.com/action/edit/Internals/jQuery.clean
context = context || document;
// !context.createElement fails in IE with an error but returns typeof 'object'
if ( typeof context.createElement === "undefined" )
context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
// If a single string is passed in and it's a single tag
// just do a createElement and skip the rest
if ( !fragment && elems.length === 1 && typeof elems[0] === "string" ) {
var match = /^<(\w+)\s*\/?>$/.exec(elems[0]);
if ( match )
return [ context.createElement( match[1] ) ];
}
var ret = [], scripts = [], div = context.createElement("div");
jQuery.each(elems, function(i, elem){
if ( typeof elem === "number" )
elem += '';
if ( !elem )
return;
// Convert html string into DOM nodes
if ( typeof elem === "string" ) {
// Fix "XHTML"-style tags in all browsers
elem = elem.replace(/(<(\w+)[^>]*?)\/>/g, function(all, front, tag){
return tag.match(/^(abbr|br|col|img|input|link|meta|param|hr|area|embed)$/i) ?
all :
front + "></" + tag + ">";
});
// Trim whitespace, otherwise indexOf won't work as expected
var tags = elem.replace(/^\s+/, "").substring(0, 10).toLowerCase();
var wrap =
// option or optgroup
!tags.indexOf("<opt") &&
[ 1, "<select multiple='multiple'>", "</select>" ] ||
!tags.indexOf("<leg") &&
[ 1, "<fieldset>", "</fieldset>" ] ||
tags.match(/^<(thead|tbody|tfoot|colg|cap)/) &&
[ 1, "<table>", "</table>" ] ||
!tags.indexOf("<tr") &&
[ 2, "<table><tbody>", "</tbody></table>" ] ||
// <thead> matched above
(!tags.indexOf("<td") || !tags.indexOf("<th")) &&
[ 3, "<table><tbody><tr>", "</tr></tbody></table>" ] ||
!tags.indexOf("<col") &&
[ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ] ||
// IE can't serialize <link> and <script> tags normally
!jQuery.support.htmlSerialize &&
[ 1, "div<div>", "</div>" ] ||
[ 0, "", "" ];
// Go to html and back, then peel off extra wrappers
div.innerHTML = wrap[1] + elem + wrap[2];
// Move to the right depth
while ( wrap[0]-- )
div = div.lastChild;
// Remove IE's autoinserted <tbody> from table fragments
if ( !jQuery.support.tbody ) {
// String was a <table>, *may* have spurious <tbody>
var hasBody = /<tbody/i.test(elem),
tbody = !tags.indexOf("<table") && !hasBody ?
div.firstChild && div.firstChild.childNodes :
// String was a bare <thead> or <tfoot>
wrap[1] == "<table>" && !hasBody ?
div.childNodes :
[];
for ( var j = tbody.length - 1; j >= 0 ; --j )
if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length )
tbody[ j ].parentNode.removeChild( tbody[ j ] );
}
// IE completely kills leading whitespace when innerHTML is used
if ( !jQuery.support.leadingWhitespace && /^\s/.test( elem ) )
div.insertBefore( context.createTextNode( elem.match(/^\s*/)[0] ), div.firstChild );
elem = jQuery.makeArray( div.childNodes );
}
if ( elem.nodeType )
ret.push( elem );
else
ret = jQuery.merge( ret, elem );
});
if ( fragment ) {
for ( var i = 0; ret[i]; i++ ) {
if ( jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
} else {
if ( ret[i].nodeType === 1 )
ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
fragment.appendChild( ret[i] );
}
}
return scripts;
}
return ret;
},
attr: function( elem, name, value ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// don't set attributes on text and comment nodes
if (!elem || elem.nodeType == 3 || elem.nodeType == 8)
return undefined;
var notxml = !jQuery.isXMLDoc( elem ),
// Whether we are setting (or getting)
set = value !== undefined;
// Try to normalize/fix the name
name = notxml && jQuery.props[ name ] || name;
// Only do all the following if this is a node (faster for style)
// IE elem.getAttribute passes even for style
if ( elem.tagName ) {
// These attributes require special treatment
var special = /href|src|style/.test( name );
// Safari mis-reports the default selected property of a hidden option
// Accessing the parent's selectedIndex property fixes it
if ( name == "selected" && elem.parentNode )
elem.parentNode.selectedIndex;
// If applicable, access the attribute via the DOM 0 way
if ( name in elem && notxml && !special ) {
if ( set ){
// We can't allow the type property to be changed (since it causes problems in IE)
if ( name == "type" && jQuery.nodeName( elem, "input" ) && elem.parentNode )
throw "type property can't be changed";
elem[ name ] = value;
}
// browsers index elements by id/name on forms, give priority to attributes.
if( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) )
return elem.getAttributeNode( name ).nodeValue;
// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
if ( name == "tabIndex" ) {
var attributeNode = elem.getAttributeNode( "tabIndex" );
return attributeNode && attributeNode.specified
? attributeNode.value
: elem.nodeName.match(/(button|input|object|select|textarea)/i)
? 0
: elem.nodeName.match(/^(a|area)$/i) && elem.href
? 0
: undefined;
}
return elem[ name ];
}
if ( !jQuery.support.style && notxml && name == "style" )
return jQuery.attr( elem.style, "cssText", value );
if ( set )
// convert the value to a string (all browsers do this but IE) see #1070
elem.setAttribute( name, "" + value );
var attr = !jQuery.support.hrefNormalized && notxml && special
// Some attributes require a special call on IE
? elem.getAttribute( name, 2 )
: elem.getAttribute( name );
// Non-existent attributes return null, we normalize to undefined
return attr === null ? undefined : attr;
}
// elem is actually elem.style ... set the style
// IE uses filters for opacity
if ( !jQuery.support.opacity && name == "opacity" ) {
if ( set ) {
// IE has trouble with opacity if it does not have layout
// Force it by setting the zoom level
elem.zoom = 1;
// Set the alpha filter to set the opacity
elem.filter = (elem.filter || "").replace( /alpha\([^)]*\)/, "" ) +
(parseInt( value ) + '' == "NaN" ? "" : "alpha(opacity=" + value * 100 + ")");
}
return elem.filter && elem.filter.indexOf("opacity=") >= 0 ?
(parseFloat( elem.filter.match(/opacity=([^)]*)/)[1] ) / 100) + '':
"";
}
name = name.replace(/-([a-z])/ig, function(all, letter){
return letter.toUpperCase();
});
if ( set )
elem[ name ] = value;
return elem[ name ];
},
trim: function( text ) {
/// <summary>
/// Remove the whitespace from the beginning and end of a string.
/// Part of JavaScript
/// </summary>
/// <returns type="String" />
/// <param name="text" type="String">
/// The string to trim.
/// </param>
return (text || "").replace( /^\s+|\s+$/g, "" );
},
makeArray: function( array ) {
/// <summary>
/// Turns anything into a true array. This is an internal method.
/// </summary>
/// <param name="array" type="Object">Anything to turn into an actual Array</param>
/// <returns type="Array" />
/// <private />
var ret = [];
if( array != null ){
var i = array.length;
// The window, strings (and functions) also have 'length'
if( i == null || typeof array === "string" || jQuery.isFunction(array) || array.setInterval )
ret[0] = array;
else
while( i )
ret[--i] = array[i];
}
return ret;
},
inArray: function( elem, array ) {
/// <summary>
/// Determines the index of the first parameter in the array.
/// </summary>
/// <param name="elem">The value to see if it exists in the array.</param>
/// <param name="array" type="Array">The array to look through for the value</param>
/// <returns type="Number" integer="true">The 0-based index of the item if it was found, otherwise -1.</returns>
for ( var i = 0, length = array.length; i < length; i++ )
// Use === because on IE, window == document
if ( array[ i ] === elem )
return i;
return -1;
},
merge: function( first, second ) {
/// <summary>
/// Merge two arrays together, removing all duplicates.
/// The new array is: All the results from the first array, followed
/// by the unique results from the second array.
/// Part of JavaScript
/// </summary>
/// <returns type="Array" />
/// <param name="first" type="Array">
/// The first array to merge.
/// </param>
/// <param name="second" type="Array">
/// The second array to merge.
/// </param>
// We have to loop this way because IE & Opera overwrite the length
// expando of getElementsByTagName
var i = 0, elem, pos = first.length;
// Also, we need to make sure that the correct elements are being returned
// (IE returns comment nodes in a '*' query)
if ( !jQuery.support.getAll ) {
while ( (elem = second[ i++ ]) != null )
if ( elem.nodeType != 8 )
first[ pos++ ] = elem;
} else
while ( (elem = second[ i++ ]) != null )
first[ pos++ ] = elem;
return first;
},
unique: function( array ) {
/// <summary>
/// Removes all duplicate elements from an array of elements.
/// </summary>
/// <param name="array" type="Array<Element>">The array to translate</param>
/// <returns type="Array<Element>">The array after translation.</returns>
var ret = [], done = {};
try {
for ( var i = 0, length = array.length; i < length; i++ ) {
var id = jQuery.data( array[ i ] );
if ( !done[ id ] ) {
done[ id ] = true;
ret.push( array[ i ] );
}
}
} catch( e ) {
ret = array;
}
return ret;
},
grep: function( elems, callback, inv ) {
/// <summary>
/// Filter items out of an array, by using a filter function.
/// The specified function will be passed two arguments: The
/// current array item and the index of the item in the array. The
/// function must return 'true' to keep the item in the array,
/// false to remove it.
/// });
/// Part of JavaScript
/// </summary>
/// <returns type="Array" />
/// <param name="elems" type="Array">
/// array The Array to find items in.
/// </param>
/// <param name="fn" type="Function">
/// The function to process each item against.
/// </param>
/// <param name="inv" type="Boolean">
/// Invert the selection - select the opposite of the function.
/// </param>
var ret = [];
// Go through the array, only saving the items
// that pass the validator function
for ( var i = 0, length = elems.length; i < length; i++ )
if ( !inv != !callback( elems[ i ], i ) )
ret.push( elems[ i ] );
return ret;
},
map: function( elems, callback ) {
/// <summary>
/// Translate all items in an array to another array of items.
/// The translation function that is provided to this method is
/// called for each item in the array and is passed one argument:
/// The item to be translated.
/// The function can then return the translated value, 'null'
/// (to remove the item), or an array of values - which will
/// be flattened into the full array.
/// Part of JavaScript
/// </summary>
/// <returns type="Array" />
/// <param name="elems" type="Array">
/// array The Array to translate.
/// </param>
/// <param name="fn" type="Function">
/// The function to process each item against.
/// </param>
var ret = [];
// Go through the array, translating each of the items to their
// new value (or values).
for ( var i = 0, length = elems.length; i < length; i++ ) {
var value = callback( elems[ i ], i );
if ( value != null )
ret[ ret.length ] = value;
}
return ret.concat.apply( [], ret );
}
});
// Use of jQuery.browser is deprecated.
// It's included for backwards compatibility and plugins,
// although they should work to migrate away.
var userAgent = navigator.userAgent.toLowerCase();
// Figure out what browser is being used
jQuery.browser = {
version: (userAgent.match( /.+(?:rv|it|ra|ie)[\/: ]([\d.]+)/ ) || [0,'0'])[1],
safari: /webkit/.test( userAgent ),
opera: /opera/.test( userAgent ),
msie: /msie/.test( userAgent ) && !/opera/.test( userAgent ),
mozilla: /mozilla/.test( userAgent ) && !/(compatible|webkit)/.test( userAgent )
};
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// jQuery.each({
// parent: function(elem){return elem.parentNode;},
// parents: function(elem){return jQuery.dir(elem,"parentNode");},
// next: function(elem){return jQuery.nth(elem,2,"nextSibling");},
// prev: function(elem){return jQuery.nth(elem,2,"previousSibling");},
// nextAll: function(elem){return jQuery.dir(elem,"nextSibling");},
// prevAll: function(elem){return jQuery.dir(elem,"previousSibling");},
// siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);},
// children: function(elem){return jQuery.sibling(elem.firstChild);},
// contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
// }, function(name, fn){
// jQuery.fn[ name ] = function( selector ) {
// /// <summary>
// /// Get a set of elements containing the unique parents of the matched
// /// set of elements.
// /// Can be filtered with an optional expressions.
// /// Part of DOM/Traversing
// /// </summary>
// /// <param name="expr" type="String" optional="true">
// /// (optional) An expression to filter the parents with
// /// </param>
// /// <returns type="jQuery" />
//
// var ret = jQuery.map( this, fn );
//
// if ( selector && typeof selector == "string" )
// ret = jQuery.multiFilter( selector, ret );
//
// return this.pushStack( jQuery.unique( ret ), name, selector );
// };
// });
jQuery.each({
parent: function(elem){return elem.parentNode;}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// Get a set of elements containing the unique parents of the matched
/// set of elements.
/// Can be filtered with an optional expressions.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the parents with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
parents: function(elem){return jQuery.dir(elem,"parentNode");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// Get a set of elements containing the unique ancestors of the matched
/// set of elements (except for the root element).
/// Can be filtered with an optional expressions.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the ancestors with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
next: function(elem){return jQuery.nth(elem,2,"nextSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// Get a set of elements containing the unique next siblings of each of the
/// matched set of elements.
/// It only returns the very next sibling, not all next siblings.
/// Can be filtered with an optional expressions.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the next Elements with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
prev: function(elem){return jQuery.nth(elem,2,"previousSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// Get a set of elements containing the unique previous siblings of each of the
/// matched set of elements.
/// Can be filtered with an optional expressions.
/// It only returns the immediately previous sibling, not all previous siblings.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the previous Elements with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
nextAll: function(elem){return jQuery.dir(elem,"nextSibling");}
}, function(name, fn){
jQuery.fn[name] = function(selector) {
/// <summary>
/// Finds all sibling elements after the current element.
/// Can be filtered with an optional expressions.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the next Elements with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
prevAll: function(elem){return jQuery.dir(elem,"previousSibling");}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// Finds all sibling elements before the current element.
/// Can be filtered with an optional expressions.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the previous Elements with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
siblings: function(elem){return jQuery.sibling(elem.parentNode.firstChild,elem);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// Get a set of elements containing all of the unique siblings of each of the
/// matched set of elements.
/// Can be filtered with an optional expressions.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the sibling Elements with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
children: function(elem){return jQuery.sibling(elem.firstChild);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>
/// Get a set of elements containing all of the unique children of each of the
/// matched set of elements.
/// Can be filtered with an optional expressions.
/// Part of DOM/Traversing
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) An expression to filter the child Elements with
/// </param>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
jQuery.each({
contents: function(elem){return jQuery.nodeName(elem,"iframe")?elem.contentDocument||elem.contentWindow.document:jQuery.makeArray(elem.childNodes);}
}, function(name, fn){
jQuery.fn[ name ] = function( selector ) {
/// <summary>Finds all the child nodes inside the matched elements including text nodes, or the content document if the element is an iframe.</summary>
/// <returns type="jQuery" />
var ret = jQuery.map( this, fn );
if ( selector && typeof selector == "string" )
ret = jQuery.multiFilter( selector, ret );
return this.pushStack( jQuery.unique( ret ), name, selector );
};
});
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// jQuery.each({
// appendTo: "append",
// prependTo: "prepend",
// insertBefore: "before",
// insertAfter: "after",
// replaceAll: "replaceWith"
// }, function(name, original){
// jQuery.fn[ name ] = function() {
// var args = arguments;
//
// return this.each(function(){
// for ( var i = 0, length = args.length; i < length; i++ )
// jQuery( args[ i ] )[ original ]( this );
// });
// };
// });
jQuery.fn.appendTo = function( selector ) {
/// <summary>
/// Append all of the matched elements to another, specified, set of elements.
/// As of jQuery 1.3.2, returns all of the inserted elements.
/// This operation is, essentially, the reverse of doing a regular
/// $(A).append(B), in that instead of appending B to A, you're appending
/// A to B.
/// </summary>
/// <param name="selector" type="Selector">
/// target to which the content will be appended.
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "append" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "appendTo", selector );
};
jQuery.fn.prependTo = function( selector ) {
/// <summary>
/// Prepend all of the matched elements to another, specified, set of elements.
/// As of jQuery 1.3.2, returns all of the inserted elements.
/// This operation is, essentially, the reverse of doing a regular
/// $(A).prepend(B), in that instead of prepending B to A, you're prepending
/// A to B.
/// </summary>
/// <param name="selector" type="Selector">
/// target to which the content will be appended.
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "prepend" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "prependTo", selector );
};
jQuery.fn.insertBefore = function( selector ) {
/// <summary>
/// Insert all of the matched elements before another, specified, set of elements.
/// As of jQuery 1.3.2, returns all of the inserted elements.
/// This operation is, essentially, the reverse of doing a regular
/// $(A).before(B), in that instead of inserting B before A, you're inserting
/// A before B.
/// </summary>
/// <param name="content" type="String">
/// Content after which the selected element(s) is inserted.
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "before" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "insertBefore", selector );
};
jQuery.fn.insertAfter = function( selector ) {
/// <summary>
/// Insert all of the matched elements after another, specified, set of elements.
/// As of jQuery 1.3.2, returns all of the inserted elements.
/// This operation is, essentially, the reverse of doing a regular
/// $(A).after(B), in that instead of inserting B after A, you're inserting
/// A after B.
/// </summary>
/// <param name="content" type="String">
/// Content after which the selected element(s) is inserted.
/// </param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "after" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "insertAfter", selector );
};
jQuery.fn.replaceAll = function( selector ) {
/// <summary>
/// Replaces the elements matched by the specified selector with the matched elements.
/// As of jQuery 1.3.2, returns all of the inserted elements.
/// </summary>
/// <param name="selector" type="Selector">The elements to find and replace the matched elements with.</param>
/// <returns type="jQuery" />
var ret = [], insert = jQuery( selector );
for ( var i = 0, l = insert.length; i < l; i++ ) {
var elems = (i > 0 ? this.clone(true) : this).get();
jQuery.fn[ "replaceWith" ].apply( jQuery(insert[i]), elems );
ret = ret.concat( elems );
}
return this.pushStack( ret, "replaceAll", selector );
};
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// jQuery.each({
// removeAttr: function( name ) {
// jQuery.attr( this, name, "" );
// if (this.nodeType == 1)
// this.removeAttribute( name );
// },
//
// addClass: function( classNames ) {
// jQuery.className.add( this, classNames );
// },
//
// removeClass: function( classNames ) {
// jQuery.className.remove( this, classNames );
// },
//
// toggleClass: function( classNames, state ) {
// if( typeof state !== "boolean" )
// state = !jQuery.className.has( this, classNames );
// jQuery.className[ state ? "add" : "remove" ]( this, classNames );
// },
//
// remove: function( selector ) {
// if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
// // Prevent memory leaks
// jQuery( "*", this ).add([this]).each(function(){
// jQuery.event.remove(this);
// jQuery.removeData(this);
// });
// if (this.parentNode)
// this.parentNode.removeChild( this );
// }
// },
//
// empty: function() {
// // Remove element nodes and prevent memory leaks
// jQuery( ">*", this ).remove();
//
// // Remove any remaining nodes
// while ( this.firstChild )
// this.removeChild( this.firstChild );
// }
// }, function(name, fn){
// jQuery.fn[ name ] = function(){
// return this.each( fn, arguments );
// };
// });
jQuery.fn.removeAttr = function(){
/// <summary>
/// Remove an attribute from each of the matched elements.
/// Part of DOM/Attributes
/// </summary>
/// <param name="key" type="String">
/// name The name of the attribute to remove.
/// </param>
/// <returns type="jQuery" />
return this.each( function( name ) {
jQuery.attr( this, name, "" );
if (this.nodeType == 1)
this.removeAttribute( name );
}, arguments );
};
jQuery.fn.addClass = function(){
/// <summary>
/// Adds the specified class(es) to each of the set of matched elements.
/// Part of DOM/Attributes
/// </summary>
/// <param name="classNames" type="String">
/// lass One or more CSS classes to add to the elements
/// </param>
/// <returns type="jQuery" />
return this.each( function( classNames ) {
jQuery.className.add( this, classNames );
}, arguments );
};
jQuery.fn.removeClass = function(){
/// <summary>
/// Removes all or the specified class(es) from the set of matched elements.
/// Part of DOM/Attributes
/// </summary>
/// <param name="cssClasses" type="String" optional="true">
/// (Optional) One or more CSS classes to remove from the elements
/// </param>
/// <returns type="jQuery" />
return this.each( function( classNames ) {
jQuery.className.remove( this, classNames );
}, arguments );
};
jQuery.fn.toggleClass = function(){
/// <summary>
/// Adds the specified class if it is not present, removes it if it is
/// present.
/// Part of DOM/Attributes
/// </summary>
/// <param name="cssClass" type="String">
/// A CSS class with which to toggle the elements
/// </param>
/// <returns type="jQuery" />
return this.each( function( classNames, state ) {
if( typeof state !== "boolean" )
state = !jQuery.className.has( this, classNames );
jQuery.className[ state ? "add" : "remove" ]( this, classNames );
}, arguments );
};
jQuery.fn.remove = function(){
/// <summary>
/// Removes all matched elements from the DOM. This does NOT remove them from the
/// jQuery object, allowing you to use the matched elements further.
/// Can be filtered with an optional expressions.
/// Part of DOM/Manipulation
/// </summary>
/// <param name="expr" type="String" optional="true">
/// (optional) A jQuery expression to filter elements by.
/// </param>
/// <returns type="jQuery" />
return this.each( function( selector ) {
if ( !selector || jQuery.filter( selector, [ this ] ).length ) {
// Prevent memory leaks
jQuery( "*", this ).add([this]).each(function(){
jQuery.event.remove(this);
jQuery.removeData(this);
});
if (this.parentNode)
this.parentNode.removeChild( this );
}
}, arguments );
};
jQuery.fn.empty = function(){
/// <summary>
/// Removes all child nodes from the set of matched elements.
/// Part of DOM/Manipulation
/// </summary>
/// <returns type="jQuery" />
return this.each( function() {
// Remove element nodes and prevent memory leaks
jQuery(this).children().remove();
// Remove any remaining nodes
while ( this.firstChild )
this.removeChild( this.firstChild );
}, arguments );
};
// Helper function used by the dimensions and offset modules
function num(elem, prop) {
return elem[0] && parseInt( jQuery.curCSS(elem[0], prop, true), 10 ) || 0;
}
var expando = "jQuery" + now(), uuid = 0, windowData = {};
jQuery.extend({
cache: {},
data: function( elem, name, data ) {
elem = elem == window ?
windowData :
elem;
var id = elem[ expando ];
// Compute a unique ID for the element
if ( !id )
id = elem[ expando ] = ++uuid;
// Only generate the data cache if we're
// trying to access or manipulate it
if ( name && !jQuery.cache[ id ] )
jQuery.cache[ id ] = {};
// Prevent overriding the named cache with undefined values
if ( data !== undefined )
jQuery.cache[ id ][ name ] = data;
// Return the named cache data, or the ID for the element
return name ?
jQuery.cache[ id ][ name ] :
id;
},
removeData: function( elem, name ) {
elem = elem == window ?
windowData :
elem;
var id = elem[ expando ];
// If we want to remove a specific section of the element's data
if ( name ) {
if ( jQuery.cache[ id ] ) {
// Remove the section of cache data
delete jQuery.cache[ id ][ name ];
// If we've removed all the data, remove the element's cache
name = "";
for ( name in jQuery.cache[ id ] )
break;
if ( !name )
jQuery.removeData( elem );
}
// Otherwise, we want to remove all of the element's data
} else {
// Clean up the element expando
try {
delete elem[ expando ];
} catch(e){
// IE has trouble directly removing the expando
// but it's ok with using removeAttribute
if ( elem.removeAttribute )
elem.removeAttribute( expando );
}
// Completely remove the data cache
delete jQuery.cache[ id ];
}
},
queue: function( elem, type, data ) {
if ( elem ){
type = (type || "fx") + "queue";
var q = jQuery.data( elem, type );
if ( !q || jQuery.isArray(data) )
q = jQuery.data( elem, type, jQuery.makeArray(data) );
else if( data )
q.push( data );
}
return q;
},
dequeue: function( elem, type ){
var queue = jQuery.queue( elem, type ),
fn = queue.shift();
if( !type || type === "fx" )
fn = queue[0];
if( fn !== undefined )
fn.call(elem);
}
});
jQuery.fn.extend({
data: function( key, value ){
var parts = key.split(".");
parts[1] = parts[1] ? "." + parts[1] : "";
if ( value === undefined ) {
var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
if ( data === undefined && this.length )
data = jQuery.data( this[0], key );
return data === undefined && parts[1] ?
this.data( parts[0] ) :
data;
} else
return this.trigger("setData" + parts[1] + "!", [parts[0], value]).each(function(){
jQuery.data( this, key, value );
});
},
removeData: function( key ){
return this.each(function(){
jQuery.removeData( this, key );
});
},
queue: function(type, data){
/// <summary>
/// 1: queue() - Returns a reference to the first element's queue (which is an array of functions).
/// 2: queue(callback) - Adds a new function, to be executed, onto the end of the queue of all matched elements.
/// 3: queue(queue) - Replaces the queue of all matched element with this new queue (the array of functions).
/// </summary>
/// <param name="type" type="Function">The function to add to the queue.</param>
/// <returns type="jQuery" />
if ( typeof type !== "string" ) {
data = type;
type = "fx";
}
if ( data === undefined )
return jQuery.queue( this[0], type );
return this.each(function(){
var queue = jQuery.queue( this, type, data );
if( type == "fx" && queue.length == 1 )
queue[0].call(this);
});
},
dequeue: function(type){
/// <summary>
/// Removes a queued function from the front of the queue and executes it.
/// </summary>
/// <param name="type" type="String" optional="true">The type of queue to access.</param>
/// <returns type="jQuery" />
return this.each(function(){
jQuery.dequeue( this, type );
});
}
});/*!
* Sizzle CSS Selector Engine - v0.9.3
* Copyright 2009, The Dojo Foundation
* Released under the MIT, BSD, and GPL Licenses.
* More information: http://sizzlejs.com/
*/
(function(){
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?/g,
done = 0,
toString = Object.prototype.toString;
var Sizzle = function(selector, context, results, seed) {
results = results || [];
context = context || document;
if ( context.nodeType !== 1 && context.nodeType !== 9 )
return [];
if ( !selector || typeof selector !== "string" ) {
return results;
}
var parts = [], m, set, checkSet, check, mode, extra, prune = true;
// Reset the position of the chunker regexp (start from head)
chunker.lastIndex = 0;
while ( (m = chunker.exec(selector)) !== null ) {
parts.push( m[1] );
if ( m[2] ) {
extra = RegExp.rightContext;
break;
}
}
if ( parts.length > 1 && origPOS.exec( selector ) ) {
if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
set = posProcess( parts[0] + parts[1], context );
} else {
set = Expr.relative[ parts[0] ] ?
[ context ] :
Sizzle( parts.shift(), context );
while ( parts.length ) {
selector = parts.shift();
if ( Expr.relative[ selector ] )
selector += parts.shift();
set = posProcess( selector, set );
}
}
} else {
var ret = seed ?
{ expr: parts.pop(), set: makeArray(seed) } :
Sizzle.find( parts.pop(), parts.length === 1 && context.parentNode ? context.parentNode : context, isXML(context) );
set = Sizzle.filter( ret.expr, ret.set );
if ( parts.length > 0 ) {
checkSet = makeArray(set);
} else {
prune = false;
}
while ( parts.length ) {
var cur = parts.pop(), pop = cur;
if ( !Expr.relative[ cur ] ) {
cur = "";
} else {
pop = parts.pop();
}
if ( pop == null ) {
pop = context;
}
Expr.relative[ cur ]( checkSet, pop, isXML(context) );
}
}
if ( !checkSet ) {
checkSet = set;
}
if ( !checkSet ) {
throw "Syntax error, unrecognized expression: " + (cur || selector);
}
if ( toString.call(checkSet) === "[object Array]" ) {
if ( !prune ) {
results.push.apply( results, checkSet );
} else if ( context.nodeType === 1 ) {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && contains(context, checkSet[i])) ) {
results.push( set[i] );
}
}
} else {
for ( var i = 0; checkSet[i] != null; i++ ) {
if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
results.push( set[i] );
}
}
}
} else {
makeArray( checkSet, results );
}
if ( extra ) {
Sizzle( extra, context, results, seed );
if ( sortOrder ) {
hasDuplicate = false;
results.sort(sortOrder);
if ( hasDuplicate ) {
for ( var i = 1; i < results.length; i++ ) {
if ( results[i] === results[i-1] ) {
results.splice(i--, 1);
}
}
}
}
}
return results;
};
Sizzle.matches = function(expr, set){
return Sizzle(expr, null, null, set);
};
Sizzle.find = function(expr, context, isXML){
var set, match;
if ( !expr ) {
return [];
}
for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
var type = Expr.order[i], match;
if ( (match = Expr.match[ type ].exec( expr )) ) {
var left = RegExp.leftContext;
if ( left.substr( left.length - 1 ) !== "\\" ) {
match[1] = (match[1] || "").replace(/\\/g, "");
set = Expr.find[ type ]( match, context, isXML );
if ( set != null ) {
expr = expr.replace( Expr.match[ type ], "" );
break;
}
}
}
}
if ( !set ) {
set = context.getElementsByTagName("*");
}
return {set: set, expr: expr};
};
Sizzle.filter = function(expr, set, inplace, not){
var old = expr, result = [], curLoop = set, match, anyFound,
isXMLFilter = set && set[0] && isXML(set[0]);
while ( expr && set.length ) {
for ( var type in Expr.filter ) {
if ( (match = Expr.match[ type ].exec( expr )) != null ) {
var filter = Expr.filter[ type ], found, item;
anyFound = false;
if ( curLoop == result ) {
result = [];
}
if ( Expr.preFilter[ type ] ) {
match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
if ( !match ) {
anyFound = found = true;
} else if ( match === true ) {
continue;
}
}
if ( match ) {
for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
if ( item ) {
found = filter( item, match, i, curLoop );
var pass = not ^ !!found;
if ( inplace && found != null ) {
if ( pass ) {
anyFound = true;
} else {
curLoop[i] = false;
}
} else if ( pass ) {
result.push( item );
anyFound = true;
}
}
}
}
if ( found !== undefined ) {
if ( !inplace ) {
curLoop = result;
}
expr = expr.replace( Expr.match[ type ], "" );
if ( !anyFound ) {
return [];
}
break;
}
}
}
// Improper expression
if ( expr == old ) {
if ( anyFound == null ) {
throw "Syntax error, unrecognized expression: " + expr;
} else {
break;
}
}
old = expr;
}
return curLoop;
};
var Expr = Sizzle.selectors = {
order: [ "ID", "NAME", "TAG" ],
match: {
ID: /#((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
CLASS: /\.((?:[\w\u00c0-\uFFFF_-]|\\.)+)/,
NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF_-]|\\.)+)['"]*\]/,
ATTR: /\[\s*((?:[\w\u00c0-\uFFFF_-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
TAG: /^((?:[\w\u00c0-\uFFFF\*_-]|\\.)+)/,
CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,
POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,
PSEUDO: /:((?:[\w\u00c0-\uFFFF_-]|\\.)+)(?:\((['"]*)((?:\([^\)]+\)|[^\2\(\)]*)+)\2\))?/
},
attrMap: {
"class": "className",
"for": "htmlFor"
},
attrHandle: {
href: function(elem){
return elem.getAttribute("href");
}
},
relative: {
"+": function(checkSet, part, isXML){
var isPartStr = typeof part === "string",
isTag = isPartStr && !/\W/.test(part),
isPartStrNotTag = isPartStr && !isTag;
if ( isTag && !isXML ) {
part = part.toUpperCase();
}
for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
if ( (elem = checkSet[i]) ) {
while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
checkSet[i] = isPartStrNotTag || elem && elem.nodeName === part ?
elem || false :
elem === part;
}
}
if ( isPartStrNotTag ) {
Sizzle.filter( part, checkSet, true );
}
},
">": function(checkSet, part, isXML){
var isPartStr = typeof part === "string";
if ( isPartStr && !/\W/.test(part) ) {
part = isXML ? part : part.toUpperCase();
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
var parent = elem.parentNode;
checkSet[i] = parent.nodeName === part ? parent : false;
}
}
} else {
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
checkSet[i] = isPartStr ?
elem.parentNode :
elem.parentNode === part;
}
}
if ( isPartStr ) {
Sizzle.filter( part, checkSet, true );
}
}
},
"": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( !part.match(/\W/) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
},
"~": function(checkSet, part, isXML){
var doneName = done++, checkFn = dirCheck;
if ( typeof part === "string" && !part.match(/\W/) ) {
var nodeCheck = part = isXML ? part : part.toUpperCase();
checkFn = dirNodeCheck;
}
checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
}
},
find: {
ID: function(match, context, isXML){
if ( typeof context.getElementById !== "undefined" && !isXML ) {
var m = context.getElementById(match[1]);
return m ? [m] : [];
}
},
NAME: function(match, context, isXML){
if ( typeof context.getElementsByName !== "undefined" ) {
var ret = [], results = context.getElementsByName(match[1]);
for ( var i = 0, l = results.length; i < l; i++ ) {
if ( results[i].getAttribute("name") === match[1] ) {
ret.push( results[i] );
}
}
return ret.length === 0 ? null : ret;
}
},
TAG: function(match, context){
return context.getElementsByTagName(match[1]);
}
},
preFilter: {
CLASS: function(match, curLoop, inplace, result, not, isXML){
match = " " + match[1].replace(/\\/g, "") + " ";
if ( isXML ) {
return match;
}
for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
if ( elem ) {
if ( not ^ (elem.className && (" " + elem.className + " ").indexOf(match) >= 0) ) {
if ( !inplace )
result.push( elem );
} else if ( inplace ) {
curLoop[i] = false;
}
}
}
return false;
},
ID: function(match){
return match[1].replace(/\\/g, "");
},
TAG: function(match, curLoop){
for ( var i = 0; curLoop[i] === false; i++ ){}
return curLoop[i] && isXML(curLoop[i]) ? match[1] : match[1].toUpperCase();
},
CHILD: function(match){
if ( match[1] == "nth" ) {
// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
match[2] == "even" && "2n" || match[2] == "odd" && "2n+1" ||
!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
// calculate the numbers (first)n+(last) including if they are negative
match[2] = (test[1] + (test[2] || 1)) - 0;
match[3] = test[3] - 0;
}
// TODO: Move to normal caching system
match[0] = done++;
return match;
},
ATTR: function(match, curLoop, inplace, result, not, isXML){
var name = match[1].replace(/\\/g, "");
if ( !isXML && Expr.attrMap[name] ) {
match[1] = Expr.attrMap[name];
}
if ( match[2] === "~=" ) {
match[4] = " " + match[4] + " ";
}
return match;
},
PSEUDO: function(match, curLoop, inplace, result, not){
if ( match[1] === "not" ) {
// If we're dealing with a complex expression, or a simple one
if ( match[3].match(chunker).length > 1 || /^\w/.test(match[3]) ) {
match[3] = Sizzle(match[3], null, null, curLoop);
} else {
var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
if ( !inplace ) {
result.push.apply( result, ret );
}
return false;
}
} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
return true;
}
return match;
},
POS: function(match){
match.unshift( true );
return match;
}
},
filters: {
enabled: function(elem){
return elem.disabled === false && elem.type !== "hidden";
},
disabled: function(elem){
return elem.disabled === true;
},
checked: function(elem){
return elem.checked === true;
},
selected: function(elem){
// Accessing this property makes selected-by-default
// options in Safari work properly
elem.parentNode.selectedIndex;
return elem.selected === true;
},
parent: function(elem){
return !!elem.firstChild;
},
empty: function(elem){
return !elem.firstChild;
},
has: function(elem, i, match){
return !!Sizzle( match[3], elem ).length;
},
header: function(elem){
return /h\d/i.test( elem.nodeName );
},
text: function(elem){
return "text" === elem.type;
},
radio: function(elem){
return "radio" === elem.type;
},
checkbox: function(elem){
return "checkbox" === elem.type;
},
file: function(elem){
return "file" === elem.type;
},
password: function(elem){
return "password" === elem.type;
},
submit: function(elem){
return "submit" === elem.type;
},
image: function(elem){
return "image" === elem.type;
},
reset: function(elem){
return "reset" === elem.type;
},
button: function(elem){
return "button" === elem.type || elem.nodeName.toUpperCase() === "BUTTON";
},
input: function(elem){
return /input|select|textarea|button/i.test(elem.nodeName);
}
},
setFilters: {
first: function(elem, i){
return i === 0;
},
last: function(elem, i, match, array){
return i === array.length - 1;
},
even: function(elem, i){
return i % 2 === 0;
},
odd: function(elem, i){
return i % 2 === 1;
},
lt: function(elem, i, match){
return i < match[3] - 0;
},
gt: function(elem, i, match){
return i > match[3] - 0;
},
nth: function(elem, i, match){
return match[3] - 0 == i;
},
eq: function(elem, i, match){
return match[3] - 0 == i;
}
},
filter: {
PSEUDO: function(elem, match, i, array){
var name = match[1], filter = Expr.filters[ name ];
if ( filter ) {
return filter( elem, i, match, array );
} else if ( name === "contains" ) {
return (elem.textContent || elem.innerText || "").indexOf(match[3]) >= 0;
} else if ( name === "not" ) {
var not = match[3];
for ( var i = 0, l = not.length; i < l; i++ ) {
if ( not[i] === elem ) {
return false;
}
}
return true;
}
},
CHILD: function(elem, match){
var type = match[1], node = elem;
switch (type) {
case 'only':
case 'first':
while (node = node.previousSibling) {
if ( node.nodeType === 1 ) return false;
}
if ( type == 'first') return true;
node = elem;
case 'last':
while (node = node.nextSibling) {
if ( node.nodeType === 1 ) return false;
}
return true;
case 'nth':
var first = match[2], last = match[3];
if ( first == 1 && last == 0 ) {
return true;
}
var doneName = match[0],
parent = elem.parentNode;
if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
var count = 0;
for ( node = parent.firstChild; node; node = node.nextSibling ) {
if ( node.nodeType === 1 ) {
node.nodeIndex = ++count;
}
}
parent.sizcache = doneName;
}
var diff = elem.nodeIndex - last;
if ( first == 0 ) {
return diff == 0;
} else {
return ( diff % first == 0 && diff / first >= 0 );
}
}
},
ID: function(elem, match){
return elem.nodeType === 1 && elem.getAttribute("id") === match;
},
TAG: function(elem, match){
return (match === "*" && elem.nodeType === 1) || elem.nodeName === match;
},
CLASS: function(elem, match){
return (" " + (elem.className || elem.getAttribute("class")) + " ")
.indexOf( match ) > -1;
},
ATTR: function(elem, match){
var name = match[1],
result = Expr.attrHandle[ name ] ?
Expr.attrHandle[ name ]( elem ) :
elem[ name ] != null ?
elem[ name ] :
elem.getAttribute( name ),
value = result + "",
type = match[2],
check = match[4];
return result == null ?
type === "!=" :
type === "=" ?
value === check :
type === "*=" ?
value.indexOf(check) >= 0 :
type === "~=" ?
(" " + value + " ").indexOf(check) >= 0 :
!check ?
value && result !== false :
type === "!=" ?
value != check :
type === "^=" ?
value.indexOf(check) === 0 :
type === "$=" ?
value.substr(value.length - check.length) === check :
type === "|=" ?
value === check || value.substr(0, check.length + 1) === check + "-" :
false;
},
POS: function(elem, match, i, array){
var name = match[2], filter = Expr.setFilters[ name ];
if ( filter ) {
return filter( elem, i, match, array );
}
}
}
};
var origPOS = Expr.match.POS;
for ( var type in Expr.match ) {
Expr.match[ type ] = RegExp( Expr.match[ type ].source + /(?![^\[]*\])(?![^\(]*\))/.source );
}
var makeArray = function(array, results) {
array = Array.prototype.slice.call( array );
if ( results ) {
results.push.apply( results, array );
return results;
}
return array;
};
// Perform a simple check to determine if the browser is capable of
// converting a NodeList to an array using builtin methods.
try {
Array.prototype.slice.call( document.documentElement.childNodes );
// Provide a fallback method if it does not work
} catch(e){
makeArray = function(array, results) {
var ret = results || [];
if ( toString.call(array) === "[object Array]" ) {
Array.prototype.push.apply( ret, array );
} else {
if ( typeof array.length === "number" ) {
for ( var i = 0, l = array.length; i < l; i++ ) {
ret.push( array[i] );
}
} else {
for ( var i = 0; array[i]; i++ ) {
ret.push( array[i] );
}
}
}
return ret;
};
}
var sortOrder;
if ( document.documentElement.compareDocumentPosition ) {
sortOrder = function( a, b ) {
var ret = a.compareDocumentPosition(b) & 4 ? -1 : a === b ? 0 : 1;
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
} else if ( "sourceIndex" in document.documentElement ) {
sortOrder = function( a, b ) {
var ret = a.sourceIndex - b.sourceIndex;
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
} else if ( document.createRange ) {
sortOrder = function( a, b ) {
var aRange = a.ownerDocument.createRange(), bRange = b.ownerDocument.createRange();
aRange.selectNode(a);
aRange.collapse(true);
bRange.selectNode(b);
bRange.collapse(true);
var ret = aRange.compareBoundaryPoints(Range.START_TO_END, bRange);
if ( ret === 0 ) {
hasDuplicate = true;
}
return ret;
};
}
// [vsdoc] The following function has been modified for IntelliSense.
// Check to see if the browser returns elements by name when
// querying by getElementById (and provide a workaround)
(function(){
// We're going to inject a fake input element with a specified name
////var form = document.createElement("form"),
//// id = "script" + (new Date).getTime();
////form.innerHTML = "<input name='" + id + "'/>";
// Inject it into the root element, check its status, and remove it quickly
////var root = document.documentElement;
////root.insertBefore( form, root.firstChild );
// The workaround has to do additional checks after a getElementById
// Which slows things down for other browsers (hence the branching)
////if ( !!document.getElementById( id ) ) {
Expr.find.ID = function(match, context, isXML){
if ( typeof context.getElementById !== "undefined" && !isXML ) {
var m = context.getElementById(match[1]);
return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
}
};
Expr.filter.ID = function(elem, match){
var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
return elem.nodeType === 1 && node && node.nodeValue === match;
};
////}
////root.removeChild( form );
})();
// [vsdoc] The following function has been modified for IntelliSense.
(function(){
// Check to see if the browser returns only elements
// when doing getElementsByTagName("*")
// Create a fake element
////var div = document.createElement("div");
////div.appendChild( document.createComment("") );
// Make sure no comments are found
////if ( div.getElementsByTagName("*").length > 0 ) {
Expr.find.TAG = function(match, context){
var results = context.getElementsByTagName(match[1]);
// Filter out possible comments
if ( match[1] === "*" ) {
var tmp = [];
for ( var i = 0; results[i]; i++ ) {
if ( results[i].nodeType === 1 ) {
tmp.push( results[i] );
}
}
results = tmp;
}
return results;
};
////}
// Check to see if an attribute returns normalized href attributes
////div.innerHTML = "<a href='#'></a>";
////if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
//// div.firstChild.getAttribute("href") !== "#" ) {
Expr.attrHandle.href = function(elem){
return elem.getAttribute("href", 2);
};
////}
})();
if ( document.querySelectorAll ) (function(){
var oldSizzle = Sizzle, div = document.createElement("div");
div.innerHTML = "<p class='TEST'></p>";
// Safari can't handle uppercase or unicode characters when
// in quirks mode.
if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
return;
}
Sizzle = function(query, context, extra, seed){
context = context || document;
// Only use querySelectorAll on non-XML documents
// (ID selectors don't work in non-HTML documents)
if ( !seed && context.nodeType === 9 && !isXML(context) ) {
try {
return makeArray( context.querySelectorAll(query), extra );
} catch(e){}
}
return oldSizzle(query, context, extra, seed);
};
Sizzle.find = oldSizzle.find;
Sizzle.filter = oldSizzle.filter;
Sizzle.selectors = oldSizzle.selectors;
Sizzle.matches = oldSizzle.matches;
})();
if ( document.getElementsByClassName && document.documentElement.getElementsByClassName ) (function(){
var div = document.createElement("div");
div.innerHTML = "<div class='test e'></div><div class='test'></div>";
// Opera can't find a second classname (in 9.6)
if ( div.getElementsByClassName("e").length === 0 )
return;
// Safari caches class attributes, doesn't catch changes (in 3.2)
div.lastChild.className = "e";
if ( div.getElementsByClassName("e").length === 1 )
return;
Expr.order.splice(1, 0, "CLASS");
Expr.find.CLASS = function(match, context, isXML) {
if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
return context.getElementsByClassName(match[1]);
}
};
})();
function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
var sibDir = dir == "previousSibling" && !isXML;
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
if ( sibDir && elem.nodeType === 1 ){
elem.sizcache = doneName;
elem.sizset = i;
}
elem = elem[dir];
var match = false;
while ( elem ) {
if ( elem.sizcache === doneName ) {
match = checkSet[elem.sizset];
break;
}
if ( elem.nodeType === 1 && !isXML ){
elem.sizcache = doneName;
elem.sizset = i;
}
if ( elem.nodeName === cur ) {
match = elem;
break;
}
elem = elem[dir];
}
checkSet[i] = match;
}
}
}
function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
var sibDir = dir == "previousSibling" && !isXML;
for ( var i = 0, l = checkSet.length; i < l; i++ ) {
var elem = checkSet[i];
if ( elem ) {
if ( sibDir && elem.nodeType === 1 ) {
elem.sizcache = doneName;
elem.sizset = i;
}
elem = elem[dir];
var match = false;
while ( elem ) {
if ( elem.sizcache === doneName ) {
match = checkSet[elem.sizset];
break;
}
if ( elem.nodeType === 1 ) {
if ( !isXML ) {
elem.sizcache = doneName;
elem.sizset = i;
}
if ( typeof cur !== "string" ) {
if ( elem === cur ) {
match = true;
break;
}
} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
match = elem;
break;
}
}
elem = elem[dir];
}
checkSet[i] = match;
}
}
}
var contains = document.compareDocumentPosition ? function(a, b){
return a.compareDocumentPosition(b) & 16;
} : function(a, b){
return a !== b && (a.contains ? a.contains(b) : true);
};
var isXML = function(elem){
return elem.nodeType === 9 && elem.documentElement.nodeName !== "HTML" ||
!!elem.ownerDocument && isXML( elem.ownerDocument );
};
var posProcess = function(selector, context){
var tmpSet = [], later = "", match,
root = context.nodeType ? [context] : context;
// Position selectors must be done after the filter
// And so must :not(positional) so we move all PSEUDOs to the end
while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
later += match[0];
selector = selector.replace( Expr.match.PSEUDO, "" );
}
selector = Expr.relative[selector] ? selector + "*" : selector;
for ( var i = 0, l = root.length; i < l; i++ ) {
Sizzle( selector, root[i], tmpSet );
}
return Sizzle.filter( later, tmpSet );
};
// EXPOSE
jQuery.find = Sizzle;
jQuery.filter = Sizzle.filter;
jQuery.expr = Sizzle.selectors;
jQuery.expr[":"] = jQuery.expr.filters;
Sizzle.selectors.filters.hidden = function(elem){
return elem.offsetWidth === 0 || elem.offsetHeight === 0;
};
Sizzle.selectors.filters.visible = function(elem){
return elem.offsetWidth > 0 || elem.offsetHeight > 0;
};
Sizzle.selectors.filters.animated = function(elem){
return jQuery.grep(jQuery.timers, function(fn){
return elem === fn.elem;
}).length;
};
jQuery.multiFilter = function( expr, elems, not ) {
/// <summary>
/// This member is internal only.
/// </summary>
/// <private />
if ( not ) {
expr = ":not(" + expr + ")";
}
return Sizzle.matches(expr, elems);
};
jQuery.dir = function( elem, dir ){
/// <summary>
/// This member is internal only.
/// </summary>
/// <private />
// This member is not documented in the jQuery API: http://docs.jquery.com/Special:Search?ns0=1&search=dir
var matched = [], cur = elem[dir];
while ( cur && cur != document ) {
if ( cur.nodeType == 1 )
matched.push( cur );
cur = cur[dir];
}
return matched;
};
jQuery.nth = function(cur, result, dir, elem){
/// <summary>
/// This member is internal only.
/// </summary>
/// <private />
// This member is not documented in the jQuery API: http://docs.jquery.com/Special:Search?ns0=1&search=nth
result = result || 1;
var num = 0;
for ( ; cur; cur = cur[dir] )
if ( cur.nodeType == 1 && ++num == result )
break;
return cur;
};
jQuery.sibling = function(n, elem){
/// <summary>
/// This member is internal only.
/// </summary>
/// <private />
// This member is not documented in the jQuery API: http://docs.jquery.com/Special:Search?ns0=1&search=nth
var r = [];
for ( ; n; n = n.nextSibling ) {
if ( n.nodeType == 1 && n != elem )
r.push( n );
}
return r;
};
return;
window.Sizzle = Sizzle;
})();
/*
* A number of helper functions used for managing events.
* Many of the ideas behind this code originated from
* Dean Edwards' addEvent library.
*/
jQuery.event = {
// Bind an event to an element
// Original by Dean Edwards
add: function(elem, types, handler, data) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
if ( elem.nodeType == 3 || elem.nodeType == 8 )
return;
// For whatever reason, IE has trouble passing the window object
// around, causing it to be cloned in the process
if ( elem.setInterval && elem != window )
elem = window;
// Make sure that the function being executed has a unique ID
if ( !handler.guid )
handler.guid = this.guid++;
// if data is passed, bind to handler
if ( data !== undefined ) {
// Create temporary function pointer to original handler
var fn = handler;
// Create unique handler function, wrapped around original handler
handler = this.proxy( fn );
// Store data in unique handler
handler.data = data;
}
// Init the element's event structure
var events = jQuery.data(elem, "events") || jQuery.data(elem, "events", {}),
handle = jQuery.data(elem, "handle") || jQuery.data(elem, "handle", function(){
// Handle the second event of a trigger and when
// an event is called after a page has unloaded
return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
jQuery.event.handle.apply(arguments.callee.elem, arguments) :
undefined;
});
// Add elem as a property of the handle function
// This is to prevent a memory leak with non-native
// event in IE.
handle.elem = elem;
// Handle multiple events separated by a space
// jQuery(...).bind("mouseover mouseout", fn);
jQuery.each(types.split(/\s+/), function(index, type) {
// Namespaced event handlers
var namespaces = type.split(".");
type = namespaces.shift();
handler.type = namespaces.slice().sort().join(".");
// Get the current list of functions bound to this event
var handlers = events[type];
if ( jQuery.event.specialAll[type] )
jQuery.event.specialAll[type].setup.call(elem, data, namespaces);
// Init the event handler queue
if (!handlers) {
handlers = events[type] = {};
// Check for a special event handler
// Only use addEventListener/attachEvent if the special
// events handler returns false
if ( !jQuery.event.special[type] || jQuery.event.special[type].setup.call(elem, data, namespaces) === false ) {
// Bind the global event handler to the element
if (elem.addEventListener)
elem.addEventListener(type, handle, false);
else if (elem.attachEvent)
elem.attachEvent("on" + type, handle);
}
}
// Add the function to the element's handler list
handlers[handler.guid] = handler;
// Keep track of which events have been used, for global triggering
jQuery.event.global[type] = true;
});
// Nullify elem to prevent memory leaks in IE
elem = null;
},
guid: 1,
global: {},
// Detach an event or set of events from an element
remove: function(elem, types, handler) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// don't do events on text and comment nodes
if ( elem.nodeType == 3 || elem.nodeType == 8 )
return;
var events = jQuery.data(elem, "events"), ret, index;
if ( events ) {
// Unbind all events for the element
if ( types === undefined || (typeof types === "string" && types.charAt(0) == ".") )
for ( var type in events )
this.remove( elem, type + (types || "") );
else {
// types is actually an event object here
if ( types.type ) {
handler = types.handler;
types = types.type;
}
// Handle multiple events seperated by a space
// jQuery(...).unbind("mouseover mouseout", fn);
jQuery.each(types.split(/\s+/), function(index, type){
// Namespaced event handlers
var namespaces = type.split(".");
type = namespaces.shift();
var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
if ( events[type] ) {
// remove the given handler for the given type
if ( handler )
delete events[type][handler.guid];
// remove all handlers for the given type
else
for ( var handle in events[type] )
// Handle the removal of namespaced events
if ( namespace.test(events[type][handle].type) )
delete events[type][handle];
if ( jQuery.event.specialAll[type] )
jQuery.event.specialAll[type].teardown.call(elem, namespaces);
// remove generic event handler if no more handlers exist
for ( ret in events[type] ) break;
if ( !ret ) {
if ( !jQuery.event.special[type] || jQuery.event.special[type].teardown.call(elem, namespaces) === false ) {
if (elem.removeEventListener)
elem.removeEventListener(type, jQuery.data(elem, "handle"), false);
else if (elem.detachEvent)
elem.detachEvent("on" + type, jQuery.data(elem, "handle"));
}
ret = null;
delete events[type];
}
}
});
}
// Remove the expando if it's no longer used
for ( ret in events ) break;
if ( !ret ) {
var handle = jQuery.data( elem, "handle" );
if ( handle ) handle.elem = null;
jQuery.removeData( elem, "events" );
jQuery.removeData( elem, "handle" );
}
}
},
// bubbling is internal
trigger: function( event, data, elem, bubbling ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// Event object or event type
var type = event.type || event;
if( !bubbling ){
event = typeof event === "object" ?
// jQuery.Event object
event[expando] ? event :
// Object literal
jQuery.extend( jQuery.Event(type), event ) :
// Just the event type (string)
jQuery.Event(type);
if ( type.indexOf("!") >= 0 ) {
event.type = type = type.slice(0, -1);
event.exclusive = true;
}
// Handle a global trigger
if ( !elem ) {
// Don't bubble custom events when global (to avoid too much overhead)
event.stopPropagation();
// Only trigger if we've ever bound an event for it
if ( this.global[type] )
jQuery.each( jQuery.cache, function(){
if ( this.events && this.events[type] )
jQuery.event.trigger( event, data, this.handle.elem );
});
}
// Handle triggering a single element
// don't do events on text and comment nodes
if ( !elem || elem.nodeType == 3 || elem.nodeType == 8 )
return undefined;
// Clean up in case it is reused
event.result = undefined;
event.target = elem;
// Clone the incoming data, if any
data = jQuery.makeArray(data);
data.unshift( event );
}
event.currentTarget = elem;
// Trigger the event, it is assumed that "handle" is a function
var handle = jQuery.data(elem, "handle");
if ( handle )
handle.apply( elem, data );
// Handle triggering native .onfoo handlers (and on links since we don't call .click() for links)
if ( (!elem[type] || (jQuery.nodeName(elem, 'a') && type == "click")) && elem["on"+type] && elem["on"+type].apply( elem, data ) === false )
event.result = false;
// Trigger the native events (except for clicks on links)
if ( !bubbling && elem[type] && !event.isDefaultPrevented() && !(jQuery.nodeName(elem, 'a') && type == "click") ) {
this.triggered = true;
try {
elem[ type ]();
// prevent IE from throwing an error for some hidden elements
} catch (e) {}
}
this.triggered = false;
if ( !event.isPropagationStopped() ) {
var parent = elem.parentNode || elem.ownerDocument;
if ( parent )
jQuery.event.trigger(event, data, parent, true);
}
},
handle: function(event) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// returned undefined or false
var all, handlers;
event = arguments[0] = jQuery.event.fix( event || window.event );
event.currentTarget = this;
// Namespaced event handlers
var namespaces = event.type.split(".");
event.type = namespaces.shift();
// Cache this now, all = true means, any handler
all = !namespaces.length && !event.exclusive;
var namespace = RegExp("(^|\\.)" + namespaces.slice().sort().join(".*\\.") + "(\\.|$)");
handlers = ( jQuery.data(this, "events") || {} )[event.type];
for ( var j in handlers ) {
var handler = handlers[j];
// Filter the functions by class
if ( all || namespace.test(handler.type) ) {
// Pass in a reference to the handler function itself
// So that we can later remove it
event.handler = handler;
event.data = handler.data;
var ret = handler.apply(this, arguments);
if( ret !== undefined ){
event.result = ret;
if ( ret === false ) {
event.preventDefault();
event.stopPropagation();
}
}
if( event.isImmediatePropagationStopped() )
break;
}
}
},
props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode metaKey newValue originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
fix: function(event) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
if ( event[expando] )
return event;
// store a copy of the original event object
// and "clone" to set read-only properties
var originalEvent = event;
event = jQuery.Event( originalEvent );
for ( var i = this.props.length, prop; i; ){
prop = this.props[ --i ];
event[ prop ] = originalEvent[ prop ];
}
// Fix target property, if necessary
if ( !event.target )
event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
// check if target is a textnode (safari)
if ( event.target.nodeType == 3 )
event.target = event.target.parentNode;
// Add relatedTarget, if necessary
if ( !event.relatedTarget && event.fromElement )
event.relatedTarget = event.fromElement == event.target ? event.toElement : event.fromElement;
// Calculate pageX/Y if missing and clientX/Y available
if ( event.pageX == null && event.clientX != null ) {
var doc = document.documentElement, body = document.body;
event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc.clientLeft || 0);
event.pageY = event.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc.clientTop || 0);
}
// Add which for key events
if ( !event.which && ((event.charCode || event.charCode === 0) ? event.charCode : event.keyCode) )
event.which = event.charCode || event.keyCode;
// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
if ( !event.metaKey && event.ctrlKey )
event.metaKey = event.ctrlKey;
// Add which for click: 1 == left; 2 == middle; 3 == right
// Note: button is not normalized, so don't use it
if ( !event.which && event.button )
event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
return event;
},
proxy: function( fn, proxy ){
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
proxy = proxy || function(){ return fn.apply(this, arguments); };
// Set the guid of unique handler to the same of original handler, so it can be removed
proxy.guid = fn.guid = fn.guid || proxy.guid || this.guid++;
// So proxy can be declared as an argument
return proxy;
},
special: {
ready: {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// Make sure the ready event is setup
setup: bindReady,
teardown: function() {}
}
},
specialAll: {
live: {
setup: function( selector, namespaces ){
jQuery.event.add( this, namespaces[0], liveHandler );
},
teardown: function( namespaces ){
if ( namespaces.length ) {
var remove = 0, name = RegExp("(^|\\.)" + namespaces[0] + "(\\.|$)");
jQuery.each( (jQuery.data(this, "events").live || {}), function(){
if ( name.test(this.type) )
remove++;
});
if ( remove < 1 )
jQuery.event.remove( this, namespaces[0], liveHandler );
}
}
}
}
};
jQuery.Event = function( src ){
// Allow instantiation without the 'new' keyword
if( !this.preventDefault )
return new jQuery.Event(src);
// Event object
if( src && src.type ){
this.originalEvent = src;
this.type = src.type;
// Event type
}else
this.type = src;
// timeStamp is buggy for some events on Firefox(#3843)
// So we won't rely on the native value
this.timeStamp = now();
// Mark it as fixed
this[expando] = true;
};
function returnFalse(){
return false;
}
function returnTrue(){
return true;
}
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
jQuery.Event.prototype = {
preventDefault: function() {
this.isDefaultPrevented = returnTrue;
var e = this.originalEvent;
if( !e )
return;
// if preventDefault exists run it on the original event
if (e.preventDefault)
e.preventDefault();
// otherwise set the returnValue property of the original event to false (IE)
e.returnValue = false;
},
stopPropagation: function() {
this.isPropagationStopped = returnTrue;
var e = this.originalEvent;
if( !e )
return;
// if stopPropagation exists run it on the original event
if (e.stopPropagation)
e.stopPropagation();
// otherwise set the cancelBubble property of the original event to true (IE)
e.cancelBubble = true;
},
stopImmediatePropagation:function(){
this.isImmediatePropagationStopped = returnTrue;
this.stopPropagation();
},
isDefaultPrevented: returnFalse,
isPropagationStopped: returnFalse,
isImmediatePropagationStopped: returnFalse
};
// Checks if an event happened on an element within another element
// Used in jQuery.event.special.mouseenter and mouseleave handlers
var withinElement = function(event) {
// Check if mouse(over|out) are still within the same parent element
var parent = event.relatedTarget;
// Traverse up the tree
while ( parent && parent != this )
try { parent = parent.parentNode; }
catch(e) { parent = this; }
if( parent != this ){
// set the correct event type
event.type = event.data;
// handle event if we actually just moused on to a non sub-element
jQuery.event.handle.apply( this, arguments );
}
};
jQuery.each({
mouseover: 'mouseenter',
mouseout: 'mouseleave'
}, function( orig, fix ){
jQuery.event.special[ fix ] = {
setup: function(){
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
jQuery.event.add( this, orig, withinElement, fix );
},
teardown: function(){
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
jQuery.event.remove( this, orig, withinElement );
}
};
});
jQuery.fn.extend({
bind: function( type, data, fn ) {
/// <summary>
/// Binds a handler to one or more events for each matched element. Can also bind custom events.
/// </summary>
/// <param name="type" type="String">One or more event types separated by a space. Built-in event type values are: blur, focus, load, resize, scroll, unload, click, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, error .</param>
/// <param name="data" optional="true" type="Object">Additional data passed to the event handler as event.data</param>
/// <param name="fn" type="Function">A function to bind to the event on each of the set of matched elements. function callback(eventObject) such that this corresponds to the dom element.</param>
return type == "unload" ? this.one(type, data, fn) : this.each(function(){
jQuery.event.add( this, type, fn || data, fn && data );
});
},
one: function( type, data, fn ) {
/// <summary>
/// Binds a handler to one or more events to be executed exactly once for each matched element.
/// </summary>
/// <param name="type" type="String">One or more event types separated by a space. Built-in event type values are: blur, focus, load, resize, scroll, unload, click, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, error .</param>
/// <param name="data" optional="true" type="Object">Additional data passed to the event handler as event.data</param>
/// <param name="fn" type="Function">A function to bind to the event on each of the set of matched elements. function callback(eventObject) such that this corresponds to the dom element.</param>
var one = jQuery.event.proxy( fn || data, function(event) {
jQuery(this).unbind(event, one);
return (fn || data).apply( this, arguments );
});
return this.each(function(){
jQuery.event.add( this, type, one, fn && data);
});
},
unbind: function( type, fn ) {
/// <summary>
/// Unbinds a handler from one or more events for each matched element.
/// </summary>
/// <param name="type" type="String">One or more event types separated by a space. Built-in event type values are: blur, focus, load, resize, scroll, unload, click, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, error .</param>
/// <param name="fn" type="Function">A function to bind to the event on each of the set of matched elements. function callback(eventObject) such that this corresponds to the dom element.</param>
return this.each(function(){
jQuery.event.remove( this, type, fn );
});
},
trigger: function( type, data ) {
/// <summary>
/// Triggers a type of event on every matched element.
/// </summary>
/// <param name="type" type="String">One or more event types separated by a space. Built-in event type values are: blur, focus, load, resize, scroll, unload, click, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, error .</param>
/// <param name="data" optional="true" type="Array">Additional data passed to the event handler as additional arguments.</param>
/// <param name="fn" type="Function">This parameter is undocumented.</param>
return this.each(function(){
jQuery.event.trigger( type, data, this );
});
},
triggerHandler: function( type, data ) {
/// <summary>
/// Triggers all bound event handlers on an element for a specific event type without executing the browser's default actions.
/// </summary>
/// <param name="type" type="String">One or more event types separated by a space. Built-in event type values are: blur, focus, load, resize, scroll, unload, click, dblclick, mousedown, mouseup, mousemove, mouseover, mouseout, mouseenter, mouseleave, change, select, submit, keydown, keypress, keyup, error .</param>
/// <param name="data" optional="true" type="Array">Additional data passed to the event handler as additional arguments.</param>
/// <param name="fn" type="Function">This parameter is undocumented.</param>
if( this[0] ){
var event = jQuery.Event(type);
event.preventDefault();
event.stopPropagation();
jQuery.event.trigger( event, data, this[0] );
return event.result;
}
},
toggle: function( fn ) {
/// <summary>
/// Toggles among two or more function calls every other click.
/// </summary>
/// <param name="fn" type="Function">The functions among which to toggle execution</param>
// Save reference to arguments for access in closure
var args = arguments, i = 1;
// link all the functions, so any of them can unbind this click handler
while( i < args.length )
jQuery.event.proxy( fn, args[i++] );
return this.click( jQuery.event.proxy( fn, function(event) {
// Figure out which function to execute
this.lastToggle = ( this.lastToggle || 0 ) % i;
// Make sure that clicks stop
event.preventDefault();
// and execute the function
return args[ this.lastToggle++ ].apply( this, arguments ) || false;
}));
},
hover: function(fnOver, fnOut) {
/// <summary>
/// Simulates hovering (moving the mouse on or off of an object).
/// </summary>
/// <param name="fnOver" type="Function">The function to fire when the mouse is moved over a matched element.</param>
/// <param name="fnOut" type="Function">The function to fire when the mouse is moved off of a matched element.</param>
return this.mouseenter(fnOver).mouseleave(fnOut);
},
ready: function(fn) {
/// <summary>
/// Binds a function to be executed whenever the DOM is ready to be traversed and manipulated.
/// </summary>
/// <param name="fn" type="Function">The function to be executed when the DOM is ready.</param>
// Attach the listeners
bindReady();
// If the DOM is already ready
if ( jQuery.isReady )
// Execute the function immediately
fn.call( document, jQuery );
// Otherwise, remember the function for later
else
// Add the function to the wait list
jQuery.readyList.push( fn );
return this;
},
live: function( type, fn ){
/// <summary>
/// Binds a handler to an event (like click) for all current - and future - matched element. Can also bind custom events.
/// </summary>
/// <param name="type" type="String">An event type</param>
/// <param name="fn" type="Function">A function to bind to the event on each of the set of matched elements</param>
var proxy = jQuery.event.proxy( fn );
proxy.guid += this.selector + type;
jQuery(document).bind( liveConvert(type, this.selector), this.selector, proxy );
return this;
},
die: function( type, fn ){
/// <summary>
/// This does the opposite of live, it removes a bound live event.
/// You can also unbind custom events registered with live.
/// If the type is provided, all bound live events of that type are removed.
/// If the function that was passed to live is provided as the second argument, only that specific event handler is removed.
/// </summary>
/// <param name="type" type="String">A live event type to unbind.</param>
/// <param name="fn" type="Function">A function to unbind from the event on each of the set of matched elements.</param>
jQuery(document).unbind( liveConvert(type, this.selector), fn ? { guid: fn.guid + this.selector + type } : null );
return this;
}
});
function liveHandler( event ){
var check = RegExp("(^|\\.)" + event.type + "(\\.|$)"),
stop = true,
elems = [];
jQuery.each(jQuery.data(this, "events").live || [], function(i, fn){
if ( check.test(fn.type) ) {
var elem = jQuery(event.target).closest(fn.data)[0];
if ( elem )
elems.push({ elem: elem, fn: fn });
}
});
elems.sort(function(a,b) {
return jQuery.data(a.elem, "closest") - jQuery.data(b.elem, "closest");
});
jQuery.each(elems, function(){
if ( this.fn.call(this.elem, event, this.fn.data) === false )
return (stop = false);
});
return stop;
}
function liveConvert(type, selector){
return ["live", type, selector.replace(/\./g, "`").replace(/ /g, "|")].join(".");
}
jQuery.extend({
isReady: false,
readyList: [],
// Handle when the DOM is ready
ready: function() {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// Make sure that the DOM is not already loaded
if ( !jQuery.isReady ) {
// Remember that the DOM is ready
jQuery.isReady = true;
// If there are functions bound, to execute
if ( jQuery.readyList ) {
// Execute all of them
jQuery.each( jQuery.readyList, function(){
this.call( document, jQuery );
});
// Reset the list of functions
jQuery.readyList = null;
}
// Trigger any bound ready events
jQuery(document).triggerHandler("ready");
}
}
});
var readyBound = false;
function bindReady(){
if ( readyBound ) return;
readyBound = true;
// Mozilla, Opera and webkit nightlies currently support this event
if ( document.addEventListener ) {
// Use the handy event callback
document.addEventListener( "DOMContentLoaded", function(){
document.removeEventListener( "DOMContentLoaded", arguments.callee, false );
jQuery.ready();
}, false );
// If IE event model is used
} else if ( document.attachEvent ) {
// ensure firing before onload,
// maybe late but safe also for iframes
document.attachEvent("onreadystatechange", function(){
if ( document.readyState === "complete" ) {
document.detachEvent( "onreadystatechange", arguments.callee );
jQuery.ready();
}
});
// If IE and not an iframe
// continually check to see if the document is ready
if ( document.documentElement.doScroll && window == window.top ) (function(){
if ( jQuery.isReady ) return;
try {
// If IE is used, use the trick by Diego Perini
// http://javascript.nwbox.com/IEContentLoaded/
document.documentElement.doScroll("left");
} catch( error ) {
setTimeout( arguments.callee, 0 );
return;
}
// and execute any waiting functions
jQuery.ready();
})();
}
// A fallback to window.onload, that will always work
jQuery.event.add( window, "load", jQuery.ready );
}
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
jQuery.each( ("blur,focus,load,resize,scroll,unload,click,dblclick," +
"mousedown,mouseup,mousemove,mouseover,mouseout,mouseenter,mouseleave," +
"change,select,submit,keydown,keypress,keyup,error").split(","), function(i, name){
// Handle event binding
jQuery.fn[name] = function(fn){
return fn ? this.bind(name, fn) : this.trigger(name);
};
});
jQuery.fn["blur"] = function(fn) {
/// <summary>
/// 1: blur() - Triggers the blur event of each matched element.
/// 2: blur(fn) - Binds a function to the blur event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("blur", fn) : this.trigger(name);
};
jQuery.fn["focus"] = function(fn) {
/// <summary>
/// 1: focus() - Triggers the focus event of each matched element.
/// 2: focus(fn) - Binds a function to the focus event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("focus", fn) : this.trigger(name);
};
jQuery.fn["load"] = function(fn) {
/// <summary>
/// 1: load() - Triggers the load event of each matched element.
/// 2: load(fn) - Binds a function to the load event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("load", fn) : this.trigger(name);
};
jQuery.fn["resize"] = function(fn) {
/// <summary>
/// 1: resize() - Triggers the resize event of each matched element.
/// 2: resize(fn) - Binds a function to the resize event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("resize", fn) : this.trigger(name);
};
jQuery.fn["scroll"] = function(fn) {
/// <summary>
/// 1: scroll() - Triggers the scroll event of each matched element.
/// 2: scroll(fn) - Binds a function to the scroll event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("scroll", fn) : this.trigger(name);
};
jQuery.fn["unload"] = function(fn) {
/// <summary>
/// 1: unload() - Triggers the unload event of each matched element.
/// 2: unload(fn) - Binds a function to the unload event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("unload", fn) : this.trigger(name);
};
jQuery.fn["click"] = function(fn) {
/// <summary>
/// 1: click() - Triggers the click event of each matched element.
/// 2: click(fn) - Binds a function to the click event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("click", fn) : this.trigger(name);
};
jQuery.fn["dblclick"] = function(fn) {
/// <summary>
/// 1: dblclick() - Triggers the dblclick event of each matched element.
/// 2: dblclick(fn) - Binds a function to the dblclick event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("dblclick", fn) : this.trigger(name);
};
jQuery.fn["mousedown"] = function(fn) {
/// <summary>
/// Binds a function to the mousedown event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("mousedown", fn) : this.trigger(name);
};
jQuery.fn["mouseup"] = function(fn) {
/// <summary>
/// Bind a function to the mouseup event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("mouseup", fn) : this.trigger(name);
};
jQuery.fn["mousemove"] = function(fn) {
/// <summary>
/// Bind a function to the mousemove event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("mousemove", fn) : this.trigger(name);
};
jQuery.fn["mouseover"] = function(fn) {
/// <summary>
/// Bind a function to the mouseover event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("mouseover", fn) : this.trigger(name);
};
jQuery.fn["mouseout"] = function(fn) {
/// <summary>
/// Bind a function to the mouseout event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("mouseout", fn) : this.trigger(name);
};
jQuery.fn["mouseenter"] = function(fn) {
/// <summary>
/// Bind a function to the mouseenter event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("mouseenter", fn) : this.trigger(name);
};
jQuery.fn["mouseleave"] = function(fn) {
/// <summary>
/// Bind a function to the mouseleave event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("mouseleave", fn) : this.trigger(name);
};
jQuery.fn["change"] = function(fn) {
/// <summary>
/// 1: change() - Triggers the change event of each matched element.
/// 2: change(fn) - Binds a function to the change event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("change", fn) : this.trigger(name);
};
jQuery.fn["select"] = function(fn) {
/// <summary>
/// 1: select() - Triggers the select event of each matched element.
/// 2: select(fn) - Binds a function to the select event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("select", fn) : this.trigger(name);
};
jQuery.fn["submit"] = function(fn) {
/// <summary>
/// 1: submit() - Triggers the submit event of each matched element.
/// 2: submit(fn) - Binds a function to the submit event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("submit", fn) : this.trigger(name);
};
jQuery.fn["keydown"] = function(fn) {
/// <summary>
/// 1: keydown() - Triggers the keydown event of each matched element.
/// 2: keydown(fn) - Binds a function to the keydown event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("keydown", fn) : this.trigger(name);
};
jQuery.fn["keypress"] = function(fn) {
/// <summary>
/// 1: keypress() - Triggers the keypress event of each matched element.
/// 2: keypress(fn) - Binds a function to the keypress event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("keypress", fn) : this.trigger(name);
};
jQuery.fn["keyup"] = function(fn) {
/// <summary>
/// 1: keyup() - Triggers the keyup event of each matched element.
/// 2: keyup(fn) - Binds a function to the keyup event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("keyup", fn) : this.trigger(name);
};
jQuery.fn["error"] = function(fn) {
/// <summary>
/// 1: error() - Triggers the error event of each matched element.
/// 2: error(fn) - Binds a function to the error event of each matched element.
/// </summary>
/// <param name="fn" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return fn ? this.bind("error", fn) : this.trigger(name);
};
// Prevent memory leaks in IE
// And prevent errors on refresh with events like mouseover in other browsers
// Window isn't included so as not to unbind existing unload events
jQuery( window ).bind( 'unload', function(){
for ( var id in jQuery.cache )
// Skip the window
if ( id != 1 && jQuery.cache[ id ].handle )
jQuery.event.remove( jQuery.cache[ id ].handle.elem );
});
// [vsdoc] The following function has been modified for IntelliSense.
// [vsdoc] Stubbing support properties to "false" since we simulate IE.
(function(){
jQuery.support = {};
jQuery.support = {
// IE strips leading whitespace when .innerHTML is used
leadingWhitespace: false,
// Make sure that tbody elements aren't automatically inserted
// IE will insert them into empty tables
tbody: false,
// Make sure that you can get all elements in an <object> element
// IE 7 always returns no results
objectAll: false,
// Make sure that link elements get serialized correctly by innerHTML
// This requires a wrapper element in IE
htmlSerialize: false,
// Get the style information from getAttribute
// (IE uses .cssText insted)
style: false,
// Make sure that URLs aren't manipulated
// (IE normalizes it by default)
hrefNormalized: false,
// Make sure that element opacity exists
// (IE uses filter instead)
opacity: false,
// Verify style float existence
// (IE uses styleFloat instead of cssFloat)
cssFloat: false,
// Will be defined later
scriptEval: false,
noCloneEvent: false,
boxModel: false
};
})();
// [vsdoc] The following member has been modified for IntelliSense.
var styleFloat = "styleFloat";
jQuery.props = {
"for": "htmlFor",
"class": "className",
"float": styleFloat,
cssFloat: styleFloat,
styleFloat: styleFloat,
readonly: "readOnly",
maxlength: "maxLength",
cellspacing: "cellSpacing",
rowspan: "rowSpan",
tabindex: "tabIndex"
};
jQuery.fn.extend({
// Keep a copy of the old load
_load: jQuery.fn.load,
load: function( url, params, callback ) {
/// <summary>
/// Loads HTML from a remote file and injects it into the DOM. By default performs a GET request, but if parameters are included
/// then a POST will be performed.
/// </summary>
/// <param name="url" type="String">The URL of the HTML page to load.</param>
/// <param name="data" optional="true" type="Map">Key/value pairs that will be sent to the server.</param>
/// <param name="callback" optional="true" type="Function">The function called when the AJAX request is complete. It should map function(responseText, textStatus, XMLHttpRequest) such that this maps the injected DOM element.</param>
/// <returns type="jQuery" />
if ( typeof url !== "string" )
return this._load( url );
var off = url.indexOf(" ");
if ( off >= 0 ) {
var selector = url.slice(off, url.length);
url = url.slice(0, off);
}
// Default to a GET request
var type = "GET";
// If the second parameter was provided
if ( params )
// If it's a function
if ( jQuery.isFunction( params ) ) {
// We assume that it's the callback
callback = params;
params = null;
// Otherwise, build a param string
} else if( typeof params === "object" ) {
params = jQuery.param( params );
type = "POST";
}
var self = this;
// Request the remote document
jQuery.ajax({
url: url,
type: type,
dataType: "html",
data: params,
complete: function(res, status){
// If successful, inject the HTML into all the matched elements
if ( status == "success" || status == "notmodified" )
// See if a selector was specified
self.html( selector ?
// Create a dummy div to hold the results
jQuery("<div/>")
// inject the contents of the document in, removing the scripts
// to avoid any 'Permission Denied' errors in IE
.append(res.responseText.replace(/<script(.|\s)*?\/script>/g, ""))
// Locate the specified elements
.find(selector) :
// If not, just inject the full result
res.responseText );
if( callback )
self.each( callback, [res.responseText, status, res] );
}
});
return this;
},
serialize: function() {
/// <summary>
/// Serializes a set of input elements into a string of data.
/// </summary>
/// <returns type="String">The serialized result</returns>
return jQuery.param(this.serializeArray());
},
serializeArray: function() {
/// <summary>
/// Serializes all forms and form elements but returns a JSON data structure.
/// </summary>
/// <returns type="String">A JSON data structure representing the serialized items.</returns>
return this.map(function(){
return this.elements ? jQuery.makeArray(this.elements) : this;
})
.filter(function(){
return this.name && !this.disabled &&
(this.checked || /select|textarea/i.test(this.nodeName) ||
/text|hidden|password|search/i.test(this.type));
})
.map(function(i, elem){
var val = jQuery(this).val();
return val == null ? null :
jQuery.isArray(val) ?
jQuery.map( val, function(val, i){
return {name: elem.name, value: val};
}) :
{name: elem.name, value: val};
}).get();
}
});
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
// Attach a bunch of functions for handling common AJAX events
// jQuery.each( "ajaxStart,ajaxStop,ajaxComplete,ajaxError,ajaxSuccess,ajaxSend".split(","), function(i,o){
// jQuery.fn[o] = function(f){
// return this.bind(o, f);
// };
// });
jQuery.fn["ajaxStart"] = function(callback) {
/// <summary>
/// Attach a function to be executed whenever an AJAX request begins and there is none already active. This is an Ajax Event.
/// </summary>
/// <param name="callback" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return this.bind("ajaxStart", f);
};
jQuery.fn["ajaxStop"] = function(callback) {
/// <summary>
/// Attach a function to be executed whenever all AJAX requests have ended. This is an Ajax Event.
/// </summary>
/// <param name="callback" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return this.bind("ajaxStop", f);
};
jQuery.fn["ajaxComplete"] = function(callback) {
/// <summary>
/// Attach a function to be executed whenever an AJAX request completes. This is an Ajax Event.
/// </summary>
/// <param name="callback" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return this.bind("ajaxComplete", f);
};
jQuery.fn["ajaxError"] = function(callback) {
/// <summary>
/// Attach a function to be executed whenever an AJAX request fails. This is an Ajax Event.
/// </summary>
/// <param name="callback" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return this.bind("ajaxError", f);
};
jQuery.fn["ajaxSuccess"] = function(callback) {
/// <summary>
/// Attach a function to be executed whenever an AJAX request completes successfully. This is an Ajax Event.
/// </summary>
/// <param name="callback" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return this.bind("ajaxSuccess", f);
};
jQuery.fn["ajaxSend"] = function(callback) {
/// <summary>
/// Attach a function to be executed before an AJAX request is sent. This is an Ajax Event.
/// </summary>
/// <param name="callback" type="Function">The function to execute.</param>
/// <returns type="jQuery" />
return this.bind("ajaxSend", f);
};
var jsc = now();
jQuery.extend({
get: function( url, data, callback, type ) {
/// <summary>
/// Loads a remote page using an HTTP GET request.
/// </summary>
/// <param name="url" type="String">The URL of the HTML page to load.</param>
/// <param name="data" optional="true" type="Map">Key/value pairs that will be sent to the server.</param>
/// <param name="callback" optional="true" type="Function">The function called when the AJAX request is complete. It should map function(responseText, textStatus) such that this maps the options for this AJAX request.</param>
/// <param name="type" optional="true" type="String">Type of data to be returned to callback function. Valid valiues are xml, html, script, json, text, _default.</param>
/// <returns type="XMLHttpRequest" />
// shift arguments if data argument was ommited
if ( jQuery.isFunction( data ) ) {
callback = data;
data = null;
}
return jQuery.ajax({
type: "GET",
url: url,
data: data,
success: callback,
dataType: type
});
},
getScript: function( url, callback ) {
/// <summary>
/// Loads and executes a local JavaScript file using an HTTP GET request.
/// </summary>
/// <param name="url" type="String">The URL of the script to load.</param>
/// <param name="callback" optional="true" type="Function">The function called when the AJAX request is complete. It should map function(data, textStatus) such that this maps the options for the AJAX request.</param>
/// <returns type="XMLHttpRequest" />
return jQuery.get(url, null, callback, "script");
},
getJSON: function( url, data, callback ) {
/// <summary>
/// Loads JSON data using an HTTP GET request.
/// </summary>
/// <param name="url" type="String">The URL of the JSON data to load.</param>
/// <param name="data" optional="true" type="Map">Key/value pairs that will be sent to the server.</param>
/// <param name="callback" optional="true" type="Function">The function called when the AJAX request is complete if the data is loaded successfully. It should map function(data, textStatus) such that this maps the options for this AJAX request.</param>
/// <returns type="XMLHttpRequest" />
return jQuery.get(url, data, callback, "json");
},
post: function( url, data, callback, type ) {
/// <summary>
/// Loads a remote page using an HTTP POST request.
/// </summary>
/// <param name="url" type="String">The URL of the HTML page to load.</param>
/// <param name="data" optional="true" type="Map">Key/value pairs that will be sent to the server.</param>
/// <param name="callback" optional="true" type="Function">The function called when the AJAX request is complete. It should map function(responseText, textStatus) such that this maps the options for this AJAX request.</param>
/// <param name="type" optional="true" type="String">Type of data to be returned to callback function. Valid valiues are xml, html, script, json, text, _default.</param>
/// <returns type="XMLHttpRequest" />
if ( jQuery.isFunction( data ) ) {
callback = data;
data = {};
}
return jQuery.ajax({
type: "POST",
url: url,
data: data,
success: callback,
dataType: type
});
},
ajaxSetup: function( settings ) {
/// <summary>
/// Sets up global settings for AJAX requests.
/// </summary>
/// <param name="settings" type="Options">A set of key/value pairs that configure the default Ajax request.</param>
jQuery.extend( jQuery.ajaxSettings, settings );
},
ajaxSettings: {
url: location.href,
global: true,
type: "GET",
contentType: "application/x-www-form-urlencoded",
processData: true,
async: true,
/*
timeout: 0,
data: null,
username: null,
password: null,
*/
// Create the request object; Microsoft failed to properly
// implement the XMLHttpRequest in IE7, so we use the ActiveXObject when it is available
// This function can be overriden by calling jQuery.ajaxSetup
xhr:function(){
return window.ActiveXObject ? new ActiveXObject("Microsoft.XMLHTTP") : new XMLHttpRequest();
},
accepts: {
xml: "application/xml, text/xml",
html: "text/html",
script: "text/javascript, application/javascript",
json: "application/json, text/javascript",
text: "text/plain",
_default: "*/*"
}
},
// Last-Modified header cache for next request
lastModified: {},
ajax: function( s ) {
/// <summary>
/// Load a remote page using an HTTP request.
/// </summary>
/// <private />
// Extend the settings, but re-extend 's' so that it can be
// checked again later (in the test suite, specifically)
s = jQuery.extend(true, s, jQuery.extend(true, {}, jQuery.ajaxSettings, s));
var jsonp, jsre = /=\?(&|$)/g, status, data,
type = s.type.toUpperCase();
// convert data if not already a string
if ( s.data && s.processData && typeof s.data !== "string" )
s.data = jQuery.param(s.data);
// Handle JSONP Parameter Callbacks
if ( s.dataType == "jsonp" ) {
if ( type == "GET" ) {
if ( !s.url.match(jsre) )
s.url += (s.url.match(/\?/) ? "&" : "?") + (s.jsonp || "callback") + "=?";
} else if ( !s.data || !s.data.match(jsre) )
s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
s.dataType = "json";
}
// Build temporary JSONP function
if ( s.dataType == "json" && (s.data && s.data.match(jsre) || s.url.match(jsre)) ) {
jsonp = "jsonp" + jsc++;
// Replace the =? sequence both in the query string and the data
if ( s.data )
s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
s.url = s.url.replace(jsre, "=" + jsonp + "$1");
// We need to make sure
// that a JSONP style response is executed properly
s.dataType = "script";
// Handle JSONP-style loading
window[ jsonp ] = function(tmp){
data = tmp;
success();
complete();
// Garbage collect
window[ jsonp ] = undefined;
try{ delete window[ jsonp ]; } catch(e){}
if ( head )
head.removeChild( script );
};
}
if ( s.dataType == "script" && s.cache == null )
s.cache = false;
if ( s.cache === false && type == "GET" ) {
var ts = now();
// try replacing _= if it is there
var ret = s.url.replace(/(\?|&)_=.*?(&|$)/, "$1_=" + ts + "$2");
// if nothing was replaced, add timestamp to the end
s.url = ret + ((ret == s.url) ? (s.url.match(/\?/) ? "&" : "?") + "_=" + ts : "");
}
// If data is available, append data to url for get requests
if ( s.data && type == "GET" ) {
s.url += (s.url.match(/\?/) ? "&" : "?") + s.data;
// IE likes to send both get and post data, prevent this
s.data = null;
}
// Watch for a new set of requests
if ( s.global && ! jQuery.active++ )
jQuery.event.trigger( "ajaxStart" );
// Matches an absolute URL, and saves the domain
var parts = /^(\w+:)?\/\/([^\/?#]+)/.exec( s.url );
// If we're requesting a remote document
// and trying to load JSON or Script with a GET
if ( s.dataType == "script" && type == "GET" && parts
&& ( parts[1] && parts[1] != location.protocol || parts[2] != location.host )){
var head = document.getElementsByTagName("head")[0];
var script = document.createElement("script");
script.src = s.url;
if (s.scriptCharset)
script.charset = s.scriptCharset;
// Handle Script loading
if ( !jsonp ) {
var done = false;
// Attach handlers for all browsers
script.onload = script.onreadystatechange = function(){
if ( !done && (!this.readyState ||
this.readyState == "loaded" || this.readyState == "complete") ) {
done = true;
success();
complete();
// Handle memory leak in IE
script.onload = script.onreadystatechange = null;
head.removeChild( script );
}
};
}
head.appendChild(script);
// We handle everything using the script element injection
return undefined;
}
var requestDone = false;
// Create the request object
var xhr = s.xhr();
// Open the socket
// Passing null username, generates a login popup on Opera (#2865)
if( s.username )
xhr.open(type, s.url, s.async, s.username, s.password);
else
xhr.open(type, s.url, s.async);
// Need an extra try/catch for cross domain requests in Firefox 3
try {
// Set the correct header, if data is being sent
if ( s.data )
xhr.setRequestHeader("Content-Type", s.contentType);
// Set the If-Modified-Since header, if ifModified mode.
if ( s.ifModified )
xhr.setRequestHeader("If-Modified-Since",
jQuery.lastModified[s.url] || "Thu, 01 Jan 1970 00:00:00 GMT" );
// Set header so the called script knows that it's an XMLHttpRequest
xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
// Set the Accepts header for the server, depending on the dataType
xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
s.accepts[ s.dataType ] + ", */*" :
s.accepts._default );
} catch(e){}
// Allow custom headers/mimetypes and early abort
if ( s.beforeSend && s.beforeSend(xhr, s) === false ) {
// Handle the global AJAX counter
if ( s.global && ! --jQuery.active )
jQuery.event.trigger( "ajaxStop" );
// close opended socket
xhr.abort();
return false;
}
if ( s.global )
jQuery.event.trigger("ajaxSend", [xhr, s]);
// Wait for a response to come back
var onreadystatechange = function(isTimeout){
// The request was aborted, clear the interval and decrement jQuery.active
if (xhr.readyState == 0) {
if (ival) {
// clear poll interval
clearInterval(ival);
ival = null;
// Handle the global AJAX counter
if ( s.global && ! --jQuery.active )
jQuery.event.trigger( "ajaxStop" );
}
// The transfer is complete and the data is available, or the request timed out
} else if ( !requestDone && xhr && (xhr.readyState == 4 || isTimeout == "timeout") ) {
requestDone = true;
// clear poll interval
if (ival) {
clearInterval(ival);
ival = null;
}
status = isTimeout == "timeout" ? "timeout" :
!jQuery.httpSuccess( xhr ) ? "error" :
s.ifModified && jQuery.httpNotModified( xhr, s.url ) ? "notmodified" :
"success";
if ( status == "success" ) {
// Watch for, and catch, XML document parse errors
try {
// process the data (runs the xml through httpData regardless of callback)
data = jQuery.httpData( xhr, s.dataType, s );
} catch(e) {
status = "parsererror";
}
}
// Make sure that the request was successful or notmodified
if ( status == "success" ) {
// Cache Last-Modified header, if ifModified mode.
var modRes;
try {
modRes = xhr.getResponseHeader("Last-Modified");
} catch(e) {} // swallow exception thrown by FF if header is not available
if ( s.ifModified && modRes )
jQuery.lastModified[s.url] = modRes;
// JSONP handles its own success callback
if ( !jsonp )
success();
} else
jQuery.handleError(s, xhr, status);
// Fire the complete handlers
complete();
if ( isTimeout )
xhr.abort();
// Stop memory leaks
if ( s.async )
xhr = null;
}
};
if ( s.async ) {
// don't attach the handler to the request, just poll it instead
var ival = setInterval(onreadystatechange, 13);
// Timeout checker
if ( s.timeout > 0 )
setTimeout(function(){
// Check to see if the request is still happening
if ( xhr && !requestDone )
onreadystatechange( "timeout" );
}, s.timeout);
}
// Send the data
try {
xhr.send(s.data);
} catch(e) {
jQuery.handleError(s, xhr, null, e);
}
// firefox 1.5 doesn't fire statechange for sync requests
if ( !s.async )
onreadystatechange();
function success(){
// If a local callback was specified, fire it and pass it the data
if ( s.success )
s.success( data, status );
// Fire the global callback
if ( s.global )
jQuery.event.trigger( "ajaxSuccess", [xhr, s] );
}
function complete(){
// Process result
if ( s.complete )
s.complete(xhr, status);
// The request was completed
if ( s.global )
jQuery.event.trigger( "ajaxComplete", [xhr, s] );
// Handle the global AJAX counter
if ( s.global && ! --jQuery.active )
jQuery.event.trigger( "ajaxStop" );
}
// return XMLHttpRequest to allow aborting the request etc.
return xhr;
},
handleError: function( s, xhr, status, e ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
// If a local callback was specified, fire it
if ( s.error ) s.error( xhr, status, e );
// Fire the global callback
if ( s.global )
jQuery.event.trigger( "ajaxError", [xhr, s, e] );
},
// Counter for holding the number of active queries
active: 0,
// Determines if an XMLHttpRequest was successful or not
httpSuccess: function( xhr ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
try {
// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
return !xhr.status && location.protocol == "file:" ||
( xhr.status >= 200 && xhr.status < 300 ) || xhr.status == 304 || xhr.status == 1223;
} catch(e){}
return false;
},
// Determines if an XMLHttpRequest returns NotModified
httpNotModified: function( xhr, url ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
try {
var xhrRes = xhr.getResponseHeader("Last-Modified");
// Firefox always returns 200. check Last-Modified date
return xhr.status == 304 || xhrRes == jQuery.lastModified[url];
} catch(e){}
return false;
},
httpData: function( xhr, type, s ) {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
var ct = xhr.getResponseHeader("content-type"),
xml = type == "xml" || !type && ct && ct.indexOf("xml") >= 0,
data = xml ? xhr.responseXML : xhr.responseText;
if ( xml && data.documentElement.tagName == "parsererror" )
throw "parsererror";
// Allow a pre-filtering function to sanitize the response
// s != null is checked to keep backwards compatibility
if( s && s.dataFilter )
data = s.dataFilter( data, type );
// The filter can actually parse the response
if( typeof data === "string" ){
// If the type is "script", eval it in global context
if ( type == "script" )
jQuery.globalEval( data );
// Get the JavaScript object, if JSON is used.
if ( type == "json" )
data = window["eval"]("(" + data + ")");
}
return data;
},
// Serialize an array of form elements or a set of
// key/values into a query string
param: function( a ) {
/// <summary>
/// This method is internal. Use serialize() instead.
/// </summary>
/// <param name="a" type="Map">A map of key/value pairs to serialize into a string.</param>'
/// <returns type="String" />
/// <private />
var s = [ ];
function add( key, value ){
s[ s.length ] = encodeURIComponent(key) + '=' + encodeURIComponent(value);
};
// If an array was passed in, assume that it is an array
// of form elements
if ( jQuery.isArray(a) || a.jquery )
// Serialize the form elements
jQuery.each( a, function(){
add( this.name, this.value );
});
// Otherwise, assume that it's an object of key/value pairs
else
// Serialize the key/values
for ( var j in a )
// If the value is an array then the key names need to be repeated
if ( jQuery.isArray(a[j]) )
jQuery.each( a[j], function(){
add( j, this );
});
else
add( j, jQuery.isFunction(a[j]) ? a[j]() : a[j] );
// Return the resulting serialization
return s.join("&").replace(/%20/g, "+");
}
});
var elemdisplay = {},
timerId,
fxAttrs = [
// height animations
[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
// width animations
[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
// opacity animations
[ "opacity" ]
];
function genFx( type, num ){
var obj = {};
jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function(){
obj[ this ] = type;
});
return obj;
}
jQuery.fn.extend({
show: function(speed,callback){
/// <summary>
/// Show all matched elements using a graceful animation and firing an optional callback after completion.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
if ( speed ) {
return this.animate( genFx("show", 3), speed, callback);
} else {
for ( var i = 0, l = this.length; i < l; i++ ){
var old = jQuery.data(this[i], "olddisplay");
this[i].style.display = old || "";
if ( jQuery.css(this[i], "display") === "none" ) {
var tagName = this[i].tagName, display;
if ( elemdisplay[ tagName ] ) {
display = elemdisplay[ tagName ];
} else {
var elem = jQuery("<" + tagName + " />").appendTo("body");
display = elem.css("display");
if ( display === "none" )
display = "block";
elem.remove();
elemdisplay[ tagName ] = display;
}
jQuery.data(this[i], "olddisplay", display);
}
}
// Set the display of the elements in a second loop
// to avoid the constant reflow
for ( var i = 0, l = this.length; i < l; i++ ){
this[i].style.display = jQuery.data(this[i], "olddisplay") || "";
}
return this;
}
},
hide: function(speed,callback){
/// <summary>
/// Hides all matched elements using a graceful animation and firing an optional callback after completion.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
if ( speed ) {
return this.animate( genFx("hide", 3), speed, callback);
} else {
for ( var i = 0, l = this.length; i < l; i++ ){
var old = jQuery.data(this[i], "olddisplay");
if ( !old && old !== "none" )
jQuery.data(this[i], "olddisplay", jQuery.css(this[i], "display"));
}
// Set the display of the elements in a second loop
// to avoid the constant reflow
for ( var i = 0, l = this.length; i < l; i++ ){
this[i].style.display = "none";
}
return this;
}
},
// Save the old toggle function
_toggle: jQuery.fn.toggle,
toggle: function( fn, fn2 ){
/// <summary>
/// Toggles displaying each of the set of matched elements.
/// </summary>
/// <returns type="jQuery" />
var bool = typeof fn === "boolean";
return jQuery.isFunction(fn) && jQuery.isFunction(fn2) ?
this._toggle.apply( this, arguments ) :
fn == null || bool ?
this.each(function(){
var state = bool ? fn : jQuery(this).is(":hidden");
jQuery(this)[ state ? "show" : "hide" ]();
}) :
this.animate(genFx("toggle", 3), fn, fn2);
},
fadeTo: function(speed,to,callback){
/// <summary>
/// Fades the opacity of all matched elements to a specified opacity.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
return this.animate({opacity: to}, speed, callback);
},
animate: function( prop, speed, easing, callback ) {
/// <summary>
/// A function for making custom animations.
/// </summary>
/// <param name="prop" type="Options">A set of style attributes that you wish to animate and to what end.</param>
/// <param name="speed" optional="true" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="easing" optional="true" type="String">The name of the easing effect that you want to use. There are two built-in values, 'linear' and 'swing'.</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
var optall = jQuery.speed(speed, easing, callback);
return this[ optall.queue === false ? "each" : "queue" ](function(){
var opt = jQuery.extend({}, optall), p,
hidden = this.nodeType == 1 && jQuery(this).is(":hidden"),
self = this;
for ( p in prop ) {
if ( prop[p] == "hide" && hidden || prop[p] == "show" && !hidden )
return opt.complete.call(this);
if ( ( p == "height" || p == "width" ) && this.style ) {
// Store display property
opt.display = jQuery.css(this, "display");
// Make sure that nothing sneaks out
opt.overflow = this.style.overflow;
}
}
if ( opt.overflow != null )
this.style.overflow = "hidden";
opt.curAnim = jQuery.extend({}, prop);
jQuery.each( prop, function(name, val){
var e = new jQuery.fx( self, opt, name );
if ( /toggle|show|hide/.test(val) )
e[ val == "toggle" ? hidden ? "show" : "hide" : val ]( prop );
else {
var parts = val.toString().match(/^([+-]=)?([\d+-.]+)(.*)$/),
start = e.cur(true) || 0;
if ( parts ) {
var end = parseFloat(parts[2]),
unit = parts[3] || "px";
// We need to compute starting value
if ( unit != "px" ) {
self.style[ name ] = (end || 1) + unit;
start = ((end || 1) / e.cur(true)) * start;
self.style[ name ] = start + unit;
}
// If a +=/-= token was provided, we're doing a relative animation
if ( parts[1] )
end = ((parts[1] == "-=" ? -1 : 1) * end) + start;
e.custom( start, end, unit );
} else
e.custom( start, val, "" );
}
});
// For JS strict compliance
return true;
});
},
stop: function(clearQueue, gotoEnd){
/// <summary>
/// Stops all currently animations on the specified elements.
/// </summary>
/// <param name="clearQueue" optional="true" type="Boolean">True to clear animations that are queued to run.</param>
/// <param name="gotoEnd" optional="true" type="Boolean">True to move the element value to the end of its animation target.</param>
/// <returns type="jQuery" />
var timers = jQuery.timers;
if (clearQueue)
this.queue([]);
this.each(function(){
// go in reverse order so anything added to the queue during the loop is ignored
for ( var i = timers.length - 1; i >= 0; i-- )
if ( timers[i].elem == this ) {
if (gotoEnd)
// force the next step to be the last
timers[i](true);
timers.splice(i, 1);
}
});
// start the next in the queue if the last step wasn't forced
if (!gotoEnd)
this.dequeue();
return this;
}
});
// Generate shortcuts for custom animations
// jQuery.each({
// slideDown: genFx("show", 1),
// slideUp: genFx("hide", 1),
// slideToggle: genFx("toggle", 1),
// fadeIn: { opacity: "show" },
// fadeOut: { opacity: "hide" }
// }, function( name, props ){
// jQuery.fn[ name ] = function( speed, callback ){
// return this.animate( props, speed, callback );
// };
// });
// [vsdoc] The following section has been denormalized from original sources for IntelliSense.
jQuery.fn.slideDown = function( speed, callback ){
/// <summary>
/// Reveal all matched elements by adjusting their height.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
return this.animate( genFx("show", 1), speed, callback );
};
jQuery.fn.slideUp = function( speed, callback ){
/// <summary>
/// Hiding all matched elements by adjusting their height.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
return this.animate( genFx("hide", 1), speed, callback );
};
jQuery.fn.slideToggle = function( speed, callback ){
/// <summary>
/// Toggles the visibility of all matched elements by adjusting their height.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
return this.animate( genFx("toggle", 1), speed, callback );
};
jQuery.fn.fadeIn = function( speed, callback ){
/// <summary>
/// Fades in all matched elements by adjusting their opacity.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
return this.animate( { opacity: "show" }, speed, callback );
};
jQuery.fn.fadeOut = function( speed, callback ){
/// <summary>
/// Fades the opacity of all matched elements to a specified opacity.
/// </summary>
/// <param name="speed" type="String">A string representing one of three predefined speeds ('slow', 'normal', or 'fast'), or
/// the number of milliseconds to run the animation</param>
/// <param name="callback" optional="true" type="Function">A function to be executed whenever the animation completes, once for each animated element. It should map function callback() such that this is the DOM element being animated.</param>
/// <returns type="jQuery" />
return this.animate( { opacity: "hide" }, speed, callback );
};
jQuery.extend({
speed: function(speed, easing, fn) {
/// <summary>
/// This member is internal.
/// </summary>
/// <private />
var opt = typeof speed === "object" ? speed : {
complete: fn || !fn && easing ||
jQuery.isFunction( speed ) && speed,
duration: speed,
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
};
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
jQuery.fx.speeds[opt.duration] || jQuery.fx.speeds._default;
// Queueing
opt.old = opt.complete;
opt.complete = function(){
if ( opt.queue !== false )
jQuery(this).dequeue();
if ( jQuery.isFunction( opt.old ) )
opt.old.call( this );
};
return opt;
},
easing: {
linear: function( p, n, firstNum, diff ) {
/// <summary>
/// This member is internal.
/// </summary>
/// <private />
return firstNum + diff * p;
},
swing: function( p, n, firstNum, diff ) {
/// <summary>
/// This member is internal.
/// </summary>
/// <private />
return ((-Math.cos(p*Math.PI)/2) + 0.5) * diff + firstNum;
}
},
timers: [],
fx: function( elem, options, prop ){
/// <summary>
/// This member is internal.
/// </summary>
/// <private />
this.options = options;
this.elem = elem;
this.prop = prop;
if ( !options.orig )
options.orig = {};
}
});
jQuery.fx.prototype = {
// Simple function for setting a style value
update: function(){
/// <summary>
/// This member is internal.
/// </summary>
/// <private />
if ( this.options.step )
this.options.step.call( this.elem, this.now, this );
(jQuery.fx.step[this.prop] || jQuery.fx.step._default)( this );
// Set display property to block for height/width animations
if ( ( this.prop == "height" || this.prop == "width" ) && this.elem.style )
this.elem.style.display = "block";
},
// Get the current size
cur: function(force){
/// <summary>
/// This member is internal.
/// </summary>
/// <private />
if ( this.elem[this.prop] != null && (!this.elem.style || this.elem.style[this.prop] == null) )
return this.elem[ this.prop ];
var r = parseFloat(jQuery.css(this.elem, this.prop, force));
return r && r > -10000 ? r : parseFloat(jQuery.curCSS(this.elem, this.prop)) || 0;
},
// Start an animation from one number to another
custom: function(from, to, unit){
this.startTime = now();
this.start = from;
this.end = to;
this.unit = unit || this.unit || "px";
this.now = this.start;
this.pos = this.state = 0;
var self = this;
function t(gotoEnd){
return self.step(gotoEnd);
}
t.elem = this.elem;
if ( t() && jQuery.timers.push(t) && !timerId ) {
timerId = setInterval(function(){
var timers = jQuery.timers;
for ( var i = 0; i < timers.length; i++ )
if ( !timers[i]() )
timers.splice(i--, 1);
if ( !timers.length ) {
clearInterval( timerId );
timerId = undefined;
}
}, 13);
}
},
// Simple 'show' function
show: function(){
/// <summary>
/// Displays each of the set of matched elements if they are hidden.
/// </summary>
// Remember where we started, so that we can go back to it later
this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
this.options.show = true;
// Begin the animation
// Make sure that we start at a small width/height to avoid any
// flash of content
this.custom(this.prop == "width" || this.prop == "height" ? 1 : 0, this.cur());
// Start by showing the element
jQuery(this.elem).show();
},
// Simple 'hide' function
hide: function(){
/// <summary>
/// Hides each of the set of matched elements if they are shown.
/// </summary>
// Remember where we started, so that we can go back to it later
this.options.orig[this.prop] = jQuery.attr( this.elem.style, this.prop );
this.options.hide = true;
// Begin the animation
this.custom(this.cur(), 0);
},
// Each step of an animation
step: function(gotoEnd){
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
var t = now();
if ( gotoEnd || t >= this.options.duration + this.startTime ) {
this.now = this.end;
this.pos = this.state = 1;
this.update();
this.options.curAnim[ this.prop ] = true;
var done = true;
for ( var i in this.options.curAnim )
if ( this.options.curAnim[i] !== true )
done = false;
if ( done ) {
if ( this.options.display != null ) {
// Reset the overflow
this.elem.style.overflow = this.options.overflow;
// Reset the display
this.elem.style.display = this.options.display;
if ( jQuery.css(this.elem, "display") == "none" )
this.elem.style.display = "block";
}
// Hide the element if the "hide" operation was done
if ( this.options.hide )
jQuery(this.elem).hide();
// Reset the properties, if the item has been hidden or shown
if ( this.options.hide || this.options.show )
for ( var p in this.options.curAnim )
jQuery.attr(this.elem.style, p, this.options.orig[p]);
// Execute the complete function
this.options.complete.call( this.elem );
}
return false;
} else {
var n = t - this.startTime;
this.state = n / this.options.duration;
// Perform the easing function, defaults to swing
this.pos = jQuery.easing[this.options.easing || (jQuery.easing.swing ? "swing" : "linear")](this.state, n, 0, 1, this.options.duration);
this.now = this.start + ((this.end - this.start) * this.pos);
// Perform the next step of the animation
this.update();
}
return true;
}
};
jQuery.extend( jQuery.fx, {
speeds:{
slow: 600,
fast: 200,
// Default speed
_default: 400
},
step: {
opacity: function(fx){
jQuery.attr(fx.elem.style, "opacity", fx.now);
},
_default: function(fx){
if ( fx.elem.style && fx.elem.style[ fx.prop ] != null )
fx.elem.style[ fx.prop ] = fx.now + fx.unit;
else
fx.elem[ fx.prop ] = fx.now;
}
}
});
if ( document.documentElement["getBoundingClientRect"] )
jQuery.fn.offset = function() {
/// <summary>
/// Gets the current offset of the first matched element relative to the viewport.
/// </summary>
/// <returns type="Object">An object with two Integer properties, 'top' and 'left'.</returns>
if ( !this[0] ) return { top: 0, left: 0 };
if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
var box = this[0].getBoundingClientRect(), doc = this[0].ownerDocument, body = doc.body, docElem = doc.documentElement,
clientTop = docElem.clientTop || body.clientTop || 0, clientLeft = docElem.clientLeft || body.clientLeft || 0,
top = box.top + (self.pageYOffset || jQuery.boxModel && docElem.scrollTop || body.scrollTop ) - clientTop,
left = box.left + (self.pageXOffset || jQuery.boxModel && docElem.scrollLeft || body.scrollLeft) - clientLeft;
return { top: top, left: left };
};
else
jQuery.fn.offset = function() {
/// <summary>
/// Gets the current offset of the first matched element relative to the viewport.
/// </summary>
/// <returns type="Object">An object with two Integer properties, 'top' and 'left'.</returns>
if ( !this[0] ) return { top: 0, left: 0 };
if ( this[0] === this[0].ownerDocument.body ) return jQuery.offset.bodyOffset( this[0] );
jQuery.offset.initialized || jQuery.offset.initialize();
var elem = this[0], offsetParent = elem.offsetParent, prevOffsetParent = elem,
doc = elem.ownerDocument, computedStyle, docElem = doc.documentElement,
body = doc.body, defaultView = doc.defaultView,
prevComputedStyle = defaultView.getComputedStyle(elem, null),
top = elem.offsetTop, left = elem.offsetLeft;
while ( (elem = elem.parentNode) && elem !== body && elem !== docElem ) {
computedStyle = defaultView.getComputedStyle(elem, null);
top -= elem.scrollTop, left -= elem.scrollLeft;
if ( elem === offsetParent ) {
top += elem.offsetTop, left += elem.offsetLeft;
if ( jQuery.offset.doesNotAddBorder && !(jQuery.offset.doesAddBorderForTableAndCells && /^t(able|d|h)$/i.test(elem.tagName)) )
top += parseInt( computedStyle.borderTopWidth, 10) || 0,
left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
prevOffsetParent = offsetParent, offsetParent = elem.offsetParent;
}
if ( jQuery.offset.subtractsBorderForOverflowNotVisible && computedStyle.overflow !== "visible" )
top += parseInt( computedStyle.borderTopWidth, 10) || 0,
left += parseInt( computedStyle.borderLeftWidth, 10) || 0;
prevComputedStyle = computedStyle;
}
if ( prevComputedStyle.position === "relative" || prevComputedStyle.position === "static" )
top += body.offsetTop,
left += body.offsetLeft;
if ( prevComputedStyle.position === "fixed" )
top += Math.max(docElem.scrollTop, body.scrollTop),
left += Math.max(docElem.scrollLeft, body.scrollLeft);
return { top: top, left: left };
};
jQuery.offset = {
initialize: function() {
if ( this.initialized ) return;
var body = document.body, container = document.createElement('div'), innerDiv, checkDiv, table, td, rules, prop, bodyMarginTop = body.style.marginTop,
html = '<div style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"><div></div></div><table style="position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;"cellpadding="0"cellspacing="0"><tr><td></td></tr></table>';
rules = { position: 'absolute', top: 0, left: 0, margin: 0, border: 0, width: '1px', height: '1px', visibility: 'hidden' };
for ( prop in rules ) container.style[prop] = rules[prop];
container.innerHTML = html;
body.insertBefore(container, body.firstChild);
innerDiv = container.firstChild, checkDiv = innerDiv.firstChild, td = innerDiv.nextSibling.firstChild.firstChild;
this.doesNotAddBorder = (checkDiv.offsetTop !== 5);
this.doesAddBorderForTableAndCells = (td.offsetTop === 5);
innerDiv.style.overflow = 'hidden', innerDiv.style.position = 'relative';
this.subtractsBorderForOverflowNotVisible = (checkDiv.offsetTop === -5);
body.style.marginTop = '1px';
this.doesNotIncludeMarginInBodyOffset = (body.offsetTop === 0);
body.style.marginTop = bodyMarginTop;
body.removeChild(container);
this.initialized = true;
},
bodyOffset: function(body) {
jQuery.offset.initialized || jQuery.offset.initialize();
var top = body.offsetTop, left = body.offsetLeft;
if ( jQuery.offset.doesNotIncludeMarginInBodyOffset )
top += parseInt( jQuery.curCSS(body, 'marginTop', true), 10 ) || 0,
left += parseInt( jQuery.curCSS(body, 'marginLeft', true), 10 ) || 0;
return { top: top, left: left };
}
};
jQuery.fn.extend({
position: function() {
/// <summary>
/// Gets the top and left positions of an element relative to its offset parent.
/// </summary>
/// <returns type="Object">An object with two integer properties, 'top' and 'left'.</returns>
var left = 0, top = 0, results;
if ( this[0] ) {
// Get *real* offsetParent
var offsetParent = this.offsetParent(),
// Get correct offsets
offset = this.offset(),
parentOffset = /^body|html$/i.test(offsetParent[0].tagName) ? { top: 0, left: 0 } : offsetParent.offset();
// Subtract element margins
// note: when an element has margin: auto the offsetLeft and marginLeft
// are the same in Safari causing offset.left to incorrectly be 0
offset.top -= num( this, 'marginTop' );
offset.left -= num( this, 'marginLeft' );
// Add offsetParent borders
parentOffset.top += num( offsetParent, 'borderTopWidth' );
parentOffset.left += num( offsetParent, 'borderLeftWidth' );
// Subtract the two offsets
results = {
top: offset.top - parentOffset.top,
left: offset.left - parentOffset.left
};
}
return results;
},
offsetParent: function() {
/// <summary>
/// This method is internal.
/// </summary>
/// <private />
var offsetParent = this[0].offsetParent || document.body;
while ( offsetParent && (!/^body|html$/i.test(offsetParent.tagName) && jQuery.css(offsetParent, 'position') == 'static') )
offsetParent = offsetParent.offsetParent;
return jQuery(offsetParent);
}
});
// Create scrollLeft and scrollTop methods
jQuery.each( ['Left'], function(i, name) {
var method = 'scroll' + name;
jQuery.fn[ method ] = function(val) {
/// <summary>
/// Gets and optionally sets the scroll left offset of the first matched element.
/// </summary>
/// <param name="val" type="Number" integer="true" optional="true">A positive number representing the desired scroll left offset.</param>
/// <returns type="Number" integer="true">The scroll left offset of the first matched element.</returns>
if (!this[0]) return null;
return val !== undefined ?
// Set the scroll offset
this.each(function() {
this == window || this == document ?
window.scrollTo(
!i ? val : jQuery(window).scrollLeft(),
i ? val : jQuery(window).scrollTop()
) :
this[ method ] = val;
}) :
// Return the scroll offset
this[0] == window || this[0] == document ?
self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
jQuery.boxModel && document.documentElement[ method ] ||
document.body[ method ] :
this[0][ method ];
};
});
// Create scrollLeft and scrollTop methods
jQuery.each( ['Top'], function(i, name) {
var method = 'scroll' + name;
jQuery.fn[ method ] = function(val) {
/// <summary>
/// Gets and optionally sets the scroll top offset of the first matched element.
/// </summary>
/// <param name="val" type="Number" integer="true" optional="true">A positive number representing the desired scroll top offset.</param>
/// <returns type="Number" integer="true">The scroll top offset of the first matched element.</returns>
if (!this[0]) return null;
return val !== undefined ?
// Set the scroll offset
this.each(function() {
this == window || this == document ?
window.scrollTo(
!i ? val : jQuery(window).scrollLeft(),
i ? val : jQuery(window).scrollTop()
) :
this[ method ] = val;
}) :
// Return the scroll offset
this[0] == window || this[0] == document ?
self[ i ? 'pageYOffset' : 'pageXOffset' ] ||
jQuery.boxModel && document.documentElement[ method ] ||
document.body[ method ] :
this[0][ method ];
};
});
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
jQuery.each([ "Height" ], function(i, name){
var tl = i ? "Left" : "Top", // top or left
br = i ? "Right" : "Bottom", // bottom or right
lower = name.toLowerCase();
// innerHeight and innerWidth
jQuery.fn["inner" + name] = function(){
/// <summary>
/// Gets the inner height of the first matched element, excluding border but including padding.
/// </summary>
/// <returns type="Number" integer="true">The outer height of the first matched element.</returns>
return this[0] ?
jQuery.css( this[0], lower, false, "padding" ) :
null;
};
// outerHeight and outerWidth
jQuery.fn["outer" + name] = function(margin) {
/// <summary>
/// Gets the outer height of the first matched element, including border and padding by default.
/// </summary>
/// <param name="margins" type="Map">A set of key/value pairs that specify the options for the method.</param>
/// <returns type="Number" integer="true">The outer height of the first matched element.</returns>
return this[0] ?
jQuery.css( this[0], lower, false, margin ? "margin" : "border" ) :
null;
};
var type = name.toLowerCase();
jQuery.fn[ type ] = function( size ) {
/// <summary>
/// Set the CSS height of every matched element. If no explicit unit
/// was specified (like 'em' or '%') then "px" is added to the width. If no parameter is specified, it gets
/// the current computed pixel height of the first matched element.
/// Part of CSS
/// </summary>
/// <returns type="jQuery" type="jQuery" />
/// <param name="cssProperty" type="String">
/// Set the CSS property to the specified value. Omit to get the value of the first matched element.
/// </param>
// Get window width or height
return this[0] == window ?
// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] ||
document.body[ "client" + name ] :
// Get document width or height
this[0] == document ?
// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
Math.max(
document.documentElement["client" + name],
document.body["scroll" + name], document.documentElement["scroll" + name],
document.body["offset" + name], document.documentElement["offset" + name]
) :
// Get or set width or height on the element
size === undefined ?
// Get width or height on the element
(this.length ? jQuery.css( this[0], type ) : null) :
// Set the width or height on the element (default to pixels if value is unitless)
this.css( type, typeof size === "string" ? size : size + "px" );
};
});
// Create innerHeight, innerWidth, outerHeight and outerWidth methods
jQuery.each([ "Width" ], function(i, name){
var tl = i ? "Left" : "Top", // top or left
br = i ? "Right" : "Bottom", // bottom or right
lower = name.toLowerCase();
// innerHeight and innerWidth
jQuery.fn["inner" + name] = function(){
/// <summary>
/// Gets the inner width of the first matched element, excluding border but including padding.
/// </summary>
/// <returns type="Number" integer="true">The outer width of the first matched element.</returns>
return this[0] ?
jQuery.css( this[0], lower, false, "padding" ) :
null;
};
// outerHeight and outerWidth
jQuery.fn["outer" + name] = function(margin) {
/// <summary>
/// Gets the outer width of the first matched element, including border and padding by default.
/// </summary>
/// <param name="margins" type="Map">A set of key/value pairs that specify the options for the method.</param>
/// <returns type="Number" integer="true">The outer width of the first matched element.</returns>
return this[0] ?
jQuery.css( this[0], lower, false, margin ? "margin" : "border" ) :
null;
};
var type = name.toLowerCase();
jQuery.fn[ type ] = function( size ) {
/// <summary>
/// Set the CSS width of every matched element. If no explicit unit
/// was specified (like 'em' or '%') then "px" is added to the width. If no parameter is specified, it gets
/// the current computed pixel width of the first matched element.
/// Part of CSS
/// </summary>
/// <returns type="jQuery" type="jQuery" />
/// <param name="cssProperty" type="String">
/// Set the CSS property to the specified value. Omit to get the value of the first matched element.
/// </param>
// Get window width or height
return this[0] == window ?
// Everyone else use document.documentElement or document.body depending on Quirks vs Standards mode
document.compatMode == "CSS1Compat" && document.documentElement[ "client" + name ] ||
document.body[ "client" + name ] :
// Get document width or height
this[0] == document ?
// Either scroll[Width/Height] or offset[Width/Height], whichever is greater
Math.max(
document.documentElement["client" + name],
document.body["scroll" + name], document.documentElement["scroll" + name],
document.body["offset" + name], document.documentElement["offset" + name]
) :
// Get or set width or height on the element
size === undefined ?
// Get width or height on the element
(this.length ? jQuery.css( this[0], type ) : null) :
// Set the width or height on the element (default to pixels if value is unitless)
this.css( type, typeof size === "string" ? size : size + "px" );
};
});
})();
|
'use strict';
module.exports = {
db: 'mongodb://db/ooni',
app: {
title: 'OONI MEAN - Development Environment'
},
facebook: {
clientID: process.env.FACEBOOK_ID || 'APP_ID',
clientSecret: process.env.FACEBOOK_SECRET || 'APP_SECRET',
callbackURL: '/auth/facebook/callback'
},
twitter: {
clientID: process.env.TWITTER_KEY || 'CONSUMER_KEY',
clientSecret: process.env.TWITTER_SECRET || 'CONSUMER_SECRET',
callbackURL: '/auth/twitter/callback'
},
google: {
clientID: process.env.GOOGLE_ID || 'APP_ID',
clientSecret: process.env.GOOGLE_SECRET || 'APP_SECRET',
callbackURL: '/auth/google/callback'
},
linkedin: {
clientID: process.env.LINKEDIN_ID || 'APP_ID',
clientSecret: process.env.LINKEDIN_SECRET || 'APP_SECRET',
callbackURL: '/auth/linkedin/callback'
},
github: {
clientID: process.env.GITHUB_ID || 'APP_ID',
clientSecret: process.env.GITHUB_SECRET || 'APP_SECRET',
callbackURL: '/auth/github/callback'
},
mailer: {
from: process.env.MAILER_FROM || 'MAILER_FROM',
options: {
service: process.env.MAILER_SERVICE_PROVIDER || 'MAILER_SERVICE_PROVIDER',
auth: {
user: process.env.MAILER_EMAIL_ID || 'MAILER_EMAIL_ID',
pass: process.env.MAILER_PASSWORD || 'MAILER_PASSWORD'
}
}
}
};
|
module.exports = function(arg) {
return typeof arg === 'string';
}
|
/*global define*/
///////////////////////////////////////////////////////////////////////////
// Copyright © Esri. All Rights Reserved.
//
// Licensed under the Apache License Version 2.0 (the 'License');
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an 'AS IS' BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
///////////////////////////////////////////////////////////////////////////
define({
"units": {
"miles": {
"displayText": "英里",
"acronym": "mi"
},
"kilometers": {
"displayText": "千米",
"acronym": "km"
},
"feet": {
"displayText": "英尺",
"acronym": "ft"
},
"meters": {
"displayText": "米",
"acronym": "m"
}
},
"searchSourceSetting": {
"searchSourceSettingTabTitle": "搜索源设置",
"searchSourceSettingTitle": "搜索源设置",
"searchSourceSettingTitleHintText": "添加并配置地理编码服务或要素图层为搜索源。这些指定的源决定了搜索框中的可搜索内容",
"addSearchSourceLabel": "添加搜索源",
"featureLayerLabel": "要素图层",
"geocoderLabel": "地理编码器",
"nameTitle": "名称",
"generalSettingLabel": "常规设置",
"allPlaceholderLabel": "用于搜索全部内容的占位符文本：",
"allPlaceholderHintText": "提示：搜索所有图层和 geocoder 时请输入要显示为占位符的文本",
"generalSettingCheckboxLabel": "显示已找到要素或位置的弹出窗口",
"countryCode": "国家或区域代码",
"countryCodeEg": "例如 ",
"countryCodeHint": "将此值留空可搜索所有国家和地区",
"questionMark": "?",
"searchInCurrentMapExtent": "仅在当前地图范围内搜索",
"zoomScale": "缩放比例",
"locatorUrl": "地理编码器 URL",
"locatorName": "地理编码器名称",
"locatorExample": "示例",
"locatorWarning": "不支持此版本的地理编码服务。该微件支持 10.0 及更高版本的地理编码服务。",
"locatorTips": "由于地理编码服务不支持建议功能，因此建议不可用。",
"layerSource": "图层源",
"setLayerSource": "设置图层源",
"setGeocoderURL": "设置地理编码器 URL",
"searchLayerTips": "由于要素服务不支持分页功能，因此建议不可用。",
"placeholder": "占位符文本",
"searchFields": "搜索字段",
"displayField": "显示字段",
"exactMatch": "完全匹配",
"maxSuggestions": "最大建议数",
"maxResults": "最大结果数",
"enableLocalSearch": "启用本地搜索",
"minScale": "最小比例",
"minScaleHint": "如果地图比例大于此比例，将使用本地搜索",
"radius": "半径",
"radiusHint": "指定以当前地图中心为中心的区域半径，用于提升地理编码候选项的等级，以便先返回距离位置最近的候选项",
"meters": "米",
"setSearchFields": "设置搜索字段",
"set": "设置",
"fieldName": "名称",
"invalidUrlTip": "URL ${URL} 无效或不可访问。"
},
"searchSetting": {
"searchSettingTabTitle": "搜索设置",
"defaultBufferDistanceLabel": "设置默认缓冲距离",
"maxResultCountLabel": "限制结果数量",
"maxResultCountHintLabel": "提示：设置最大可见结果的数量。将值设置为 1 将返回最近的要素",
"maxBufferDistanceLabel": "设置最大缓冲距离",
"bufferDistanceUnitLabel": "缓冲距离单位",
"defaultBufferHintLabel": "提示: 设置缓冲滑块的默认值",
"maxBufferHintLabel": "提示: 设置缓冲滑块的最大值",
"bufferUnitLabel": "提示: 为创建缓冲定义单位",
"selectGraphicLocationSymbol": "地址或位置符号",
"graphicLocationSymbolHintText": "提示: 所搜索地址或所单击位置的符号",
"addressLocationPolygonHintText": "提示：配置的面图层符号，要用于邻域搜索。",
"popupTitleForPolygon": "选择所选地址位置的面",
"popupTitleForPolyline": "选择地址位置的线",
"addressLocationPolylineHintText": "提示：配置的折线图层符号，要用于邻域搜索。",
"fontColorLabel": "选择搜索结果的字体颜色",
"fontColorHintText": "提示: 搜索结果的字体颜色",
"highlightColorLabel": "设置选择颜色",
"highlightColorHintText": "提示：选择颜色",
"zoomToSelectedFeature": "缩放至所选要素",
"zoomToSelectedFeatureHintText": "提示: 缩放至所选要素，而非缓冲",
"intersectSearchLocation": "返回相交面",
"intersectSearchLocationHintText": "提示: 返回包含搜索位置的面，而非缓冲内的面",
"enableProximitySearch": "启用邻域搜索",
"enableProximitySearchHintText": "提示：启用该功能可搜索所选结果附近的位置",
"bufferVisibilityLabel": "设置缓冲可见性",
"bufferVisibilityHintText": "提示: 缓冲将显示在地图上",
"bufferColorLabel": "设置缓冲符号",
"bufferColorHintText": "提示: 选择缓冲的颜色和透明度",
"searchLayerResultLabel": "仅绘制所选图层结果",
"searchLayerResultHint": "提示: 地图上将仅绘制搜索结果中的所选图层",
"showToolToSelectLabel": "设置位置按钮",
"showToolToSelectHintText": "提示：请提供要在地图上设置地点的按钮，而不是始终在点击地图时设置地点",
"geoDesicParamLabel": "使用测地线缓冲",
"geoDesicParamHintText": "提示：请使用测地线缓冲而不是欧氏缓冲(平面)",
"showImageGalleryLabel": "显示图像库",
"showImageGalleryHint": "提示：如果选中复选框，则显示微件面板中的图像库，否则将隐藏",
"showResultCountOfLayerLabel": "显示每个图层的搜索结果计数",
"showResultCountOfLayerHint": "提示：将搜索结果数显示于每个图层名称后",
"editDescription": "介绍性文本",
"editDescriptionTip": "显示在搜索框上方的微件中的文本。",
"noResultsFound": "未找到结果时的消息",
"noResultFoundHint": "提示：设置在搜索区域内未找到结果时显示的消息",
"noFeatureFoundText": "未找到任何结果 ",
"searchHeaderText": "在地图上搜索地址或定位",
"setCurrentLocationLabel": "设置当前位置按钮",
"setCurrentLocationHintText": "提示：提供一个按钮以使用用户的当前位置",
"bufferDistanceSliderLabel": "缓冲区距离滑块",
"bufferDistanceTextboxLabel": "缓冲区文本框",
"bufferDistanceSliderandTextboxLabel": "缓冲区距离滑块和文本框",
"bufferItemOptionLegend": "缓冲区输入选项"
},
"layerSelector": {
"selectLayerLabel": "选择搜索图层",
"layerSelectionHint": "提示: 使用设置按钮选择图层",
"addLayerButton": "设置"
},
"routeSetting": {
"routeSettingTabTitle": "方向设置",
"routeServiceUrl": "路径服务",
"buttonSet": "设置",
"routeServiceUrlHintText": "提示: 单击“设置”以浏览和选择路径服务",
"directionLengthUnit": "方向长度单位",
"unitsForRouteHintText": "提示: 用于显示路径单位",
"selectRouteSymbol": "选择用于显示路径的符号",
"routeSymbolHintText": "提示: 用于显示路径的线符号",
"routingDisabledMsg": "要启用方向，请确保已在项目的应用程序设置中启用路径。",
"enableDirectionLabel": "启用方向",
"enableDirectionText": "提示：请选中以在微件中启用方向"
},
"symbologySetting": {
"symbologySettingTabTitle": "符号系统设置",
"addSymbologyBtnLabel": "添加新符号",
"layerNameTitle": "图层名称",
"fieldTitle": "字段",
"valuesTitle": "值",
"symbolTitle": "符号",
"actionsTitle": "操作",
"invalidConfigMsg": "重复的字段：图层 ${layerName} 的字段 ${fieldName}"
},
"filterSetting": {
"filterSettingTabTitle": "过滤器设置",
"addTaskTip": "向选定的搜索图层添加一个或多个过滤器，并为每个过滤器配置参数。",
"enableMapFilter": "从地图中移除预设图层过滤器。",
"newFilter": "新建过滤器",
"filterExpression": "过滤器表达式",
"layerDefaultSymbolTip": "使用图层的默认符号",
"uploadImage": "上传图像",
"selectLayerTip": "请选择图层。",
"setTitleTip": "请设置标题。",
"noTasksTip": "未配置任何过滤器。请单击“${newFilter}”添加新过滤器。",
"collapseFiltersTip": "打开微件时折叠过滤器表达式(如有)",
"groupFiltersTip": "按图层对过滤器进行分组",
"infoTab": "信息",
"expressionsTab": "表达式",
"optionsTab": "选项",
"autoApplyWhenWidgetOpen": "打开微件时应用此过滤器",
"expandFiltersOnLoad": "展开微件加载上的过滤器"
},
"networkServiceChooser": {
"arcgislabel": "从 ArcGIS Online 添加",
"serviceURLabel": "添加服务 URL",
"routeURL": "路径 URL",
"validateRouteURL": "验证",
"exampleText": "示例",
"hintRouteURL1": "https://route.arcgis.com/arcgis/rest/services/World/Route/NAServer/",
"hintRouteURL2": "https://route.arcgis.com/arcgis/rest/services/World/Route/NAServer/Route_World",
"invalidRouteServiceURL": "请指定有效的路径服务。",
"rateLimitExceeded": "超过速率限制。请稍后再试。",
"errorInvokingService": "用户名或密码错误。"
},
"errorStrings": {
"bufferErrorString": "请输入有效的数值。",
"selectLayerErrorString": "请选择要搜索的图层。",
"invalidDefaultValue": "默认缓冲距离不能为空。请指定缓冲距离",
"invalidMaximumValue": "最大缓冲距离不能为空。请指定缓冲距离",
"defaultValueLessThanMax": "请在最大限制范围内指定默认缓冲距离",
"defaultBufferValueGreaterThanOne": "默认缓冲距离不得小于 0",
"maximumBufferValueGreaterThanOne": "请指定大于 0 的最大缓冲距离",
"invalidMaximumResultCountValue": "请指定有效的最大结果数值",
"invalidSearchSources": "搜索源设置无效"
},
"symbolPickerPreviewText": "预览:"
});
|
/*! JsRender v1.0pre: http://github.com/BorisMoore/jsrender */
/*
* Optimized version of jQuery Templates, for rendering to string.
* Does not require jQuery, or HTML DOM
* Integrates with JsViews (http://github.com/BorisMoore/jsviews)
* Copyright 2012, Boris Moore
* Released under the MIT License.
*/
// informal pre beta commit counter: 2
define(['jquery'], function(jQuery, undefined) {
//========================== Top-level vars ==========================
var versionNumber = "v1.0pre",
$, rTag, rTmplString, extend,
sub = {},
FALSE = false, TRUE = true,
//jQuery = window.jQuery,
rPath = /^(?:true|false|\d[\d.]*|(null)|([\w$]+|~([\w$]+)|#(view|([\w$]+))?)([\w$.]*?)(?:[.[]([\w$]+)\]?)?|(['"]).*\8)$/g,
// nil object helper view viewProperty pathTokens leafToken string
rParams = /(\()(?=|\s*\()|(?:([([])\s*)?(?:([#~]?[\w$.]+)?\s*((\+\+|--)|\+|-|&&|\|\||===|!==|==|!=|<=|>=|[<>%*!:?\/]|(=))\s*|([#~]?[\w$.]+)([([])?)|(,\s*)|(\(?)\\?(?:(')|("))|(?:\s*([)\]])([([]?))|(\s+)/g,
// lftPrn lftPrn2 path operator err eq path2 prn comma lftPrn2 apos quot rtPrn prn2 space
// (left paren? followed by (path? followed by operator) or (path followed by paren?)) or comma or apos or quot or right paren or space
rNewLine = /\r?\n/g,
rUnescapeQuotes = /\\(['"])/g,
rEscapeQuotes = /\\?(['"])/g,
rBuildHash = /\x08(~)?([^\x08]+)\x08/g,
autoViewKey = 0,
autoTmplName = 0,
escapeMapForHtml = {
"&": "&",
"<": "<",
">": ">"
},
tmplAttr = "data-jsv-tmpl",
fnDeclStr = "var j=j||" + (jQuery ? "jQuery." : "js") + "views,",
htmlSpecialChar = /[\x00"&'<>]/g,
slice = Array.prototype.slice,
render = {},
// jsviews object ($.views if jQuery is loaded)
jsv = {
jsviews: versionNumber,
sub: sub, // subscription, e.g. JsViews integration
debugMode: TRUE,
err: function( e ) {
return jsv.debugMode ? ("<br/><b>Error:</b> <em> " + (e.message || e) + ". </em>") : '""';
},
tmplFn: tmplFn,
render: render,
templates: templates,
tags: tags,
helpers: helpers,
converters: converters,
View: View,
convert: convert,
delimiters: setDelimiters,
tag: renderTag
};
//========================== Top-level functions ==========================
//===================
// jsviews.delimiters
//===================
function setDelimiters( openChars, closeChars ) {
// Set the tag opening and closing delimiters. Default is "{{" and "}}"
// openChar, closeChars: opening and closing strings, each with two characters
var firstOpenChar = "\\" + openChars.charAt( 0 ), // Escape the characters - since they could be regex special characters
secondOpenChar = "\\" + openChars.charAt( 1 ),
firstCloseChar = "\\" + closeChars.charAt( 0 ),
secondCloseChar = "\\" + closeChars.charAt( 1 );
// Build regex with new delimiters
jsv.rTag = rTag // make rTag available to JsViews (or other components) for parsing binding expressions
= secondOpenChar
// tag (followed by / space or }) or colon or html or code
+ "(?:(?:(\\w+(?=[\\/\\s" + firstCloseChar + "]))|(?:(\\w+)?(:)|(>)|(\\*)))"
// params
+ "\\s*((?:[^" + firstCloseChar + "]|" + firstCloseChar + "(?!" + secondCloseChar + "))*?)"
// slash or closeBlock
+ "(\\/)?|(?:\\/(\\w+)))"
// }}
+ firstCloseChar;
// Default rTag: tag converter colon html code params slash closeBlock
// /{{(?:(?:(\w+(?=[\/\s\}]))|(?:(\w+)?(:)|(>)|(\*)))\s*((?:[^}]|}(?!\}))*?)(\/)?|(?:\/(\w+)))}}
// /{{(?:(?:(\w+(?=[\/!\s\}!]))|(?:(\w+)?(:)|(>)|(\*)))((?:[^\}]|}(?!}))*?)(\/)?|(?:\/(\w+)))}}/g;
rTag = new RegExp( firstOpenChar + rTag + secondCloseChar, "g" );
rTmplString = new RegExp( "<.*>|" + openChars + ".*" + closeChars );
return this;
}
//=================
// View.hlp
//=================
function getHelper( helper ) {
// Helper method called as view.hlp() from compiled template, for helper functions or template parameters ~foo
var view = this,
tmplHelpers = view.tmpl.helpers || {};
helper = (view.ctx[ helper ] ? view.ctx : tmplHelpers[ helper ] ? tmplHelpers : helpers[ helper ] ? helpers : {})[ helper ];
return typeof helper !== "function" ? helper : function() {
return helper.apply(view, arguments);
};
}
//=================
// jsviews.convert
//=================
function convert( converter, view, text ) {
var tmplConverters = view.tmpl.converters;
converter = tmplConverters && tmplConverters[ converter ] || converters[ converter ];
return converter ? converter.call( view, text ) : text;
}
//=================
// jsviews.tag
//=================
function renderTag( tag, parentView, converter, content, tagObject ) {
// Called from within compiled template function, to render a nested tag
// Returns the rendered tag
tagObject.props = tagObject.props || {};
var ret,
tmpl = tagObject.props.tmpl,
tmplTags = parentView.tmpl.tags,
nestedTemplates = parentView.tmpl.templates,
args = arguments,
tagFn = tmplTags && tmplTags[ tag ] || tags[ tag ];
if ( !tagFn ) {
return "";
}
// Set the tmpl property to the content of the block tag, unless set as an override property on the tag
content = content && parentView.tmpl.tmpls[ content - 1 ];
tmpl = tmpl || content || undefined;
tagObject.tmpl =
"" + tmpl === tmpl // if a string
? nestedTemplates && nestedTemplates[ tmpl ] || templates[ tmpl ] || templates( tmpl )
: tmpl;
tagObject.isTag = TRUE;
tagObject.converter = converter;
tagObject.view = parentView;
tagObject.renderContent = renderContent;
if ( parentView.ctx ) {
extend( tagObject.ctx, parentView.ctx);
}
ret = tagFn.apply( tagObject, args.length > 5 ? slice.call( args, 5 ) : [] );
return ret || ( ret == undefined ? "" : ret.toString()); // (If ret is the value 0 or false, will render to string)
}
//=================
// View constructor
//=================
function View( context, path, parentView, data, template, index ) {
// Constructor for view object in view hierarchy. (Augmented by JsViews if JsViews is loaded)
var views = parentView.views,
// TODO: add this, as part of smart re-linking on existing content ($.link method), or remove completely
// self = parentView.views[ index ];
// if ( !self ) { ... }
self = {
tmpl: template,
path: path,
parent: parentView,
data: data,
ctx: context,
views: $.isArray( data ) ? [] : {},
hlp: getHelper
};
if ( $.isArray( views )) {
views.splice(
self.index = index !== undefined
? index
: views.length, 0, self
);
} else {
views[ self.index = "_" + autoViewKey++ ] = self;
}
return self;
}
//=================
// Registration
//=================
function addToStore( self, store, name, item, process ) {
// Add item to named store such as templates, helpers, converters...
var key, onStore;
if ( name && typeof name === "object" && !name.nodeType ) {
// If name is a map, iterate over map and call store for key
for ( key in name ) {
store( key, name[ key ]);
}
return self;
}
if ( !name || item === undefined ) {
if ( process ) {
item = process( undefined, item || name );
}
} else if ( "" + name === name ) { // name must be a string
if ( item === null ) {
// If item is null, delete this entry
delete store[name];
} else if ( item = process ? process( name, item ) : item ) {
store[ name ] = item;
}
}
if ( onStore = sub.onStoreItem ) {
// e.g. JsViews integration
onStore( store, name, item, process );
}
return item;
}
function templates( name, tmpl ) {
// Register templates
// Setter: Use $.view.tags( name, tagFn ) or $.view.tags({ name: tagFn, ... }) to add additional tags to the registered tags collection.
// Getter: Use var tagFn = $.views.tags( name ) or $.views.tags[name] or $.views.tags.name to return the function for the registered tag.
// Remove: Use $.view.tags( name, null ) to remove a registered tag from $.view.tags.
// When registering for {{foo a b c==d e=f}}, tagFn should be a function with the signature:
// function(a,b). The 'this' pointer will be a hash with properties c and e.
return addToStore( this, templates, name, tmpl, compile );
}
function tags( name, tagFn ) {
// Register template tags
// Setter: Use $.view.tags( name, tagFn ) or $.view.tags({ name: tagFn, ... }) to add additional tags to the registered tags collection.
// Getter: Use var tagFn = $.views.tags( name ) or $.views.tags[name] or $.views.tags.name to return the function for the registered tag.
// Remove: Use $.view.tags( name, null ) to remove a registered tag from $.view.tags.
// When registering for {{foo a b c==d e=f}}, tagFn should be a function with the signature:
// function(a,b). The 'this' pointer will be a hash with properties c and e.
return addToStore( this, tags, name, tagFn );
}
function helpers( name, helperFn ) {
// Register helper functions for use in templates (or in data-link expressions if JsViews is loaded)
// Setter: Use $.view.helpers( name, helperFn ) or $.view.helpers({ name: helperFn, ... }) to add additional helpers to the registered helpers collection.
// Getter: Use var helperFn = $.views.helpers( name ) or $.views.helpers[name] or $.views.helpers.name to return the function.
// Remove: Use $.view.helpers( name, null ) to remove a registered helper function from $.view.helpers.
// Within a template, access the helper using the syntax: {{... ~myHelper(...) ...}}.
return addToStore( this, helpers, name, helperFn );
}
function converters( name, converterFn ) {
// Register converter functions for use in templates (or in data-link expressions if JsViews is loaded)
// Setter: Use $.view.converters( name, converterFn ) or $.view.converters({ name: converterFn, ... }) to add additional converters to the registered converters collection.
// Getter: Use var converterFn = $.views.converters( name ) or $.views.converters[name] or $.views.converters.name to return the converter function.
// Remove: Use $.view.converters( name, null ) to remove a registered converter from $.view.converters.
// Within a template, access the converter using the syntax: {{myConverter:...}}.
return addToStore( this, converters, name, converterFn );
}
//=================
// renderContent
//=================
function renderContent( data, context, parentView, path, index ) {
// Render template against data as a tree of subviews (nested template), or as a string (top-level template).
// tagName parameter for internal use only. Used for rendering templates registered as tags (which may have associated presenter objects)
var i, l, dataItem, newView, itemWrap, itemsWrap, itemResult, parentContext, tmpl, layout,
props = {},
swapContent = index === TRUE,
self = this,
result = "";
if ( self.isTag ) {
// This is a call from renderTag
tmpl = self.tmpl;
context = context || self.ctx;
parentView = parentView || self.view;
path = path || self.path;
index = index || self.index;
props = self.props;
} else {
tmpl = self.jquery && self[0] // This is a call $.fn.render
|| self; // This is a call from tmpl.render
}
parentView = parentView || jsv.topView;
parentContext = parentView.ctx;
layout = tmpl.layout;
if ( data === parentView ) {
// Inherit the data from the parent view.
// This may be the contents of an {{if}} block
data = parentView.data;
layout = TRUE;
}
// Set additional context on views created here, (as modified context inherited from the parent, and be inherited by child views)
// Note: If no jQuery, extend does not support chained copies - so limit extend() to two parameters
context = (context && context === parentContext)
? parentContext
: (parentContext
// if parentContext, make copy
? ((parentContext = extend( {}, parentContext ), context)
// If context, merge context with copied parentContext
? extend( parentContext, context )
: parentContext)
// if no parentContext, use context, or default to {}
: context || {});
if ( props.link === FALSE ) {
// Override inherited value of link by an explicit setting in props: link=false
// The child views of an unlinked view are also unlinked. So setting child back to true will not have any effect.
context.link = FALSE;
}
if ( !tmpl.fn ) {
tmpl = templates[ tmpl ] || templates( tmpl );
}
itemWrap = context.link && sub.onRenderItem;
itemsWrap = context.link && sub.onRenderItems;
if ( tmpl ) {
if ( $.isArray( data ) && !layout ) {
// Create a view for the array, whose child views correspond to each data item.
// (Note: if index and parentView are passed in along with parent view, treat as
// insert -e.g. from view.addViews - so parentView is already the view item for array)
newView = swapContent ? parentView : (index !== undefined && parentView) || View( context, path, parentView, data, tmpl, index );
for ( i = 0, l = data.length; i < l; i++ ) {
// Create a view for each data item.
dataItem = data[ i ];
itemResult = tmpl.fn( dataItem, View( context, path, newView, dataItem, tmpl, (index||0) + i ), jsv );
result += itemWrap ? itemWrap( itemResult, props ) : itemResult;
}
} else {
// Create a view for singleton data object.
newView = swapContent ? parentView : View( context, path, parentView, data, tmpl, index );
result += (data || layout) ? tmpl.fn( data, newView, jsv ) : "";
}
parentView.topKey = newView.index;
return itemsWrap ? itemsWrap( result, path, newView.index, tmpl, props ) : result;
}
return ""; // No tmpl. Could throw...
}
//===========================
// Build and compile template
//===========================
// Generate a reusable function that will serve to render a template against data
// (Compile AST then build template function)
function syntaxError() {
throw "Syntax error";
}
function tmplFn( markup, tmpl, bind ) {
// Compile markup to AST (abtract syntax tree) then build the template function code from the AST nodes
// Used for compiling templates, and also by JsViews to build functions for data link expressions
var newNode, node, i, l, code, hasTag, hasEncoder, getsValue, hasConverter, hasViewPath, tag, converter, params, hash, nestedTmpl, allowCode,
tmplOptions = tmpl ? {
allowCode: allowCode = tmpl.allowCode,
debug: tmpl.debug
} : {},
nested = tmpl && tmpl.tmpls,
astTop = [],
loc = 0,
stack = [],
content = astTop,
current = [,,,astTop],
nestedIndex = 0;
//==== nested functions ====
function pushPreceedingContent( shift ) {
shift -= loc;
if ( shift ) {
content.push( markup.substr( loc, shift ).replace( rNewLine, "\\n" ));
}
}
function parseTag( all, tagName, converter, colon, html, code, params, slash, closeBlock, index ) {
// tag converter colon html code params slash closeBlock
// /{{(?:(?:(\w+(?=[\/!\s\}!]))|(?:(\w+)?(:)|(?:(>)|(\*)))((?:[^\}]|}(?!}))*?)(\/)?|(?:\/(\w+)))}}/g;
// Build abstract syntax tree (AST): [ tagName, converter, params, content, hash, contentMarkup ]
if ( html ) {
colon = ":";
converter = "html";
}
var hash = "",
passedCtx = "",
block = !slash && !colon; // Block tag if not self-closing and not {{:}} or {{>}} (special case)
//==== nested helper function ====
tagName = tagName || colon;
pushPreceedingContent( index );
loc = index + all.length; // location marker - parsed up to here
if ( code ) {
if ( allowCode ) {
content.push([ "*", params.replace( rUnescapeQuotes, "$1" ) ]);
}
} else if ( tagName ) {
if ( tagName === "else" ) {
current[ 5 ] = markup.substring( current[ 5 ], index ); // contentMarkup for block tag
current = stack.pop();
content = current[ 3 ];
block = TRUE;
}
params = (params
? parseParams( params, bind )
.replace( rBuildHash, function( all, isCtx, keyValue ) {
if ( isCtx ) {
passedCtx += keyValue + ",";
} else {
hash += keyValue + ",";
}
return "";
})
: "");
hash = hash.slice( 0, -1 );
params = params.slice( 0, -1 );
newNode = [
tagName,
converter || "",
params,
block && [],
"{" + (hash ? ("props:{" + hash + "},"): "") + "path:'" + params + "'" + (passedCtx ? ",ctx:{" + passedCtx.slice( 0, -1 ) + "}" : "") + "}"
];
if ( block ) {
stack.push( current );
current = newNode;
current[ 5 ] = loc; // Store current location of open tag, to be able to add contentMarkup when we reach closing tag
}
content.push( newNode );
} else if ( closeBlock ) {
//if ( closeBlock !== current[ 0 ]) {
// throw "unmatched close tag: /" + closeBlock + ". Expected /" + current[ 0 ];
//}
current[ 5 ] = markup.substring( current[ 5 ], index ); // contentMarkup for block tag
current = stack.pop();
}
if ( !current ) {
throw "Expected block tag";
}
content = current[ 3 ];
}
//==== /end of nested functions ====
markup = markup.replace( rEscapeQuotes, "\\$1" );
// Build the AST (abstract syntax tree) under astTop
markup.replace( rTag, parseTag );
pushPreceedingContent( markup.length );
// Use the AST (astTop) to build the template function
l = astTop.length;
code = (l ? "" : '"";');
for ( i = 0; i < l; i++ ) {
// AST nodes: [ tagName, converter, params, content, hash, contentMarkup ]
node = astTop[ i ];
if ( node[ 0 ] === "*" ) {
code = code.slice( 0, i ? -1 : -3 ) + ";" + node[ 1 ] + (i + 1 < l ? "ret+=" : "");
} else if ( "" + node === node ) { // type string
code += '"' + node + '"+';
} else {
tag = node[ 0 ];
converter = node[ 1 ];
params = node[ 2 ];
content = node[ 3 ];
hash = node[ 4 ];
markup = node[ 5 ];
if ( content ) {
// Create template object for nested template
nestedTmpl = TmplObject( markup, tmplOptions, tmpl, nestedIndex++ );
// Compile to AST and then to compiled function
tmplFn( markup, nestedTmpl);
nested.push( nestedTmpl );
}
hasViewPath = hasViewPath || hash.indexOf( "view" ) > -1;
code += (tag === ":"
? (converter === "html"
? (hasEncoder = TRUE, "e(" + params)
: converter
? (hasConverter = TRUE, 'c("' + converter + '",view,' + params)
: (getsValue = TRUE, "((v=" + params + ')!=u?v:""')
)
: (hasTag = TRUE, 't("' + tag + '",view,"' + (converter || "") + '",'
+ (content ? nested.length : '""') // For block tags, pass in the key (nested.length) to the nested content template
+ "," + hash + (params ? "," : "") + params))
+ ")+";
}
}
code = new Function( "data, view, j, b, u", fnDeclStr
+ (getsValue ? "v," : "")
+ (hasTag ? "t=j.tag," : "")
+ (hasConverter ? "c=j.convert," : "")
+ (hasEncoder ? "e=j.converters.html," : "")
+ "ret; try{\n\n"
+ (tmplOptions.debug ? "debugger;" : "")
+ (allowCode ? 'ret=' : 'return ')
+ code.slice( 0, -1 ) + ";\n\n"
+ (allowCode ? "return ret;" : "")
+ "}catch(e){return j.err(e);}"
);
// Include only the var references that are needed in the code
if ( tmpl ) {
tmpl.fn = code;
tmpl.useVw = hasConverter || hasViewPath || hasTag;
}
return code;
}
function parseParams( params, bind ) {
var named,
fnCall = {},
parenDepth = 0,
quoted = FALSE, // boolean for string content in double quotes
aposed = FALSE; // or in single quotes
function parseTokens( all, lftPrn0, lftPrn, path, operator, err, eq, path2, prn, comma, lftPrn2, apos, quot, rtPrn, prn2, space ) {
// rParams = /(?:([([])\s*)?(?:([#~]?[\w$.]+)?\s*((\+\+|--)|\+|-|&&|\|\||===|!==|==|!=|<=|>=|[<>%*!:?\/]|(=))\s*|([#~]?[\w$.^]+)([([])?)|(,\s*)|(\(?)\\?(?:(')|("))|(?:\s*([)\]])([([]?))|(\s+)/g,
// lftPrn path operator err eq path2 prn comma lftPrn3 apos quot rtPrn prn2 space
// (left paren? followed by (path? followed by operator) or (path followed by paren?)) or comma or apos or quot or right paren or space
operator = operator || "";
lftPrn = lftPrn || lftPrn0 || lftPrn2;
path = path || path2;
prn = prn || prn2 || "";
operator = operator || "";
function parsePath( all, nil, object, helper, view, viewProperty, pathTokens, leafToken ) {
// rPath = /^(?:true|false|\d[\d.]*|(null)|([\w$]+|~([\w$]+)|#(view|([\w$]+))?)([\w$.]*?)(?:[.[]([\w$]+)\]?)?|(['"]).*\8)$/g,
// nil object helper view viewProperty pathTokens leafToken string
if ( object ) {
var ret = (helper
? 'view.hlp("' + helper + '")'
: view
? "view"
: "data")
+ (leafToken
? (viewProperty
? "." + viewProperty
: helper
? ""
: (view ? "" : "." + object)
) + (pathTokens || "")
: (leafToken = helper ? "" : view ? viewProperty || "" : object, ""));
if ( bind && prn !== "(" ) {
ret = "b(" + ret + ',"' + leafToken + '")';
}
return ret + (leafToken ? "." + leafToken : "");
}
return nil ? "u" : all;
}
if ( err ) {
syntaxError();
} else {
return (aposed
// within single-quoted string
? (aposed = !apos, (aposed ? all : '"'))
: quoted
// within double-quoted string
? (quoted = !quot, (quoted ? all : '"'))
:
(
(lftPrn
? (parenDepth++, lftPrn)
: "")
+ (space
? (parenDepth
? ""
: named
? (named = FALSE, "\b")
: ","
)
: eq
// named param
? (parenDepth && syntaxError(), named = TRUE, '\b' + path + ':')
: path
// path
? (path.replace( rPath, parsePath )
+ (prn
? (fnCall[ ++parenDepth ] = TRUE, prn)
: operator)
)
: operator
? all
: rtPrn
// function
? ((fnCall[ parenDepth-- ] = FALSE, rtPrn)
+ (prn
? (fnCall[ ++parenDepth ] = TRUE, prn)
: "")
)
: comma
? (fnCall[ parenDepth ] || syntaxError(), ",") // We don't allow top-level literal arrays or objects
: lftPrn0
? ""
: (aposed = apos, quoted = quot, '"')
))
);
}
}
params = (params + " " ).replace( rParams, parseTokens );
return params;
}
function compile( name, tmpl, parent, options ) {
// tmpl is either a template object, a selector for a template script block, the name of a compiled template, or a template object
// options is the set of template properties, c
var tmplOrMarkup, elem, key, nested, nestedItem;
//==== nested functions ====
function tmplOrMarkupFromStr( value ) {
// If value is of type string - treat as selector, or name of compiled template
// Return the template object, if already compiled, or the markup string
if ( ("" + value === value) || value.nodeType > 0 ) {
// If selector is valid and returns at least one element, get first element
elem = value.nodeType > 0 ? value : !rTmplString.test( value ) && jQuery && jQuery( value )[0];
if ( elem && elem.type ) {
// It is a script element
// Create a name for data linking if none provided
value = templates[ elem.getAttribute( tmplAttr )];
if ( !value ) {
// Not already compiled and cached, so compile and cache the name
name = name || "_" + autoTmplName++;
elem.setAttribute( tmplAttr, name );
value = compile( name, elem.innerHTML, parent, options ); // Use tmpl as options
templates[ name ] = value;
}
}
return value;
}
// If value is not a string or dom element, return undefined
}
//==== Compile the template ====
tmplOrMarkup = tmplOrMarkupFromStr( tmpl );
// If tmpl is a template object, use it for options
options = options || (tmpl.markup ? tmpl : {});
options.name = name;
nested = options.templates;
// If tmpl is not a markup string or a selector string, then it must be a template object
// In that case, get it from the markup property of the object
if ( !tmplOrMarkup && tmpl.markup && (tmplOrMarkup = tmplOrMarkupFromStr( tmpl.markup ))) {
if ( tmplOrMarkup.fn && (tmplOrMarkup.debug !== tmpl.debug || tmplOrMarkup.allowCode !== tmpl.allowCode )) {
// if the string references a compiled template object, but the debug or allowCode props are different, need to recompile
tmplOrMarkup = tmplOrMarkup.markup;
}
}
if ( tmplOrMarkup !== undefined ) {
if ( name && !parent ) {
render[ name ] = function() {
return tmpl.render.apply( tmpl, arguments );
};
}
if ( tmplOrMarkup.fn || tmpl.fn ) {
// tmpl is already compiled, so use it, or if different name is provided, clone it
if ( tmplOrMarkup.fn ) {
if ( name && name !== tmplOrMarkup.name ) {
tmpl = extend( extend( {}, tmplOrMarkup ), options);
} else {
tmpl = tmplOrMarkup;
}
}
} else {
// tmplOrMarkup is a markup string, not a compiled template
// Create template object
tmpl = TmplObject( tmplOrMarkup, options, parent, 0 );
// Compile to AST and then to compiled function
tmplFn( tmplOrMarkup, tmpl );
}
for ( key in nested ) {
// compile nested template declarations
nestedItem = nested[ key ];
if ( nestedItem.name !== key ) {
nested[ key ] = compile( key, nestedItem, tmpl );
}
}
return tmpl;
}
}
//==== /end of function compile ====
function TmplObject( markup, options, parent, index ) {
// Template object constructor
// nested helper function
function extendStore( storeName ) {
if ( parent[ storeName ]) {
// Include parent items except if overridden by item of same name in options
tmpl[ storeName ] = extend( extend( {}, parent[ storeName ] ), options[ storeName ] );
}
}
options = options || {};
var tmpl = {
markup: markup,
tmpls: [],
links: [],
render: renderContent
};
if ( parent ) {
if ( parent.templates ) {
tmpl.templates = extend( extend( {}, parent.templates ), options.templates );
}
tmpl.parent = parent;
tmpl.name = parent.name + "[" + index + "]";
tmpl.index = index;
}
extend( tmpl, options );
if ( parent ) {
extendStore( "templates" );
extendStore( "tags" );
extendStore( "helpers" );
extendStore( "converters" );
}
return tmpl;
}
//========================== Initialize ==========================
if ( jQuery ) {
////////////////////////////////////////////////////////////////////////////////////////////////
// jQuery is loaded, so make $ the jQuery object
$ = jQuery;
$.templates = templates;
$.render = render;
$.views = jsv;
$.fn.render = renderContent;
} else {
////////////////////////////////////////////////////////////////////////////////////////////////
// jQuery is not loaded.
$ = window.jsviews = jsv;
$.extend = function( target, source ) {
var name;
target = target || {};
for ( name in source ) {
target[ name ] = source[ name ];
}
return target;
};
$.isArray = Array && Array.isArray || function( obj ) {
return Object.prototype.toString.call( obj ) === "[object Array]";
};
}
extend = $.extend;
jsv.topView = { views: {}, tmpl: {}, hlp: getHelper, ctx: jsv.helpers };
function replacerForHtml( ch ) {
// Original code from Mike Samuel <msamuel@google.com>
return escapeMapForHtml[ ch ]
// Intentional assignment that caches the result of encoding ch.
|| (escapeMapForHtml[ ch ] = "&#" + ch.charCodeAt( 0 ) + ";");
}
//========================== Register tags ==========================
tags({
"if": function() {
var ifTag = this,
view = ifTag.view;
view.onElse = function( tagObject, args ) {
var i = 0,
l = args.length;
while ( l && !args[ i++ ]) {
// Only render content if args.length === 0 (i.e. this is an else with no condition) or if a condition argument is truey
if ( i === l ) {
return "";
}
}
view.onElse = undefined; // If condition satisfied, so won't run 'else'.
tagObject.path = "";
return tagObject.renderContent( view );
// Test is satisfied, so render content, while remaining in current data context
// By passing the view, we inherit data context from the parent view, and the content is treated as a layout template
// (so if the data is an array, it will not iterate over the data
};
return view.onElse( this, arguments );
},
"else": function() {
var view = this.view;
return view.onElse ? view.onElse( this, arguments ) : "";
},
"for": function() {
var i,
self = this,
result = "",
args = arguments,
l = args.length;
if ( self.props.layout ) {
self.tmpl.layout = TRUE;
}
for ( i = 0; i < l; i++ ) {
result += self.renderContent( args[ i ]);
}
return result;
},
"=": function( value ) {
return value;
},
"*": function( value ) {
return value;
}
});
//========================== Register global helpers ==========================
// helpers({ // Global helper functions
// // TODO add any useful built-in helper functions
// });
//========================== Register converters ==========================
converters({
html: function( text ) {
// HTML encoding helper: Replace < > & and ' and " by corresponding entities.
// inspired by Mike Samuel <msamuel@google.com>
return text != undefined ? String( text ).replace( htmlSpecialChar, replacerForHtml ) : "";
}
});
//========================== Define default delimiters ==========================
setDelimiters( "{{", "}}" );
});
|
'use strict';
angular.module('ta.bootstrap.fa').value('faOptions', {
icon : {},
front : {
name : 'fa-user',
btnType : 'btn-success',
tittleType : 'text-success'
},
back : {
name : 'fa-circle',
btnType : 'btn-primary',
tittleType : 'text-primary'
},
sets : {
sizes : [{
text : 'TA_FA_SIZE_DEFAULT'
}, {
text : 'TA_FA_SIZE_LG',
value : 'fa-lg'
}, {
text : 'TA_FA_SIZE_2X',
value : 'fa-2x'
}, {
text : 'TA_FA_SIZE_3X',
value : 'fa-3x'
}, {
text : 'TA_FA_SIZE_4X',
value : 'fa-4x'
}, {
text : 'TA_FA_SIZE_5X',
value : 'fa-5x'
}],
directions : [{
pic : 'fa-arrow-up',
tooltip : 'TA_FA_DIR_DEFAULT'
}, {
pic : 'fa-arrow-right',
tooltip : 'TA_FA_DIR_RIGHT',
value : 'fa-rotate-90'
}, {
pic : 'fa-arrow-down',
tooltip : 'TA_FA_DIR_DOWN',
value : 'fa-rotate-180'
}, {
pic : 'fa-arrow-left',
tooltip : 'TA_FA_DIR_LEFT',
value : 'fa-rotate-270'
}, {
pic : 'fa-arrows-h',
tooltip : 'TA_FA_DIR_FLAP_H',
value : 'fa-flip-horizontal'
}, {
pic : 'fa-arrows-v',
tooltip : 'TA_FA_DIR_FLAP_V',
value : 'fa-flip-vertical'
}],
colors : ['', 'text-muted', 'text-primary', 'text-success', 'text-info', 'text-warning', 'text-danger']
}
});
|
var __extends = (this && this.__extends) || (function () {
var extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
return function (d, b) {
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
define(["require", "exports", "aurelia-task-queue", "./validate-trigger", "./validate-binding-behavior-base"], function (require, exports, aurelia_task_queue_1, validate_trigger_1, validate_binding_behavior_base_1) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
* Binding behavior. Indicates the bound property should be validated
* when the validate trigger specified by the associated controller's
* validateTrigger property occurs.
*/
var ValidateBindingBehavior = (function (_super) {
__extends(ValidateBindingBehavior, _super);
function ValidateBindingBehavior() {
return _super !== null && _super.apply(this, arguments) || this;
}
ValidateBindingBehavior.prototype.getValidateTrigger = function (controller) {
return controller.validateTrigger;
};
ValidateBindingBehavior.inject = [aurelia_task_queue_1.TaskQueue];
return ValidateBindingBehavior;
}(validate_binding_behavior_base_1.ValidateBindingBehaviorBase));
exports.ValidateBindingBehavior = ValidateBindingBehavior;
/**
* Binding behavior. Indicates the bound property will be validated
* manually, by calling controller.validate(). No automatic validation
* triggered by data-entry or blur will occur.
*/
var ValidateManuallyBindingBehavior = (function (_super) {
__extends(ValidateManuallyBindingBehavior, _super);
function ValidateManuallyBindingBehavior() {
return _super !== null && _super.apply(this, arguments) || this;
}
ValidateManuallyBindingBehavior.prototype.getValidateTrigger = function () {
return validate_trigger_1.validateTrigger.manual;
};
ValidateManuallyBindingBehavior.inject = [aurelia_task_queue_1.TaskQueue];
return ValidateManuallyBindingBehavior;
}(validate_binding_behavior_base_1.ValidateBindingBehaviorBase));
exports.ValidateManuallyBindingBehavior = ValidateManuallyBindingBehavior;
/**
* Binding behavior. Indicates the bound property should be validated
* when the associated element blurs.
*/
var ValidateOnBlurBindingBehavior = (function (_super) {
__extends(ValidateOnBlurBindingBehavior, _super);
function ValidateOnBlurBindingBehavior() {
return _super !== null && _super.apply(this, arguments) || this;
}
ValidateOnBlurBindingBehavior.prototype.getValidateTrigger = function () {
return validate_trigger_1.validateTrigger.blur;
};
ValidateOnBlurBindingBehavior.inject = [aurelia_task_queue_1.TaskQueue];
return ValidateOnBlurBindingBehavior;
}(validate_binding_behavior_base_1.ValidateBindingBehaviorBase));
exports.ValidateOnBlurBindingBehavior = ValidateOnBlurBindingBehavior;
/**
* Binding behavior. Indicates the bound property should be validated
* when the associated element is changed by the user, causing a change
* to the model.
*/
var ValidateOnChangeBindingBehavior = (function (_super) {
__extends(ValidateOnChangeBindingBehavior, _super);
function ValidateOnChangeBindingBehavior() {
return _super !== null && _super.apply(this, arguments) || this;
}
ValidateOnChangeBindingBehavior.prototype.getValidateTrigger = function () {
return validate_trigger_1.validateTrigger.change;
};
ValidateOnChangeBindingBehavior.inject = [aurelia_task_queue_1.TaskQueue];
return ValidateOnChangeBindingBehavior;
}(validate_binding_behavior_base_1.ValidateBindingBehaviorBase));
exports.ValidateOnChangeBindingBehavior = ValidateOnChangeBindingBehavior;
/**
* Binding behavior. Indicates the bound property should be validated
* when the associated element blurs or is changed by the user, causing
* a change to the model.
*/
var ValidateOnChangeOrBlurBindingBehavior = (function (_super) {
__extends(ValidateOnChangeOrBlurBindingBehavior, _super);
function ValidateOnChangeOrBlurBindingBehavior() {
return _super !== null && _super.apply(this, arguments) || this;
}
ValidateOnChangeOrBlurBindingBehavior.prototype.getValidateTrigger = function () {
return validate_trigger_1.validateTrigger.changeOrBlur;
};
ValidateOnChangeOrBlurBindingBehavior.inject = [aurelia_task_queue_1.TaskQueue];
return ValidateOnChangeOrBlurBindingBehavior;
}(validate_binding_behavior_base_1.ValidateBindingBehaviorBase));
exports.ValidateOnChangeOrBlurBindingBehavior = ValidateOnChangeOrBlurBindingBehavior;
});
|
// Avoid `console` errors in browsers that lack a console.
(function() {
var method;
var noop = function () {};
var methods = [
'assert', 'clear', 'count', 'debug', 'dir', 'dirxml', 'error',
'exception', 'group', 'groupCollapsed', 'groupEnd', 'info', 'log',
'markTimeline', 'profile', 'profileEnd', 'table', 'time', 'timeEnd',
'timeline', 'timelineEnd', 'timeStamp', 'trace', 'warn'
];
var length = methods.length;
var console = (window.console = window.console || {});
while (length--) {
method = methods[length];
// Only stub undefined methods.
if (!console[method]) {
console[method] = noop;
}
}
}());
// Place any jQuery/helper plugins in here.
$(document).foundation();
|
/**
* Copyright 2014 Telerik AD
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
(function(f, define){
define([], f);
})(function(){
(function( window, undefined ) {
var kendo = window.kendo || (window.kendo = { cultures: {} });
kendo.cultures["mt"] = {
name: "mt",
numberFormat: {
pattern: ["-n"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3],
percent: {
pattern: ["-%n","%n"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3],
symbol: "%"
},
currency: {
pattern: ["-$n","$n"],
decimals: 2,
",": ",",
".": ".",
groupSize: [3],
symbol: "€"
}
},
calendars: {
standard: {
days: {
names: ["Il-Ħadd","It-Tnejn","It-Tlieta","L-Erbgħa","Il-Ħamis","Il-Ġimgħa","Is-Sibt"],
namesAbbr: ["Ħad","Tne","Tli","Erb","Ħam","Ġim","Sib"],
namesShort: ["I","I","I","L","I","I","I"]
},
months: {
names: ["Jannar","Frar","Marzu","April","Mejju","Ġunju","Lulju","Awissu","Settembru","Ottubru","Novembru","Diċembru",""],
namesAbbr: ["Jan","Fra","Mar","Apr","Mej","Ġun","Lul","Awi","Set","Ott","Nov","Diċ",""]
},
AM: ["AM","am","AM"],
PM: ["PM","pm","PM"],
patterns: {
d: "dd/MM/yyyy",
D: "dddd, d' ta\' 'MMMM yyyy",
F: "dddd, d' ta\' 'MMMM yyyy HH:mm:ss",
g: "dd/MM/yyyy HH:mm",
G: "dd/MM/yyyy HH:mm:ss",
m: "d' ta\' 'MMMM",
M: "d' ta\' 'MMMM",
s: "yyyy'-'MM'-'dd'T'HH':'mm':'ss",
t: "HH:mm",
T: "HH:mm:ss",
u: "yyyy'-'MM'-'dd HH':'mm':'ss'Z'",
y: "MMMM yyyy",
Y: "MMMM yyyy"
},
"/": "/",
":": ":",
firstDay: 1
}
}
}
})(this);
return window.kendo;
}, typeof define == 'function' && define.amd ? define : function(_, f){ f(); });
|
/* eslint-disable */
import httpMocks from 'node-mocks-http';
import events from 'events';
import chaiHttp from 'chai-http';
import chai from 'chai';
import sinon from 'sinon';
import server from '../../../server';
import * as middlewares from '../../../middlewares/';
chai.use(chaiHttp);
chai.should();
const responseEvent = () => httpMocks
.createResponse({ eventEmitter: events.EventEmitter });
describe('Middlewares', () => {
let superAdminToken, adminToken, regularToken;
let superAdmin, admin, regular;
let request;
beforeEach((done) => {
setTimeout(() => {
done();
}, 2000);
});
before((done) => {
chai.request(server)
.post('/api/users/login/')
.send({
identifier: 'ajudensi',
password: 'password123',
})
.end((err, res) => {
superAdminToken = res.body.token;
superAdmin = res.body;
chai.request(server)
.post('/api/users/login/')
.send({
identifier: 'SiliconValley',
password: 'password123',
})
.end((err, res) => {
adminToken = res.body.token;
admin = res.body;
chai.request(server)
.post('/api/users/login/')
.send({
identifier: 'thePiper',
password: 'password123',
})
.end((err, res) => {
regularToken = res.body.token;
regular = res.body;
done();
});
});
});
});
describe('verifyAuthentication', () => {
it('should continue if token is valid', (done) => {
const response = httpMocks.createResponse();
request = httpMocks.createRequest({
method: 'GET',
url: '/api/users/',
headers: { authorization: superAdminToken }
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
middlewares.verifyAuthentication(request, response, middlewareStub.callback);
middlewareStub.callback.should.have.been.called;
done();
});
it('should not continue if token is invalid', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'GET',
url: '/api/search/users/',
headers: {
authorization: 'bearer abcdefghijklmnopqrstuvwxyz1234567890',
},
locals: {
user: {
decoded: { userId: 0, roleId: 0 },
isAuthenticated: false
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('you are not signed in');
done();
});
middlewares.verifyRouteAndMethod(request, response, middlewareStub.callback);
});
});
describe('validateDeleteUser', () => {
it('should only allow superadmin and account owner to delete account', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'DELETE',
url: '/api/users/1',
headers: { authorization: regularToken },
locals: {
user: {
decoded: {
roleId: regular.roleId,
userId: regular.userId
}
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('you cannot perform this action');
done();
});
middlewares.validateDeleteUser(request, response, middlewareStub.callback);
});
it('should not allow admin to delete accounts', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'DELETE',
url: '/api/users/10',
headers: { authorization: `bearer ${adminToken}` },
locals: {
user: {
decoded: {
roleId: admin.roleId,
userId: admin.userId
}
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('you cannot perform this action');
done();
});
middlewares.validateDeleteUser(request, response, middlewareStub.callback);
});
it('should allow superadmin to delete account', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'DELETE',
url: '/api/users/10',
headers: { authorization: `bearer ${superAdminToken}` },
locals: {
user: {
decoded: {
roleId: superAdmin.roleId,
userId: superAdmin.userId
}
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
middlewares.validateDeleteUser(request, response, middlewareStub.callback);
middlewareStub.callback.should.have.been.called;
done();
});
});
describe('validateUserInput', () => {
it('should return `bad request` when email is empty', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/users',
body: {
username: 'kingsLanding',
email: '',
firstname: 'tyrion',
lastname: 'lannister',
password: 'terribleLannister'
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('enter a valid email');
response._isJSON().should.eql(true);
response.statusCode.should.eql(400);
});
middlewares.validateUserInput(request, response, middlewareStub.callback);
});
it('should return `bad request` when username is empty', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/users/',
body: {
username: '',
email: 'test@test.com',
firstname: 'tyrion',
lastname: 'lannister',
password: 'terribleLannister'
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('enter a valid username');
done();
});
middlewares.validateUserInput(request, response, middlewareStub.callback);
});
it('should return `bad request` when firstname is empty', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/users/',
body: {
username: 'kingsLanding',
email: 'test@test.com',
firstname: '',
lastname: 'lannister',
password: 'terribleLannister'
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('enter a valid firstname');
done();
});
middlewares.validateUserInput(request, response, middlewareStub.callback);
});
it('should return `bad request` when lastname is empty', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/users/',
body: {
username: 'kingsLanding',
email: 'test@test.com',
firstname: 'tyrion',
lastname: '',
password: 'terribleLannister'
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('enter a valid lastname');
done();
});
middlewares.validateUserInput(request, response, middlewareStub.callback);
});
it('should return `bad request` when roleId is 1', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/users/',
body: {
roleId: 1,
username: 'kingsLanding',
email: 'test@test.com',
firstname: 'tyrion',
lastname: 'lannister',
password: 'terribleLannister'
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('you cannot signup with this priviledge');
done();
});
middlewares.validateUserInput(request, response, middlewareStub.callback);
});
it('should continue when all the fields are complete', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/users',
body: {
username: 'chieka',
firstname: 'ebere',
lastname: 'samuel',
email: 'chieke@ebere.com',
password: 'password123'
},
locals: {}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
middlewares.validateUserInput(request, response, middlewareStub.callback);
middlewareStub.callback.should.have.been.called;
done();
});
});
describe('validateLoginInput', () => {
it('should continue when email and password is provided', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/users/login/',
body: {
email: 'thePiper',
password: 'password123'
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
middlewares.validateLoginInput(request, response, middlewareStub.callback);
middlewareStub.callback.should.have.been.called;
done();
});
it('should not continue when password is null', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/users/login',
body: {
email: 'kk@mail.com',
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('username and password are required');
});
middlewares.validateLoginInput(request, response, middlewareStub.callback);
});
});
describe('validateUserUpdate', () => {
it('should not continue when user want to modify admin profile', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'PUT',
url: '/api/users/',
params: {
id: '2'
},
body: {
email: 'admin@email.com',
},
locals: {
user: {
decoded: {}
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('you cannot modify this user');
});
middlewares.validateUserUpdate(request, response, middlewareStub.callback);
});
it('should continue when user is the owner', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'PUT',
url: '/api/users/2',
headers: { authorization: `bearer ${regularToken}` },
body: {
username: 'petertosh',
},
params: {
id: regular.id
},
locals: {
user: {
decoded: { roleId: regular.roleId, userId: regular.userId }
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
middlewares.validateUserUpdate(request, response, middlewareStub.callback);
middlewareStub.callback.should.not.have.been.called;
done();
});
it('should continue when user is the owner', (done) => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'PUT',
url: '/api/users/2',
headers: { authorization: `bearer ${regularToken}` },
body: {
username: 'petertosh',
},
params: {
id: regular.id
},
locals: {
user: {
decoded: { roleId: regular.roleId, userId: regular.userId }
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
middlewares.validateUserUpdate(request, response, middlewareStub.callback);
middlewareStub.callback.should.not.have.been.called;
done();
});
it('should return `bad request` trying to modify locked account', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'PUT',
url: '/api/users',
body: {
username: 'noone',
email: 'arya@stark.com',
firstname: 'arya',
lastname: 'stark',
password: 'nooneispassword',
},
params: { id: 1 },
locals: {
user: {
decoded: {
roleId: 3,
userId: 5
}
}
}
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
data.message.should.eql('you are not permitted');
response._isJSON().should.eql(true);
response.statusCode.should.eql(401);
});
middlewares.validateUserUpdate(request, response, middlewareStub.callback);
});
});
describe('validateDocumentInput', () => {
it('it should return `bad request if case of an an empty title', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/documents/',
headers: { authorization: regularToken },
body: {
body: 'Okonkwo was well known throughout the nine villages and even beyond',
},
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
response.statusCode.should.eql(400);
data.message.should.eql('enter valid title');
});
middlewares.validateDocumentInput(request, response, middlewareStub.callback);
});
it('it should return `bad request if case of an an empty access', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/documents/',
headers: { authorization: regularToken },
body: {
title: 'things fall apart',
},
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
response.statusCode.should.eql(400);
data.message.should.eql('enter valid access');
});
middlewares.validateDocumentInput(request, response, middlewareStub.callback);
});
it('it should return `bad request if case of an an empty content', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/documents/',
headers: { authorization: regularToken },
body: {
title: 'things fall apart',
access: 'public'
},
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
response.statusCode.should.eql(400);
data.message.should.eql('enter valid content');
});
middlewares.validateDocumentInput(request, response, middlewareStub.callback);
});
it('it should return `bad request if case of an an ivalid title length', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/documents/',
headers: { authorization: regularToken },
body: {
title: 'abc',
access: 'public',
body: 'Okonkwo was well known throughout the nine villages and even beyond'
},
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
response.statusCode.should.eql(400);
data.message.should.eql('document title must be between 5 and 100 characters');
});
middlewares.validateDocumentInput(request, response, middlewareStub.callback);
});
it('it should return bad request if title already exist', () => {
const response = responseEvent();
request = httpMocks.createRequest({
method: 'POST',
url: '/api/documents/',
headers: { authorization: regularToken },
body: {
title: 'who moved my cheese',
access: 'public',
body: 'Okonkwo was well known throughout the nine villages and even beyond'
},
});
const middlewareStub = {
callback: () => { }
};
sinon.spy(middlewareStub, 'callback');
response.on('end', () => {
const data = JSON.parse(response._getData());
response.statusCode.should.eql(400);
data.message.should.eql('document with title already exist');
});
middlewares.validateDocumentInput(request, response, middlewareStub.callback);
});
});
});
|
(function ($) {
// Use underscore.js html escaper
// http://underscorejs.org/#escape
var _escape;
(function () {
var entityMap = {
escape: {
'&': '&',
'<': '<',
'>': '>',
'"': '"',
"'": '''
}
};
var escapeKeys = [];
for (var k in entityMap.escape) {
if (entityMap.escape.hasOwnProperty(k)) {
escapeKeys.push(k);
}
}
escapeKeys = escapeKeys.join('');
var entityRegexes = {
escape: new RegExp('[' + escapeKeys + ']', 'g')
};
_escape = function (string) {
if (string == null) { return ''; }
return ('' + string).replace(entityRegexes['escape'], function (match) {
return entityMap['escape'][match];
});
};
})();
var _defaultOptions = {
linkAttributes: {
title: 'Click outside of link to edit',
contenteditable: 'false'
},
parseLinks: true,
newlines: true,
editable: true
};
var _options = null;
var _methods = {
destroy: function () {
// remove listeners
this.off('change keydown keypress input', _placeholderUpdate);
this.off('blur', this.data('onBlurListener'));
this.off('focus', this.data('onFocusListener'));
this.find('a').off('mousedown', this.data('onMouseDownListener'));
},
value: function (val) {
if (typeof val === 'string') {
return _methods.setValue.call(this, val);
}
return _methods.getValue.call(this);
},
getValue: function () {
var text, inner;
var textEl = this.clone();
var children = textEl.children('div');
textEl.find('br').replaceWith('\n');
if (children) {
children.detach();
text = textEl.text();
children.each(function (indx, child) {
inner = $(child).text();
if (inner === '\n') {
text += inner;
} else {
text += ('\n' + inner);
}
});
} else {
text = textEl.text();
}
return text;
},
setValue: function (val) {
if (_options && _options.parseLinks) {
this.html(_parseLinks(val));
} else {
this.html(val);
}
_placeholderUpdate.call(this);
return this;
}
};
var _parseLinks = function (text, options) {
if (!text) { return ''; }
options || (options = {});
var linkMaps = [];
var escaped = [];
// use String.prototype.replace because its a crossbrowser way to iterate over links
text.replace(_linkDetectionRegex, function () {
var url = arguments[0];
var index = arguments[arguments.length - 2];
// Map the positions of link and non-link text
linkMaps.push({
linkTag: _makeLink(url, options.linkAttributes),
linkStart: index,
linkEnd: index + url.length
});
// don't actually change the text yet
return url;
});
var lastI = 0;
// Go though each link, and escape the text between it and the last link
for (var i = 0; i < linkMaps.length; i++) {
escaped.push(_escape(text.slice(lastI, linkMaps[i].linkStart)));
escaped.push(linkMaps[i].linkTag);
lastI = linkMaps[i].linkEnd;
};
// Escape everything after the last link
if (lastI) {
escaped.push(_escape(text.slice(lastI)));
} else {
// or if there where no links just escape the whole string
escaped.push(_escape(text));
}
escaped = escaped.join('');
if (options.newlines) { escaped = escaped.replace(/\n/g, '<br>'); }
return escaped;
};
var _makeLink = function (url, attrs) {
var linkStart = "<a href='" + (url.substr(0,4) == 'http' ? url : 'http://' + url) + "' ";
var linkEnd = ">" + url + "</a>";
var linkAttributes = '';
for (var a in attrs) {
if (attrs.hasOwnProperty(a) && a !== 'href' && a !== 'src') {
linkAttributes += (a + "='" + attrs[a] + "' ");
}
}
return linkStart + linkAttributes + linkEnd;
};
var _linkDetectionRegex = /(([a-z]+:\/\/)?(([a-z0-9\-]+\.)+([a-z]{2}|aero|arpa|biz|com|coop|edu|gov|info|int|jobs|mil|museum|name|nato|net|org|pro|travel|local|internal))(:[0-9]{1,5})?(\/[a-z0-9_\-\.~]+)*(\/([a-z0-9_\-\.]*)(\?[a-z0-9+_\-\.%=&]*)?)?(#[a-zA-Z0-9!$&'()*+.=-_~:@/?]*)?)(?=(\)|\(|\<|\>|\s|$))/gi;
// emulate placeholder text in contenteditable HTML
// this was inspired by https://github.com/sprucemedia/jQuery.divPlaceholder.js
var _placeholderUpdate = function () {
$(this).each(function () {
if (this.textContent) {
this.setAttribute('data-div-placeholder-content', 'true');
}
else {
this.removeAttribute('data-div-placeholder-content');
}
});
};
var _smarttext = function ($el, options) {
if (options.parseLinks) {
$el.html(_parseLinks(_methods['value'].call($el), options));
} else {
$el.html(_methods['value'].call($el));
}
// This ensures (cross-browser) that if the user clicks the link before
// the element gets focus we follow the hyperlink as usual
$el.find('a').one('mousedown', $el.data('onMouseDownListener'));
return $el;
};
$.fn.smarttext = function () {
var args = Array.prototype.slice.apply(arguments);
var isMethod = typeof args[0] === 'string';
if (isMethod) {
return _methods[args[0]].apply(this, args.slice(1));
}
_options = $.extend(true, {}, _defaultOptions, args[0]);
return this.each(function (indx, el) {
var $el = $(el);
$el.attr('contenteditable', _options.editable);
var onFocusListener = function () {
if ($el.data('follow-link')) { return; }
$el.find('a').attr('contenteditable', _options.editable);
};
var onBlurListener = function () {
_smarttext($el, _options);
$el.find('a').attr('contenteditable', _options.linkAttributes.contenteditable);
$el.data('follow-link', false);
};
var onMouseDownListener = function () {
// we are relying on the mousedown event firing before focus
if ($(this).attr('contenteditable') === 'false') {
$el.data('follow-link', true);
}
}
$el.data('onFocusListener', onFocusListener);
$el.data('onBlurListener', onBlurListener);
$el.data('onMouseDownListener', onMouseDownListener);
_smarttext($el, _options);
_placeholderUpdate.call($el);
$el.on('focus', onFocusListener).on('blur', onBlurListener);
$el.on('change keydown keypress input', _placeholderUpdate);
});
};
})(jQuery);
|
/**
* User.js
*
* @description :: TODO: You might write a short summary of how this model works and what it represents here.
* @docs :: http://sailsjs.org/#!documentation/models
*/
module.exports = {
attributes: {
name: {
type: 'string'
},
password: {
type: 'string'
}
}
};
|
(function () {
'use strict';
angular
.module('archetypes')
.config(routeConfig);
routeConfig.$inject = ['$stateProvider'];
function routeConfig($stateProvider) {
$stateProvider
.state('archetypes', {
abstract: true,
url: '/archetypes',
template: '<ui-view/>'
})
.state('archetypes.list', {
url: '',
templateUrl: 'modules/archetypes/client/views/list-archetypes.client.view.html',
controller: 'ArchetypesListController',
controllerAs: 'vm',
data: {
pageTitle: 'Archetypes List'
}
})
.state('archetypes.create', {
url: '/create',
templateUrl: 'modules/archetypes/client/views/form-archetype.client.view.html',
controller: 'ArchetypesController',
controllerAs: 'vm',
resolve: {
archetypeResolve: newArchetype
},
data: {
roles: ['user', 'admin'],
pageTitle: 'Archetypes Create'
}
})
.state('archetypes.edit', {
url: '/:archetypeId/edit',
templateUrl: 'modules/archetypes/client/views/form-archetype.client.view.html',
controller: 'ArchetypesController',
controllerAs: 'vm',
resolve: {
archetypeResolve: getArchetype
},
data: {
roles: ['user', 'admin'],
pageTitle: 'Edit Archetype {{ archetypeResolve.name }}'
}
})
.state('archetypes.view', {
url: '/:archetypeId',
templateUrl: 'modules/archetypes/client/views/view-archetype.client.view.html',
controller: 'ArchetypesController',
controllerAs: 'vm',
resolve: {
archetypeResolve: getArchetype
},
data: {
pageTitle: 'Archetype {{ archetypeResolve.name }}'
}
});
}
getArchetype.$inject = ['$stateParams', 'ArchetypesService'];
function getArchetype($stateParams, ArchetypesService) {
return ArchetypesService.get({
archetypeId: $stateParams.archetypeId
}).$promise;
}
newArchetype.$inject = ['ArchetypesService'];
function newArchetype(ArchetypesService) {
return new ArchetypesService();
}
}());
|
/* eslint-disable */
var path = require("path");
var webpack = require("webpack");
module.exports = {
entry: [
"babel-polyfill",
"./index"
],
output: {
path: path.join(__dirname, "dist"),
filename: "bundle.js",
publicPath: "/dist/"
},
plugins: [
new webpack.optimize.OccurenceOrderPlugin(),
new webpack.DefinePlugin({
"process.env": {
"NODE_ENV": JSON.stringify("production")
}
}),
new webpack.optimize.UglifyJsPlugin({
compressor: {
warnings: false
}
})
],
module: {
loaders: [{
test: /\.md$/,
loader: "html-loader!markdown-loader?gfm=false"
}, {
test: /\.(js|jsx)$/,
exclude: /node_modules/,
loader: "babel-loader"
}, {
test: /\.css$/,
loader: "style-loader!css-loader"
}, {
test: /\.(png|jpg|gif)$/,
loader: "url-loader?limit=8192"
}, {
test: /\.svg$/,
loader: "url?limit=10000&mimetype=image/svg+xml"
}, {test: /\.(png|woff|woff2|eot|ttf)$/, loader: 'url-loader?limit=100000'}]
}
};
|
"use strict";
module.exports = {
getHost: function getHost(origin) {
return origin.replace(/([^\/:\s])\/.*$/, '$1');
},
getCookie: function getCookie(str, ckName) {
if (undefined === ckName || "" === ckName) {
return "";
}
if (str == null) {
return '';
} else {
return stringSplice(str, ckName, ";", "");
}
}
};
function stringSplice(src, k, e, sp) {
if (src === "") {
return "";
}
sp = sp === "" ? "=" : sp;
k += sp;
var ps = src.indexOf(k);
if (ps < 0) {
return "";
}
ps += k.length;
var pe = src.indexOf(e, ps);
if (pe < ps) {
pe = src.length;
}
return src.substring(ps, pe);
};
|
var gulp = require('gulp'),
path = require('path'),
del = require('del');
gulp.task('clean', function () {
return del(['./aot', './dist']);
});
gulp.task('copy-assets', function (done) {
var gTask;
var sourceFiles = ['src/assets/**/*'];
var destination = 'dist/assets/';
gTask = gulp.src(sourceFiles)
.pipe(gulp.dest(destination));
if (gTask) gTask.on('end', done);
});
gulp.task('copy-user', function (done) {
var sourceFiles = path.resolve(__dirname, 'dist/assets/**/*');
var destination = path.resolve(__dirname, '../../src/assets/');
var gTask = gulp.src(sourceFiles)
.pipe(gulp.dest(destination));
if (gTask) gTask.on('end', done);
});
|
import * as components from './index.components';
import * as config from './index.config';
import * as run from './index.run';
const App = angular.module(
'myATApp', [
// plugins
require('angular-ui-router'),
"ngAnimate",
"LocalStorageModule",
"ngSanitize",
"ngMessages",
"ngAria",
"ngMaterial",
"satellizer",
"pascalprecht.translate",
"oc.lazyLoad",
// core
require('./core/core.module').name,
// components
require('./index.components').name,
// routes
require('./index.routes').name,
// pages
require('./pages/page/page.module').name,
// Add new pages above
]
);
App
.config(config)
.run(run);
export default App;
|
'use_strict';
module.exports = function(grunt) {
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
bump: {
options: {
files: ['package.json', 'bower.json'],
updateConfigs: [],
commit: true,
commitMessage: 'Release v%VERSION%',
commitFiles: ['package.json', 'bower.json']
}
},
jshint: {
options: {
curly: true,
eqeqeq: true,
eqnull: true,
browser: true,
globals: {
jQuery: true
},
},
src: {
options: {
node: true,
globals: {
it: true,
beforeEach: true,
expect: true,
element: true,
browser: true,
module: true,
spyOn: true,
inject: true,
repeater: true,
describe: true,
angular: true,
jQuery: true
}
},
files: {
src: ['src/**/*.js', 'spec/**/*.js']
},
}
},
less: {
dist: {
options: {
yuicompress: true
},
files: {
"dist/ez-timepicker.min.css": "src/less/ez-timepicker.less"
}
}
},
ngtemplates: {
'ez.timepicker': {
src: 'src/template/ez-timepicker.html',
dest: 'dist/ez-timepicker-tpls.js',
options: {
url: function(url) { return url.replace('src/template/', ''); }
}
}
},
uglify: {
options: {
mangle: true,
compress: true
},
dist: {
files: {
'dist/ez-timepicker.min.js': [
'src/js/ez-timepicker.js'
]
}
}
},
watch: {
dev: {
files: ['src/**/*'],
tasks: ['default'],
options: {
livereload: 9091,
}
}
}
});
grunt.loadNpmTasks('grunt-contrib-jshint');
grunt.loadNpmTasks('grunt-contrib-uglify');
grunt.loadNpmTasks('grunt-angular-templates');
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.loadNpmTasks('grunt-contrib-less');
grunt.loadNpmTasks('grunt-bump');
grunt.registerTask('default', ['jshint', 'uglify', 'less', 'ngtemplates']);
};
|
/* @flow */
import net from 'net';
// exponential backoff, roughly 100ms-6s
const retries = [1, 2, 3, 4, 5].map((num) => Math.exp(num) * 40);
const streams = { stdout: process.stdout }; // overwritable by tests
const communicate = async function communicate(
socketPath: string,
message: string,
): Promise<void> {
await new Promise((resolve: () => void, reject: (Error) => void) => {
const client = net.connect(socketPath, () => {
client.end(message);
client.pipe(streams.stdout);
});
client.on('error', (err: ErrnoError) => reject(err));
client.on('close', (err: ?Error) => {
if (err) { reject(err); }
else { resolve(); }
});
});
};
const main = async function main(...args: string[]): Promise<void> {
try { await communicate(...args); }
catch (err) {
const recoverable = (
err.code === 'ECONNREFUSED' ||
err.code === 'ENOENT'
);
if (recoverable && retries.length) {
await new Promise((resolve: () => void, reject: (Error) => void) => {
setTimeout(() => {
main(...args).then(resolve, reject);
}, retries.shift());
});
}
}
};
/* istanbul ignore if */
if ((require: any).main === module) {
(async(): Promise<void> => {
try { await main(...process.argv.slice(2)); }
catch (err) { process.stderr.write(`${err.stack}\n`); process.exit(1); }
})();
}
export {
main,
streams as _streams,
retries as _retries,
};
|
require('./rpc');
|
import React from 'react'
import PropTypes from 'prop-types'
import LoadingSpinner from './LoadingSpinner'
// Waits for X ms before showing a spinner
class DelayedSpinner extends React.PureComponent {
constructor() {
super()
this.state = {}
}
componentDidMount() {
this.timer = setTimeout(() => this.setState({show: true}), this.props.delay)
}
componentWillUnmount() {
clearTimeout(this.timer)
}
render() {
return this.state.show ? <LoadingSpinner /> : null
}
}
DelayedSpinner.propTypes = {
delay: PropTypes.number
}
DelayedSpinner.defaultProps = {
delay: 500
}
export default DelayedSpinner
|
'use strict';
// MODULES //
var isString = require( 'validate.io-string-primitive' ),
isObject = require( 'validate.io-object' ),
contains = require( 'validate.io-contains' ),
templates = require( './templates' ),
path = require( 'path' ),
fs = require( 'fs' );
// COPY //
/**
* FUNCTION: cp( dest[, opts ] )
* Synchronously creates a .gitignore file.
*
* @param {String} dest - .gitignore destination directory
* @param {Object} [opts] - function options
* @param {String} [opts.template="default"] - .gitignore template to use
*/
function cp( dest, opts ) {
var tmpl = 'default',
fpath,
dpath;
if ( !isString( dest ) ) {
throw new TypeError( 'cp()::invalid input argument. First argument must be a string primitive. Value: `' + dest + '`.' );
}
if ( arguments.length > 1 ) {
if ( !isObject( opts ) ) {
throw new TypeError( 'cp()::invalid input argument. Options argument must be an object. Value: `' + opts + '`.' );
}
if ( opts.hasOwnProperty( 'template' ) ) {
tmpl = opts.template;
if ( !isString( tmpl ) ) {
throw new TypeError( 'cp()::invalid option. Template option must be a string primitive. Option: `' + tmpl + '`.' );
}
if ( !contains( templates, tmpl ) ) {
throw new Error( 'cp()::invalid option. Unrecognized template name. Must be one of [' + templates.join( ',' ) + '] Option: `' + tmpl + '`.' );
}
}
}
fpath = path.join( __dirname, tmpl, 'gitignore' );
dpath = path.join( dest, '.gitignore' );
fs.writeFileSync( dpath, fs.readFileSync( fpath ) );
} // end FUNCTION cp()
// EXPORTS //
module.exports = cp;
|
/**
* Created by maglo on 27/09/2016.
*/
Ext.define("JS.article.List",{
extend:"JS.panel.HistoryGridPanel",
config:{
panelData: {
url: "",
panelClass: "",
gridUrl: Routing.generate("get_manuscrits"),
actions: []
},
grid: {
store: {
proxy: {
url: Routing.generate("get_manuscrits", {_format: "json"})
}
},
type: "custom",
dynamicTplClass: "JS.article.GridCustom"
}
},
initialize:function(){
var me = this;
var panelData = me.getPanelData(),
actions = [];
var action = {
param: {"url": "get_manuscrits", "panelClass": "ERating.emprunt.UserFilterForm", "formUrl": "", "gridUrl": "api_v1_get_filtered_emprunt"},
libelle: "Filtre utilisateur",
description: "Advanced search"
};
actions.push(action);
panelData.actions = actions;
this.callParent(arguments);
},
onGridSelect: function (grid, selectedIndex, selectedRecord, selectedIndexes, selectedRecords) {
var me = this;
this.callParent(arguments);
},
onStoreLoaded: function () {
var me = this;
var grid = me.getGrid();
me.callParent();
}
});
|
/*
* Utils functions
*
*/
var crypt = require('crypto');
/**
* Break string str each maxLen symbols
* @param str
* @param maxLen
* @returns {string}
*/
module.exports.linebrk = function (str, maxLen) {
var res = '';
var i = 0;
while (i + maxLen < str.length) {
res += str.substring(i, i + maxLen) + "\n";
i += maxLen;
}
return res + str.substring(i, str.length);
};
module.exports.detectEnvironment = function () {
if (typeof(window) !== 'undefined' && window && !(process && process.title === 'node')) {
return 'browser';
}
return 'node';
};
/**
* Trying get a 32-bit unsigned integer from the partial buffer
* @param buffer
* @param offset
* @returns {Number}
*/
module.exports.get32IntFromBuffer = function (buffer, offset) {
offset = offset || 0;
var size = 0;
if ((size = buffer.length - offset) > 0) {
if (size >= 4) {
return buffer.readUInt32BE(offset);
} else {
var res = 0;
for (var i = offset + size, d = 0; i > offset; i--, d += 2) {
res += buffer[i - 1] * Math.pow(16, d);
}
return res;
}
} else {
return NaN;
}
};
module.exports._ = {
isObject: function (value) {
var type = typeof value;
return !!value && (type == 'object' || type == 'function');
},
isString: function (value) {
return typeof value == 'string' || value instanceof String;
},
isNumber: function (value) {
return typeof value == 'number' || !isNaN(parseFloat(value)) && isFinite(value);
},
/**
* Returns copy of `obj` without `removeProp` field.
* @param obj
* @param removeProp
* @returns Object
*/
omit: function (obj, removeProp) {
var newObj = {};
for (var prop in obj) {
if (!obj.hasOwnProperty(prop) || prop === removeProp) {
continue;
}
newObj[prop] = obj[prop];
}
return newObj;
}
};
/**
* Strips everything around the opening and closing lines, including the lines
* themselves.
*/
module.exports.trimSurroundingText = function (data, opening, closing) {
var trimStartIndex = 0;
var trimEndIndex = data.length;
var openingBoundaryIndex = data.indexOf(opening);
if (openingBoundaryIndex >= 0) {
trimStartIndex = openingBoundaryIndex + opening.length;
}
var closingBoundaryIndex = data.indexOf(closing, openingBoundaryIndex);
if (closingBoundaryIndex >= 0) {
trimEndIndex = closingBoundaryIndex;
}
return data.substring(trimStartIndex, trimEndIndex);
}
|
(function($){
$.getScript('/js/moment.min.js', function(){
var url = 'https://api.twitter.com/1/statuses/user_timeline/' + twitter_stream[0] + '.json?count=' + twitter_stream[1] + '&exclude_replies=' + (twitter_stream[2] ? 0 : 1) + '&trim_user=true&callback=?';
var linkify = function(text){
text = text
.replace(/(https?:\/\/)([\w\-:;?&=+.%#\/]+)/gi, '<a href="$1$2">$2</a>')
.replace(/(^|\W)@(\w+)/g, '$1<a href="http://twitter.com/$2">@$2</a>')
.replace(/(^|\W)#(\w+)/g, '$1<a href="http://search.twitter.com/search?q=%23$2">#$2</a>');
return text;
};
$.getJSON(url, function(json){
var result = '';
for (var i=0, len=json.length; i<len; i++){
var item = json[i];
result += '<li>' + linkify(item.text) + '<small>' + moment(item.created_at).fromNow() + '</small></li>';
}
$('#tweets').html(result);
});
});
})(jQuery);
|
import Resource from './resource';
export default class Message extends Resource {
constructor(client, id) {
super(client, 'message', id);
}
}
|
/** @constructor */
ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1 = (function() {
ScalaJS.c.java_io_FilterOutputStream.call(this)
});
ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1.prototype = new ScalaJS.inheritable.java_io_FilterOutputStream();
ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1.prototype.constructor = ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1;
ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1.prototype.close__V = (function() {
ScalaJS.impls.scala_sys_process_BasicIO$Uncloseable$class__close__Lscala_sys_process_BasicIO$Uncloseable__V(this)
});
ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1.prototype.init___Ljava_io_OutputStream = (function(out$1) {
ScalaJS.c.java_io_FilterOutputStream.prototype.init___Ljava_io_OutputStream.call(this, out$1);
ScalaJS.impls.scala_sys_process_BasicIO$Uncloseable$class__$init$__Lscala_sys_process_BasicIO$Uncloseable__V(this);
return this
});
/** @constructor */
ScalaJS.inheritable.scala_sys_process_BasicIO$Uncloseable$$anon$1 = (function() {
/*<skip>*/
});
ScalaJS.inheritable.scala_sys_process_BasicIO$Uncloseable$$anon$1.prototype = ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1.prototype;
ScalaJS.is.scala_sys_process_BasicIO$Uncloseable$$anon$1 = (function(obj) {
return (!(!((obj && obj.$classData) && obj.$classData.ancestors.scala_sys_process_BasicIO$Uncloseable$$anon$1)))
});
ScalaJS.as.scala_sys_process_BasicIO$Uncloseable$$anon$1 = (function(obj) {
if ((ScalaJS.is.scala_sys_process_BasicIO$Uncloseable$$anon$1(obj) || (obj === null))) {
return obj
} else {
ScalaJS.throwClassCastException(obj, "scala.sys.process.BasicIO$Uncloseable$$anon$1")
}
});
ScalaJS.isArrayOf.scala_sys_process_BasicIO$Uncloseable$$anon$1 = (function(obj, depth) {
return (!(!(((obj && obj.$classData) && (obj.$classData.arrayDepth === depth)) && obj.$classData.arrayBase.ancestors.scala_sys_process_BasicIO$Uncloseable$$anon$1)))
});
ScalaJS.asArrayOf.scala_sys_process_BasicIO$Uncloseable$$anon$1 = (function(obj, depth) {
if ((ScalaJS.isArrayOf.scala_sys_process_BasicIO$Uncloseable$$anon$1(obj, depth) || (obj === null))) {
return obj
} else {
ScalaJS.throwArrayCastException(obj, "Lscala.sys.process.BasicIO$Uncloseable$$anon$1;", depth)
}
});
ScalaJS.data.scala_sys_process_BasicIO$Uncloseable$$anon$1 = new ScalaJS.ClassTypeData({
scala_sys_process_BasicIO$Uncloseable$$anon$1: 0
}, false, "scala.sys.process.BasicIO$Uncloseable$$anon$1", ScalaJS.data.java_io_FilterOutputStream, {
scala_sys_process_BasicIO$Uncloseable$$anon$1: 1,
scala_sys_process_BasicIO$Uncloseable: 1,
java_io_FilterOutputStream: 1,
java_io_OutputStream: 1,
java_io_Flushable: 1,
java_io_Closeable: 1,
java_lang_AutoCloseable: 1,
java_lang_Object: 1
});
ScalaJS.c.scala_sys_process_BasicIO$Uncloseable$$anon$1.prototype.$classData = ScalaJS.data.scala_sys_process_BasicIO$Uncloseable$$anon$1;
//@ sourceMappingURL=BasicIO$Uncloseable$$anon$1.js.map
|
var expect = require('expect.js');
var eio = require('../../');
var Blob = require('blob');
describe('blob', function () {
this.timeout(30000);
it('should be able to receive binary data as blob when bouncing it back (ws)', function (done) {
var binaryData = new Int8Array(5);
for (var i = 0; i < 5; i++) {
binaryData[i] = i;
}
var socket = new eio.Socket();
socket.binaryType = 'blob';
socket.on('open', function () {
socket.on('upgrade', function () {
socket.send(binaryData);
socket.on('message', function (data) {
expect(data).to.be.a(global.Blob);
var fr = new FileReader();
fr.onload = function () {
var ab = this.result;
var ia = new Int8Array(ab);
expect(ia).to.eql(binaryData);
socket.close();
done();
};
fr.readAsArrayBuffer(data);
});
});
});
});
it('should be able to send data as a blob when bouncing it back (ws)', function (done) {
var binaryData = new Int8Array(5);
for (var i = 0; i < 5; i++) {
binaryData[i] = i;
}
var socket = new eio.Socket();
socket.on('open', function () {
socket.on('upgrade', function () {
socket.send(new Blob([binaryData.buffer]));
socket.on('message', function (data) {
expect(data).to.be.an(ArrayBuffer);
expect(new Int8Array(data)).to.eql(binaryData);
socket.close();
done();
});
});
});
});
it('should be able to send data as a blob encoded into base64 when bouncing it back (ws)', function (done) {
var binaryData = new Int8Array(5);
for (var i = 0; i < 5; i++) {
binaryData[i] = i;
}
var socket = new eio.Socket({ forceBase64: true });
socket.on('open', function () {
socket.on('upgrade', function () {
socket.send(new Blob([binaryData.buffer]));
socket.on('message', function (data) {
expect(data).to.be.an(ArrayBuffer);
expect(new Int8Array(data)).to.eql(binaryData);
socket.close();
done();
});
});
});
});
});
|
(function(database){
var mongodb = require("mongodb");
var mongodbUrl = "mongodb://localhost:27017/theBoard"
var theDb = null;
database.getDb = function(next){
if(theDb){
next(null, theDb);
}
else{
mongodb.MongoClient.connect(mongodbUrl, function(err, db){
if(err){
next(err, null);
}
else{
mongodb.MongoClient.connect(mongodbUrl, function(err, db){
if(err){
next(err, null);
}
else{
theDb = {
db: db,
notes: db.collection("notes")
}
next(null, theDb);
}
});
}
});
}
}
})(module.exports)
|
const tasks = require('./tasks');
tasks.replaceWebpack();
console.log('[Copy assets]');
console.log('--------------------------------');
tasks.copyAssets('build');
console.log('[Webpack Build]');
console.log('--------------------------------');
exec('webpack --config webpack/prod.config.js --progress --profile --colors');
|
import { expect } from 'chai';
import * as helpers from './helpers';
import * as funcs from './ch2-q8';
for (let key in funcs) {
let func = funcs[key];
describe('ch2-q8: ' + key, function() {
beforeEach(function() {
this.list = helpers.createLinkedList();
});
it('returns null with empty list', function() {
expect(func(this.list.head)).to.be.null;
});
it('returns null when there is no loop', function() {
helpers.push(this.list, 1, 2, 3, 4, 5, 6);
expect(func(this.list.head)).to.be.null;
});
it('returns node when there is a loop 1', function() {
helpers.push(this.list, 1, 2, 3, 4, 5, 6);
let node = this.list.head;
this.list.tail.next = node;
expect(func(this.list.head)).to.equal(node);
});
it('returns node when there is a loop 2', function() {
helpers.push(this.list, 1, 2, 3, 4, 5, 6);
let node = this.list.head.next.next.next;
this.list.tail.next = node;
expect(func(this.list.head)).to.equal(node);
});
it('returns node when there is a loop 3', function() {
helpers.push(this.list, 1, 2, 3, 4, 5, 6);
let node = this.list.tail;
this.list.tail.next = node;
expect(func(this.list.head)).to.equal(node);
});
});
}
|
'use strict';
var ngOptionsMinErr = minErr('ngOptions');
/**
* @ngdoc directive
* @name select
* @restrict E
*
* @description
* HTML `SELECT` element with angular data-binding.
*
* # `ngOptions`
*
* The `ngOptions` attribute can be used to dynamically generate a list of `<option>`
* elements for the `<select>` element using the array or object obtained by evaluating the
* `ngOptions` comprehension_expression.
*
* When an item in the `<select>` menu is selected, the array element or object property
* represented by the selected option will be bound to the model identified by the `ngModel`
* directive.
*
* <div class="alert alert-warning">
* **Note:** `ngModel` compares by reference, not value. This is important when binding to an
* array of objects. See an example [in this jsfiddle](http://jsfiddle.net/qWzTb/).
* </div>
*
* Optionally, a single hard-coded `<option>` element, with the value set to an empty string, can
* be nested into the `<select>` element. This element will then represent the `null` or "not selected"
* option. See example below for demonstration.
*
* <div class="alert alert-warning">
* **Note:** `ngOptions` provides an iterator facility for the `<option>` element which should be used instead
* of {@link ng.directive:ngRepeat ngRepeat} when you want the
* `select` model to be bound to a non-string value. This is because an option element can only
* be bound to string values at present.
* </div>
*
* @param {string} ngModel Assignable angular expression to data-bind to.
* @param {string=} name Property name of the form under which the control is published.
* @param {string=} required The control is considered valid only if value is entered.
* @param {string=} ngRequired Adds `required` attribute and `required` validation constraint to
* the element when the ngRequired expression evaluates to true. Use `ngRequired` instead of
* `required` when you want to data-bind to the `required` attribute.
* @param {comprehension_expression=} ngOptions in one of the following forms:
*
* * for array data sources:
* * `label` **`for`** `value` **`in`** `array`
* * `select` **`as`** `label` **`for`** `value` **`in`** `array`
* * `label` **`group by`** `group` **`for`** `value` **`in`** `array`
* * `select` **`as`** `label` **`group by`** `group` **`for`** `value` **`in`** `array` **`track by`** `trackexpr`
* * for object data sources:
* * `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
* * `select` **`as`** `label` **`for (`**`key` **`,`** `value`**`) in`** `object`
* * `label` **`group by`** `group` **`for (`**`key`**`,`** `value`**`) in`** `object`
* * `select` **`as`** `label` **`group by`** `group`
* **`for` `(`**`key`**`,`** `value`**`) in`** `object`
*
* Where:
*
* * `array` / `object`: an expression which evaluates to an array / object to iterate over.
* * `value`: local variable which will refer to each item in the `array` or each property value
* of `object` during iteration.
* * `key`: local variable which will refer to a property name in `object` during iteration.
* * `label`: The result of this expression will be the label for `<option>` element. The
* `expression` will most likely refer to the `value` variable (e.g. `value.propertyName`).
* * `select`: The result of this expression will be bound to the model of the parent `<select>`
* element. If not specified, `select` expression will default to `value`.
* * `group`: The result of this expression will be used to group options using the `<optgroup>`
* DOM element.
* * `trackexpr`: Used when working with an array of objects. The result of this expression will be
* used to identify the objects in the array. The `trackexpr` will most likely refer to the
* `value` variable (e.g. `value.propertyName`).
*
* @example
<example>
<file name="index.html">
<script>
function MyCntrl($scope) {
$scope.colors = [
{name:'black', shade:'dark'},
{name:'white', shade:'light'},
{name:'red', shade:'dark'},
{name:'blue', shade:'dark'},
{name:'yellow', shade:'light'}
];
$scope.myColor = $scope.colors[2]; // red
}
</script>
<div ng-controller="MyCntrl">
<ul>
<li ng-repeat="color in colors">
Name: <input ng-model="color.name">
[<a href ng-click="colors.splice($index, 1)">X</a>]
</li>
<li>
[<a href ng-click="colors.push({})">add</a>]
</li>
</ul>
<hr/>
Color (null not allowed):
<select ng-model="myColor" ng-options="color.name for color in colors"></select><br>
Color (null allowed):
<span class="nullable">
<select ng-model="myColor" ng-options="color.name for color in colors">
<option value="">-- choose color --</option>
</select>
</span><br/>
Color grouped by shade:
<select ng-model="myColor" ng-options="color.name group by color.shade for color in colors">
</select><br/>
Select <a href ng-click="myColor = { name:'not in list', shade: 'other' }">bogus</a>.<br>
<hr/>
Currently selected: {{ {selected_color:myColor} }}
<div style="border:solid 1px black; height:20px"
ng-style="{'background-color':myColor.name}">
</div>
</div>
</file>
<file name="protractor.js" type="protractor">
it('should check ng-options', function() {
expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('red');
element.all(by.select('myColor')).first().click();
element.all(by.css('select[ng-model="myColor"] option')).first().click();
expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('black');
element(by.css('.nullable select[ng-model="myColor"]')).click();
element.all(by.css('.nullable select[ng-model="myColor"] option')).first().click();
expect(element(by.binding('{selected_color:myColor}')).getText()).toMatch('null');
});
</file>
</example>
*/
var ngOptionsDirective = valueFn({ terminal: true });
// jshint maxlen: false
var selectDirective = ['$compile', '$parse', function($compile, $parse) {
//000011111111110000000000022222222220000000000000000000003333333333000000000000004444444444444440000000005555555555555550000000666666666666666000000000000000777777777700000000000000000008888888888
var NG_OPTIONS_REGEXP = /^\s*([\s\S]+?)(?:\s+as\s+([\s\S]+?))?(?:\s+group\s+by\s+([\s\S]+?))?\s+for\s+(?:([\$\w][\$\w]*)|(?:\(\s*([\$\w][\$\w]*)\s*,\s*([\$\w][\$\w]*)\s*\)))\s+in\s+([\s\S]+?)(?:\s+track\s+by\s+([\s\S]+?))?$/,
nullModelCtrl = {$setViewValue: noop};
// jshint maxlen: 100
return {
restrict: 'E',
require: ['select', '?ngModel'],
controller: ['$element', '$scope', '$attrs', function($element, $scope, $attrs) {
var self = this,
optionsMap = {},
ngModelCtrl = nullModelCtrl,
nullOption,
unknownOption;
self.databound = $attrs.ngModel;
self.init = function(ngModelCtrl_, nullOption_, unknownOption_) {
ngModelCtrl = ngModelCtrl_;
nullOption = nullOption_;
unknownOption = unknownOption_;
};
self.addOption = function(value) {
assertNotHasOwnProperty(value, '"option value"');
optionsMap[value] = true;
if (ngModelCtrl.$viewValue == value) {
$element.val(value);
if (unknownOption.parent()) unknownOption.remove();
}
};
self.removeOption = function(value) {
if (this.hasOption(value)) {
delete optionsMap[value];
if (ngModelCtrl.$viewValue == value) {
this.renderUnknownOption(value);
}
}
};
self.renderUnknownOption = function(val) {
var unknownVal = '? ' + hashKey(val) + ' ?';
unknownOption.val(unknownVal);
$element.prepend(unknownOption);
$element.val(unknownVal);
unknownOption.prop('selected', true); // needed for IE
};
self.hasOption = function(value) {
return optionsMap.hasOwnProperty(value);
};
$scope.$on('$destroy', function() {
// disable unknown option so that we don't do work when the whole select is being destroyed
self.renderUnknownOption = noop;
});
}],
link: function(scope, element, attr, ctrls) {
// if ngModel is not defined, we don't need to do anything
if (!ctrls[1]) return;
var selectCtrl = ctrls[0],
ngModelCtrl = ctrls[1],
multiple = attr.multiple,
optionsExp = attr.ngOptions,
nullOption = false, // if false, user will not be able to select it (used by ngOptions)
emptyOption,
// we can't just jqLite('<option>') since jqLite is not smart enough
// to create it in <select> and IE barfs otherwise.
optionTemplate = jqLite(document.createElement('option')),
optGroupTemplate =jqLite(document.createElement('optgroup')),
unknownOption = optionTemplate.clone();
// find "null" option
for(var i = 0, children = element.children(), ii = children.length; i < ii; i++) {
if (children[i].value === '') {
emptyOption = nullOption = children.eq(i);
break;
}
}
selectCtrl.init(ngModelCtrl, nullOption, unknownOption);
// required validator
if (multiple) {
ngModelCtrl.$isEmpty = function(value) {
return !value || value.length === 0;
};
}
if (optionsExp) setupAsOptions(scope, element, ngModelCtrl);
else if (multiple) setupAsMultiple(scope, element, ngModelCtrl);
else setupAsSingle(scope, element, ngModelCtrl, selectCtrl);
////////////////////////////
function setupAsSingle(scope, selectElement, ngModelCtrl, selectCtrl) {
ngModelCtrl.$render = function() {
var viewValue = ngModelCtrl.$viewValue;
if (selectCtrl.hasOption(viewValue)) {
if (unknownOption.parent()) unknownOption.remove();
selectElement.val(viewValue);
if (viewValue === '') emptyOption.prop('selected', true); // to make IE9 happy
} else {
if (isUndefined(viewValue) && emptyOption) {
selectElement.val('');
} else {
selectCtrl.renderUnknownOption(viewValue);
}
}
};
selectElement.on('change', function() {
scope.$apply(function() {
if (unknownOption.parent()) unknownOption.remove();
ngModelCtrl.$setViewValue(selectElement.val());
});
});
}
function setupAsMultiple(scope, selectElement, ctrl) {
var lastView;
ctrl.$render = function() {
var items = new HashMap(ctrl.$viewValue);
forEach(selectElement.find('option'), function(option) {
option.selected = isDefined(items.get(option.value));
});
};
// we have to do it on each watch since ngModel watches reference, but
// we need to work of an array, so we need to see if anything was inserted/removed
scope.$watch(function selectMultipleWatch() {
if (!equals(lastView, ctrl.$viewValue)) {
lastView = shallowCopy(ctrl.$viewValue);
ctrl.$render();
}
});
selectElement.on('change', function() {
scope.$apply(function() {
var array = [];
forEach(selectElement.find('option'), function(option) {
if (option.selected) {
array.push(option.value);
}
});
ctrl.$setViewValue(array);
});
});
}
function setupAsOptions(scope, selectElement, ctrl) {
var match;
if (!(match = optionsExp.match(NG_OPTIONS_REGEXP))) {
throw ngOptionsMinErr('iexp',
"Expected expression in form of " +
"'_select_ (as _label_)? for (_key_,)?_value_ in _collection_'" +
" but got '{0}'. Element: {1}",
optionsExp, startingTag(selectElement));
}
var displayFn = $parse(match[2] || match[1]),
valueName = match[4] || match[6],
keyName = match[5],
groupByFn = $parse(match[3] || ''),
valueFn = $parse(match[2] ? match[1] : valueName),
valuesFn = $parse(match[7]),
track = match[8],
trackFn = track ? $parse(match[8]) : null,
// This is an array of array of existing option groups in DOM.
// We try to reuse these if possible
// - optionGroupsCache[0] is the options with no option group
// - optionGroupsCache[?][0] is the parent: either the SELECT or OPTGROUP element
optionGroupsCache = [[{element: selectElement, label:''}]];
if (nullOption) {
// compile the element since there might be bindings in it
$compile(nullOption)(scope);
// remove the class, which is added automatically because we recompile the element and it
// becomes the compilation root
nullOption.removeClass('ng-scope');
// we need to remove it before calling selectElement.empty() because otherwise IE will
// remove the label from the element. wtf?
nullOption.remove();
}
// clear contents, we'll add what's needed based on the model
selectElement.empty();
selectElement.on('change', function() {
scope.$apply(function() {
var optionGroup,
collection = valuesFn(scope) || [],
locals = {},
key, value, optionElement, index, groupIndex, length, groupLength, trackIndex;
if (multiple) {
value = [];
for (groupIndex = 0, groupLength = optionGroupsCache.length;
groupIndex < groupLength;
groupIndex++) {
// list of options for that group. (first item has the parent)
optionGroup = optionGroupsCache[groupIndex];
for(index = 1, length = optionGroup.length; index < length; index++) {
if ((optionElement = optionGroup[index].element)[0].selected) {
key = optionElement.val();
if (keyName) locals[keyName] = key;
if (trackFn) {
for (trackIndex = 0; trackIndex < collection.length; trackIndex++) {
locals[valueName] = collection[trackIndex];
if (trackFn(scope, locals) == key) break;
}
} else {
locals[valueName] = collection[key];
}
value.push(valueFn(scope, locals));
}
}
}
} else {
key = selectElement.val();
if (key == '?') {
value = undefined;
} else if (key === ''){
value = null;
} else {
if (trackFn) {
for (trackIndex = 0; trackIndex < collection.length; trackIndex++) {
locals[valueName] = collection[trackIndex];
if (trackFn(scope, locals) == key) {
value = valueFn(scope, locals);
break;
}
}
} else {
locals[valueName] = collection[key];
if (keyName) locals[keyName] = key;
value = valueFn(scope, locals);
}
}
// Update the null option's selected property here so $render cleans it up correctly
if (optionGroupsCache[0].length > 1) {
if (optionGroupsCache[0][1].id !== key) {
optionGroupsCache[0][1].selected = false;
}
}
}
ctrl.$setViewValue(value);
});
});
ctrl.$render = render;
// TODO(vojta): can't we optimize this ?
scope.$watch(render);
function render() {
// Temporary location for the option groups before we render them
var optionGroups = {'':[]},
optionGroupNames = [''],
optionGroupName,
optionGroup,
option,
existingParent, existingOptions, existingOption,
modelValue = ctrl.$modelValue,
values = valuesFn(scope) || [],
keys = keyName ? sortedKeys(values) : values,
key,
groupLength, length,
groupIndex, index,
locals = {},
selected,
selectedSet = false, // nothing is selected yet
lastElement,
element,
label;
if (multiple) {
if (trackFn && isArray(modelValue)) {
selectedSet = new HashMap([]);
for (var trackIndex = 0; trackIndex < modelValue.length; trackIndex++) {
locals[valueName] = modelValue[trackIndex];
selectedSet.put(trackFn(scope, locals), modelValue[trackIndex]);
}
} else {
selectedSet = new HashMap(modelValue);
}
}
// We now build up the list of options we need (we merge later)
for (index = 0; length = keys.length, index < length; index++) {
key = index;
if (keyName) {
key = keys[index];
if ( key.charAt(0) === '$' ) continue;
locals[keyName] = key;
}
locals[valueName] = values[key];
optionGroupName = groupByFn(scope, locals) || '';
if (!(optionGroup = optionGroups[optionGroupName])) {
optionGroup = optionGroups[optionGroupName] = [];
optionGroupNames.push(optionGroupName);
}
if (multiple) {
selected = isDefined(
selectedSet.remove(trackFn ? trackFn(scope, locals) : valueFn(scope, locals))
);
} else {
if (trackFn) {
var modelCast = {};
modelCast[valueName] = modelValue;
selected = trackFn(scope, modelCast) === trackFn(scope, locals);
} else {
selected = modelValue === valueFn(scope, locals);
}
selectedSet = selectedSet || selected; // see if at least one item is selected
}
label = displayFn(scope, locals); // what will be seen by the user
// doing displayFn(scope, locals) || '' overwrites zero values
label = isDefined(label) ? label : '';
optionGroup.push({
// either the index into array or key from object
id: trackFn ? trackFn(scope, locals) : (keyName ? keys[index] : index),
label: label,
selected: selected // determine if we should be selected
});
}
if (!multiple) {
if (nullOption || modelValue === null) {
// insert null option if we have a placeholder, or the model is null
optionGroups[''].unshift({id:'', label:'', selected:!selectedSet});
} else if (!selectedSet) {
// option could not be found, we have to insert the undefined item
optionGroups[''].unshift({id:'?', label:'', selected:true});
}
}
// Now we need to update the list of DOM nodes to match the optionGroups we computed above
for (groupIndex = 0, groupLength = optionGroupNames.length;
groupIndex < groupLength;
groupIndex++) {
// current option group name or '' if no group
optionGroupName = optionGroupNames[groupIndex];
// list of options for that group. (first item has the parent)
optionGroup = optionGroups[optionGroupName];
if (optionGroupsCache.length <= groupIndex) {
// we need to grow the optionGroups
existingParent = {
element: optGroupTemplate.clone().attr('label', optionGroupName),
label: optionGroup.label
};
existingOptions = [existingParent];
optionGroupsCache.push(existingOptions);
selectElement.append(existingParent.element);
} else {
existingOptions = optionGroupsCache[groupIndex];
existingParent = existingOptions[0]; // either SELECT (no group) or OPTGROUP element
// update the OPTGROUP label if not the same.
if (existingParent.label != optionGroupName) {
existingParent.element.attr('label', existingParent.label = optionGroupName);
}
}
lastElement = null; // start at the beginning
for(index = 0, length = optionGroup.length; index < length; index++) {
option = optionGroup[index];
if ((existingOption = existingOptions[index+1])) {
// reuse elements
lastElement = existingOption.element;
if (existingOption.label !== option.label) {
lastElement.text(existingOption.label = option.label);
}
if (existingOption.id !== option.id) {
lastElement.val(existingOption.id = option.id);
}
// lastElement.prop('selected') provided by jQuery has side-effects
if (existingOption.selected !== option.selected) {
lastElement.prop('selected', (existingOption.selected = option.selected));
}
} else {
// grow elements
// if it's a null option
if (option.id === '' && nullOption) {
// put back the pre-compiled element
element = nullOption;
} else {
// jQuery(v1.4.2) Bug: We should be able to chain the method calls, but
// in this version of jQuery on some browser the .text() returns a string
// rather then the element.
(element = optionTemplate.clone())
.val(option.id)
.prop('selected', option.selected)
.text(option.label);
}
existingOptions.push(existingOption = {
element: element,
label: option.label,
id: option.id,
selected: option.selected
});
if (lastElement) {
lastElement.after(element);
} else {
existingParent.element.append(element);
}
lastElement = element;
}
}
// remove any excessive OPTIONs in a group
index++; // increment since the existingOptions[0] is parent element not OPTION
while(existingOptions.length > index) {
existingOptions.pop().element.remove();
}
}
// remove any excessive OPTGROUPs from select
while(optionGroupsCache.length > groupIndex) {
optionGroupsCache.pop()[0].element.remove();
}
}
}
}
};
}];
var optionDirective = ['$interpolate', function($interpolate) {
var nullSelectCtrl = {
addOption: noop,
removeOption: noop
};
return {
restrict: 'E',
priority: 100,
compile: function(element, attr) {
if (isUndefined(attr.value)) {
var interpolateFn = $interpolate(element.text(), true);
if (!interpolateFn) {
attr.$set('value', element.text());
}
}
return function (scope, element, attr) {
var selectCtrlName = '$selectController',
parent = element.parent(),
selectCtrl = parent.data(selectCtrlName) ||
parent.parent().data(selectCtrlName); // in case we are in optgroup
if (selectCtrl && selectCtrl.databound) {
// For some reason Opera defaults to true and if not overridden this messes up the repeater.
// We don't want the view to drive the initialization of the model anyway.
element.prop('selected', false);
} else {
selectCtrl = nullSelectCtrl;
}
if (interpolateFn) {
scope.$watch(interpolateFn, function interpolateWatchAction(newVal, oldVal) {
attr.$set('value', newVal);
if (oldVal !== newVal) {
selectCtrl.removeOption(oldVal);
}
selectCtrl.addOption(newVal);
});
} else {
selectCtrl.addOption(attr.value);
}
element.on('$destroy', function() {
selectCtrl.removeOption(attr.value);
});
};
}
};
}];
|
/**
* Created by elijah on 7/21/15.
*/
var express = require("express");
var router = express.Router();
var Q = require('q');
var cookieParser = require('cookie-parser');
var impredis = require("../../imp_services/impredis.js");
express(cookieParser());
router.route('/:userName').get( function(req,res){
var user = req.params.userName;
impredis.delete(req.cookies.IMPId);
impredis.delete(req.params.userName);
require('../../imp_services/implogging')(req.cookies.IMPId, function(logService) {
logService.action.user = user;
logService.setType(901);
logService.store(function (err, results) {
if (err) res.status(500).send(err);
});
});
impredis.exists(req.cookies.IMPId, function(err, reply) {
if(reply == 1) {
console.log("Failure");
res.status(500).send("There was an error logging out.")
}
else{
res.send("Success!");
}
});
});
module.exports = router;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.