code
stringlengths 2
1.05M
|
|---|
var crypto = require('crypto');
var fs = require('fs');
var keypair = require('keypair');
var pair = keypair();
fs.writeFile('Publickey.pem', pair.public, function (err) {
if (err) {
console.log('Cant write Public key to file!');
}
});
fs.writeFile('Privatekey.pem', pair.private, function (err) {
if (err) {
console.log('Cant write private key to file!');
}
});
console.log(pair);
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _stringify = require('babel-runtime/core-js/json/stringify');
var _stringify2 = _interopRequireDefault(_stringify);
var _assign = require('babel-runtime/core-js/object/assign');
var _assign2 = _interopRequireDefault(_assign);
exports.recordErrors = recordErrors;
exports.injectGremlins = injectGremlins;
exports.createHorde = createHorde;
exports.seedHorde = seedHorde;
exports.unleashHorde = unleashHorde;
exports.waitForGremlins = waitForGremlins;
exports.unleashGremlins = unleashGremlins;
exports.default = task;
var _path = require('path');
var _path2 = _interopRequireDefault(_path);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
var defaults = {
wait: {
maxErrors: 100,
maxTime: 10 * 1000
}
};
function recordErrors(errors) {
return function executeRecordErrors(nightmare) {
nightmare.on('page', function () {
var type = arguments.length <= 0 || arguments[0] === undefined ? 'error' : arguments[0];
var message = arguments[1];
var stack = arguments[2];
if (type !== 'error') return;
errors.push({ message: message, stack: stack });
});
};
}
function injectGremlins() {
return function executeInjectGremlins(nightmare) {
nightmare.inject('js', _path2.default.join(__dirname, 'gremlins.min.js'));
};
}
function createHorde() {
return function executeCreateHorde(nightmare) {
nightmare.evaluate(function () {
window.horde = window.gremlins.createHorde();
});
};
}
function seedHorde() {
var seed = arguments.length <= 0 || arguments[0] === undefined ? Date.now() : arguments[0];
return function executeSeedHorde(nightmare) {
nightmare.evaluate(function (seedNum) {
window.horde.seed(seedNum);
}, seed);
};
}
function unleashHorde() {
var _options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
var options = (0, _assign2.default)({}, defaults.unleash, _options);
return function executeUnleashHorde(nightmare) {
nightmare.evaluate(function (jsonOptions) {
window.horde.unleash(JSON.parse(jsonOptions));
}, (0, _stringify2.default)(options));
};
}
function waitForGremlins(errors) {
var _options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
var options = (0, _assign2.default)({}, defaults.wait, _options);
return function executeWaitForGremlins(nightmare) {
var start = Date.now();
nightmare.wait(function (errorsLength, startTime, maxErrors, maxTime) {
return Date.now() - startTime > maxTime || errorsLength >= maxErrors;
}, errors.length, start, options.maxErrors, options.maxTime);
};
}
function unleashGremlins() {
var _options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
var options = (0, _assign2.default)({}, defaults.unleash, { seed: Date.now() }, _options);
var errors = [];
return function executeUnleashGremlins(nightmare) {
nightmare.use(recordErrors(errors)).use(injectGremlins()).use(createHorde(options.create)).use(seedHorde(options.seed)).use(unleashHorde(options.unleash)).use(waitForGremlins(errors, options.wait)).queue(function (done) {
return done(null, errors);
});
};
}
function task() {
var _options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
return function executeTask(done, _runOptions) {
var options = (0, _assign2.default)({}, _options, _runOptions);
this.use(unleashGremlins(options)).then(done.bind(null, null));
};
} |
ngapp.controller('resolveModalController', function ($scope, errorTypeFactory, pluginErrorService, hotkeyService) {
// HELPER FUNCTIONS
let prepareResolutions = function() {
$scope.resolutions = pluginErrorService.getResolutions($scope.error);
$scope.selectedIndex = $scope.resolutions.indexOf($scope.error.resolution);
};
let setError = function() {
if ($scope.errorIndex >= $scope.errorsToResolve.length) {
$scope.$emit('closeModal');
return;
}
$scope.error = $scope.errorsToResolve[$scope.errorIndex];
$scope.group = $scope.errorGroups[$scope.error.group];
prepareResolutions();
};
// SCOPE FUNCTIONS
$scope.selectResolution = function(resolution) {
$scope.error.resolution = resolution;
$scope.nextError();
};
$scope.nextError = function() {
$scope.errorIndex++;
setError();
};
$scope.previousError = function() {
if ($scope.errorIndex === 0) return;
$scope.errorIndex--;
setError();
};
$scope.handleResolutionKey = function(e) {
let n = e.keyCode - 49; // 49 -> keycode for 1
if (n >= 0 && n < $scope.resolutions.length) {
$scope.selectResolution($scope.resolutions[n]);
}
};
// SET UP HOTKEYS
hotkeyService.buildOnKeyDown($scope, 'onKeyDown', 'resolveModal');
// INITIALIZATION
$scope.errorsToResolve = $scope.modalOptions.errors;
$scope.errorGroups = errorTypeFactory.errorTypes();
$scope.errorIndex = 0;
setError();
});
|
$(document).ready(function(){
console.log('this is here');
global_force = null;
track_submit();
});
function track_submit(){
$('#target_country').on('change', function(){
//empty the div
$('#viz').empty();
$('#grouping').hide();
var target_country = this.value;
var obj_ = {'team': target_country};
console.log('selected target is', obj_);
fetch_data(obj_);
});
}
function fetch_data(obj_){
$.ajax({url: '/get_team/',
type:'GET',
data: obj_,
success: function(resp){
resp = JSON.parse(resp);
console.log(resp);
draw_options(resp);
}
});
}
function draw_options(data){
$('#opponent_country').empty().append("<option id='null' value='null'></option>");
for(each in data){
$('#opponent_country').append("<option id="+each+" value='"+each+"'>"+each+"</option>");
}
$('#opponent_country').on('change', function(){
var opponent_country = this.value;
var data_ = data[opponent_country];
draw_data(data_);
});
}
/**
* Creates k chunks of years (max k = 10 and min is either 4 or the number of years if < 4)
*/
function year_grouping_map(years){
var years_obj = {};
var distinct_years = {};
var colors = d3.scale.category20();
var k;
var max_n_years = 10;
var min_n_years = 4;
years = years.sort();
if (years.length < max_n_years*2){
if (years.length < min_n_years){
k = years.length
}
else{
k = min_n_years;
}
}
else{
k = max_n_years;
}
var n = Math.floor(years.length/k);
for (var i=0; i<years.length; i++){
var year = years[i];
if (i % n == 0){
var val_ = years[i]+'-'+(!years[i+n] ? years[i] : years[i+n]);
var key_ = year;
years_obj[key_] = val_;
}
else{
years_obj[year] = val_;
}
distinct_years[val_] = colors(val_);
}
return {map: years_obj, keys: Object.keys(distinct_years), colors: distinct_years};
}
function locations_colors(locations){
var loc_cols = {};
var col_obj = d3.scale.category10();
for (i in locations){
loc_cols[locations[i]] = col_obj(locations[i]);
}
return loc_cols;
}
function draw_data(data_){
var viz_div = '#viz';
$(viz_div).empty();
//setting the groupings bg color just in case the page is not loaded again
$('.group').css('background-color', 'whitesmoke');
if(global_force){
global_force.stop();
}
var width = window.innerWidth;
var height = window.innerHeight - ((window.innerHeight/100) * 10);
var padding = 0;
var n_items = 0;
var year_groups = [];
var locations = [];
for (m_t in data_){
n_items += data_[m_t].length;
for (mt in data_[m_t]){
year_groups.push(data_[m_t][mt].year);
locations.push(data_[m_t][mt].location_c);
}
}
//getting years objects, which gives max 10 chunks for the years played
var years_obj = year_grouping_map(year_groups);
var years_map = years_obj.map;
var years_keys = years_obj.keys;
var years_colors = years_obj.colors;
//colors the countries
loc_cols = locations_colors(locations);
//constructing the nodes
var nodes = [];
for (key in data_){
for (match in data_[key]){
nodes.push({
match_type: key,
result: data_[key][match].result,
month: data_[key][match].month,
year: data_[key][match].year,
year_group: years_map[data_[key][match].year],
toss: data_[key][match].toss,
location: data_[key][match].location,
location_c: data_[key][match].location_c,
color: 'gray',//colors[key],
radius: 9,
cx: width/2,
cy: height/2
});
}
}
//grouping scales
var scales = {
all: {},
match_type: {
nodes_scale : d3.scale.ordinal().domain(['ODI', 'T20I', 'Test']).rangePoints([width*0.2, width*0.75]),
text_scale: d3.scale.ordinal().domain(['ODI', 'T20I', 'Test']).rangePoints([width*0.7, width*0.8, width*0.9]),
circle_scale: d3.scale.ordinal().domain(['ODI', 'T20I', 'Test']).rangePoints([width*0.69, width*0.79, width*0.89], 0.001),
tick_items: ['ODI', 'T20I', 'Test'],
circle_colors: {'ODI': '#1E8BC3', 'T20I': '#1BBC9B', 'Test': '#E74C3C'},
},
result: {
nodes_scale: d3.scale.ordinal().domain(['won', 'lost', 'draw', 'aban', 'tied', 'n/r']).rangePoints([width*0.2, width*0.8]),
text_scale: d3.scale.ordinal().domain(['won', 'lost', 'draw', 'aban', 'tied', 'n/r']).rangePoints([width*0.6, width*0.8]),
circle_scale: d3.scale.ordinal().domain(['won', 'lost', 'draw', 'aban', 'tied', 'n/r']).rangePoints([width*0.4, width*0.8], 0.001),
tick_items: ['won', 'lost', 'draw', 'aban', 'tied', 'n/r'],
circle_colors: {'won': '#26A65B', 'lost': '#F5D76E', 'draw': '#E26A6A', 'aban': '#F89406', 'tied': '#6C7A89', 'n/r': '#674172'},
},
month: {
nodes_scale: d3.scale.ordinal().domain(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']).rangePoints([width*0.2, width*0.8]),
text_scale: d3.scale.ordinal().domain(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']).rangePoints([width*0.1, width*0.9]),
circle_scale: d3.scale.ordinal().domain(['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']).rangePoints([width*0.4, width*0.9], 0.001),
tick_items: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
circle_colors: {'Jan': '#2ecc71', 'Feb': '#9b59b6', 'Mar': '#16a085', 'Apr': '#2980b9', 'May': 'teal', 'Jun': '#e67e22', 'Jul': '#f39c12', 'Aug': '#c0392b', 'Sep': '#bdc3c7', 'Oct': '#7f8c8d', 'Nov': 'red', 'Dec': 'cornflowerblue'},
},
year_group: {
nodes_scale: d3.scale.ordinal().domain(years_keys).rangePoints([width*0.2, width*0.8]),
text_scale: d3.scale.ordinal().domain(years_keys).rangePoints([0, width*0.95], 1),
circle_scale: d3.scale.ordinal().domain(years_keys).rangePoints([0, width*0.95], 1),
tick_items: years_keys,
circle_colors: years_colors
},
toss: {
nodes_scale : d3.scale.ordinal().domain(['won', '-', 'lost']).rangePoints([width*0.2, width*0.75]),
text_scale: d3.scale.ordinal().domain(['won', '-', 'lost']).rangePoints([width*0.7, width*0.8, width*0.9]),
circle_scale: d3.scale.ordinal().domain(['won', '-', 'lost']).rangePoints([width*0.69, width*0.79, width*0.89], 0.001),
tick_items: ['won', '-', 'lost'],
circle_colors: {'won': '#1E824C', '-': '#F89406', 'lost': '#D35400'}
},
location_c: {
nodes_scale: d3.scale.ordinal().domain(locations).rangePoints([width*0.2, width*0.9]),
text_scale: d3.scale.ordinal().domain(locations).rangePoints([0, width*0.9], 1),
circle_scale: d3.scale.ordinal().domain(locations).rangePoints([0, width*0.9], 1),
tick_items: locations,
circle_colors: loc_cols,
},
};
//tooltip
var tooltip = d3.select(viz_div).append("div").attr("class", "tooltip").style("opacity", 0);
//constructing the svg
var svg = d3.select(viz_div).append('svg').attr('width', width).attr('height', height);
//creating the force object
var force = d3.layout.force()
.nodes(nodes)
.size([width, height])
.gravity(0)
.on("tick", tick)
.start();
global_force = force;
//constructing the circle
var node = svg.selectAll('.node').data(nodes)
.enter().append("g")
.attr("class", "node")
.call(force.drag);
node.append("circle")
.style("fill", function(d) { return d.color; })
.attr("r", function(d) { return d.radius; })
.on("mouseover", function(d) {
tooltip.transition().duration(50).style("opacity", 0.9);
var ttip_html = "<div class='ttip_row'>MATCH TYPE: "+d.match_type+" </div>";
ttip_html += "<div class='ttip_row'>RESULT: "+d.result+" </div>";
ttip_html += "<div class='ttip_row'>MONTH: "+d.month+" </div>";
ttip_html += "<div class='ttip_row'>YEAR: "+d.year+" </div>";
ttip_html += "<div class='ttip_row'>LOCATION: "+d.location+', '+d.location_c+"</div>";
ttip_html += "<div class='ttip_row'>TOSS: "+d.toss+"</div>";
tooltip.html(ttip_html).style("left", (d3.event.pageX + 5) + "px").style("top", (d3.event.pageY - 28) + "px");
})
.on("mouseout", function(d) {
tooltip.transition().duration(50).style("opacity", 0);
});
//adding legend for no grouping
svg.append('text')
.attr('class', 'tick')
.attr('x', width * 0.8)
.attr('y', 10)
.style('fill', 'gray')
.style("text-decoration", "underline")
.text('ALL MATCHES ['+nodes.length+']');
//adding credits
svg.append('text')
.attr('class', 'tick')
.attr('x', width * 0.75)
.attr('y', height * 0.9)
.style('fill', 'gray')
.style('font-size', '11px')
.text('Data extracted from ESPNCricinfo.com (2015)');
function tick(e) {
node
.each(gravity(0.15 * e.alpha))
.each(collide(0.65))
.attr("cx", function(d) { return d.x; })
.attr("cy", function(d) { return d.y; })
.attr("transform", function(d) { return "translate(" + d.x + "," + d.y + ")"; });
}
function gravity(alpha) {
return function(d) {
d.y += (d.cy - d.y) * alpha;
d.x += (d.cx - d.x) * alpha;
};
}
function collide(alpha) {
var quadtree = d3.geom.quadtree(nodes);
return function(d) {
var r = d.radius + padding,
nx1 = d.x - r,
nx2 = d.x + r,
ny1 = d.y - r,
ny2 = d.y + r;
quadtree.visit(function(quad, x1, y1, x2, y2) {
if (quad.point && (quad.point !== d)) {
var x = d.x - quad.point.x,
y = d.y - quad.point.y,
l = Math.sqrt(x * x + y * y),
r = d.radius + quad.point.radius + (d.color !== quad.point.color) * padding ;
if (l < r) {
l = (l - r) / l * alpha;
d.x -= x *= l;
d.y -= y *= l;
quad.point.x += x;
quad.point.y += y;
}
}
force.resume();
return x1 > nx2 || x2 < nx1 || y1 > ny2 || y2 < ny1;
});
};
}
$('#grouping').css('display', 'inline');
$('.group').unbind('click').bind('click', function(){
$('.group').css('background-color', 'whitesmoke');
$('#viz').hide();
$('#load').show();
var group_id = this.id;
$('#'+group_id).css('background-color', 'springgreen');
if (group_id == 'all'){
regroup();
return;
}
var nodes_scale = scales[group_id].nodes_scale;
var text_scale = scales[group_id].text_scale;
var tick_items = scales[group_id].tick_items;
var circle_scale = scales[group_id].circle_scale;
var circle_colors = scales[group_id].circle_colors;
grouping_method(svg, text_scale, circle_scale, circle_colors, nodes_scale, tick_items, group_id);
});
function grouping_method(svg, text_scale, circle_scale, circle_colors, node_scale, tick_items, key_){
$('.tick').remove();
for (each in tick_items){
var group_ = d3.selectAll(".node").filter(function(d){ return eval('d.'+key_) == tick_items[each]; });
svg.append('text').attr('class', 'tick').attr('x', circle_scale(tick_items[each]) ).attr('y', 20).style('fill', circle_colors[tick_items[each]]).style("text-decoration", "underline").text(tick_items[each].toUpperCase() + '['+group_[0].length+']');
group_.transition().duration(100).attr('cx', function(d){ d.cx = node_scale(tick_items[each]) ; }).selectAll('circle').style('fill', circle_colors[tick_items[each]]);
}
//tick({type: "tick", alpha: 0.8});
$('#load').hide();
$('#viz').show();
}
function regroup(){
$('.tick').remove();
var group_ = d3.selectAll(".node").filter(function(d){ return d; });
group_.transition().duration(2000).attr('cx', function(d){ d.cx = width/2 }).selectAll('circle').style('fill', 'lightgray');
svg.append('text')
.attr('class', 'tick')
.attr('x', width*0.8 )
.attr('y', 10)
.style('fill', 'gray')
.style("text-decoration", "underline")
.text('ALL MATCHES ['+group_[0].length+']');
$('#load').hide();
$('#viz').show();
}
} |
module.exports = function(grunt) {
"use strict";
grunt.initConfig({
pkg: grunt.file.readJSON("package.json"),
licence: grunt.file.read("LICENSE"),
uglify: {
options: {
banner: "/*\n<%= pkg.name %> v<%= pkg.version %> \n\n<%= licence %>*/\n",
preserveComments: "some"
},
build: {
src: [
"src/tgame.js",
"src/tgame.*.js"
],
dest: "build/<%= pkg.name %>.min.js"
}
},
jshint: {
options: {
eqeqeq: true,
undef: true,
unused: true,
strict: true,
indent: 2,
immed: true,
latedef: "nofunc",
newcap: true,
nonew: true,
trailing: true,
globals: {
tgame: true
}
},
grunt: {
options: {
node: true
},
src: "Gruntfile.js"
},
src: {
options: {
browser: true
},
src: "src/*.js",
},
}
});
grunt.loadNpmTasks("grunt-contrib-jshint");
grunt.loadNpmTasks("grunt-contrib-uglify");
grunt.registerTask("lint", ["jshint"]);
grunt.registerTask("default", ["jshint", "uglify"]);
}; |
var fs = require("fs");
var path = require("path");
fs.unlink(path.join(__dirname, "testFileThatMustExists.txt"), function (err) {
if (err) throw err;
console.log('successfully deleted testFileThatMustExists.txt');
});
|
/* global process, nodeRequire*/
(function () {
const top= `${process.cwd().replace(/\\/g,"/")}`;
const build= `${top}/build`;
const www=`${top}/www`;
const js=`${www}/js`;
const gen=`${js}/g2`;
//console.log(`${js}/reqConf2.js`);
const fs=nodeRequire("fs");
//console.log(fs.existsSync(`${js}/reqConf2.js`));
const conf=nodeRequire(`${js}/reqConf2`).conf;
const entry="selProject";
const filename=`${entry}_concat`;
//const urlPrefix="js";
function uglifyWithSourceMap(str,url) {
try {
var UglifyJS = nodeRequire("uglify-es");
var r=UglifyJS.minify({[`${filename}.js`]:str},{
sourceMap: {
url,includeSources:true,
}
});
if (r.error) return {code:str};
//console.log(r);
return r;
}catch(e) {
console.log("Uglify fail "+e);
return {code:str};
}
}
return {
name: `${entry}`,
//name: 'js/almond',
//include: [`${entry}`],
optimize:"none",
baseUrl: www,
wrap: {
startFile: `${build}/run2_head.txt`,
endFile: `${build}/run2_tail.txt`
},
paths: conf.paths,
out: r=>{
const u=uglifyWithSourceMap(r,`${filename}.min.js.map`);
if (u.map) fs.writeFileSync( `${gen}/${filename}.min.js.map`,u.map);
fs.writeFileSync( `${gen}/${filename}.min.js`,u.code);
},
shim: conf.shim
};
})();
|
export default {
"davis_rain": {
"desc": "降雨传感器",
"port": "PI",
"port_nums": [0, 1],
"data_nums": [
{
"data_num": 0,
"unit": "mm",
"type": "rain",
"desc": "降雨量"
}
]
},
"mec10": {
"desc": "土壤传感器",
"port": "485",
"port_nums": [0, 1],
"data_nums": [
{
"data_num": 0,
"unit": "℃",
"type": "temperature",
"desc": "土壤温度"
},
{
"data_num": 1,
"unit": "%",
"type": "humdity",
"desc": "土壤湿度"
}
]
},
"nh122": {
"desc": "环境传感器",
"port": "485",
"port_nums": [0, 1],
"data_nums": [
{
"data_num": 0,
"unit": "℃",
"type": "temperature",
"desc": "空气温度"
},
{
"data_num": 1,
"unit": "%",
"type": "humdity",
"desc": "空气湿度"
},
{
"data_num": 2,
"unit": "hPa",
"type": "pressure",
"desc": "气压"
}
]
},
"nhfs45bu": {
"desc": "风速传感器",
"port": "AD",
"port_nums": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
"data_nums": [
{
"data_num": 0,
"unit": "m/s",
"type": "windspeed",
"desc": "风速"
}
]
},
"nhfx46au": {
"desc": "风向传感器",
"port": "AD",
"port_nums": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
"data_nums": [
{
"data_num": 0,
"unit": "°",
"type": "winddirect",
"desc": "风向"
}
]
},
"nhzd10": {
"desc": "光照传感器",
"port": "AD",
"port_nums": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
"data_nums": [
{
"data_num": 0,
"unit": "lux",
"type": "solar",
"desc": "光照"
}
]
},
"th10s": {
"desc": "土壤传感器",
"port": "485",
"port_nums": [0, 1],
"data_nums": [
{
"data_num": 0,
"unit": "℃",
"type": "temperature",
"desc": "土壤温度"
},
{
"data_num": 1,
"unit": "%",
"type": "humdity",
"desc": "土壤湿度"
}
]
},
"ms10vt": {
"desc": "土壤传感器",
"port": "AD",
"port_nums": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
"data_nums": [
{
"data_num": 0,
"unit": "℃",
"type": "temperature",
"desc": "土壤温度"
}
]
},
"ms10vh": {
"desc": "土壤传感器",
"port": "AD",
"port_nums": [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
"data_nums": [
{
"data_num": 0,
"unit": "%",
"type": "humdity",
"desc": "土壤湿度"
}
]
},
"wxt520": {
"desc": "环境传感器",
"port": "485",
"port_nums": [0, 1],
"data_nums": [
{
"data_num": 0,
"unit": "m/s",
"type": "windspeed",
"desc": "风速"
},
{
"data_num": 1,
"unit": "°",
"type": "winddirect",
"desc": "风向"
},
{
"data_num": 2,
"unit": "℃",
"type": "temperature",
"desc": "空气温度"
},
{
"data_num": 3,
"unit": "%",
"type": "humdity",
"desc": "空气湿度"
},
{
"data_num": 4,
"unit": "hPa",
"type": "pressure",
"desc": "气压"
}
]
},
"hisi": {
"desc": "图像传感器",
"port": "Img",
"port_nums": [0, 1],
"data_nums": [
{
"data_num": 0,
"unit": "",
"type": "image",
"desc": "图像"
}
]
}
}
|
module("basic context");
Handlebars.registerHelper('helperMissing', function(helper, context) {
if(helper === "link_to") {
return new Handlebars.SafeString("<a>" + context + "</a>");
}
});
var shouldCompileTo = function(string, hashOrArray, expected, message) {
shouldCompileToWithPartials(string, hashOrArray, false, expected, message);
};
var shouldCompileToWithPartials = function(string, hashOrArray, partials, expected, message) {
var template = CompilerContext[partials ? 'compileWithPartial' : 'compile'](string), ary;
if(Object.prototype.toString.call(hashOrArray) === "[object Array]") {
helpers = hashOrArray[1];
if(helpers) {
for(var prop in Handlebars.helpers) {
helpers[prop] = Handlebars.helpers[prop];
}
}
ary = [];
ary.push(hashOrArray[0]);
ary.push({ helpers: hashOrArray[1], partials: hashOrArray[2] });
} else {
ary = [hashOrArray];
}
result = template.apply(this, ary);
equal(result, expected, "'" + expected + "' should === '" + result + "': " + message);
};
var shouldThrow = function(fn, exception, message) {
var caught = false;
try {
fn();
}
catch (e) {
if (e instanceof exception) {
caught = true;
}
}
ok(caught, message || null);
}
test("compiling with a basic context", function() {
shouldCompileTo("Goodbye\n{{cruel}}\n{{world}}!", {cruel: "cruel", world: "world"}, "Goodbye\ncruel\nworld!",
"It works if all the required keys are provided");
});
test("comments", function() {
shouldCompileTo("{{! Goodbye}}Goodbye\n{{cruel}}\n{{world}}!",
{cruel: "cruel", world: "world"}, "Goodbye\ncruel\nworld!",
"comments are ignored");
});
test("boolean", function() {
var string = "{{#goodbye}}GOODBYE {{/goodbye}}cruel {{world}}!";
shouldCompileTo(string, {goodbye: true, world: "world"}, "GOODBYE cruel world!",
"booleans show the contents when true");
shouldCompileTo(string, {goodbye: false, world: "world"}, "cruel world!",
"booleans do not show the contents when false");
});
test("zeros", function() {
shouldCompileTo("num1: {{num1}}, num2: {{num2}}", {num1: 42, num2: 0},
"num1: 42, num2: 0");
shouldCompileTo("num: {{.}}", 0, "num: 0");
shouldCompileTo("num: {{num1/num2}}", {num1: {num2: 0}}, "num: 0");
});
test("newlines", function() {
shouldCompileTo("Alan's\nTest", {}, "Alan's\nTest");
shouldCompileTo("Alan's\rTest", {}, "Alan's\rTest");
});
test("escaping text", function() {
shouldCompileTo("Awesome's", {}, "Awesome's", "text is escaped so that it doesn't get caught on single quotes");
shouldCompileTo("Awesome\\", {}, "Awesome\\", "text is escaped so that the closing quote can't be ignored");
shouldCompileTo("Awesome\\\\ foo", {}, "Awesome\\\\ foo", "text is escaped so that it doesn't mess up backslashes");
shouldCompileTo("Awesome {{foo}}", {foo: '\\'}, "Awesome \\", "text is escaped so that it doesn't mess up backslashes");
shouldCompileTo(' " " ', {}, ' " " ', "double quotes never produce invalid javascript");
});
test("escaping expressions", function() {
shouldCompileTo("{{{awesome}}}", {awesome: "&\"\\<>"}, '&\"\\<>',
"expressions with 3 handlebars aren't escaped");
shouldCompileTo("{{&awesome}}", {awesome: "&\"\\<>"}, '&\"\\<>',
"expressions with {{& handlebars aren't escaped");
shouldCompileTo("{{awesome}}", {awesome: "&\"'`\\<>"}, '&"'`\\<>',
"by default expressions should be escaped");
});
test("functions returning safestrings shouldn't be escaped", function() {
var hash = {awesome: function() { return new Handlebars.SafeString("&\"\\<>"); }};
shouldCompileTo("{{awesome}}", hash, '&\"\\<>',
"functions returning safestrings aren't escaped");
});
test("functions", function() {
shouldCompileTo("{{awesome}}", {awesome: function() { return "Awesome"; }}, "Awesome",
"functions are called and render their output");
});
test("functions with context argument", function() {
shouldCompileTo("{{awesome frank}}",
{awesome: function(context) { return context; },
frank: "Frank"},
"Frank", "functions are called with context arguments");
});
test("paths with hyphens", function() {
shouldCompileTo("{{foo-bar}}", {"foo-bar": "baz"}, "baz", "Paths can contain hyphens (-)");
});
test("nested paths", function() {
shouldCompileTo("Goodbye {{alan/expression}} world!", {alan: {expression: "beautiful"}},
"Goodbye beautiful world!", "Nested paths access nested objects");
});
test("nested paths with empty string value", function() {
shouldCompileTo("Goodbye {{alan/expression}} world!", {alan: {expression: ""}},
"Goodbye world!", "Nested paths access nested objects with empty string");
});
test("literal paths", function() {
shouldCompileTo("Goodbye {{[@alan]/expression}} world!", {"@alan": {expression: "beautiful"}},
"Goodbye beautiful world!", "Literal paths can be used");
});
test("--- TODO --- bad idea nested paths", function() {
return;
var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
shouldThrow(function() {
CompilerContext.compile("{{#goodbyes}}{{../name/../name}}{{/goodbyes}}")(hash);
}, Handlebars.Exception,
"Cannot jump (..) into previous context after moving into a context.");
var string = "{{#goodbyes}}{{.././world}} {{/goodbyes}}";
shouldCompileTo(string, hash, "world world world ", "Same context (.) is ignored in paths");
});
test("that current context path ({{.}}) doesn't hit helpers", function() {
shouldCompileTo("test: {{.}}", [null, {helper: "awesome"}], "test: ");
});
test("complex but empty paths", function() {
shouldCompileTo("{{person/name}}", {person: {name: null}}, "");
shouldCompileTo("{{person/name}}", {person: {}}, "");
});
test("this keyword in paths", function() {
var string = "{{#goodbyes}}{{this}}{{/goodbyes}}";
var hash = {goodbyes: ["goodbye", "Goodbye", "GOODBYE"]};
shouldCompileTo(string, hash, "goodbyeGoodbyeGOODBYE",
"This keyword in paths evaluates to current context");
string = "{{#hellos}}{{this/text}}{{/hellos}}"
hash = {hellos: [{text: "hello"}, {text: "Hello"}, {text: "HELLO"}]};
shouldCompileTo(string, hash, "helloHelloHELLO", "This keyword evaluates in more complex paths");
});
module("inverted sections");
test("inverted sections with unset value", function() {
var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
var hash = {};
shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value isn't set.");
});
test("inverted section with false value", function() {
var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
var hash = {goodbyes: false};
shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value is false.");
});
test("inverted section with empty set", function() {
var string = "{{#goodbyes}}{{this}}{{/goodbyes}}{{^goodbyes}}Right On!{{/goodbyes}}";
var hash = {goodbyes: []};
shouldCompileTo(string, hash, "Right On!", "Inverted section rendered when value is empty set.");
});
module("blocks");
test("array", function() {
var string = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!"
var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
"Arrays iterate over the contents when not empty");
shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
"Arrays ignore the contents when empty");
});
test("empty block", function() {
var string = "{{#goodbyes}}{{/goodbyes}}cruel {{world}}!"
var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
shouldCompileTo(string, hash, "cruel world!",
"Arrays iterate over the contents when not empty");
shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
"Arrays ignore the contents when empty");
});
test("nested iteration", function() {
});
test("block with complex lookup", function() {
var string = "{{#goodbyes}}{{text}} cruel {{../name}}! {{/goodbyes}}"
var hash = {name: "Alan", goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}]};
shouldCompileTo(string, hash, "goodbye cruel Alan! Goodbye cruel Alan! GOODBYE cruel Alan! ",
"Templates can access variables in contexts up the stack with relative path syntax");
});
test("helper with complex lookup", function() {
var string = "{{#goodbyes}}{{{link ../prefix}}}{{/goodbyes}}"
var hash = {prefix: "/root", goodbyes: [{text: "Goodbye", url: "goodbye"}]};
var helpers = {link: function(prefix) {
return "<a href='" + prefix + "/" + this.url + "'>" + this.text + "</a>"
}};
shouldCompileTo(string, [hash, helpers], "<a href='/root/goodbye'>Goodbye</a>")
});
test("helper block with complex lookup expression", function() {
var string = "{{#goodbyes}}{{../name}}{{/goodbyes}}"
var hash = {name: "Alan"};
var helpers = {goodbyes: function(fn) {
var out = "";
var byes = ["Goodbye", "goodbye", "GOODBYE"];
for (var i = 0,j = byes.length; i < j; i++) {
out += byes[i] + " " + fn(this) + "! ";
}
return out;
}};
shouldCompileTo(string, [hash, helpers], "Goodbye Alan! goodbye Alan! GOODBYE Alan! ");
});
test("helper with complex lookup and nested template", function() {
var string = "{{#goodbyes}}{{#link ../prefix}}{{text}}{{/link}}{{/goodbyes}}";
var hash = {prefix: '/root', goodbyes: [{text: "Goodbye", url: "goodbye"}]};
var helpers = {link: function (prefix, fn) {
return "<a href='" + prefix + "/" + this.url + "'>" + fn(this) + "</a>";
}};
shouldCompileToWithPartials(string, [hash, helpers], false, "<a href='/root/goodbye'>Goodbye</a>");
});
test("helper with complex lookup and nested template in VM+Compiler", function() {
var string = "{{#goodbyes}}{{#link ../prefix}}{{text}}{{/link}}{{/goodbyes}}";
var hash = {prefix: '/root', goodbyes: [{text: "Goodbye", url: "goodbye"}]};
var helpers = {link: function (prefix, fn) {
return "<a href='" + prefix + "/" + this.url + "'>" + fn(this) + "</a>";
}};
shouldCompileToWithPartials(string, [hash, helpers], true, "<a href='/root/goodbye'>Goodbye</a>");
});
test("block with deep nested complex lookup", function() {
var string = "{{#outer}}Goodbye {{#inner}}cruel {{../../omg}}{{/inner}}{{/outer}}";
var hash = {omg: "OMG!", outer: [{ inner: [{ text: "goodbye" }] }] };
shouldCompileTo(string, hash, "Goodbye cruel OMG!");
});
test("block helper", function() {
var string = "{{#goodbyes}}{{text}}! {{/goodbyes}}cruel {{world}}!";
var template = CompilerContext.compile(string);
result = template({world: "world"}, { helpers: {goodbyes: function(fn) { return fn({text: "GOODBYE"}); }}});
equal(result, "GOODBYE! cruel world!", "Block helper executed");
});
test("block helper staying in the same context", function() {
var string = "{{#form}}<p>{{name}}</p>{{/form}}"
var template = CompilerContext.compile(string);
result = template({name: "Yehuda"}, {helpers: {form: function(fn) { return "<form>" + fn(this) + "</form>" } }});
equal(result, "<form><p>Yehuda</p></form>", "Block helper executed with current context");
});
test("block helper should have context in this", function() {
var source = "<ul>{{#people}}<li>{{#link}}{{name}}{{/link}}</li>{{/people}}</ul>";
var link = function(fn) {
return '<a href="/people/' + this.id + '">' + fn(this) + '</a>';
};
var data = { "people": [
{ "name": "Alan", "id": 1 },
{ "name": "Yehuda", "id": 2 }
]};
shouldCompileTo(source, [data, {link: link}], "<ul><li><a href=\"/people/1\">Alan</a></li><li><a href=\"/people/2\">Yehuda</a></li></ul>");
});
test("block helper for undefined value", function() {
shouldCompileTo("{{#empty}}shouldn't render{{/empty}}", {}, "");
});
test("block helper passing a new context", function() {
var string = "{{#form yehuda}}<p>{{name}}</p>{{/form}}"
var template = CompilerContext.compile(string);
result = template({yehuda: {name: "Yehuda"}}, { helpers: {form: function(context, fn) { return "<form>" + fn(context) + "</form>" }}});
equal(result, "<form><p>Yehuda</p></form>", "Context variable resolved");
});
test("block helper passing a complex path context", function() {
var string = "{{#form yehuda/cat}}<p>{{name}}</p>{{/form}}"
var template = CompilerContext.compile(string);
result = template({yehuda: {name: "Yehuda", cat: {name: "Harold"}}}, { helpers: {form: function(context, fn) { return "<form>" + fn(context) + "</form>" }}});
equal(result, "<form><p>Harold</p></form>", "Complex path variable resolved");
});
test("nested block helpers", function() {
var string = "{{#form yehuda}}<p>{{name}}</p>{{#link}}Hello{{/link}}{{/form}}"
var template = CompilerContext.compile(string);
result = template({
yehuda: {name: "Yehuda" }
}, {
helpers: {
link: function(fn) { return "<a href='" + this.name + "'>" + fn(this) + "</a>" },
form: function(context, fn) { return "<form>" + fn(context) + "</form>" }
}
});
equal(result, "<form><p>Yehuda</p><a href='Yehuda'>Hello</a></form>", "Both blocks executed");
});
test("block inverted sections", function() {
shouldCompileTo("{{#people}}{{name}}{{^}}{{none}}{{/people}}", {none: "No people"},
"No people");
});
test("block inverted sections with empty arrays", function() {
shouldCompileTo("{{#people}}{{name}}{{^}}{{none}}{{/people}}", {none: "No people", people: []},
"No people");
});
test("block helper inverted sections", function() {
var string = "{{#list people}}{{name}}{{^}}<em>Nobody's here</em>{{/list}}"
var list = function(context, options) {
if (context.length > 0) {
var out = "<ul>";
for(var i = 0,j=context.length; i < j; i++) {
out += "<li>";
out += options.fn(context[i]);
out += "</li>";
}
out += "</ul>";
return out;
} else {
return "<p>" + options.inverse(this) + "</p>";
}
};
var hash = {people: [{name: "Alan"}, {name: "Yehuda"}]};
var empty = {people: []};
var rootMessage = {
people: [],
message: "Nobody's here"
}
var messageString = "{{#list people}}Hello{{^}}{{message}}{{/list}}";
// the meaning here may be kind of hard to catch, but list.not is always called,
// so we should see the output of both
shouldCompileTo(string, [hash, { list: list }], "<ul><li>Alan</li><li>Yehuda</li></ul>", "an inverse wrapper is passed in as a new context");
shouldCompileTo(string, [empty, { list: list }], "<p><em>Nobody's here</em></p>", "an inverse wrapper can be optionally called");
shouldCompileTo(messageString, [rootMessage, { list: list }], "<p>Nobody's here</p>", "the context of an inverse is the parent of the block");
});
module("helpers hash");
test("providing a helpers hash", function() {
shouldCompileTo("Goodbye {{cruel}} {{world}}!", [{cruel: "cruel"}, {world: "world"}], "Goodbye cruel world!",
"helpers hash is available");
shouldCompileTo("Goodbye {{#iter}}{{cruel}} {{world}}{{/iter}}!", [{iter: [{cruel: "cruel"}]}, {world: "world"}],
"Goodbye cruel world!", "helpers hash is available inside other blocks");
});
test("in cases of conflict, the explicit hash wins", function() {
});
test("the helpers hash is available is nested contexts", function() {
});
module("partials");
test("basic partials", function() {
var string = "Dudes: {{#dudes}}{{> dude}}{{/dudes}}";
var partial = "{{name}} ({{url}}) ";
var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: Yehuda (http://yehuda) Alan (http://alan) ",
"Basic partials output based on current context.");
});
test("partials with context", function() {
var string = "Dudes: {{>dude dudes}}";
var partial = "{{#this}}{{name}} ({{url}}) {{/this}}";
var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
shouldCompileToWithPartials(string, [hash, {}, {dude: partial}], true, "Dudes: Yehuda (http://yehuda) Alan (http://alan) ",
"Partials can be passed a context");
});
test("partial in a partial", function() {
var string = "Dudes: {{#dudes}}{{>dude}}{{/dudes}}";
var dude = "{{name}} {{> url}} ";
var url = "<a href='{{url}}'>{{url}}</a>";
var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
shouldCompileToWithPartials(string, [hash, {}, {dude: dude, url: url}], true, "Dudes: Yehuda <a href='http://yehuda'>http://yehuda</a> Alan <a href='http://alan'>http://alan</a> ", "Partials are rendered inside of other partials");
});
test("rendering undefined partial throws an exception", function() {
shouldThrow(function() {
var template = CompilerContext.compile("{{> whatever}}");
template();
}, Handlebars.Exception, "Should throw exception");
});
test("rendering template partial in vm mode throws an exception", function() {
shouldThrow(function() {
var template = CompilerContext.compile("{{> whatever}}");
var string = "Dudes: {{>dude}} {{another_dude}}";
var dude = "{{name}}";
var hash = {name:"Jeepers", another_dude:"Creepers"};
template();
}, Handlebars.Exception, "Should throw exception");
});
test("rendering function partial in vm mode", function() {
var string = "Dudes: {{#dudes}}{{> dude}}{{/dudes}}";
var partial = function(context) {
return context.name + ' (' + context.url + ') ';
};
var hash = {dudes: [{name: "Yehuda", url: "http://yehuda"}, {name: "Alan", url: "http://alan"}]};
shouldCompileTo(string, [hash, {}, {dude: partial}], "Dudes: Yehuda (http://yehuda) Alan (http://alan) ",
"Function partials output based in VM.");
});
test("GH-14: a partial preceding a selector", function() {
var string = "Dudes: {{>dude}} {{another_dude}}";
var dude = "{{name}}";
var hash = {name:"Jeepers", another_dude:"Creepers"};
shouldCompileToWithPartials(string, [hash, {}, {dude:dude}], true, "Dudes: Jeepers Creepers", "Regular selectors can follow a partial");
});
test("Partials with literal paths", function() {
var string = "Dudes: {{> [dude]}}";
var dude = "{{name}}";
var hash = {name:"Jeepers", another_dude:"Creepers"};
shouldCompileToWithPartials(string, [hash, {}, {dude:dude}], true, "Dudes: Jeepers", "Partials can use literal paths");
});
module("String literal parameters");
test("simple literals work", function() {
var string = 'Message: {{hello "world" 12 true false}}';
var hash = {};
var helpers = {hello: function(param, times, bool1, bool2) {
if(typeof times !== 'number') { times = "NaN"; }
if(typeof bool1 !== 'boolean') { bool1 = "NaB"; }
if(typeof bool2 !== 'boolean') { bool2 = "NaB"; }
return "Hello " + param + " " + times + " times: " + bool1 + " " + bool2;
}}
shouldCompileTo(string, [hash, helpers], "Message: Hello world 12 times: true false", "template with a simple String literal");
});
test("using a quote in the middle of a parameter raises an error", function() {
shouldThrow(function() {
var string = 'Message: {{hello wo"rld"}}';
CompilerContext.compile(string);
}, Error, "should throw exception");
});
test("escaping a String is possible", function(){
var string = 'Message: {{{hello "\\"world\\""}}}';
var hash = {}
var helpers = {hello: function(param) { return "Hello " + param; }}
shouldCompileTo(string, [hash, helpers], "Message: Hello \"world\"", "template with an escaped String literal");
});
test("it works with ' marks", function() {
var string = 'Message: {{{hello "Alan\'s world"}}}';
var hash = {}
var helpers = {hello: function(param) { return "Hello " + param; }}
shouldCompileTo(string, [hash, helpers], "Message: Hello Alan's world", "template with a ' mark");
});
module("multiple parameters");
test("simple multi-params work", function() {
var string = 'Message: {{goodbye cruel world}}';
var hash = {cruel: "cruel", world: "world"}
var helpers = {goodbye: function(cruel, world) { return "Goodbye " + cruel + " " + world; }}
shouldCompileTo(string, [hash, helpers], "Message: Goodbye cruel world", "regular helpers with multiple params");
});
test("block multi-params work", function() {
var string = 'Message: {{#goodbye cruel world}}{{greeting}} {{adj}} {{noun}}{{/goodbye}}';
var hash = {cruel: "cruel", world: "world"}
var helpers = {goodbye: function(cruel, world, fn) {
return fn({greeting: "Goodbye", adj: cruel, noun: world});
}}
shouldCompileTo(string, [hash, helpers], "Message: Goodbye cruel world", "block helpers with multiple params");
})
module("safestring");
test("constructing a safestring from a string and checking its type", function() {
var safe = new Handlebars.SafeString("testing 1, 2, 3");
ok(safe instanceof Handlebars.SafeString, "SafeString is an instance of Handlebars.SafeString");
equal(safe, "testing 1, 2, 3", "SafeString is equivalent to its underlying string");
});
module("helperMissing");
test("if a context is not found, helperMissing is used", function() {
var string = "{{hello}} {{link_to world}}"
var context = { hello: "Hello", world: "world" };
shouldCompileTo(string, context, "Hello <a>world</a>")
});
module("knownHelpers");
test("Known helper should render helper", function() {
var template = CompilerContext.compile("{{hello}}", {knownHelpers: {"hello" : true}})
var result = template({}, {helpers: {hello: function() { return "foo"; }}});
equal(result, "foo", "'foo' should === '" + result);
});
test("Unknown helper in knownHelpers only mode should be passed as undefined", function() {
var template = CompilerContext.compile("{{typeof hello}}", {knownHelpers: {'typeof': true}, knownHelpersOnly: true})
var result = template({}, {helpers: {'typeof': function(arg) { return typeof arg; }, hello: function() { return "foo"; }}});
equal(result, "undefined", "'undefined' should === '" + result);
});
test("Builtin helpers available in knownHelpers only mode", function() {
var template = CompilerContext.compile("{{#unless foo}}bar{{/unless}}", {knownHelpersOnly: true})
var result = template({});
equal(result, "bar", "'bar' should === '" + result);
});
test("Field lookup works in knownHelpers only mode", function() {
var template = CompilerContext.compile("{{foo}}", {knownHelpersOnly: true})
var result = template({foo: 'bar'});
equal(result, "bar", "'bar' should === '" + result);
});
test("Conditional blocks work in knownHelpers only mode", function() {
var template = CompilerContext.compile("{{#foo}}bar{{/foo}}", {knownHelpersOnly: true})
var result = template({foo: 'baz'});
equal(result, "bar", "'bar' should === '" + result);
});
test("Invert blocks work in knownHelpers only mode", function() {
var template = CompilerContext.compile("{{^foo}}bar{{/foo}}", {knownHelpersOnly: true})
var result = template({foo: false});
equal(result, "bar", "'bar' should === '" + result);
});
module("blockHelperMissing");
test("lambdas are resolved by blockHelperMissing, not handlebars proper", function() {
var string = "{{#truthy}}yep{{/truthy}}";
var data = { truthy: function() { return true; } };
shouldCompileTo(string, data, "yep");
});
var teardown;
module("built-in helpers", {
setup: function(){ teardown = null; },
teardown: function(){ if (teardown) { teardown(); } }
});
test("with", function() {
var string = "{{#with person}}{{first}} {{last}}{{/with}}";
shouldCompileTo(string, {person: {first: "Alan", last: "Johnson"}}, "Alan Johnson");
});
test("if", function() {
var string = "{{#if goodbye}}GOODBYE {{/if}}cruel {{world}}!";
shouldCompileTo(string, {goodbye: true, world: "world"}, "GOODBYE cruel world!",
"if with boolean argument shows the contents when true");
shouldCompileTo(string, {goodbye: "dummy", world: "world"}, "GOODBYE cruel world!",
"if with string argument shows the contents");
shouldCompileTo(string, {goodbye: false, world: "world"}, "cruel world!",
"if with boolean argument does not show the contents when false");
shouldCompileTo(string, {world: "world"}, "cruel world!",
"if with undefined does not show the contents");
shouldCompileTo(string, {goodbye: ['foo'], world: "world"}, "GOODBYE cruel world!",
"if with non-empty array shows the contents");
shouldCompileTo(string, {goodbye: [], world: "world"}, "cruel world!",
"if with empty array does not show the contents");
});
test("if with function argument", function() {
var string = "{{#if goodbye}}GOODBYE {{/if}}cruel {{world}}!";
shouldCompileTo(string, {goodbye: function() {return true}, world: "world"}, "GOODBYE cruel world!",
"if with function shows the contents when function returns true");
shouldCompileTo(string, {goodbye: function() {return this.world}, world: "world"}, "GOODBYE cruel world!",
"if with function shows the contents when function returns string");
shouldCompileTo(string, {goodbye: function() {return false}, world: "world"}, "cruel world!",
"if with function does not show the contents when returns false");
shouldCompileTo(string, {goodbye: function() {return this.foo}, world: "world"}, "cruel world!",
"if with function does not show the contents when returns undefined");
});
test("each", function() {
var string = "{{#each goodbyes}}{{text}}! {{/each}}cruel {{world}}!"
var hash = {goodbyes: [{text: "goodbye"}, {text: "Goodbye"}, {text: "GOODBYE"}], world: "world"};
shouldCompileTo(string, hash, "goodbye! Goodbye! GOODBYE! cruel world!",
"each with array argument iterates over the contents when not empty");
shouldCompileTo(string, {goodbyes: [], world: "world"}, "cruel world!",
"each with array argument ignores the contents when empty");
});
test("log", function() {
var string = "{{log blah}}"
var hash = { blah: "whee" };
var logArg;
var originalLog = Handlebars.log;
Handlebars.log = function(arg){ logArg = arg; }
teardown = function(){ Handlebars.log = originalLog; }
shouldCompileTo(string, hash, "", "log should not display");
equals("whee", logArg, "should call log with 'whee'");
});
test("overriding property lookup", function() {
});
test("passing in data to a compiled function that expects data - works with helpers", function() {
var template = CompilerContext.compile("{{hello}}", {data: true});
var helpers = {
hello: function(options) {
return options.data.adjective + " " + this.noun;
}
};
var result = template({noun: "cat"}, {helpers: helpers, data: {adjective: "happy"}});
equals("happy cat", result, "Data output by helper");
});
test("passing in data to a compiled function that expects data - works with helpers in partials", function() {
var template = CompilerContext.compile("{{>my_partial}}", {data: true});
var partials = {
my_partial: CompilerContext.compile("{{hello}}", {data: true})
};
var helpers = {
hello: function(options) {
return options.data.adjective + " " + this.noun;
}
};
var result = template({noun: "cat"}, {helpers: helpers, partials: partials, data: {adjective: "happy"}});
equals("happy cat", result, "Data output by helper inside partial");
});
test("passing in data to a compiled function that expects data - works with helpers and parameters", function() {
var template = CompilerContext.compile("{{hello world}}", {data: true});
var helpers = {
hello: function(noun, options) {
return options.data.adjective + " " + noun + (this.exclaim ? "!" : "");
}
};
var result = template({exclaim: true, world: "world"}, {helpers: helpers, data: {adjective: "happy"}});
equals("happy world!", result, "Data output by helper");
});
test("passing in data to a compiled function that expects data - works with block helpers", function() {
var template = CompilerContext.compile("{{#hello}}{{world}}{{/hello}}", {data: true});
var helpers = {
hello: function(fn) {
return fn(this);
},
world: function(options) {
return options.data.adjective + " world" + (this.exclaim ? "!" : "");
}
};
var result = template({exclaim: true}, {helpers: helpers, data: {adjective: "happy"}});
equals("happy world!", result, "Data output by helper");
});
test("passing in data to a compiled function that expects data - works with block helpers that use ..", function() {
var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
var helpers = {
hello: function(fn) {
return fn({exclaim: "?"});
},
world: function(thing, options) {
return options.data.adjective + " " + thing + (this.exclaim || "");
}
};
var result = template({exclaim: true, zomg: "world"}, {helpers: helpers, data: {adjective: "happy"}});
equals("happy world?", result, "Data output by helper");
});
test("passing in data to a compiled function that expects data - data is passed to with block helpers where children use ..", function() {
var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
var helpers = {
hello: function(fn, inverse) {
return fn.data.accessData + " " + fn({exclaim: "?"});
},
world: function(thing, options) {
return options.data.adjective + " " + thing + (this.exclaim || "");
}
};
var result = template({exclaim: true, zomg: "world"}, {helpers: helpers, data: {adjective: "happy", accessData: "#win"}});
equals("#win happy world?", result, "Data output by helper");
});
test("you can override inherited data when invoking a helper", function() {
var template = CompilerContext.compile("{{#hello}}{{world zomg}}{{/hello}}", {data: true});
var helpers = {
hello: function(fn) {
return fn({exclaim: "?", zomg: "world"}, { data: {adjective: "sad"} });
},
world: function(thing, options) {
return options.data.adjective + " " + thing + (this.exclaim || "");
}
};
var result = template({exclaim: true, zomg: "planet"}, {helpers: helpers, data: {adjective: "happy"}});
equals("sad world?", result, "Overriden data output by helper");
});
test("you can override inherited data when invoking a helper with depth", function() {
var template = CompilerContext.compile("{{#hello}}{{world ../zomg}}{{/hello}}", {data: true});
var helpers = {
hello: function(fn) {
return fn({exclaim: "?"}, { data: {adjective: "sad"} });
},
world: function(thing, options) {
return options.data.adjective + " " + thing + (this.exclaim || "");
}
};
var result = template({exclaim: true, zomg: "world"}, {helpers: helpers, data: {adjective: "happy"}});
equals("sad world?", result, "Overriden data output by helper");
});
test("helpers take precedence over same-named context properties", function() {
var template = CompilerContext.compile("{{goodbye}} {{cruel world}}");
var helpers = {
goodbye: function() {
return this.goodbye.toUpperCase();
}
};
var context = {
cruel: function(world) {
return "cruel " + world.toUpperCase();
},
goodbye: "goodbye",
world: "world"
};
var result = template(context, {helpers: helpers});
equals(result, "GOODBYE cruel WORLD", "Helper executed");
});
test("helpers take precedence over same-named context properties", function() {
var template = CompilerContext.compile("{{#goodbye}} {{cruel world}}{{/goodbye}}");
var helpers = {
goodbye: function(fn) {
return this.goodbye.toUpperCase() + fn(this);
}
};
var context = {
cruel: function(world) {
return "cruel " + world.toUpperCase();
},
goodbye: "goodbye",
world: "world"
};
var result = template(context, {helpers: helpers});
equals(result, "GOODBYE cruel WORLD", "Helper executed");
});
test("Scoped names take precedence over helpers", function() {
var template = CompilerContext.compile("{{this.goodbye}} {{cruel world}} {{cruel this.goodbye}}");
var helpers = {
goodbye: function() {
return this.goodbye.toUpperCase();
}
};
var context = {
cruel: function(world) {
return "cruel " + world.toUpperCase();
},
goodbye: "goodbye",
world: "world"
};
var result = template(context, {helpers: helpers});
equals(result, "goodbye cruel WORLD cruel GOODBYE", "Helper not executed");
});
test("Scoped names take precedence over block helpers", function() {
var template = CompilerContext.compile("{{#goodbye}} {{cruel world}}{{/goodbye}} {{this.goodbye}}");
var helpers = {
goodbye: function(fn) {
return this.goodbye.toUpperCase() + fn(this);
}
};
var context = {
cruel: function(world) {
return "cruel " + world.toUpperCase();
},
goodbye: "goodbye",
world: "world"
};
var result = template(context, {helpers: helpers});
equals(result, "GOODBYE cruel WORLD goodbye", "Helper executed");
});
test("helpers can take an optional hash", function() {
var template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" times=12}}');
var helpers = {
goodbye: function(options) {
return "GOODBYE " + options.hash.cruel + " " + options.hash.world + " " + options.hash.times + " TIMES";
}
};
var context = {};
var result = template(context, {helpers: helpers});
equals(result, "GOODBYE CRUEL WORLD 12 TIMES", "Helper output hash");
});
test("helpers can take an optional hash with booleans", function() {
var helpers = {
goodbye: function(options) {
if (options.hash.print === true) {
return "GOODBYE " + options.hash.cruel + " " + options.hash.world;
} else if (options.hash.print === false) {
return "NOT PRINTING";
} else {
return "THIS SHOULD NOT HAPPEN";
}
}
};
var context = {};
var template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" print=true}}');
var result = template(context, {helpers: helpers});
equals(result, "GOODBYE CRUEL WORLD", "Helper output hash");
var template = CompilerContext.compile('{{goodbye cruel="CRUEL" world="WORLD" print=false}}');
var result = template(context, {helpers: helpers});
equals(result, "NOT PRINTING", "Boolean helper parameter honored");
});
test("block helpers can take an optional hash", function() {
var template = CompilerContext.compile('{{#goodbye cruel="CRUEL" times=12}}world{{/goodbye}}');
var helpers = {
goodbye: function(options) {
return "GOODBYE " + options.hash.cruel + " " + options.fn(this) + " " + options.hash.times + " TIMES";
}
};
var result = template({}, {helpers: helpers});
equals(result, "GOODBYE CRUEL world 12 TIMES", "Hash parameters output");
});
test("block helpers can take an optional hash with booleans", function() {
var helpers = {
goodbye: function(options) {
if (options.hash.print === true) {
return "GOODBYE " + options.hash.cruel + " " + options.fn(this);
} else if (options.hash.print === false) {
return "NOT PRINTING";
} else {
return "THIS SHOULD NOT HAPPEN";
}
}
};
var template = CompilerContext.compile('{{#goodbye cruel="CRUEL" print=true}}world{{/goodbye}}');
var result = template({}, {helpers: helpers});
equals(result, "GOODBYE CRUEL world", "Boolean hash parameter honored");
var template = CompilerContext.compile('{{#goodbye cruel="CRUEL" print=false}}world{{/goodbye}}');
var result = template({}, {helpers: helpers});
equals(result, "NOT PRINTING", "Boolean hash parameter honored");
});
test("arguments to helpers can be retrieved from options hash in string form", function() {
var template = CompilerContext.compile('{{wycats is.a slave.driver}}', {stringParams: true});
var helpers = {
wycats: function(passiveVoice, noun, options) {
return "HELP ME MY BOSS " + passiveVoice + ' ' + noun;
}
};
var result = template({}, {helpers: helpers});
equals(result, "HELP ME MY BOSS is.a slave.driver", "String parameters output");
});
test("when using block form, arguments to helpers can be retrieved from options hash in string form", function() {
var template = CompilerContext.compile('{{#wycats is.a slave.driver}}help :({{/wycats}}', {stringParams: true});
var helpers = {
wycats: function(passiveVoice, noun, options) {
return "HELP ME MY BOSS " + passiveVoice + ' ' +
noun + ': ' + options.fn(this);
}
};
var result = template({}, {helpers: helpers});
equals(result, "HELP ME MY BOSS is.a slave.driver: help :(", "String parameters output");
});
test("when inside a block in String mode, .. passes the appropriate context in the options hash", function() {
var template = CompilerContext.compile('{{#with dale}}{{tomdale ../need dad.joke}}{{/with}}', {stringParams: true});
var helpers = {
tomdale: function(desire, noun, options) {
return "STOP ME FROM READING HACKER NEWS I " +
options.contexts[0][desire] + " " + noun;
},
"with": function(context, options) {
return options.fn(options.contexts[0][context]);
}
};
var result = template({
dale: {},
need: 'need-a'
}, {helpers: helpers});
equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke", "Proper context variable output");
});
test("when inside a block in String mode, .. passes the appropriate context in the options hash to a block helper", function() {
var template = CompilerContext.compile('{{#with dale}}{{#tomdale ../need dad.joke}}wot{{/tomdale}}{{/with}}', {stringParams: true});
var helpers = {
tomdale: function(desire, noun, options) {
return "STOP ME FROM READING HACKER NEWS I " +
options.contexts[0][desire] + " " + noun + " " +
options.fn(this);
},
"with": function(context, options) {
return options.fn(options.contexts[0][context]);
}
};
var result = template({
dale: {},
need: 'need-a'
}, {helpers: helpers});
equals(result, "STOP ME FROM READING HACKER NEWS I need-a dad.joke wot", "Proper context variable output");
});
module("Regressions")
test("GH-94: Cannot read property of undefined", function() {
var data = {"books":[{"title":"The origin of species","author":{"name":"Charles Darwin"}},{"title":"Lazarillo de Tormes"}]};
var string = "{{#books}}{{title}}{{author.name}}{{/books}}";
shouldCompileTo(string, data, "The origin of speciesCharles DarwinLazarillo de Tormes",
"Renders without an undefined property error");
});
test("GH-150: Inverted sections print when they shouldn't", function() {
var string = "{{^set}}not set{{/set}} :: {{#set}}set{{/set}}";
shouldCompileTo(string, {}, "not set :: ", "inverted sections run when property isn't present in context");
shouldCompileTo(string, {set: undefined}, "not set :: ", "inverted sections run when property is undefined");
shouldCompileTo(string, {set: false}, "not set :: ", "inverted sections run when property is false");
shouldCompileTo(string, {set: true}, " :: set", "inverted sections don't run when property is true");
});
test("Mustache man page", function() {
var string = "Hello {{name}}. You have just won ${{value}}!{{#in_ca}} Well, ${{taxed_value}}, after taxes.{{/in_ca}}"
var data = {
"name": "Chris",
"value": 10000,
"taxed_value": 10000 - (10000 * 0.4),
"in_ca": true
}
shouldCompileTo(string, data, "Hello Chris. You have just won $10000! Well, $6000, after taxes.", "the hello world mustache example works");
});
test("GH-158: Using array index twice, breaks the template", function() {
var string = "{{arr.[0]}}, {{arr.[1]}}";
var data = { "arr": [1,2] };
shouldCompileTo(string, data, "1, 2", "it works as expected");
});
test("bug reported by @fat where lambdas weren't being properly resolved", function() {
var string = "<strong>This is a slightly more complicated {{thing}}.</strong>.\n{{! Just ignore this business. }}\nCheck this out:\n{{#hasThings}}\n<ul>\n{{#things}}\n<li class={{className}}>{{word}}</li>\n{{/things}}</ul>.\n{{/hasThings}}\n{{^hasThings}}\n\n<small>Nothing to check out...</small>\n{{/hasThings}}";
var data = {
thing: function() {
return "blah";
},
things: [
{className: "one", word: "@fat"},
{className: "two", word: "@dhg"},
{className: "three", word:"@sayrer"}
],
hasThings: function() {
return true;
}
};
var output = "<strong>This is a slightly more complicated blah.</strong>.\n\nCheck this out:\n\n<ul>\n\n<li class=one>@fat</li>\n\n<li class=two>@dhg</li>\n\n<li class=three>@sayrer</li>\n</ul>.\n\n";
shouldCompileTo(string, data, output);
});
|
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", "react", "office-ui-fabric-react/lib/Checkbox"], function (require, exports, React, Checkbox_1) {
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var CheckboxBasicExample = (function (_super) {
__extends(CheckboxBasicExample, _super);
function CheckboxBasicExample() {
var _this = _super.call(this) || this;
_this.state = {
isChecked: false
};
_this._onCheckboxChange = _this._onCheckboxChange.bind(_this);
return _this;
}
CheckboxBasicExample.prototype.render = function () {
var _this = this;
var isChecked = this.state.isChecked;
return (React.createElement("div", null,
React.createElement(Checkbox_1.Checkbox, { label: 'Uncontrolled checkbox', onChange: this._onCheckboxChange, inputProps: {
onFocus: function () { console.log('Uncontrolled checkbox is focused'); },
onBlur: function () { console.log('Uncontrolled checkbox is blured'); }
} }),
React.createElement(Checkbox_1.Checkbox, { label: 'Uncontrolled checkbox with defaultChecked true', defaultChecked: true, onChange: this._onCheckboxChange }),
React.createElement(Checkbox_1.Checkbox, { label: 'Disabled uncontrolled checkbox with defaultChecked true', disabled: true, defaultChecked: true, onChange: this._onCheckboxChange }),
React.createElement(Checkbox_1.Checkbox, { label: 'Controlled checkbox', checked: isChecked, onChange: function (ev, checked) { return _this.setState({ isChecked: checked }); } })));
};
CheckboxBasicExample.prototype._onCheckboxChange = function (ev, isChecked) {
console.log("The option has been changed to " + isChecked + ".");
};
return CheckboxBasicExample;
}(React.Component));
exports.CheckboxBasicExample = CheckboxBasicExample;
});
//# sourceMappingURL=Checkbox.Basic.Example.js.map
|
function randomPos(w, h) {
return new Two.Vector(Math.random() * w, Math.random() * h);
}
function Model(world) {
var self = this;
this.world = world;
this.despawn = function() {
var agent = self.world.agents.pop();
self.publish('despawn', agent);
}
this.spawn = function() {
var position = randomPos(self.world.width, self.world.height);
var agent = new Agent(position, self.world);
self.world.agents.push(agent);
self.publish('spawn', agent);
}
this.step = function(dt) {
self.world.step(dt);
self.world.agents.forEach(function(agent) {
agent.step(dt);
});
self.publish('step', dt);
}
// pub/sub mechanism
Mediator(this);
}
|
class InvoicesAll{
constructor(){
if( $('#invoices').length == 0 ) return;
this.bindEvents();
this.getUnpaidInvoices();
this.startLoading();
}
bindEvents(){
var _this = this;
$('[data-action="get-all-invoices"]').click(function(){
_this.startLoading();
_this.getAllInvoices();
});
$('[data-action="get-unpaid-invoices"]').click(function(){
_this.startLoading();
_this.getUnpaidInvoices();
});
}
startLoading(){
if( $('#invoices-list').length > 0 ){
$('#invoices-list').addClass('hidden');
}
$('#invoices-list-loading').removeClass('hidden');
}
showError(){
$('#invoices-list-loading').addClass('hidden');
$('#invoices-list-error').removeClass('hidden');
}
cloneEmptyList(){
if( $('#invoices-list').length > 0 ){
$('#invoices-list').remove();
}
$('#invoices').prepend( $('#invoices-list-template').clone().attr('id','invoices-list') );
}
getAllInvoices(){
var _this = this;
$.post('/invoices', { '_token' : $('#invoices [name=_token]').val() })
.done(function( response ){
if( response.invoices.length == 0 ){
_this.showError();
}else{
_this.cloneEmptyList();
_this.populateList( response );
}
});
}
getUnpaidInvoices(){
var _this = this;
$.post('/invoices/unpaid', { '_token' : $('#invoices [name=_token]').val() })
.done(function( response ){
if( response.invoices.length == 0 ){
_this.showError();
}else{
_this.cloneEmptyList();
_this.populateList( response );
}
});
}
populateList( response ){
var invoices = response.invoices;
var invoice_list_body = $('#invoices-list tbody');
$.each(invoices, function(index, invoice){
var invoice_line = invoice_list_body.find('tr.template').clone();
var date = new Date( invoice.date );
if( invoice.status == 'paid' ){
date = 'Paid';
}else{
date = moment(date).format("DD MMM, YYYY");
}
// Populate the data
invoice_line.find('.invoice-number').html( invoice.number );
invoice_line.find('.invoice-status .label-status').html( invoice.status ).addClass( response.status_classes[ invoice.status ] );
invoice_line.find('.invoice-organization').html( invoice.organization );
invoice_line.find('.invoice-client-name').html( invoice.first_name + ' ' + invoice.last_name );
invoice_line.find('.invoice-amount-outstanding').html( invoice.currency_code+' '+invoice.amount_outstanding )
.attr('data-sort',invoice.amount_outstanding*100);
invoice_line.find('.invoice-paid').html( invoice.currency_code+' '+invoice.paid )
.attr('data-sort',invoice.paid*100);
invoice_line.find('.invoice-amount').html( invoice.currency_code+' '+invoice.amount )
.attr('data-sort',invoice.amount*100);
invoice_line.find('.invoice-due-date').html( date );
invoice_line.find('.view-invoice').attr( 'href', invoice.links.view );
invoice_line.find('.edit-invoice').attr( 'href', invoice.links.edit );
// Show the lines
invoice_line.removeClass('template').removeClass('hidden');
// Adds to the body
invoice_list_body.append(invoice_line);
});
$('#invoices-list-loading').addClass('hidden');
$('#invoices-list').removeClass('hidden');
$('#invoices-list tr.template').remove();
// Sort table
new Tablesort(document.getElementById('invoices-list'));
}
} |
// All symbols in the Small Form Variants block as per Unicode v6.0.0:
[
'\uFE50',
'\uFE51',
'\uFE52',
'\uFE53',
'\uFE54',
'\uFE55',
'\uFE56',
'\uFE57',
'\uFE58',
'\uFE59',
'\uFE5A',
'\uFE5B',
'\uFE5C',
'\uFE5D',
'\uFE5E',
'\uFE5F',
'\uFE60',
'\uFE61',
'\uFE62',
'\uFE63',
'\uFE64',
'\uFE65',
'\uFE66',
'\uFE67',
'\uFE68',
'\uFE69',
'\uFE6A',
'\uFE6B',
'\uFE6C',
'\uFE6D',
'\uFE6E',
'\uFE6F'
]; |
import Draw from './L.PM.Draw';
Draw.Circle = Draw.extend({
initialize(map) {
this._map = map;
this._shape = 'Circle';
this.toolbarButtonName = 'drawCircle';
},
enable(options) {
// TODO: Think about if these options could be passed globally for all
// instances of L.PM.Draw. So a dev could set drawing style one time as some kind of config
L.Util.setOptions(this, options);
this.options.radius = 0;
// enable draw mode
this._enabled = true;
// create a new layergroup
this._layerGroup = new L.LayerGroup();
this._layerGroup._pmTempLayer = true;
this._layerGroup.addTo(this._map);
// this is the circle we want to draw
this._layer = L.circle([0, 0], this.options.templineStyle);
this._layer._pmTempLayer = true;
this._layerGroup.addLayer(this._layer);
// this is the marker in the center of the circle
this._centerMarker = L.marker([0, 0], {
icon: L.divIcon({ className: 'marker-icon' }),
draggable: true,
zIndexOffset: 100,
});
this._centerMarker._pmTempLayer = true;
this._layerGroup.addLayer(this._centerMarker);
// this is the hintmarker on the mouse cursor
this._hintMarker = L.marker([0, 0], {
icon: L.divIcon({ className: 'marker-icon cursor-marker' }),
});
this._hintMarker._pmTempLayer = true;
this._layerGroup.addLayer(this._hintMarker);
// show the hintmarker if the option is set
if(this.options.cursorMarker) {
L.DomUtil.addClass(this._hintMarker._icon, 'visible');
}
// this is the hintline from the hint marker to the center marker
this._hintline = L.polyline([], this.options.hintlineStyle);
this._hintline._pmTempLayer = true;
this._layerGroup.addLayer(this._hintline);
// change map cursor
this._map._container.style.cursor = 'crosshair';
// create a polygon-point on click
this._map.on('click', this._placeCenterMarker, this);
// sync hint marker with mouse cursor
this._map.on('mousemove', this._syncHintMarker, this);
// fire drawstart event
this._map.fire('pm:drawstart', { shape: this._shape, workingLayer: this._layer });
// toggle the draw button of the Toolbar in case drawing mode got enabled without the button
this._map.pm.Toolbar.toggleButton(this.toolbarButtonName, true);
// an array used in the snapping mixin.
// TODO: think about moving this somewhere else?
this._otherSnapLayers = [];
},
disable() {
// disable drawing mode
// cancel, if drawing mode isn't event enabled
if(!this._enabled) {
return;
}
this._enabled = false;
// reset cursor
this._map._container.style.cursor = 'default';
// unbind listeners
this._map.off('click', this._finishShape, this);
this._map.off('click', this._placeCenterMarker, this);
this._map.off('mousemove', this._syncHintMarker, this);
// remove helping layers
this._map.removeLayer(this._layerGroup);
// fire drawend event
this._map.fire('pm:drawend', { shape: this._shape });
// toggle the draw button of the Toolbar in case drawing mode got disabled without the button
this._map.pm.Toolbar.toggleButton(this.toolbarButtonName, false);
// cleanup snapping
if(this.options.snappable) {
this._cleanupSnapping();
}
},
enabled() {
return this._enabled;
},
toggle(options) {
if(this.enabled()) {
this.disable();
} else {
this.enable(options);
}
},
_syncHintLine() {
const latlng = this._centerMarker.getLatLng();
// set coords for hintline from marker to last vertex of drawin polyline
this._hintline.setLatLngs([latlng, this._hintMarker.getLatLng()]);
},
_syncCircleRadius() {
const A = this._centerMarker.getLatLng();
const B = this._hintMarker.getLatLng();
const distance = A.distanceTo(B);
this._layer.setRadius(distance);
},
_syncHintMarker(e) {
// move the cursor marker
this._hintMarker.setLatLng(e.latlng);
// if snapping is enabled, do it
if(this.options.snappable) {
const fakeDragEvent = e;
fakeDragEvent.target = this._hintMarker;
this._handleSnapping(fakeDragEvent);
}
},
_placeCenterMarker(e) {
// assign the coordinate of the click to the hintMarker, that's necessary for
// mobile where the marker can't follow a cursor
if(!this._hintMarker._snapped) {
this._hintMarker.setLatLng(e.latlng);
}
// get coordinate for new vertex by hintMarker (cursor marker)
const latlng = this._hintMarker.getLatLng();
this._centerMarker.setLatLng(latlng);
this._map.off('click', this._placeCenterMarker, this);
this._map.on('click', this._finishShape, this);
this._placeCircleCenter();
},
_placeCircleCenter() {
const latlng = this._centerMarker.getLatLng();
if(latlng) {
this._layer.setLatLng(latlng);
// sync the hintline with hint marker
this._hintMarker.on('move', this._syncHintLine, this);
this._hintMarker.on('move', this._syncCircleRadius, this);
}
},
_finishShape() {
// calc the radius
const center = this._centerMarker.getLatLng();
const cursor = this._hintMarker.getLatLng();
const radius = center.distanceTo(cursor);
// create the final circle layer
const circleLayer = L.circle(center, { radius }).addTo(this._map);
// disable drawing
this.disable();
// fire the pm:create event and pass shape and layer
this._map.fire('pm:create', {
shape: this._shape,
layer: circleLayer,
});
},
_createMarker(latlng) {
// create the new marker
const marker = new L.Marker(latlng, {
draggable: false,
icon: L.divIcon({ className: 'marker-icon' }),
});
marker._pmTempLayer = true;
// add it to the map
this._layerGroup.addLayer(marker);
return marker;
},
});
|
import Ember from 'ember';
import BasicMetadata from '../generics/basic-metadata';
/**
* Defines a slot where items can be worn in
* a body. Slots are defined per race.
*
* @class WearableSlot
* @namespace Inventory
* @extends {Ember.Object}
* @uses BasicMetadata
*/
export default Ember.Object.extend(BasicMetadata, {
/**
* Indicates how many items can be worn in this slot.
*
* @property itemCapacity
* @type {Number}
*/
itemCapacity: 1,
/**
* Restricts this slot to particular gender IDs.
* If empty, there is no restriction.
*
* @property allowedGenders
* @type {string[]}
*/
allowedGenders: Ember.computed(function() { return Ember.A(); })
});
|
const test = require('ava');
var CssbeautifyCli = require('../lib/cssbeautify-cli'),
cssbeautifyCli;
test('withoutNew', function (test) {
cssbeautifyCli = CssbeautifyCli();
test.is(cssbeautifyCli instanceof CssbeautifyCli, true);
});
test('withNew', function (test) {
cssbeautifyCli = new CssbeautifyCli();
test.is(cssbeautifyCli instanceof CssbeautifyCli, true);
});
|
import {extend} from './utils';
const DEFAULT_BASE_URL = '/fixtures';
const DEFAULT_RESET_URL = '/_ah/yawp/datastore/delete-all';
const DEFAULT_LAZY_PROPERTIES = ['id']; // needed till harmony proxies
const DEFAULT_FETCH_OPTIONS = {};
export default (request) => {
class Fixtures {
constructor() {
this._baseUrl = DEFAULT_BASE_URL;
this._resetUrl = DEFAULT_RESET_URL;
this._lazyProperties = DEFAULT_LAZY_PROPERTIES;
this._defaultFetchOptions = DEFAULT_FETCH_OPTIONS;
this._defaultNamespace = null;
this.promise = null;
this.fixtures = [];
this.lazy = {};
}
config(callback) {
callback(this);
}
defaultNamespace(ns) {
this._defaultNamespace = ns;
}
baseUrl(url) {
this._baseUrl = url;
}
resetUrl(url) {
this._resetUrl = url;
}
lazyProperties(properties) {
this._lazyProperties = properties;
}
defaultFetchOptions(options) {
extend(this._defaultFetchOptions, options);
}
reset(all) {
return request(this._resetUrl, {
method: 'GET'
}).then(() => {
this.clear(all);
});
}
clear(all) {
this.promise = null;
for (let i = 0, l = this.fixtures.length; i < l; i++) {
var name = this.fixtures[i].name;
var path = this.fixtures[i].path;
this.bindFixture(name, path);
all && this.bindLazy(name, path);
}
}
bind(name, path) {
this.fixtures.push({name, path});
this.bindFixture(name, path);
this.bindLazy(name);
}
bindFixture(name, path) {
this[name] = new Fixture(this, name, path).api;
}
bindLazy(name) {
this.lazy[name] = new Lazy(this, name).api;
}
chain(promiseFn) {
if (!this.promise) {
this.promise = promiseFn();
} else {
this.promise = this.promise.then(promiseFn);
}
return this.promise;
}
load(callback) {
if (!this.promise) {
return new Promise(() => callback && callback());
}
return this.promise.then(() => callback && callback());
}
}
class Fixture {
constructor(fx, name, path) {
this.fx = fx;
this.name = name;
this.path = path;
this.api = this.createApi();
}
createApi() {
var api = (key, data) => {
return this.fx.chain(this.load(key, data));
};
api.self = this;
return api;
}
url() {
return this.fx._baseUrl + this.path;
}
load(key, data) {
this.createStubs(key);
return this.createLoadPromiseFn(key, data);
}
createLoadPromiseFn(key, data) {
if (!data) {
data = this.getLazyDataFor(key);
}
return () => {
if (this.isLoaded(key)) {
return this.api[key];
}
return this.prepare(data).then((object) => {
const { __namespace, ...data } = object;
delete object.__namespace;
const namespace = __namespace === undefined ? this.fx._defaultNamespace : __namespace;
const options = {
method: 'POST',
headers: { namespace },
json: true,
body: JSON.stringify(data),
};
extend(options, this.fx._defaultFetchOptions);
return request(this.url(), options).then((response) => {
this.api[key] = response;
return response;
});
});
};
}
getLazyDataFor(key) {
var lazy = this.fx.lazy[this.name].self;
return lazy.getData(key);
}
prepare(data) {
return new Promise((resolve) => {
let object = {};
extend(object, data);
let lazyProperties = [];
this.inspectLazyProperties(object, lazyProperties);
this.resolveLazyProperties(object, lazyProperties, resolve);
});
}
resolveLazyProperties(object, lazyProperties, resolve) {
if (!lazyProperties.length) {
resolve(object);
} else {
var promise = lazyProperties[0]();
for (var i = 1, l = lazyProperties.length; i < l; i++) {
promise = promise.then(lazyProperties[i]);
}
promise.then(() => {
resolve(object);
});
}
}
inspectLazyProperties(object, lazyProperties) {
for (let key in object) {
if (!object.hasOwnProperty(key)) {
continue;
}
let value = object[key];
if (value instanceof Function) {
lazyProperties.push(() => {
return value().then((actualValue) => {
object[key] = actualValue;
});
});
continue;
}
if (value instanceof Object) {
this.inspectLazyProperties(value, lazyProperties);
return;
}
}
}
createStubs(key) {
if (this.hasStubs(key)) {
return;
}
let self = this;
this.api[key] = this.fx._lazyProperties.reduce((map, property) => {
map[property] = () => {
return new Promise((resolve) => resolve(self.api[key][property]));
};
return map;
}, {});
this.api[key].__stub__ = true;
}
isLoaded(key) {
return this.api[key] && !this.hasStubs(key);
}
hasStubs(key) {
return this.api[key] && this.api[key].__stub__;
}
}
class Lazy {
constructor(fx, name) {
this.fx = fx;
this.name = name;
this.data = {};
this.api = this.createApi();
}
createApi() {
let api = (key, data) => {
this.createLazyStubs(key);
if (data) {
this.data[key] = data;
}
return this.api[key];
};
api.self = this;
return api;
}
getData(key) {
return this.data[key];
}
createLazyStubs(key) {
if (this.hasStubs(key)) {
return;
}
this.api[key] = this.fx._lazyProperties.reduce((map, property) => {
map[property] = () => {
return this.getFixtureRef().load(key)().then((object) => object[property]);
};
return map;
}, {});
this.api[key].__stub__ = true;
}
hasStubs(key) {
return this.api[key] && this.api[key].__stub__;
}
getFixtureRef() {
return this.fx[this.name].self;
}
}
return new Fixtures();
};
|
import React from 'react'
import R from 'ramda'
import { connect } from 'react-redux'
import h from "lib/ui/hyperscript_with_helpers"
import { createObject } from 'actions'
import {
getIsCreating,
getOrgRolesAssignable,
getCurrentOrg,
getApps,
getImportErrors
} from 'selectors'
import {AppForm, UserForm} from 'components/forms'
const ObjectFormContainerFactory = ({objectType})=> {
const
formClass = { app: AppForm, user: UserForm }[objectType],
ObjectFormContainer = props => h.div(".new-page", [h(formClass, props)]),
mapStateToProps = (state, ownProps) => {
const props = {
isSubmitting: getIsCreating({objectType}, state),
currentOrg: getCurrentOrg(state),
numApps: getApps(state).length
}
if(objectType == "user"){
props.orgRolesAssignable = getOrgRolesAssignable(state)
}
if(objectType == "app"){
props.renderImporter = true
props.environments = ["development", "staging", "production"]
}
return props
},
mapDispatchToProps = (dispatch, ownProps) => ({
onSubmit: params => {
dispatch(createObject({
objectType,
params: (params.params || params),
toImport: params.toImport
}))
}
})
return connect(mapStateToProps, mapDispatchToProps)(ObjectFormContainer)
}
export default ObjectFormContainerFactory |
'use strict'
module.exports = {
collections: {
users: {
username: {
type: 'STRING 100'
},
password: {
type: 'STRING 60'
},
role: {
type: 'STRING 255',
comment: 'May contain a comma-separated list of roles, e.g.: \'moderator, admin\''
}
},
files: {
mime: {
type: 'STRING 100'
},
name: {
type: 'TEXT'
},
size: {
type: 'INTEGER'
}
}
},
endpoints: {
'POST /users/login': {
extendable: true,
comment: 'Attempts to log a user in (login).',
params: {
username: {
required: true,
regex: '^\\S+\\@\\S+\\.\\S+$'
},
password: {
required: true,
regex: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,18}$'
}
},
handlers: {
core: './users/login'
},
errors: {
6: 'There is no user with this username.',
7: 'Incorrect password.'
},
'response': {
'token': {
'present': 'always',
'type': 'string',
'comment': 'The session toaken/ID.'
},
'user': {
'present': 'always',
'type': 'object',
'comment': "An object containing the currently logged-in user's information."
}
}
},
'GET /users': {
extendable: true,
restrict: true,
handlers: {
core: './users/get'
},
comment: 'Returns a list of users.'
},
'GET /users/:id(\\d+)/': {
extendable: true,
restrict: true,
handlers: {
core: './users/getone'
},
comment: 'Returns information about a user with the specified ID.'
},
'DELETE /users': {
extendable: true,
comment: 'Removes a user.',
restrict: 'admin'
},
'POST /users': {
extendable: true,
comment: 'Registers a new user.',
params: {
username: {
required: true,
regex: '^\\S+\\@\\S+\\.\\S+$'
},
password: {
required: true,
regex: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,18}$'
}
},
handlers: {
core: './users/post'
},
errors: {
5: 'This username is already registered.'
}
},
'GET /users/exists/:username': {
extendable: true,
params: {
username: {
required: true,
regex: '^\\S+\\@\\S+\\.\\S+$'
}
},
handlers: {
core: './users/exists'
}
},
'PUT /apiko/setup': {
extendable: false,
comment: 'Updates the server\'s current setup.',
handlers: {
core: './apiko/setup/put'
},
errors: {
3: 'This server is protected by a secret that has to be supplied in the \'secret\' parameter.',
4: 'The \'setup\' parameter containing the actual setup is mandatory.'
}
},
'GET /apiko/setup': {
extendable: false,
comment: 'Retrieves the server\'s current setup.',
handlers: {
core: './apiko/setup/get'
},
errors: {
3: 'This server is protected by a secret that has to be supplied in the \'secret\' parameter.'
}
},
'GET /apiko/core': {
extendable: false,
comment: 'Retrieves the server\'s core endpoints and collections.',
handlers: {
core: './apiko/core/get'
},
errors: {
3: 'This server is protected by a secret that has to be supplied in the \'secret\' parameter.'
}
},
'GET /files': {
extendable: true,
comment: 'Retrieves a list of all files.'
},
'GET /files/:id': {
extendable: true,
comment: 'Downloads a file specified by ID.',
params: {
id: {
required: true,
regex: '^\\d{1,10}$'
}
},
handlers: {
core: './files/getone'
},
errors: {
10: 'No such file.'
}
},
'POST /files': {
extendable: true,
comment: 'Uploads a new file.',
params: {
id: {
required: false
},
size: {
required: false
},
name: {
required: false
},
mime: {
required: false
}
},
handlers: {
core: './files/post'
},
errors: {
12: 'The file upload failed.',
13: 'The file upload has been aborted by the client (timeout or close event on the socket).'
}
},
'PUT /files/:id': {
extendable: true,
comment: 'Not implemented. Overwriting files is not implemented by default.',
handlers: {
core: './files/put'
},
errors: {
11: 'Not implemented. Overwriting files is not implemented by default.'
}
},
'DELETE /files/:id': {
extendable: true,
comment: 'Removes a file specified by ID.',
params: {
id: {
required: true,
regex: '^\\d{1,10}$'
}
},
handlers: {
core: './files/delete'
},
errors: {
10: 'No such record.'
}
},
'GET /apiko/stats': {
extendable: false,
comment: 'Stats data with optional interval parameters. If no interval is set, data for the recent 30 days will be returned.',
handlers: {
core: './apiko/stats/get'
},
params: {
start: {
required: false,
regex: '^\\d+$',
comment: 'Time interval start for the requested stats as an UNIX timestamp.'
},
end: {
required: false,
regex: '^\\d+$',
comment: 'Time interval end for the requested stats as an UNIX timestamp.'
},
only_counter: {
required: false,
comment: 'Retrieves only stats counter without detalization if true'
}
}
},
'GET /apiko/reference': {
extendable: false,
comment: 'Displays a generated API reference of this API server.',
handlers: {
core: './apiko/reference/get'
},
params: {
secret: {
required: false,
comment: 'The server\' secret, required to display the reference if the server is set to protect with a secret.'
},
core: {
required: false,
comment: 'Will display the core endpoints as a part of the reference if a true-like value is supplied.'
}
},
errors: {
3: 'This server is protected by a secret that has to be supplied in the \'secret\' parameter.'
}
},
'POST /users/password/change/:id': {
extendable: true,
comment: 'Attempts to change a user password (according to specified user ID).',
ownership: true,
restrict: 'admin', // only the user themself and an admin can change their password
params: {
id: {
required: true,
regex: '^\\d{1,10}$',
comment: 'User ID of whom password is being changed.'
},
current: {
required: true,
comment: 'The specified user\'s old password.'
},
new: {
required: true,
regex: '^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d).{8,18}$',
comment: 'The specified user\'s new password.'
}
},
handlers: {
core: './users/passwordchange'
},
errors: {
7: 'Incorrect old password.',
10: 'No user with such id'
},
'response': {}
},
'POST /users/password/reset/:id': {
extendable: true,
comment: 'Attempts to reset a user password (according to specified user ID).',
ownership: true,
restrict: 'admin', // only the user themself and an admin can change their password
params: {
id: {
required: true,
regex: '^\\d{1,10}$',
comment: 'User ID of whom password is being changed.'
}
},
handlers: {
core: './users/passwordreset'
},
errors: {
10: 'No user with such id'
},
'response': {
'new': {
'present': 'always',
'type': 'string',
'comment': 'A new random password'
}
}
}
}
}
|
import React from 'react';
import ReactDOM from 'react-dom';
import { Provider } from 'react-redux';
import { createStore, applyMiddleware } from 'redux';
import {Router, Route, IndexRoute, browserHistory} from 'react-router';
import reduxThunk from 'redux-thunk';
import axios from 'axios';
import requireAuth from './components/hoc/require_authentication';
import App from './components/app';
import PollById from './components/poll_by_id';
import CreatePoll from './components/create_poll';
import reducers from './reducers';
import { TOKEN_KEY } from './actions/constants';
import { AUTH_USER, UNAUTH_USER } from './actions/types';
import { VOTING_APP_SERVER__URL } from './actions/uris';
const createStoreWithMiddleware = applyMiddleware(reduxThunk)(createStore);
const store = createStoreWithMiddleware(reducers);
const userData = localStorage.getItem(TOKEN_KEY);
if(userData) {
axios.post(`${VOTING_APP_SERVER__URL}/test-authorization`,JSON.parse(userData))
.then(response => {
if(response.data.is_authorized) {
store.dispatch({ type:AUTH_USER });
}
renderDOM();
})
.catch(() => {
localStorage.removeItem(TOKEN_KEY);
store.dispatch({ type:UNAUTH_USER });
renderDOM();
});
} else {
renderDOM();
}
function renderDOM() {
ReactDOM.render(
<Provider store={ store }>
<Router history={browserHistory}>
<Route path="/" component={App}></Route>
<Route path="/mypolls" component={requireAuth(App)}></Route>
<Route path="/create-poll" component={requireAuth(CreatePoll)}></Route>
<Route path="/poll/:pollId" component={PollById}></Route>
<Route path="/edit/poll/:pollId" component={requireAuth(CreatePoll)}></Route>
</Router>
</Provider>
, document.querySelector('.app'));
}
|
var AWS = require('../core');
AWS.Route53 = AWS.Service.defineService('route53', ['2012-12-12'], {
/**
* @api private
*/
setupRequestListeners: function setupRequestListeners(request) {
request.on('build', this.sanitizeUrl);
},
/**
* @api private
*/
sanitizeUrl: function sanitizeUrl(request) {
var path = request.httpRequest.path;
request.httpRequest.path = path.replace(/\/%2F\w+%2F/, '/');
},
/**
* @api private
*/
setEndpoint: function setEndpoint(endpoint) {
if (endpoint) {
AWS.Service.prototype.setEndpoint(endpoint);
} else {
var opts = {sslEnabled: true}; // SSL is always enabled for Route53
this.endpoint = new AWS.Endpoint(this.api.globalEndpoint, opts);
}
}
});
module.exports = AWS.Route53;
|
!function(t){t.fn.datetimepicker.dates.th={days:["อาทิตย์","จันทร์","อังคาร","พุธ","พฤหัส","ศุกร์","เสาร์","อาทิตย์"],daysShort:["อา","จ","อ","พ","พฤ","ศ","ส","อา"],daysMin:["อา","จ","อ","พ","พฤ","ศ","ส","อา"],months:["มกราคม","กุมภาพันธ์","มีนาคม","เมษายน","พฤษภาคม","มิถุนายน","กรกฎาคม","สิงหาคม","กันยายน","ตุลาคม","พฤศจิกายน","ธันวาคม"],monthsShort:["ม.ค.","ก.พ.","มี.ค.","เม.ย.","พ.ค.","มิ.ย.","ก.ค.","ส.ค.","ก.ย.","ต.ค.","พ.ย.","ธ.ค."],today:"วันนี้",suffix:[],meridiem:[]}}(jQuery); |
import test from 'ava'
import {comparePolygons} from './helpers/asserts'
test('comparePolygons on same single vertex', t => {
let a = {vertices: [{_x: 0, _y: 0, _z: 0}]}
t.true(comparePolygons(a, a))
})
test('comparePolygons on different vertices', t => {
let a = {vertices: [{_x: 0, _y: 0, _z: 0}]}, b = {vertices: [{_x: 1, _y: 1, _z: 1}]}
t.false(comparePolygons(a, b))
})
test('comparePolygons on same polygon', t => {
let a = {vertices: [
{_x: 0, _y: 0, _z: 0},
{_x: 1, _y: 1, _z: 1},
{_x: -1, _y: 1, _z: 1}
]}
t.true(comparePolygons(a, a))
})
test('comparePolygons on same polygon with different vertice order', t => {
let a = {vertices: [
{_x: 0, _y: 0, _z: 0},
{_x: 1, _y: 1, _z: 1},
{_x: -1, _y: 1, _z: 1}
]},
b = {vertices: [
{_x: -1, _y: 1, _z: 1},
{_x: 0, _y: 0, _z: 0},
{_x: 1, _y: 1, _z: 1}
]}
t.true(comparePolygons(a, b))
})
test('comparePolygons on different polygon with same vertice', t => {
let a = {vertices: [
{_x: 0, _y: 0, _z: 0},
{_x: 1, _y: 1, _z: 1},
{_x: -1, _y: 1, _z: 1}
]},
b = {vertices: [
{_x: 0, _y: 0, _z: 0},
{_x: -1, _y: 1, _z: 1},
{_x: 1, _y: 1, _z: 1}
]}
t.false(comparePolygons(a, b))
})
|
var expect = require("expect.js");
var JsonDB = require("../JsonDB.js");
var DatabaseError = require("../lib/Errors").DatabaseError;
var DataError = require("../lib/Errors").DataError;
var fs = require('fs');
var testFile1 = "test/test_file1";
var testFile2 = "test/dirCreation/test_file2";
var faulty = "test/faulty.json";
var testFile3 = "test/test_file3";
var testFile4 = "test/array_file";
var testFile5 = "test/test_file_empty";
var testFile6 = "test/test_delete";
describe('JsonDB', function () {
describe('Exception/Error', function () {
it('should create create a DataError', function () {
var error = new DataError("Test", 5);
expect(error).to.have.property("message", "Test");
expect(error).to.have.property("id", 5);
expect(error).to.have.property("inner");
expect(error.toString()).to.eql("DataError: Test");
})
it('should create create a DatabaseError', function () {
var nested = new Error("don't work");
var error = new DatabaseError("Test", 5, nested);
expect(error).to.have.property("message", "Test");
expect(error).to.have.property("id", 5);
expect(error).to.have.property("inner", nested);
expect(error.toString()).to.eql("DatabaseError: Test:\nError: don't work");
})
});
describe('Initialisation', function () {
var db = new JsonDB(testFile1, true, true);
it('should create the JSON File', function (done) {
fs.exists(testFile1 + ".json", function (exists) {
expect(exists).to.be.ok();
done();
});
})
it('should create the JSON File when called directly', function (done) {
var jsondb = new JsonDB(testFile5, true, false);
fs.exists(testFile5 + ".json", function (exists) {
expect(exists).to.be.ok();
done();
});
})
it('should set en empty root', function () {
expect(JSON.stringify(db.getData("/"))).to.eql("{}");
})
it('should return a DatabaseError when loading faulty file', function () {
db = new JsonDB(faulty, true);
expect(function (args) {
db.getData(args);
}).withArgs("/").to.throwException(function (e) {
expect(e).to.be.a(DatabaseError);
});
})
it('should return a DatabaseError when saving without successful loading.', function () {
expect(db.save).to.throwException(function (e) {
expect(e).to.be.a(DatabaseError);
});
})
})
describe('Data Management', function () {
var db = new JsonDB(testFile2, true);
it('should store the data at the root', function () {
var object = {test: {test: "test"}};
db.push("/", object);
expect(db.getData("/")).to.be(object);
})
it('should override the data at the root', function () {
var object = {test: "test"};
db.push("/", object);
expect(db.getData("/")).to.be(object);
})
it('should merge the data at the root', function () {
var object = {test: {test: ['Okay']}};
db.push("/", object);
var data = db.getData("/");
expect(data).to.be(object);
object = {test: {test: ['Perfect'], okay: "test"}}
db.push("/", object, false);
expect(JSON.stringify(db.getData("/"))).to.eql('{\"test\":{\"test\":[\"Okay\",\"Perfect\"],\"okay\":\"test\"}}');
})
it('should return right data for datapath', function () {
db = new JsonDB(testFile2, true);
expect(JSON.stringify(db.getData("/test"))).to.eql('{\"test\":[\"Okay\",\"Perfect\"],\"okay\":\"test\"}');
})
it('should override only the data at datapath', function () {
var object = ['overriden'];
db.push("/test/test", object);
expect(db.getData("/test/test")).to.be(object);
})
it('should remove trailing Slash when pushing/getting data (/)', function () {
var object = {test: {test: "test"}};
db.push("/testing/", object);
expect(db.getData("/testing")).to.be(object);
})
it('should remove trailing Slash when deleting data (/)', function () {
db.delete("/testing/");
expect(function (args) {
db.getData(args);
}).withArgs("/testing/").to.throwException(function (e) {
expect(e).to.be.a(DataError);
});
})
it('should merge the data at datapath', function () {
var object = ['test2'];
db.push("/test/test", object, false);
expect(JSON.stringify(db.getData("/test/test"))).to.eql('[\"overriden\",\"test2\"]');
})
it('should create the tree to reach datapath', function () {
var object = ['test2'];
db.push("/my/tree/is/awesome", object, false);
expect(JSON.stringify(db.getData("/my/tree/is/awesome"))).to.eql('[\"test2\"]');
})
it('should throw an Error when merging Object with Array', function () {
expect(function (path, data, override) {
db.push(path, data, override);
}).withArgs("/test/test", {myTest: "test"}, false).to.throwException(function (e) {
expect(e).to.be.a(DataError);
});
})
it('should throw an Error when merging Array with Object', function () {
expect(function (path, data, override) {
db.push(path, data, override);
}).withArgs("/test", ['test'], false).to.throwException(function (e) {
expect(e).to.be.a(DataError);
});
})
it('should throw an Error when asking for empty datapath', function () {
expect(function (args) {
db.getData(args);
}).withArgs("").to.throwException(function (e) {
expect(e).to.be.a(DataError);
});
})
it('should delete the data', function () {
db.delete("/test/test");
expect(function (args) {
db.getData(args);
}).withArgs("/test/test").to.throwException(function (e) {
expect(e).to.be.a(DataError);
});
})
it('should reload the file', function () {
var data = JSON.stringify({test: "Okay", perfect: 1});
fs.writeFileSync(testFile2 + ".json", data, 'utf8');
db.reload();
expect(db.getData("/test")).to.be("Okay");
expect(db.getData("/perfect")).to.be(1);
})
});
describe('Human Readable', function () {
var db = new JsonDB(testFile3, true, true);
it('should save the data in an human readable format', function (done) {
var object = {test: {readable: "test"}};
db.push("/", object);
fs.readFile(testFile3 + ".json", "utf8", function (err, data) {
if (err) {
done(err);
return;
}
expect(data).to.be(JSON.stringify(object, null, 4));
done();
});
})
});
describe('Array Support', function () {
var db = new JsonDB(testFile4, true);
it('should create an array with a string at index 0', function () {
db.push('/arraytest/myarray[0]', "test", true);
var myarray = db.getData('/arraytest/myarray');
expect(myarray).to.be.an('array');
expect(myarray[0]).to.be('test');
});
it('should throw an Error when using an array with a string at index TEST', function () {
expect(function (args) {
db.push('/arraytest/myarray[TEST]', "works", true);
}).withArgs("/arraytest/arrayTesting[1]").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 200);
});
});
it('should add an object at index 1', function () {
var obj = {property: "perfect"};
db.push('/arraytest/myarray[1]', obj, true);
var myarray = db.getData('/arraytest/myarray');
expect(myarray).to.be.an('array');
expect(myarray[1]).to.be(obj);
});
it('should create a nested array with an object at index 0', function () {
var data = {test: "works"};
db.push('/arraytest/nested[0]/obj', data, true);
var obj = db.getData('/arraytest/nested[0]');
expect(obj).to.be.an('object');
expect(obj).to.have.property('obj', data);
});
it('should access the object at index 1', function () {
var obj = db.getData('/arraytest/myarray[1]');
expect(obj).to.be.an('object');
expect(obj).to.have.property('property', 'perfect');
});
it('should access the object property at index 1', function () {
var property = db.getData('/arraytest/myarray[1]/property');
expect(property).to.be.a('string');
expect(property).to.be('perfect');
});
it('should throw an error when accessing non-present index', function () {
var obj = {property: "perfect"};
db.push('/arraytest/arrayTesting[0]', obj, true);
expect(function (args) {
db.getData(args);
}).withArgs("/arraytest/arrayTesting[1]").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 10);
});
});
it('should delete the object at index 1', function () {
db.delete('/arraytest/myarray[1]');
expect(function (args) {
db.getData(args);
}).withArgs("/arraytest/myarray[1]").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 10);
});
});
it('should throw an error when deleting non-present index', function () {
expect(function (args) {
db.delete(args);
}).withArgs("/arraytest/myarray[10]").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 10);
});
});
it('should throw an error when trying to set an object as an array', function () {
db.push('/arraytest/fakearray', {fake: "fake"}, true);
expect(function (args) {
db.push(args, {test: 'test'}, true);
}).withArgs("/arraytest/fakearray[1]").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 11);
});
});
it('should throw an error when trying to access an object as an array', function () {
db.push('/arraytest/fakearray', {fake: "fake"}, true);
expect(function (args) {
db.getData(args);
}).withArgs("/arraytest/fakearray[1]").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 11);
});
});
it('should throw an error when trying to set an object as an array (2)', function () {
db.push('/arraytest/fakearray', {fake: "fake"}, true);
expect(function (args) {
db.push(args, {test: 'test'}, true);
}).withArgs("/arraytest/fakearray[1]/fake").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 11);
});
});
it('should merge nested arrays', function () {
db.push('/merging/array[0]', ['test']);
db.push('/merging/array[0]', ['secondTest'], false);
var data = db.getData('/merging/array[0]');
expect(data).to.be.an('array');
expect(data).to.contain('test');
expect(data).to.contain('secondTest');
});
it('should remove the index of an array, not set it to null', function () {
db.push('/deleteTest/array[0]', 'test');
db.push('/deleteTest/array[1]', 'test2');
db.delete('/deleteTest/array[1]');
db.save(true);
var json = JSON.parse(fs.readFileSync(testFile4+'.json'));
expect(json.deleteTest).to.be.an('object');
expect(json.deleteTest.array).to.be.an('array');
expect(json.deleteTest.array[0]).to.be('test');
expect(json.deleteTest.array[1]).to.be(undefined);
});
it('should append a value to the existing array', function () {
db.push('/arraytest/appendArray', [0], true);
db.push('/arraytest/appendArray[]', 1, true);
var array = db.getData('/arraytest/appendArray');
expect(array).to.be.an('array');
var index1 = db.getData('/arraytest/appendArray[1]');
expect(index1).to.be(1);
});
it('should throw an error when deleting a append command', function () {
expect(function (args) {
db.delete(args);
}).withArgs("/arraytest/appendArray[]").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 10);
});
});
it('should append a value to the existing array and create property', function () {
db.push('/arraytest/appendArray2', [0], true);
db.push('/arraytest/appendArray2[]/test', 1, true);
var array = db.getData('/arraytest/appendArray2');
expect(array).to.be.an('array');
var index1 = db.getData('/arraytest/appendArray2[1]/test');
expect(index1).to.be(1);
});
it('should throw an error when trying to append to a non array', function () {
db.push('/arraytest/fakearray', {fake: "fake"}, true);
expect(function (args) {
db.push(args, {test: 'test'}, true);
}).withArgs("/arraytest/fakearray[]/fake").to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 11);
});
});
describe('last item', function () {
it('should throw an exception when array is empty when using -1', function () {
db.push('/arraylast/myarrayempty', [], true);
expect(function (args) {
db.getData(args);
}).withArgs('/arraylast/myarrayempty[-1]').to.throwException(function (e) {
expect(e).to.be.a(DataError);
expect(e).to.have.property('id', 10);
});
});
it('should set the fist item when using -1 on empty array', function () {
db.push('/arraylast/emptyArray', [], true);
db.push('/arraylast/emptyArray[-1]', 3);
var lastItem = db.getData('/arraylast/emptyArray[0]');
expect(lastItem).to.be(3);
});
it('should return the last key when using -1', function () {
db.push('/arraylast/myarray', [1, 2, 3], true);
var lastItem = db.getData('/arraylast/myarray[-1]');
expect(lastItem).to.be(3);
});
it('should replace the last item when using -1', function () {
db.push('/arraylast/a1', [1, 2, 3], true);
db.push('/arraylast/a1[-1]', 5);
var lastItem = db.getData('/arraylast/a1[-1]');
expect(lastItem).to.be(5);
});
it('should delete the last item when using -1', function () {
db.push('/arraylast/a2', [1, 2, 3], true);
db.delete('/arraylast/a2[-1]');
var lastItem = db.getData('/arraylast/a2[-1]');
expect(lastItem).to.be(2);
});
});
});
describe('Delete Info', function(){
var db = new JsonDB(testFile6, true);
it('should delete the data and save the file if saveOnPush is set', function (done) {
var object = {test: {readable: "test"}};
db.push("/", object);
fs.readFile(testFile6 + ".json", "utf8", function (err, data) {
if (err) {
done(err);
return;
}
expect(data).to.be(JSON.stringify(object));
db.delete('/test');
fs.readFile(testFile6 + ".json", "utf8", function (err, data) {
if (err) {
done(err);
return;
}
expect(data).to.be(JSON.stringify({}));
done();
});
});
});
});
describe('Cleanup', function () {
it('should remove the test files', function () {
fs.unlinkSync(testFile1 + ".json");
fs.unlinkSync(testFile2 + ".json");
fs.unlinkSync(testFile3 + ".json");
fs.unlinkSync(testFile4 + ".json");
fs.unlinkSync(testFile5 + ".json");
fs.unlinkSync(testFile6 + ".json");
fs.rmdirSync("test/dirCreation");
});
});
}); |
/*!
* Bootstrap v3.2.0 (http://getbootstrap.com)
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
*/
/*!
* Generated using the Bootstrap Customizer (http://getbootstrap.com/customize/?id=cac3ae4c7dbc1bbac143)
* Config saved to config.json and https://gist.github.com/cac3ae4c7dbc1bbac143
*/
if (typeof jQuery === "undefined") { throw new Error("Bootstrap's JavaScript requires jQuery") }
/* ========================================================================
* Bootstrap: alert.js v3.2.0
* http://getbootstrap.com/javascript/#alerts
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// ALERT CLASS DEFINITION
// ======================
var dismiss = '[data-dismiss="alert"]'
var Alert = function (el) {
$(el).on('click', dismiss, this.close)
}
Alert.VERSION = '3.2.0'
Alert.prototype.close = function (e) {
var $this = $(this)
var selector = $this.attr('data-target')
if (!selector) {
selector = $this.attr('href')
selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
}
var $parent = $(selector)
if (e) e.preventDefault()
if (!$parent.length) {
$parent = $this.hasClass('alert') ? $this : $this.parent()
}
$parent.trigger(e = $.Event('close.bs.alert'))
if (e.isDefaultPrevented()) return
$parent.removeClass('in')
function removeElement() {
// detach from parent, fire event then clean up data
$parent.detach().trigger('closed.bs.alert').remove()
}
$.support.transition && $parent.hasClass('fade') ?
$parent
.one('bsTransitionEnd', removeElement)
.emulateTransitionEnd(150) :
removeElement()
}
// ALERT PLUGIN DEFINITION
// =======================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.alert')
if (!data) $this.data('bs.alert', (data = new Alert(this)))
if (typeof option == 'string') data[option].call($this)
})
}
var old = $.fn.alert
$.fn.alert = Plugin
$.fn.alert.Constructor = Alert
// ALERT NO CONFLICT
// =================
$.fn.alert.noConflict = function () {
$.fn.alert = old
return this
}
// ALERT DATA-API
// ==============
$(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)
}(jQuery);
/* ========================================================================
* Bootstrap: button.js v3.2.0
* http://getbootstrap.com/javascript/#buttons
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// BUTTON PUBLIC CLASS DEFINITION
// ==============================
var Button = function (element, options) {
this.$element = $(element)
this.options = $.extend({}, Button.DEFAULTS, options)
this.isLoading = false
}
Button.VERSION = '3.2.0'
Button.DEFAULTS = {
loadingText: 'loading...'
}
Button.prototype.setState = function (state) {
var d = 'disabled'
var $el = this.$element
var val = $el.is('input') ? 'val' : 'html'
var data = $el.data()
state = state + 'Text'
if (data.resetText == null) $el.data('resetText', $el[val]())
$el[val](data[state] == null ? this.options[state] : data[state])
// push to event loop to allow forms to submit
setTimeout($.proxy(function () {
if (state == 'loadingText') {
this.isLoading = true
$el.addClass(d).attr(d, d)
} else if (this.isLoading) {
this.isLoading = false
$el.removeClass(d).removeAttr(d)
}
}, this), 0)
}
Button.prototype.toggle = function () {
var changed = true
var $parent = this.$element.closest('[data-toggle="buttons"]')
if ($parent.length) {
var $input = this.$element.find('input')
if ($input.prop('type') == 'radio') {
if ($input.prop('checked') && this.$element.hasClass('active')) changed = false
else $parent.find('.active').removeClass('active')
}
if (changed) $input.prop('checked', !this.$element.hasClass('active')).trigger('change')
}
if (changed) this.$element.toggleClass('active')
}
// BUTTON PLUGIN DEFINITION
// ========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.button')
var options = typeof option == 'object' && option
if (!data) $this.data('bs.button', (data = new Button(this, options)))
if (option == 'toggle') data.toggle()
else if (option) data.setState(option)
})
}
var old = $.fn.button
$.fn.button = Plugin
$.fn.button.Constructor = Button
// BUTTON NO CONFLICT
// ==================
$.fn.button.noConflict = function () {
$.fn.button = old
return this
}
// BUTTON DATA-API
// ===============
$(document).on('click.bs.button.data-api', '[data-toggle^="button"]', function (e) {
var $btn = $(e.target)
if (!$btn.hasClass('btn')) $btn = $btn.closest('.btn')
Plugin.call($btn, 'toggle')
e.preventDefault()
})
}(jQuery);
/* ========================================================================
* Bootstrap: dropdown.js v3.2.0
* http://getbootstrap.com/javascript/#dropdowns
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// DROPDOWN CLASS DEFINITION
// =========================
var backdrop = '.dropdown-backdrop'
var toggle = '[data-toggle="dropdown"]'
var Dropdown = function (element) {
$(element).on('click.bs.dropdown', this.toggle)
}
Dropdown.VERSION = '3.2.0'
Dropdown.prototype.toggle = function (e) {
var $this = $(this)
if ($this.is('.disabled, :disabled')) return
var $parent = getParent($this)
var isActive = $parent.hasClass('open')
clearMenus()
if (!isActive) {
if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
// if mobile we use a backdrop because click events don't delegate
$('<div class="dropdown-backdrop"/>').insertAfter($(this)).on('click', clearMenus)
}
var relatedTarget = { relatedTarget: this }
$parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))
if (e.isDefaultPrevented()) return
$this.trigger('focus')
$parent
.toggleClass('open')
.trigger('shown.bs.dropdown', relatedTarget)
}
return false
}
Dropdown.prototype.keydown = function (e) {
if (!/(38|40|27)/.test(e.keyCode)) return
var $this = $(this)
e.preventDefault()
e.stopPropagation()
if ($this.is('.disabled, :disabled')) return
var $parent = getParent($this)
var isActive = $parent.hasClass('open')
if (!isActive || (isActive && e.keyCode == 27)) {
if (e.which == 27) $parent.find(toggle).trigger('focus')
return $this.trigger('click')
}
var desc = ' li:not(.divider):visible a'
var $items = $parent.find('[role="menu"]' + desc + ', [role="listbox"]' + desc)
if (!$items.length) return
var index = $items.index($items.filter(':focus'))
if (e.keyCode == 38 && index > 0) index-- // up
if (e.keyCode == 40 && index < $items.length - 1) index++ // down
if (!~index) index = 0
$items.eq(index).trigger('focus')
}
function clearMenus(e) {
if (e && e.which === 3) return
$(backdrop).remove()
$(toggle).each(function () {
var $parent = getParent($(this))
var relatedTarget = { relatedTarget: this }
if (!$parent.hasClass('open')) return
$parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))
if (e.isDefaultPrevented()) return
$parent.removeClass('open').trigger('hidden.bs.dropdown', relatedTarget)
})
}
function getParent($this) {
var selector = $this.attr('data-target')
if (!selector) {
selector = $this.attr('href')
selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
}
var $parent = selector && $(selector)
return $parent && $parent.length ? $parent : $this.parent()
}
// DROPDOWN PLUGIN DEFINITION
// ==========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.dropdown')
if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))
if (typeof option == 'string') data[option].call($this)
})
}
var old = $.fn.dropdown
$.fn.dropdown = Plugin
$.fn.dropdown.Constructor = Dropdown
// DROPDOWN NO CONFLICT
// ====================
$.fn.dropdown.noConflict = function () {
$.fn.dropdown = old
return this
}
// APPLY TO STANDARD DROPDOWN ELEMENTS
// ===================================
$(document)
.on('click.bs.dropdown.data-api', clearMenus)
.on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
.on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
.on('keydown.bs.dropdown.data-api', toggle + ', [role="menu"], [role="listbox"]', Dropdown.prototype.keydown)
}(jQuery);
/* ========================================================================
* Bootstrap: modal.js v3.2.0
* http://getbootstrap.com/javascript/#modals
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// MODAL CLASS DEFINITION
// ======================
var Modal = function (element, options) {
this.options = options
this.$body = $(document.body)
this.$element = $(element)
this.$backdrop =
this.isShown = null
this.scrollbarWidth = 0
if (this.options.remote) {
this.$element
.find('.modal-content')
.load(this.options.remote, $.proxy(function () {
this.$element.trigger('loaded.bs.modal')
}, this))
}
}
Modal.VERSION = '3.2.0'
Modal.DEFAULTS = {
backdrop: true,
keyboard: true,
show: true
}
Modal.prototype.toggle = function (_relatedTarget) {
return this.isShown ? this.hide() : this.show(_relatedTarget)
}
Modal.prototype.show = function (_relatedTarget) {
var that = this
var e = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
this.$element.trigger(e)
if (this.isShown || e.isDefaultPrevented()) return
this.isShown = true
this.checkScrollbar()
this.$body.addClass('modal-open')
this.setScrollbar()
this.escape()
this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
this.backdrop(function () {
var transition = $.support.transition && that.$element.hasClass('fade')
if (!that.$element.parent().length) {
that.$element.appendTo(that.$body) // don't move modals dom position
}
that.$element
.show()
.scrollTop(0)
if (transition) {
that.$element[0].offsetWidth // force reflow
}
that.$element
.addClass('in')
.attr('aria-hidden', false)
that.enforceFocus()
var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
transition ?
that.$element.find('.modal-dialog') // wait for modal to slide in
.one('bsTransitionEnd', function () {
that.$element.trigger('focus').trigger(e)
})
.emulateTransitionEnd(300) :
that.$element.trigger('focus').trigger(e)
})
}
Modal.prototype.hide = function (e) {
if (e) e.preventDefault()
e = $.Event('hide.bs.modal')
this.$element.trigger(e)
if (!this.isShown || e.isDefaultPrevented()) return
this.isShown = false
this.$body.removeClass('modal-open')
this.resetScrollbar()
this.escape()
$(document).off('focusin.bs.modal')
this.$element
.removeClass('in')
.attr('aria-hidden', true)
.off('click.dismiss.bs.modal')
$.support.transition && this.$element.hasClass('fade') ?
this.$element
.one('bsTransitionEnd', $.proxy(this.hideModal, this))
.emulateTransitionEnd(300) :
this.hideModal()
}
Modal.prototype.enforceFocus = function () {
$(document)
.off('focusin.bs.modal') // guard against infinite focus loop
.on('focusin.bs.modal', $.proxy(function (e) {
if (this.$element[0] !== e.target && !this.$element.has(e.target).length) {
this.$element.trigger('focus')
}
}, this))
}
Modal.prototype.escape = function () {
if (this.isShown && this.options.keyboard) {
this.$element.on('keyup.dismiss.bs.modal', $.proxy(function (e) {
e.which == 27 && this.hide()
}, this))
} else if (!this.isShown) {
this.$element.off('keyup.dismiss.bs.modal')
}
}
Modal.prototype.hideModal = function () {
var that = this
this.$element.hide()
this.backdrop(function () {
that.$element.trigger('hidden.bs.modal')
})
}
Modal.prototype.removeBackdrop = function () {
this.$backdrop && this.$backdrop.remove()
this.$backdrop = null
}
Modal.prototype.backdrop = function (callback) {
var that = this
var animate = this.$element.hasClass('fade') ? 'fade' : ''
if (this.isShown && this.options.backdrop) {
var doAnimate = $.support.transition && animate
this.$backdrop = $('<div class="modal-backdrop ' + animate + '" />')
.appendTo(this.$body)
this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
if (e.target !== e.currentTarget) return
this.options.backdrop == 'static'
? this.$element[0].focus.call(this.$element[0])
: this.hide.call(this)
}, this))
if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
this.$backdrop.addClass('in')
if (!callback) return
doAnimate ?
this.$backdrop
.one('bsTransitionEnd', callback)
.emulateTransitionEnd(150) :
callback()
} else if (!this.isShown && this.$backdrop) {
this.$backdrop.removeClass('in')
var callbackRemove = function () {
that.removeBackdrop()
callback && callback()
}
$.support.transition && this.$element.hasClass('fade') ?
this.$backdrop
.one('bsTransitionEnd', callbackRemove)
.emulateTransitionEnd(150) :
callbackRemove()
} else if (callback) {
callback()
}
}
Modal.prototype.checkScrollbar = function () {
if (document.body.clientWidth >= window.innerWidth) return
this.scrollbarWidth = this.scrollbarWidth || this.measureScrollbar()
}
Modal.prototype.setScrollbar = function () {
var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
if (this.scrollbarWidth) this.$body.css('padding-right', bodyPad + this.scrollbarWidth)
}
Modal.prototype.resetScrollbar = function () {
this.$body.css('padding-right', '')
}
Modal.prototype.measureScrollbar = function () { // thx walsh
var scrollDiv = document.createElement('div')
scrollDiv.className = 'modal-scrollbar-measure'
this.$body.append(scrollDiv)
var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
this.$body[0].removeChild(scrollDiv)
return scrollbarWidth
}
// MODAL PLUGIN DEFINITION
// =======================
function Plugin(option, _relatedTarget) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.modal')
var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
if (typeof option == 'string') data[option](_relatedTarget)
else if (options.show) data.show(_relatedTarget)
})
}
var old = $.fn.modal
$.fn.modal = Plugin
$.fn.modal.Constructor = Modal
// MODAL NO CONFLICT
// =================
$.fn.modal.noConflict = function () {
$.fn.modal = old
return this
}
// MODAL DATA-API
// ==============
$(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
var $this = $(this)
var href = $this.attr('href')
var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) // strip for ie7
var option = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
if ($this.is('a')) e.preventDefault()
$target.one('show.bs.modal', function (showEvent) {
if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown
$target.one('hidden.bs.modal', function () {
$this.is(':visible') && $this.trigger('focus')
})
})
Plugin.call($target, option, this)
})
}(jQuery);
/* ========================================================================
* Bootstrap: tooltip.js v3.2.0
* http://getbootstrap.com/javascript/#tooltip
* Inspired by the original jQuery.tipsy by Jason Frame
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// TOOLTIP PUBLIC CLASS DEFINITION
// ===============================
var Tooltip = function (element, options) {
this.type =
this.options =
this.enabled =
this.timeout =
this.hoverState =
this.$element = null
this.init('tooltip', element, options)
}
Tooltip.VERSION = '3.2.0'
Tooltip.DEFAULTS = {
animation: true,
placement: 'top',
selector: false,
template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
trigger: 'hover focus',
title: '',
delay: 0,
html: false,
container: false,
viewport: {
selector: 'body',
padding: 0
}
}
Tooltip.prototype.init = function (type, element, options) {
this.enabled = true
this.type = type
this.$element = $(element)
this.options = this.getOptions(options)
this.$viewport = this.options.viewport && $(this.options.viewport.selector || this.options.viewport)
var triggers = this.options.trigger.split(' ')
for (var i = triggers.length; i--;) {
var trigger = triggers[i]
if (trigger == 'click') {
this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
} else if (trigger != 'manual') {
var eventIn = trigger == 'hover' ? 'mouseenter' : 'focusin'
var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
this.$element.on(eventIn + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
}
}
this.options.selector ?
(this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
this.fixTitle()
}
Tooltip.prototype.getDefaults = function () {
return Tooltip.DEFAULTS
}
Tooltip.prototype.getOptions = function (options) {
options = $.extend({}, this.getDefaults(), this.$element.data(), options)
if (options.delay && typeof options.delay == 'number') {
options.delay = {
show: options.delay,
hide: options.delay
}
}
return options
}
Tooltip.prototype.getDelegateOptions = function () {
var options = {}
var defaults = this.getDefaults()
this._options && $.each(this._options, function (key, value) {
if (defaults[key] != value) options[key] = value
})
return options
}
Tooltip.prototype.enter = function (obj) {
var self = obj instanceof this.constructor ?
obj : $(obj.currentTarget).data('bs.' + this.type)
if (!self) {
self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
$(obj.currentTarget).data('bs.' + this.type, self)
}
clearTimeout(self.timeout)
self.hoverState = 'in'
if (!self.options.delay || !self.options.delay.show) return self.show()
self.timeout = setTimeout(function () {
if (self.hoverState == 'in') self.show()
}, self.options.delay.show)
}
Tooltip.prototype.leave = function (obj) {
var self = obj instanceof this.constructor ?
obj : $(obj.currentTarget).data('bs.' + this.type)
if (!self) {
self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
$(obj.currentTarget).data('bs.' + this.type, self)
}
clearTimeout(self.timeout)
self.hoverState = 'out'
if (!self.options.delay || !self.options.delay.hide) return self.hide()
self.timeout = setTimeout(function () {
if (self.hoverState == 'out') self.hide()
}, self.options.delay.hide)
}
Tooltip.prototype.show = function () {
var e = $.Event('show.bs.' + this.type)
if (this.hasContent() && this.enabled) {
this.$element.trigger(e)
var inDom = $.contains(document.documentElement, this.$element[0])
if (e.isDefaultPrevented() || !inDom) return
var that = this
var $tip = this.tip()
var tipId = this.getUID(this.type)
this.setContent()
$tip.attr('id', tipId)
this.$element.attr('aria-describedby', tipId)
if (this.options.animation) $tip.addClass('fade')
var placement = typeof this.options.placement == 'function' ?
this.options.placement.call(this, $tip[0], this.$element[0]) :
this.options.placement
var autoToken = /\s?auto?\s?/i
var autoPlace = autoToken.test(placement)
if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
$tip
.detach()
.css({ top: 0, left: 0, display: 'block' })
.addClass(placement)
.data('bs.' + this.type, this)
this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
var pos = this.getPosition()
var actualWidth = $tip[0].offsetWidth
var actualHeight = $tip[0].offsetHeight
if (autoPlace) {
var orgPlacement = placement
var $parent = this.$element.parent()
var parentDim = this.getPosition($parent)
placement = placement == 'bottom' && pos.top + pos.height + actualHeight - parentDim.scroll > parentDim.height ? 'top' :
placement == 'top' && pos.top - parentDim.scroll - actualHeight < 0 ? 'bottom' :
placement == 'right' && pos.right + actualWidth > parentDim.width ? 'left' :
placement == 'left' && pos.left - actualWidth < parentDim.left ? 'right' :
placement
$tip
.removeClass(orgPlacement)
.addClass(placement)
}
var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
this.applyPlacement(calculatedOffset, placement)
var complete = function () {
that.$element.trigger('shown.bs.' + that.type)
that.hoverState = null
}
$.support.transition && this.$tip.hasClass('fade') ?
$tip
.one('bsTransitionEnd', complete)
.emulateTransitionEnd(150) :
complete()
}
}
Tooltip.prototype.applyPlacement = function (offset, placement) {
var $tip = this.tip()
var width = $tip[0].offsetWidth
var height = $tip[0].offsetHeight
// manually read margins because getBoundingClientRect includes difference
var marginTop = parseInt($tip.css('margin-top'), 10)
var marginLeft = parseInt($tip.css('margin-left'), 10)
// we must check for NaN for ie 8/9
if (isNaN(marginTop)) marginTop = 0
if (isNaN(marginLeft)) marginLeft = 0
offset.top = offset.top + marginTop
offset.left = offset.left + marginLeft
// $.fn.offset doesn't round pixel values
// so we use setOffset directly with our own function B-0
$.offset.setOffset($tip[0], $.extend({
using: function (props) {
$tip.css({
top: Math.round(props.top),
left: Math.round(props.left)
})
}
}, offset), 0)
$tip.addClass('in')
// check to see if placing tip in new offset caused the tip to resize itself
var actualWidth = $tip[0].offsetWidth
var actualHeight = $tip[0].offsetHeight
if (placement == 'top' && actualHeight != height) {
offset.top = offset.top + height - actualHeight
}
var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)
if (delta.left) offset.left += delta.left
else offset.top += delta.top
var arrowDelta = delta.left ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
var arrowPosition = delta.left ? 'left' : 'top'
var arrowOffsetPosition = delta.left ? 'offsetWidth' : 'offsetHeight'
$tip.offset(offset)
this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], arrowPosition)
}
Tooltip.prototype.replaceArrow = function (delta, dimension, position) {
this.arrow().css(position, delta ? (50 * (1 - delta / dimension) + '%') : '')
}
Tooltip.prototype.setContent = function () {
var $tip = this.tip()
var title = this.getTitle()
$tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
$tip.removeClass('fade in top bottom left right')
}
Tooltip.prototype.hide = function () {
var that = this
var $tip = this.tip()
var e = $.Event('hide.bs.' + this.type)
this.$element.removeAttr('aria-describedby')
function complete() {
if (that.hoverState != 'in') $tip.detach()
that.$element.trigger('hidden.bs.' + that.type)
}
this.$element.trigger(e)
if (e.isDefaultPrevented()) return
$tip.removeClass('in')
$.support.transition && this.$tip.hasClass('fade') ?
$tip
.one('bsTransitionEnd', complete)
.emulateTransitionEnd(150) :
complete()
this.hoverState = null
return this
}
Tooltip.prototype.fixTitle = function () {
var $e = this.$element
if ($e.attr('title') || typeof ($e.attr('data-original-title')) != 'string') {
$e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
}
}
Tooltip.prototype.hasContent = function () {
return this.getTitle()
}
Tooltip.prototype.getPosition = function ($element) {
$element = $element || this.$element
var el = $element[0]
var isBody = el.tagName == 'BODY'
return $.extend({}, (typeof el.getBoundingClientRect == 'function') ? el.getBoundingClientRect() : null, {
scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop(),
width: isBody ? $(window).width() : $element.outerWidth(),
height: isBody ? $(window).height() : $element.outerHeight()
}, isBody ? { top: 0, left: 0 } : $element.offset())
}
Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
return placement == 'bottom' ? { top: pos.top + pos.height, left: pos.left + pos.width / 2 - actualWidth / 2 } :
placement == 'top' ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } :
placement == 'left' ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
/* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }
}
Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
var delta = { top: 0, left: 0 }
if (!this.$viewport) return delta
var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
var viewportDimensions = this.getPosition(this.$viewport)
if (/right|left/.test(placement)) {
var topEdgeOffset = pos.top - viewportPadding - viewportDimensions.scroll
var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight
if (topEdgeOffset < viewportDimensions.top) { // top overflow
delta.top = viewportDimensions.top - topEdgeOffset
} else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow
delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset
}
} else {
var leftEdgeOffset = pos.left - viewportPadding
var rightEdgeOffset = pos.left + viewportPadding + actualWidth
if (leftEdgeOffset < viewportDimensions.left) { // left overflow
delta.left = viewportDimensions.left - leftEdgeOffset
} else if (rightEdgeOffset > viewportDimensions.width) { // right overflow
delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset
}
}
return delta
}
Tooltip.prototype.getTitle = function () {
var title
var $e = this.$element
var o = this.options
title = $e.attr('data-original-title')
|| (typeof o.title == 'function' ? o.title.call($e[0]) : o.title)
return title
}
Tooltip.prototype.getUID = function (prefix) {
do prefix += ~~(Math.random() * 1000000)
while (document.getElementById(prefix))
return prefix
}
Tooltip.prototype.tip = function () {
return (this.$tip = this.$tip || $(this.options.template))
}
Tooltip.prototype.arrow = function () {
return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
}
Tooltip.prototype.validate = function () {
if (!this.$element[0].parentNode) {
this.hide()
this.$element = null
this.options = null
}
}
Tooltip.prototype.enable = function () {
this.enabled = true
}
Tooltip.prototype.disable = function () {
this.enabled = false
}
Tooltip.prototype.toggleEnabled = function () {
this.enabled = !this.enabled
}
Tooltip.prototype.toggle = function (e) {
var self = this
if (e) {
self = $(e.currentTarget).data('bs.' + this.type)
if (!self) {
self = new this.constructor(e.currentTarget, this.getDelegateOptions())
$(e.currentTarget).data('bs.' + this.type, self)
}
}
self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
}
Tooltip.prototype.destroy = function () {
clearTimeout(this.timeout)
this.hide().$element.off('.' + this.type).removeData('bs.' + this.type)
}
// TOOLTIP PLUGIN DEFINITION
// =========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.tooltip')
var options = typeof option == 'object' && option
if (!data && option == 'destroy') return
if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.tooltip
$.fn.tooltip = Plugin
$.fn.tooltip.Constructor = Tooltip
// TOOLTIP NO CONFLICT
// ===================
$.fn.tooltip.noConflict = function () {
$.fn.tooltip = old
return this
}
}(jQuery);
/* ========================================================================
* Bootstrap: popover.js v3.2.0
* http://getbootstrap.com/javascript/#popovers
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// POPOVER PUBLIC CLASS DEFINITION
// ===============================
var Popover = function (element, options) {
this.init('popover', element, options)
}
if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
Popover.VERSION = '3.2.0'
Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
placement: 'right',
trigger: 'click',
content: '',
template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
})
// NOTE: POPOVER EXTENDS tooltip.js
// ================================
Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
Popover.prototype.constructor = Popover
Popover.prototype.getDefaults = function () {
return Popover.DEFAULTS
}
Popover.prototype.setContent = function () {
var $tip = this.tip()
var title = this.getTitle()
var content = this.getContent()
$tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
$tip.find('.popover-content').empty()[ // we use append for html objects to maintain js events
this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'
](content)
$tip.removeClass('fade top bottom left right in')
// IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
// this manually by checking the contents.
if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
}
Popover.prototype.hasContent = function () {
return this.getTitle() || this.getContent()
}
Popover.prototype.getContent = function () {
var $e = this.$element
var o = this.options
return $e.attr('data-content')
|| (typeof o.content == 'function' ?
o.content.call($e[0]) :
o.content)
}
Popover.prototype.arrow = function () {
return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
}
Popover.prototype.tip = function () {
if (!this.$tip) this.$tip = $(this.options.template)
return this.$tip
}
// POPOVER PLUGIN DEFINITION
// =========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.popover')
var options = typeof option == 'object' && option
if (!data && option == 'destroy') return
if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.popover
$.fn.popover = Plugin
$.fn.popover.Constructor = Popover
// POPOVER NO CONFLICT
// ===================
$.fn.popover.noConflict = function () {
$.fn.popover = old
return this
}
}(jQuery);
/* ========================================================================
* Bootstrap: tab.js v3.2.0
* http://getbootstrap.com/javascript/#tabs
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// TAB CLASS DEFINITION
// ====================
var Tab = function (element) {
this.element = $(element)
}
Tab.VERSION = '3.2.0'
Tab.prototype.show = function () {
var $this = this.element
var $ul = $this.closest('ul:not(.dropdown-menu)')
var selector = $this.data('target')
if (!selector) {
selector = $this.attr('href')
selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
}
if ($this.parent('li').hasClass('active')) return
var previous = $ul.find('.active:last a')[0]
var e = $.Event('show.bs.tab', {
relatedTarget: previous
})
$this.trigger(e)
if (e.isDefaultPrevented()) return
var $target = $(selector)
this.activate($this.closest('li'), $ul)
this.activate($target, $target.parent(), function () {
$this.trigger({
type: 'shown.bs.tab',
relatedTarget: previous
})
})
}
Tab.prototype.activate = function (element, container, callback) {
var $active = container.find('> .active')
var transition = callback
&& $.support.transition
&& $active.hasClass('fade')
function next() {
$active
.removeClass('active')
.find('> .dropdown-menu > .active')
.removeClass('active')
element.addClass('active')
if (transition) {
element[0].offsetWidth // reflow for transition
element.addClass('in')
} else {
element.removeClass('fade')
}
if (element.parent('.dropdown-menu')) {
element.closest('li.dropdown').addClass('active')
}
callback && callback()
}
transition ?
$active
.one('bsTransitionEnd', next)
.emulateTransitionEnd(150) :
next()
$active.removeClass('in')
}
// TAB PLUGIN DEFINITION
// =====================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.tab')
if (!data) $this.data('bs.tab', (data = new Tab(this)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.tab
$.fn.tab = Plugin
$.fn.tab.Constructor = Tab
// TAB NO CONFLICT
// ===============
$.fn.tab.noConflict = function () {
$.fn.tab = old
return this
}
// TAB DATA-API
// ============
$(document).on('click.bs.tab.data-api', '[data-toggle="tab"], [data-toggle="pill"]', function (e) {
e.preventDefault()
Plugin.call($(this), 'show')
})
}(jQuery);
/* ========================================================================
* Bootstrap: affix.js v3.2.0
* http://getbootstrap.com/javascript/#affix
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// AFFIX CLASS DEFINITION
// ======================
var Affix = function (element, options) {
this.options = $.extend({}, Affix.DEFAULTS, options)
this.$target = $(this.options.target)
.on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
.on('click.bs.affix.data-api', $.proxy(this.checkPositionWithEventLoop, this))
this.$element = $(element)
this.affixed =
this.unpin =
this.pinnedOffset = null
this.checkPosition()
}
Affix.VERSION = '3.2.0'
Affix.RESET = 'affix affix-top affix-bottom'
Affix.DEFAULTS = {
offset: 0,
target: window
}
Affix.prototype.getPinnedOffset = function () {
if (this.pinnedOffset) return this.pinnedOffset
this.$element.removeClass(Affix.RESET).addClass('affix')
var scrollTop = this.$target.scrollTop()
var position = this.$element.offset()
return (this.pinnedOffset = position.top - scrollTop)
}
Affix.prototype.checkPositionWithEventLoop = function () {
setTimeout($.proxy(this.checkPosition, this), 1)
}
Affix.prototype.checkPosition = function () {
if (!this.$element.is(':visible')) return
var scrollHeight = $(document).height()
var scrollTop = this.$target.scrollTop()
var position = this.$element.offset()
var offset = this.options.offset
var offsetTop = offset.top
var offsetBottom = offset.bottom
if (typeof offset != 'object') offsetBottom = offsetTop = offset
if (typeof offsetTop == 'function') offsetTop = offset.top(this.$element)
if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)
var affix = this.unpin != null && (scrollTop + this.unpin <= position.top) ? false :
offsetBottom != null && (position.top + this.$element.height() >= scrollHeight - offsetBottom) ? 'bottom' :
offsetTop != null && (scrollTop <= offsetTop) ? 'top' : false
if (this.affixed === affix) return
if (this.unpin != null) this.$element.css('top', '')
var affixType = 'affix' + (affix ? '-' + affix : '')
var e = $.Event(affixType + '.bs.affix')
this.$element.trigger(e)
if (e.isDefaultPrevented()) return
this.affixed = affix
this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null
this.$element
.removeClass(Affix.RESET)
.addClass(affixType)
.trigger($.Event(affixType.replace('affix', 'affixed')))
if (affix == 'bottom') {
this.$element.offset({
top: scrollHeight - this.$element.height() - offsetBottom
})
}
}
// AFFIX PLUGIN DEFINITION
// =======================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.affix')
var options = typeof option == 'object' && option
if (!data) $this.data('bs.affix', (data = new Affix(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.affix
$.fn.affix = Plugin
$.fn.affix.Constructor = Affix
// AFFIX NO CONFLICT
// =================
$.fn.affix.noConflict = function () {
$.fn.affix = old
return this
}
// AFFIX DATA-API
// ==============
$(window).on('load', function () {
$('[data-spy="affix"]').each(function () {
var $spy = $(this)
var data = $spy.data()
data.offset = data.offset || {}
if (data.offsetBottom) data.offset.bottom = data.offsetBottom
if (data.offsetTop) data.offset.top = data.offsetTop
Plugin.call($spy, data)
})
})
}(jQuery);
/* ========================================================================
* Bootstrap: collapse.js v3.2.0
* http://getbootstrap.com/javascript/#collapse
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// COLLAPSE PUBLIC CLASS DEFINITION
// ================================
var Collapse = function (element, options) {
this.$element = $(element)
this.options = $.extend({}, Collapse.DEFAULTS, options)
this.transitioning = null
if (this.options.parent) this.$parent = $(this.options.parent)
if (this.options.toggle) this.toggle()
}
Collapse.VERSION = '3.2.0'
Collapse.DEFAULTS = {
toggle: true
}
Collapse.prototype.dimension = function () {
var hasWidth = this.$element.hasClass('width')
return hasWidth ? 'width' : 'height'
}
Collapse.prototype.show = function () {
if (this.transitioning || this.$element.hasClass('in')) return
var startEvent = $.Event('show.bs.collapse')
this.$element.trigger(startEvent)
if (startEvent.isDefaultPrevented()) return
var actives = this.$parent && this.$parent.find('> .panel > .in')
if (actives && actives.length) {
var hasData = actives.data('bs.collapse')
if (hasData && hasData.transitioning) return
Plugin.call(actives, 'hide')
hasData || actives.data('bs.collapse', null)
}
var dimension = this.dimension()
this.$element
.removeClass('collapse')
.addClass('collapsing')[dimension](0)
this.transitioning = 1
var complete = function () {
this.$element
.removeClass('collapsing')
.addClass('collapse in')[dimension]('')
this.transitioning = 0
this.$element
.trigger('shown.bs.collapse')
}
if (!$.support.transition) return complete.call(this)
var scrollSize = $.camelCase(['scroll', dimension].join('-'))
this.$element
.one('bsTransitionEnd', $.proxy(complete, this))
.emulateTransitionEnd(350)[dimension](this.$element[0][scrollSize])
}
Collapse.prototype.hide = function () {
if (this.transitioning || !this.$element.hasClass('in')) return
var startEvent = $.Event('hide.bs.collapse')
this.$element.trigger(startEvent)
if (startEvent.isDefaultPrevented()) return
var dimension = this.dimension()
this.$element[dimension](this.$element[dimension]())[0].offsetHeight
this.$element
.addClass('collapsing')
.removeClass('collapse')
.removeClass('in')
this.transitioning = 1
var complete = function () {
this.transitioning = 0
this.$element
.trigger('hidden.bs.collapse')
.removeClass('collapsing')
.addClass('collapse')
}
if (!$.support.transition) return complete.call(this)
this.$element
[dimension](0)
.one('bsTransitionEnd', $.proxy(complete, this))
.emulateTransitionEnd(350)
}
Collapse.prototype.toggle = function () {
this[this.$element.hasClass('in') ? 'hide' : 'show']()
}
// COLLAPSE PLUGIN DEFINITION
// ==========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.collapse')
var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
if (!data && options.toggle && option == 'show') option = !option
if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.collapse
$.fn.collapse = Plugin
$.fn.collapse.Constructor = Collapse
// COLLAPSE NO CONFLICT
// ====================
$.fn.collapse.noConflict = function () {
$.fn.collapse = old
return this
}
// COLLAPSE DATA-API
// =================
$(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {
var href
var $this = $(this)
var target = $this.attr('data-target')
|| e.preventDefault()
|| (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
var $target = $(target)
var data = $target.data('bs.collapse')
var option = data ? 'toggle' : $this.data()
var parent = $this.attr('data-parent')
var $parent = parent && $(parent)
if (!data || !data.transitioning) {
if ($parent) $parent.find('[data-toggle="collapse"][data-parent="' + parent + '"]').not($this).addClass('collapsed')
$this[$target.hasClass('in') ? 'addClass' : 'removeClass']('collapsed')
}
Plugin.call($target, option)
})
}(jQuery);
/* ========================================================================
* Bootstrap: scrollspy.js v3.2.0
* http://getbootstrap.com/javascript/#scrollspy
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// SCROLLSPY CLASS DEFINITION
// ==========================
function ScrollSpy(element, options) {
var process = $.proxy(this.process, this)
this.$body = $('body')
this.$scrollElement = $(element).is('body') ? $(window) : $(element)
this.options = $.extend({}, ScrollSpy.DEFAULTS, options)
this.selector = (this.options.target || '') + ' .nav li > a'
this.offsets = []
this.targets = []
this.activeTarget = null
this.scrollHeight = 0
this.$scrollElement.on('scroll.bs.scrollspy', process)
this.refresh()
this.process()
}
ScrollSpy.VERSION = '3.2.0'
ScrollSpy.DEFAULTS = {
offset: 10
}
ScrollSpy.prototype.getScrollHeight = function () {
return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight)
}
ScrollSpy.prototype.refresh = function () {
var offsetMethod = 'offset'
var offsetBase = 0
if (!$.isWindow(this.$scrollElement[0])) {
offsetMethod = 'position'
offsetBase = this.$scrollElement.scrollTop()
}
this.offsets = []
this.targets = []
this.scrollHeight = this.getScrollHeight()
var self = this
this.$body
.find(this.selector)
.map(function () {
var $el = $(this)
var href = $el.data('target') || $el.attr('href')
var $href = /^#./.test(href) && $(href)
return ($href
&& $href.length
&& $href.is(':visible')
&& [[$href[offsetMethod]().top + offsetBase, href]]) || null
})
.sort(function (a, b) { return a[0] - b[0] })
.each(function () {
self.offsets.push(this[0])
self.targets.push(this[1])
})
}
ScrollSpy.prototype.process = function () {
var scrollTop = this.$scrollElement.scrollTop() + this.options.offset
var scrollHeight = this.getScrollHeight()
var maxScroll = this.options.offset + scrollHeight - this.$scrollElement.height()
var offsets = this.offsets
var targets = this.targets
var activeTarget = this.activeTarget
var i
if (this.scrollHeight != scrollHeight) {
this.refresh()
}
if (scrollTop >= maxScroll) {
return activeTarget != (i = targets[targets.length - 1]) && this.activate(i)
}
if (activeTarget && scrollTop <= offsets[0]) {
return activeTarget != (i = targets[0]) && this.activate(i)
}
for (i = offsets.length; i--;) {
activeTarget != targets[i]
&& scrollTop >= offsets[i]
&& (!offsets[i + 1] || scrollTop <= offsets[i + 1])
&& this.activate(targets[i])
}
}
ScrollSpy.prototype.activate = function (target) {
this.activeTarget = target
$(this.selector)
.parentsUntil(this.options.target, '.active')
.removeClass('active')
var selector = this.selector +
'[data-target="' + target + '"],' +
this.selector + '[href="' + target + '"]'
var active = $(selector)
.parents('li')
.addClass('active')
if (active.parent('.dropdown-menu').length) {
active = active
.closest('li.dropdown')
.addClass('active')
}
active.trigger('activate.bs.scrollspy')
}
// SCROLLSPY PLUGIN DEFINITION
// ===========================
function Plugin(option) {
return this.each(function () {
var $this = $(this)
var data = $this.data('bs.scrollspy')
var options = typeof option == 'object' && option
if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))
if (typeof option == 'string') data[option]()
})
}
var old = $.fn.scrollspy
$.fn.scrollspy = Plugin
$.fn.scrollspy.Constructor = ScrollSpy
// SCROLLSPY NO CONFLICT
// =====================
$.fn.scrollspy.noConflict = function () {
$.fn.scrollspy = old
return this
}
// SCROLLSPY DATA-API
// ==================
$(window).on('load.bs.scrollspy.data-api', function () {
$('[data-spy="scroll"]').each(function () {
var $spy = $(this)
Plugin.call($spy, $spy.data())
})
})
}(jQuery);
/* ========================================================================
* Bootstrap: transition.js v3.2.0
* http://getbootstrap.com/javascript/#transitions
* ========================================================================
* Copyright 2011-2014 Twitter, Inc.
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
* ======================================================================== */
+function ($) {
'use strict';
// CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
// ============================================================
function transitionEnd() {
var el = document.createElement('bootstrap')
var transEndEventNames = {
WebkitTransition : 'webkitTransitionEnd',
MozTransition : 'transitionend',
OTransition : 'oTransitionEnd otransitionend',
transition : 'transitionend'
}
for (var name in transEndEventNames) {
if (el.style[name] !== undefined) {
return { end: transEndEventNames[name] }
}
}
return false // explicit for ie8 ( ._.)
}
// http://blog.alexmaccaw.com/css-transitions
$.fn.emulateTransitionEnd = function (duration) {
var called = false
var $el = this
$(this).one('bsTransitionEnd', function () { called = true })
var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
setTimeout(callback, duration)
return this
}
$(function () {
$.support.transition = transitionEnd()
if (!$.support.transition) return
$.event.special.bsTransitionEnd = {
bindType: $.support.transition.end,
delegateType: $.support.transition.end,
handle: function (e) {
if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)
}
}
})
}(jQuery);
|
var chatList = document.getElementById("chat-messages");
if (chatList) {
// Get IRC updates from the couch
Couch.urlPrefix = '/couch';
var db = Couch.db('rochackircmarkov');
db.changes(null, {
include_docs: true,
filter: 'couchgrams/text'
}).onChange(function (resp) {
if (resp.results) resp.results.forEach(addChatRow);
});
// Get latest IRC messages
db.view('couchgrams/text', {
descending: true,
limit: 25,
include_docs: true,
error: function () {},
success: function (resp) {
if (resp && resp.rows) resp.rows.reverse().forEach(addChatRow);
}
});
}
var urlRegex = /[a-z]{2,}:\/\/*[^ ]*(?= |$)/g;
function addChatRow(row) {
var date = new Date(row.id * 1000);
var text = row.doc.text;
var sender = row.doc.sender;
// Insert chat message
var li = document.createElement("li");
if (sender) li.appendChild(document.createTextNode('<' + sender + '> '));
/*
if (sender) {
var b = document.createElement("strong");
b.appendChild(document.createTextNode(sender));
li.appendChild(b);
li.appendChild(document.createTextNode(" "));
}
*/
// Turn URLs into links.
var urls = [];
var match;
while (match = urlRegex.exec(text)) {
urls.push(match[0]);
}
text.split(urlRegex).forEach(function (text) {
// Write text segment
li.appendChild(document.createTextNode(text));
// Write link
if (urls.length == 0) return;
var url = urls.pop();
var link = document.createElement("a");
link.setAttribute("href", url);
link.appendChild(document.createTextNode(url));
li.appendChild(link);
});
li.title = date.toLocaleString();
chatList.appendChild(li);
}
var localVideoEl = document.getElementById('localVideo');
var remoteVideosEl = document.getElementById('remotes');
// create our webrtc connection
var webrtc = new WebRTC({
localVideoEl: localVideoEl,
remoteVideosEl: remoteVideosEl,
// immediately ask for camera access
autoRequestMedia: true,
peerConnectionConfig: {
iceServers: navigator.mozGetUserMedia ?
[{"url":"stun:124.124.124.2"}] :
[{"url": "stun:stun.l.google.com:19302"}],
onChannelOpened: function (channel) {
console.log('channel opened', channel);
},
onChannelMessage: function (event) {
console.log('channel message', event.data);
}
},
log: false
});
// when it's ready, join
webrtc.on('readyToCall', function () {
webrtc.joinRoom('RocHack');
});
var showIRC = !window.localStorage['hide-irc'];
var toggleIRCLink = document.getElementById("toggle-irc");
function updateIRCView() {
window.localStorage['hide-irc'] = showIRC ? "" : "hide";
document.body.className = showIRC ?
document.body.className.replace(/ hide-irc/g, '') :
document.body.className + ' hide-irc';
toggleIRCLink.innerHTML = showIRC ? "»" : "«";
}
updateIRCView();
toggleIRCLink.addEventListener("click", function (e) {
e.preventDefault();
showIRC = !showIRC;
updateIRCView();
setTimeout(updateVideoSizes, 500);
}, false);
function fitVideos(container, videos) {
if (!videos[0]) return 1;
var videoWidth = videos[0].offsetWidth;
var videoHeight = videos[0].offsetHeight;
var aspect = videoHeight / videoWidth;
var containerWidth = container.offsetWidth;
var containerHeight = container.offsetHeight;
var numVideos = videos.length;
var bestFit = 0;
for (var cols = 1; cols <= numVideos; cols++) {
var width, height, w;
var rows = Math.ceil(numVideos/cols);
width = containerWidth/cols;
height = width * aspect;
var totalHeight = rows * height;
if (totalHeight <= containerHeight) {
w = 1/cols;
if (w > bestFit) bestFit = w;
}
height = containerHeight/rows;
width = height / aspect;
var totalWidth = cols * width;
if (totalWidth <= containerWidth) {
w = width/containerWidth;
if (w > bestFit) bestFit = w;
}
}
return bestFit * containerWidth;
}
// Update the size of the videos dynamically
function updateVideoSizes() {
var videos = [].slice.call(remoteVideosEl.getElementsByTagName("*"));
var width = fitVideos(remoteVideosEl, videos) + "px";
videos.forEach(function (video) {
video.style.width = width;
});
}
updateVideoSizes();
webrtc.on('videoAdded', updateVideoSizes);
webrtc.on('videoRemoved', updateVideoSizes);
webrtc.on('readyToCall', updateVideoSizes);
window.addEventListener('resize', updateVideoSizes, false);
|
import React from 'react';
import { Link } from 'react-router-dom';
import { Field, FieldArray, reduxForm } from 'redux-form';
import { TextField } from 'redux-form-material-ui';
import api from 'lib/api';
import * as helper from 'lib/helper';
import messages from 'lib/text';
import style from './style.css';
import TagsInput from 'react-tagsinput';
import ProductSearchDialog from 'modules/shared/productSearch';
import ProductCategorySelect from './productCategorySelect';
import ProductCategoryMultiSelect from './productCategoryMultiSelect';
import Paper from 'material-ui/Paper';
import FontIcon from 'material-ui/FontIcon';
import IconButton from 'material-ui/IconButton';
import FlatButton from 'material-ui/FlatButton';
import RaisedButton from 'material-ui/RaisedButton';
import IconMenu from 'material-ui/IconMenu';
import MenuItem from 'material-ui/MenuItem';
const Fragment = React.Fragment;
const TagsField = ({ input, placeholder }) => {
const tagsArray =
input.value && Array.isArray(input.value) ? input.value : [];
return (
<TagsInput
value={tagsArray}
inputProps={{ placeholder: placeholder }}
onChange={tags => {
input.onChange(tags);
}}
/>
);
};
const ProductShort = ({
id,
name,
thumbnailUrl,
priceFormatted,
enabled,
discontinued,
actions
}) => (
<div
className={
style.relatedProduct +
(enabled === false || discontinued === true
? ' ' + style.relatedProductDisabled
: '')
}
>
<div className={style.relatedProductImage}>
{thumbnailUrl && thumbnailUrl !== '' && <img src={thumbnailUrl} />}
</div>
<div className={style.relatedProductText}>
<Link to={`/admin/product/${id}`}>{name}</Link>
<br />
<div>{priceFormatted}</div>
</div>
<div className={style.relatedProductActions}>{actions}</div>
</div>
);
const RelatedProductActions = ({ fields, index }) => (
<IconMenu
targetOrigin={{ horizontal: 'right', vertical: 'top' }}
anchorOrigin={{ horizontal: 'right', vertical: 'top' }}
iconButtonElement={
<IconButton touch={true}>
<FontIcon color="#777" className="material-icons">
more_vert
</FontIcon>
</IconButton>
}
>
<MenuItem
primaryText={messages.actions_delete}
onClick={() => fields.remove(index)}
/>
{index > 0 && (
<MenuItem
primaryText={messages.actions_moveUp}
onClick={() => fields.move(index, index - 1)}
/>
)}
{index + 1 < fields.length && (
<MenuItem
primaryText={messages.actions_moveDown}
onClick={() => fields.move(index, index + 1)}
/>
)}
</IconMenu>
);
const RelatedProduct = ({ settings, product, actions }) => {
if (product) {
const priceFormatted = helper.formatCurrency(product.price, settings);
const imageUrl =
product && product.images.length > 0 ? product.images[0].url : null;
const thumbnailUrl = helper.getThumbnailUrl(imageUrl, 100);
return (
<ProductShort
id={product.id}
name={product.name}
thumbnailUrl={thumbnailUrl}
priceFormatted={priceFormatted}
enabled={product.enabled}
discontinued={product.discontinued}
actions={actions}
/>
);
} else {
// product doesn't exist
return (
<ProductShort
id="-"
name=""
thumbnailUrl=""
priceFormatted=""
actions={actions}
/>
);
}
};
class ProductsArray extends React.Component {
constructor(props) {
super(props);
this.state = {
showAddItem: false,
products: []
};
}
showAddItem = () => {
this.setState({ showAddItem: true });
};
hideAddItem = () => {
this.setState({ showAddItem: false });
};
addItem = productId => {
this.hideAddItem();
this.props.fields.push(productId);
};
componentDidMount() {
const ids = this.props.fields.getAll();
this.fetchProducts(ids);
}
componentWillReceiveProps(nextProps) {
const currentIds = this.props.fields.getAll();
const newIds = nextProps.fields.getAll();
if (currentIds !== newIds) {
this.fetchProducts(newIds);
}
}
fetchProducts = ids => {
if (ids && Array.isArray(ids) && ids.length > 0) {
api.products
.list({
limit: 50,
fields:
'id,name,enabled,discontinued,price,on_sale,regular_price,images',
ids: ids
})
.then(productsResponse => {
this.setState({ products: productsResponse.json.data });
});
} else {
this.setState({
products: []
});
}
};
render() {
const {
settings,
fields,
meta: { touched, error, submitFailed }
} = this.props;
const { products } = this.state;
return (
<div>
<Paper className={style.relatedProducts} zDepth={1}>
{fields.map((field, index) => {
const actions = (
<RelatedProductActions fields={fields} index={index} />
);
const productId = fields.get(index);
const product = products.find(item => item.id === productId);
return (
<RelatedProduct
key={index}
settings={settings}
product={product}
actions={actions}
/>
);
})}
<ProductSearchDialog
open={this.state.showAddItem}
title={messages.addOrderItem}
settings={settings}
onSubmit={this.addItem}
onCancel={this.hideAddItem}
submitLabel={messages.add}
cancelLabel={messages.cancel}
/>
</Paper>
<div>
<RaisedButton
label={messages.addOrderItem}
onClick={this.showAddItem}
/>
</div>
</div>
);
}
}
const ProductAdditionalForm = ({
handleSubmit,
pristine,
reset,
submitting,
initialValues,
settings,
categories
}) => {
return (
<form onSubmit={handleSubmit}>
<Paper className="paper-box" zDepth={1}>
<div className={style.innerBox}>
<div
className="row middle-xs"
style={{
padding: '0 0 15px 0',
borderBottom: '1px solid #e0e0e0',
marginBottom: 20
}}
>
<div className="col-xs-12 col-sm-4">{messages.category}</div>
<div className="col-xs-12 col-sm-8">
<Field
name="category_id"
component={ProductCategorySelect}
categories={categories}
/>
</div>
</div>
<div
className="row middle-xs"
style={{
padding: '0 0 15px 0',
borderBottom: '1px solid #e0e0e0',
marginBottom: 25
}}
>
<div className="col-xs-12 col-sm-4">
{messages.additionalCategories}
</div>
<div className="col-xs-12 col-sm-8">
<FieldArray
name="category_ids"
component={ProductCategoryMultiSelect}
categories={categories}
/>
</div>
</div>
<div
className="row middle-xs"
style={{ padding: '0 0 20px 0', borderBottom: '1px solid #e0e0e0' }}
>
<div className="col-xs-12 col-sm-4">{messages.tags}</div>
<div className="col-xs-12 col-sm-8">
<Field
name="tags"
component={TagsField}
placeholder={messages.newTag}
/>
</div>
</div>
<div
className="row middle-xs"
style={{ borderBottom: '1px solid #e0e0e0', marginBottom: 20 }}
>
<div className="col-xs-12 col-sm-4">{messages.position}</div>
<div className="col-xs-12 col-sm-8">
<Field
name="position"
component={TextField}
floatingLabelText={messages.position}
fullWidth={false}
style={{ width: 128 }}
type="number"
/>
</div>
</div>
{messages.relatedProducts}
<FieldArray
name="related_product_ids"
component={ProductsArray}
settings={settings}
/>
</div>
<div
className={
'buttons-box ' +
(pristine ? 'buttons-box-pristine' : 'buttons-box-show')
}
>
<FlatButton
label={messages.cancel}
className={style.button}
onClick={reset}
disabled={pristine || submitting}
/>
<RaisedButton
type="submit"
label={messages.save}
primary={true}
className={style.button}
disabled={pristine || submitting}
/>
</div>
</Paper>
</form>
);
};
export default reduxForm({
form: 'ProductAdditionalForm',
enableReinitialize: true
})(ProductAdditionalForm);
|
d3.chart('BaseChart').extend('BarChart', {
initialize: function() {
var chart = this;
chart.base
.classed('Barchart', true);
// make actual layers
chart.layer('bars', chart.areas.plot, {
// data format:
// [ { name : x-axis-bar-label, value : N }, ...]
dataBind : function(data) {
// save the data in case we need to reset it
chart.data = data;
// how many bars?
chart.bars = data.length;
// compute box size
chart.bar_width = (chart.w - chart.margins.left - ((chart.bars - 1) *
chart.margins.padding)) / chart.bars;
// adjust the x domain - the number of bars.
chart.x.domain([0, chart.bars]);
// adjust the y domain - find the max in the data.
chart.datamax = chart.usermax || d3.max(data, function(d) {
return d.value;
});
chart.y.domain([0, chart.datamax]);
// draw yaxis
var yAxis = d3.svg.axis()
.scale(chart.y)
.orient('left')
.ticks(4)
.tickFormat(chart.y.tickFormat(4, '%'));
if(chart.displayYAxis) {
chart.areas.ylabels
.call(yAxis);
}
return this.selectAll('rect')
.data(data);
},
insert : function() {
return this.append('rect')
.classed('bar', true);
}
});
// a layer for the x text labels.
chart.layer('xlabels', chart.areas.xlabels, {
dataBind : function(data) {
// first append a line to the top.
this.append('line')
.attr('x1', 0)
.attr('x2', chart.w - chart.margins.left)
.attr('y1', 0)
.attr('y2', 0)
.style('stroke-width', '1')
.style('shape-rendering', 'crispEdges');
return this.selectAll('text')
.data(data);
},
insert : function() {
return this.append('text')
.classed('label', true)
.attr('text-anchor', 'middle')
.attr('x', function(d, i) {
return chart.x(i) - 0.5 + chart.bar_width/2;
})
.attr('dy', '1em')
.text(function(d) {
return d.name;
});
}
});
// on new/update data
// render the bars.
var onEnter = function() {
this.attr('x', function(d, i) {
return chart.x(i) - 0.5;
})
.attr('y', function(d) {
return chart.h - chart.margins.bottom - chart.margins.top - chart.y(chart.datamax - d.value) - 0.5;
})
.attr('val', function(d) {
return d.value;
})
.attr('width', chart.bar_width)
.attr('height', function(d) {
//return chart.h - chart.margins.bottom - chart.y(chart.datamax - d.value);
return chart.y(chart.datamax - d.value);
});
};
chart.layer('bars').on('enter', onEnter);
chart.layer('bars').on('update', onEnter);
}
});
|
// Eloquent JavaScript
// Run this file in your terminal using `node my_solution.js`.
//Make sure it works before moving on!
// Program Structure
// Write your own variable and do something to it.
var myName = "Erica";
//User Input
// var fav = prompt("What's your favorite food?");
// if (fav) {
// console.log("Hey! That's my favorite too!");
// }
// Complete one of the exercises: Looping a Triangle, FizzBuzz, or Chess Board
// FizzBuzz
// for (var i=0; i<=100; i++){
// if ((i % 3 === 0) && (i % 5 === 0)){
// console.log("FizzBuzz");
// }
// else if (i % 3 === 0) {
// console.log("Fizz");
// }
// else if (i % 5 === 0){
// console.log("Buzz");
// }
// else {
// console.log(i);
// }
// }
//Refactor FizzBuzz
// for (var i=0; i<=100; i++){
// ((i % (3*5)) === 0) ? console.log("FizzBuzz")
// : (i % 3 === 0) ? console.log("Fizz")
// : (i % 5 === 0) ? console.log("Buzz")
// : console.log(i);
// }
// Functions
// Complete the `minimum` exercise.
var min = function(num1, num2){
var min = (num1 < num2) ? num1 : num2;
return min;
}
console.log(min(0, 10));
// → 0
console.log(min(0, -10));
// → -10
//Recursion
var isEven = function(num){
//if num is negative, change it to positive
if (num < 0)
num = -num;
//base case
if (num === 0)
return true;
else if (num === 1)
return false;
//repeat and decrement down to base case
else
return isEven(num-2);
}
console.log(isEven(50));
// → true
console.log(isEven(75));
// → false
console.log(isEven(-1));
// → ??
// Data Structures: Objects and Arrays
// Create an object called "me" that stores your name, age, 3 favorite foods,
//and a quirk below.
var me = {
name: "Erica",
age: 33,
favFoods: ["Jamaican food", "Italian food", "Chinese food"],
quirk: "Proud introvert!"
}
console.log(me); |
/*!
* rss controller
*/
const config = require('../config')
const convert = require('data2xml')()
const { Post } = require('../services/')
const render = require('../common/render')
const cache = require('../common/cache')
/**
* rss输出
* @param req
* @param res
* @param next
*/
exports.index = async (req, res, next) => {
if (!config.rss) {
res.statusCode = 404
return res.send('Please set `rss` in configuration')
}
res.contentType('application/xml')
try {
const rss = await cache.get('rss')
if (rss) {
res.wrapSend(rss)
return next()
}
const queryOpt = { limit: config.rss.max_rss_items, sort: '-create_at' }
const posts = (await Post.getPostsByQuery({}, queryOpt)) || []
const rssObj = {
_attr: { version: '2.0' },
channel: {
title: config.rss.title,
link: config.rss.link,
language: config.rss.language,
description: config.rss.description,
item: []
}
}
posts.forEach(post => {
rssObj.channel.item.push({
title: post.title,
link: config.rss.link + '/p/' + post._id,
guid: config.rss.link + '/p/' + post._id,
description: render.markdown(post.content),
author: post.author.login_name,
pubDate: post.create_at.toUTCString()
})
})
const rssContent = convert('rss', rssObj)
cache.set('rss', rssContent, 60 * 5) // 五分钟
res.wrapSend(rssContent)
} catch (error) {
res.status(500).wrapSend(' rss error')
}
}
|
var os = require('os');
var CMD_SEPARATOR = "\r\n";
module.exports = function(commandLine, output, cb, socket) {
var commandParts = commandLine.split(' ');
if (commandParts.length != 2) {
output('501 Syntax: HELO hostname' + CMD_SEPARATOR);
} else {
output('250 ' + os.hostname() + CMD_SEPARATOR);
}
} |
version https://git-lfs.github.com/spec/v1
oid sha256:f2b63a5514ad1eaaecedf5c69e09d67a5ddeb1bf840e147a4d4c65f2c2b41ee4
size 1970
|
version https://git-lfs.github.com/spec/v1
oid sha256:9db15624b9307b4395766aa64e0887d6c2431edc356d1e19eb4c90968f3033fc
size 87677
|
const Planet = require(__dirname + '/../model/model.js');
module.exports = [
{
method: 'GET',
path: '/planets',
handler: function(req, reply) {
Planet.find({}, (err, docs) => {
if (err) {
return reply(err);
}
return reply(docs);
});
}
},
{
method: 'POST',
path: '/planets',
handler: function(req, reply) {
var newPlanet = new Planet(req.payload);
newPlanet.save((err, newPlanet) => {
if (err) {
return reply(err);
}
reply(newPlanet).created('/planets/' + newPlanet._id);
});
}
},
{
method: 'PUT',
path: '/planets/{name}',
handler: function(req, reply) {
Planet.findOne({ 'name': req.params.name }, (err, planet) => {
if (err) {
return reply(err);
}
planet.color = req.payload.color;
planet.size = req.payload.size;
planet.moonsNumber = req.payload.moonsNumber;
planet.save((err, planet) => {
if (err) {
return reply(err);
}
return reply(planet);
});
});
}
},
{
method: 'DELETE',
path: '/planets/{name}',
handler: function(req, reply) {
Planet.findOne({ 'name': req.params.name }, (err, planet) => {
if (err) {
return reply(err);
}
if (planet) {
planet.remove();
return reply({ message: 'OMG! We destroyed a planet!' });
}
});
}
}
];
|
;(function(factory){var registeredInModuleLoader=false;if(typeof define==='function'&&define.amd){define(factory);registeredInModuleLoader=true;}
if(typeof exports==='object'){module.exports=factory();registeredInModuleLoader=true;}
if(!registeredInModuleLoader){var OldCookies=window.Cookies;var api=window.Cookies=factory();api.noConflict=function(){window.Cookies=OldCookies;return api;};}}(function(){function extend(){var i=0;var result={};for(;i<arguments.length;i++){var attributes=arguments[i];for(var key in attributes){result[key]=attributes[key];}}
return result;}
function init(converter){function api(key,value,attributes){var result;if(typeof document==='undefined'){return;}
if(arguments.length>1){attributes=extend({path:'/'},api.defaults,attributes);if(typeof attributes.expires==='number'){var expires=new Date();expires.setMilliseconds(expires.getMilliseconds()+attributes.expires*864e+5);attributes.expires=expires;}
attributes.expires=attributes.expires?attributes.expires.toUTCString():'';try{result=JSON.stringify(value);if(/^[\{\[]/.test(result)){value=result;}}catch(e){}
if(!converter.write){value=encodeURIComponent(String(value)).replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g,decodeURIComponent);}else{value=converter.write(value,key);}
key=encodeURIComponent(String(key));key=key.replace(/%(23|24|26|2B|5E|60|7C)/g,decodeURIComponent);key=key.replace(/[\(\)]/g,escape);var stringifiedAttributes='';for(var attributeName in attributes){if(!attributes[attributeName]){continue;}
stringifiedAttributes+='; '+attributeName;if(attributes[attributeName]===true){continue;}
stringifiedAttributes+='='+attributes[attributeName];}
return(document.cookie=key+'='+value+stringifiedAttributes);}
if(!key){result={};}
var cookies=document.cookie?document.cookie.split('; '):[];var rdecode=/(%[0-9A-Z]{2})+/g;var i=0;for(;i<cookies.length;i++){var parts=cookies[i].split('=');var cookie=parts.slice(1).join('=');if(cookie.charAt(0)==='"'){cookie=cookie.slice(1,-1);}
try{var name=parts[0].replace(rdecode,decodeURIComponent);cookie=converter.read?converter.read(cookie,name):converter(cookie,name)||cookie.replace(rdecode,decodeURIComponent);if(this.json){try{cookie=JSON.parse(cookie);}catch(e){}}
if(key===name){result=cookie;break;}
if(!key){result[name]=cookie;}}catch(e){}}
return result;}
api.set=api;api.get=function(key){return api.call(api,key);};api.getJSON=function(){return api.apply({json:true},[].slice.call(arguments));};api.defaults={};api.remove=function(key,attributes){api(key,'',extend(attributes,{expires:-1}));};api.withConverter=init;return api;}
return init(function(){});})); |
/**
* Created by hxsd on 2016/3/28.
*/
/*直接扩展与原型扩展的区别在于 原型扩展是对类型的 直接扩展是对实例的*/
/* 第一个
* 获取视口的宽度和高度，自定义函数
* */
window._width = function(){
var pageWidth = window.innerWidth;
//若之前拿到的不是一个数
if(typeof pageWidth != "number"){
if(document.compatMode == "CSS1Compat"){
pageWidth = document.documentElement.clientWidth;
}else{
pageWidth = document.body.clientWidth;
}
}
return pageWidth;
};
window._height = function(){
var pageHeight = window.innerHeight;
//若之前拿到的不是一个数
if(typeof pageHeight != "number"){
if(document.compatMode == "CSS1Compat"){
pageHeight = document.documentElement.clientHeight;
}else{
pageHeight = document.body.clientHeight;
}
}
return pageHeight;
};
/* 第二个
* 1、找到 姓名 中的 姓
* 2、将 姓 变化为可以进行比较的数字
* 3、进行比较
* 让指定的名称的标签居中显示，自定义函数
* */
Array.prototype.sortByChinaFirstName = function() {
//数组排序的方法
// sort(fun)
// fun-->排序器
// 存在两个参数，a和b
// 当这个fun返回 负数 的时候，表述 a < b
// 当这个fun返回 正数 的时候，表述 a > b
var arrFirstName = ['赵','钱','孙','李','周','吴','郑','王','蔡'];
//a，b 叫做 约定 ecma script
function firstNameSort(a, b) {
//1、找到 姓名 中的 姓
//2、将 姓 变化为可以进行比较的数字
//3、进行比较
//a = 蔡毅斌
//b = 王旭
var a_firstName = a.charAt(0); //将在指定位置的字符返回（字符串）
var b_firstName = b.charAt(0);
//找到两个姓 在arrFirstName数组中的所在位置（下标）
var a_index, b_index;
a_index = 0;
b_index = 0;
for (var i = 0; i < arrFirstName.length; i++) {
if (arrFirstName[i] == a_firstName) {
a_index = i;
break;
}
}
for (var i = 0; i < arrFirstName.length; i++) {
if (arrFirstName[i] == b_firstName) {
b_index = i;
break;
}
}
return b_index - a_index;
}
//this 代表的是 具体调用这个方法（sortByChinaFirstName）的数组的实例
return this.sort(firstNameSort);
}
/* 第三个
* 让指定的名称的标签居中显示，自定义函数
*
* */
function init(id){
var sWidth = _width(),sHeight=_height(); //屏幕的宽和高
var bWidth,bHeight; //盒子的宽和高
var bTop,bLeft; //盒子的坐标
//目前缺少：
// 没有为下边的表达式的4个变量取值
// 对于box（类似于div标签）取宽和高
// 如下的3点事ecmascript 3.0 中定义好的标准；每个浏览器在解析的时候都存在不同
// 1、box.clientWidth 盒子的宽-----不包含边框（滚动条）的宽
// 在ie8以下浏览器：padding值不被包含在offsetWidth当中
// 在ie8以后：padding值被包含在offsetWidth当中
// 2、box.offsetWidth 盒子的宽-----包含边框和滚动条的宽
// 在ie8以下浏览器：margin值被包含在offsetWidth当中
// 在ie8以后：margin值不被包含在offsetWidth当中
// 3、box.screenWidth 盒子的宽-----不包含滚动条（包含边框）的宽
// 上述3个值，是只读的。
// 4、box.style.width 盒子的宽-----包含边框和滚动条的宽
// 他被写在标签以内，才可以取得值；若写在样式表中，就无法取值
var box = document.getElementById(id);
bWidth = box.clientWidth;
bHeight = box.clientHeight;
bTop = (sHeight / 2 - bHeight / 2) + "px";
bLeft = (sWidth /2 - bWidth / 2) + "px";
box.style.left = bLeft;
box.style.top = bTop;
}
/* 第四个
* 辅助提醒自动完成补全的功能，自定义函数
*
* */
function autoComplite(inputTextId, searchBody) {
var flag = false;
//找到需要“自动完成提醒词组”的输入框的对象实例
var txtSearch = document.getElementById(inputTextId);
txtSearch.style.textIndent = 4 + "px";
//找到需要“自动完成提醒词组”显示的Box下面的ul
//为什么是ul呢？由于ul对于行级的元素比较好控制
//这些内容后市动态创建的，备选词条的结构是<div><ul><li>.....
var _boxDiv = document.createElement("div");
_boxDiv.onmouseover = function () {
flag = true;
};
_boxDiv.onmouseout = function () {
flag = false;
};
_boxDiv.setAttribute("id", "txtInfo");
var _boxDivUl = document.createElement("ul");
_boxDiv.appendChild(_boxDivUl);
txtSearch.onkeyup = function () {
if (document.getElementById("txtInfo") == undefined) {
this.parentElement.appendChild(_boxDiv);
}
//定位先不写
//将input：text的父级标签 position更改为：非静态
this.parentElement.style.position = "relative";
_boxDiv.style.position = "absolute";
_boxDiv.style.left = "2px";
_boxDiv.style.top = "35px"; //这里假定txtbox的高是20px，正常的逻辑应该是获取】
_boxDiv.style.width = "446px";
_boxDiv.style.height = "auto";
_boxDiv.style.textIndent = "5px";
_boxDiv.style.backgroundColor = "#fff";
_boxDiv.style.zIndex = 300;
//控制台输入以下
console.log("onkeyup\t" + this.value);
//得到用户输入的内容
var userInput = this.value;
//每次提醒前，先清空原来的内容
_boxDivUl.innerHTML = ""; //先清空
//若子字符串是空字符串 ，则不进行搜索（不显示）
if (userInput.length == 0) {
return;
}
for (var i = 0; i < searchBody.length; i++) {
//arr[i] 数组项中某一个
//indexOf 返回值：
// -1 表述母串没有参数所代表的子字符串
// 0或者大于0正整数 表述在母字符串中找到了子字符串，并且数字代表其出现位置
if (searchBody[i].indexOf(userInput) >= 0) {
//将找到母字符串提取出来
//将这段字符串添加ul当中去
var li = document.createElement("li");
li.style.listStyle = "none";
li.style.fontSize = "14px";
li.style.lineHeight = "30px";
li.onmouseover = function () {
this.style.backgroundColor = "#ffdfc6";
};
li.onmouseout = function () {
this.style.backgroundColor = "#fff";
};
//将此行的内容更改为找到的符合条件的母字符串
li.innerText = searchBody[i];
//订阅这个行li的点击事件
li.onclick = function () {
//更改输入框的内容为 当前行值
txtSearch.value = this.innerText;
//将提醒框的Box隐藏
_boxDiv.style.display = "none";
};
//将创建好的 元素添加到当前文档中
_boxDivUl.appendChild(li);
}
}
_boxDiv.style.display = "block";
};
//订阅焦点丢失事件
txtSearch.onblur = function () {
if (flag == false) {
//将提醒的box 显示
_boxDiv.style.display = "none";
}
}
}
// 5、图片轮播主函数
// 所有图片所在的div盒子的ID值
// 要求，所轮播的图片必须包含在div中。
function pptImages(divID) {
var bigDiv = document.getElementById(divID);
var childDiv = bigDiv.getElementsByTagName("div"); //所有的图片 div
//初始化data-index属性
for(var i =0;i<childDiv.length;i++){
childDiv[i].setAttribute("data-index",i);
}
var ul = document.createElement("ul");
var mouseOnLi = false; //表述鼠标是否在li标签上
for (i = 0; i < childDiv.length; i++) {
var li = document.createElement("li");
li.innerText = i + 1;
ul.appendChild(li);
//添加li的onmouseover事件
li.onmouseover = function () {
//找到对应的图片
var imgIndex = parseInt(this.innerText) - 1;
var cImgDiv;
for (var i = 0; i < bigDiv.children.length; i++) {
if (bigDiv.children[i].getAttribute("data-index") == String(imgIndex)) {
cImgDiv = bigDiv.children[i]; //找到当前图片的实例
break; //找到了，不必再循环了
}
}
bigDiv.removeChild(cImgDiv); //移除掉
bigDiv.appendChild(cImgDiv); //这时，它出现在最后一个
if (cImgDiv) danRu(cImgDiv); //淡入的显示
mouseOnLi = true;
};
li.onmouseout = function () {
mouseOnLi = false;
};
}
bigDiv.appendChild(ul);
//在进入轮播前，前执行一次
var currentImgDiv = childDiv[0]; //找到当前应该显示图片div
bigDiv.removeChild(currentImgDiv); //移除掉
bigDiv.appendChild(currentImgDiv); //这时，它出现在最后一个
ul.children[0].style.backgroundColor = "red";
danRu(currentImgDiv);
var changeIndexInterval = setInterval(function () {
if (!mouseOnLi) {
currentImgDiv = childDiv[0]; //找到当前应该显示图片div
bigDiv.removeChild(currentImgDiv); //移除掉
bigDiv.appendChild(currentImgDiv); //这时，它出现在最后一个
//找到是第几张图片
var liIndex = currentImgDiv.getAttribute("data-index");
for (var j = 0; j < ul.children.length; j++) {
ul.children[j].style.backgroundColor = "#555"; //先将所有的li都该回到原来的颜色
}
ul.children[liIndex].style.backgroundColor = "red"; //让指定的li的颜色变化
danRu(currentImgDiv);
}
}, 3000);
}
//图片轮播的辅助 淡入函数
function danRu(element){
var opacity = 0;
element.style.opacity = opacity + "";
var interval = setInterval(function(){
opacity += 0.1;
element.style.opacity = opacity + "";
if(opacity >=1) clearInterval(interval);
},50);
} |
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/* tslint:disable:no-unused-variable */
var app_component_1 = require("./app.component");
var testing_1 = require("@angular/core/testing");
var platform_browser_1 = require("@angular/platform-browser");
//////// SPECS /////////////
describe('AppComponent', function () {
var de;
var comp;
var fixture;
beforeEach(testing_1.async(function () {
testing_1.TestBed.configureTestingModule({
declarations: [app_component_1.AppComponent]
})
.compileComponents();
}));
beforeEach(function () {
fixture = testing_1.TestBed.createComponent(app_component_1.AppComponent);
comp = fixture.componentInstance;
de = fixture.debugElement.query(platform_browser_1.By.css('h1'));
});
it('should create component', function () { return expect(comp).toBeDefined(); });
it('should have expected <h1> text', function () {
fixture.detectChanges();
var h1 = de.nativeElement;
expect(h1.innerText).toMatch(/angular/i, '<h1> should say something about "Angular"');
});
});
//# sourceMappingURL=app.component.spec.js.map |
'use strict';
// Init the application configuration module for AngularJS application
var ApplicationConfiguration = (function() {
// Init module configuration options
var applicationModuleName = 'railway';
var applicationModuleVendorDependencies = ['ngResource', 'ngCookies', 'ngSanitize', 'ui.router', 'ui.bootstrap', 'ui.utils'];
// Add a new vertical module
var registerModule = function(moduleName, dependencies) {
// Create angular module
angular.module(moduleName, dependencies || []);
// Add the module to the AngularJS configuration file
angular.module(applicationModuleName).requires.push(moduleName);
};
return {
applicationModuleName: applicationModuleName,
applicationModuleVendorDependencies: applicationModuleVendorDependencies,
registerModule: registerModule
};
})();
|
/* ***********************************************************
* This file was automatically generated on 2014-12-10. *
* *
* Bindings Version 2.0.4 *
* *
* If you have a bugfix for this file and want to commit it, *
* please fix the bug in the generator. You can find a link *
* to the generator git on tinkerforge.com *
*************************************************************/
var Device = require('./Device');
BrickletNFCRFID.DEVICE_IDENTIFIER = 246;
BrickletNFCRFID.CALLBACK_STATE_CHANGED = 8;
BrickletNFCRFID.FUNCTION_REQUEST_TAG_ID = 1;
BrickletNFCRFID.FUNCTION_GET_TAG_ID = 2;
BrickletNFCRFID.FUNCTION_GET_STATE = 3;
BrickletNFCRFID.FUNCTION_AUTHENTICATE_MIFARE_CLASSIC_PAGE = 4;
BrickletNFCRFID.FUNCTION_WRITE_PAGE = 5;
BrickletNFCRFID.FUNCTION_REQUEST_PAGE = 6;
BrickletNFCRFID.FUNCTION_GET_PAGE = 7;
BrickletNFCRFID.FUNCTION_GET_IDENTITY = 255;
BrickletNFCRFID.TAG_TYPE_MIFARE_CLASSIC = 0;
BrickletNFCRFID.TAG_TYPE_TYPE1 = 1;
BrickletNFCRFID.TAG_TYPE_TYPE2 = 2;
BrickletNFCRFID.STATE_INITIALIZATION = 0;
BrickletNFCRFID.STATE_IDLE = 128;
BrickletNFCRFID.STATE_ERROR = 192;
BrickletNFCRFID.STATE_REQUEST_TAG_ID = 2;
BrickletNFCRFID.STATE_REQUEST_TAG_ID_READY = 130;
BrickletNFCRFID.STATE_REQUEST_TAG_ID_ERROR = 194;
BrickletNFCRFID.STATE_AUTHENTICATING_MIFARE_CLASSIC_PAGE = 3;
BrickletNFCRFID.STATE_AUTHENTICATING_MIFARE_CLASSIC_PAGE_READY = 131;
BrickletNFCRFID.STATE_AUTHENTICATING_MIFARE_CLASSIC_PAGE_ERROR = 195;
BrickletNFCRFID.STATE_WRITE_PAGE = 4;
BrickletNFCRFID.STATE_WRITE_PAGE_READY = 132;
BrickletNFCRFID.STATE_WRITE_PAGE_ERROR = 196;
BrickletNFCRFID.STATE_REQUEST_PAGE = 5;
BrickletNFCRFID.STATE_REQUEST_PAGE_READY = 133;
BrickletNFCRFID.STATE_REQUEST_PAGE_ERROR = 197;
BrickletNFCRFID.KEY_A = 0;
BrickletNFCRFID.KEY_B = 1;
function BrickletNFCRFID(uid, ipcon) {
//Device that can read and write NFC and RFID tags
/*
Creates an object with the unique device ID *uid* and adds it to
the IP Connection *ipcon*.
*/
Device.call(this, this, uid, ipcon);
BrickletNFCRFID.prototype = Object.create(Device);
this.responseExpected = {};
this.callbackFormats = {};
this.APIVersion = [2, 0, 0];
this.responseExpected[BrickletNFCRFID.FUNCTION_REQUEST_TAG_ID] = Device.RESPONSE_EXPECTED_FALSE;
this.responseExpected[BrickletNFCRFID.FUNCTION_GET_TAG_ID] = Device.RESPONSE_EXPECTED_ALWAYS_TRUE;
this.responseExpected[BrickletNFCRFID.FUNCTION_GET_STATE] = Device.RESPONSE_EXPECTED_ALWAYS_TRUE;
this.responseExpected[BrickletNFCRFID.FUNCTION_AUTHENTICATE_MIFARE_CLASSIC_PAGE] = Device.RESPONSE_EXPECTED_FALSE;
this.responseExpected[BrickletNFCRFID.FUNCTION_WRITE_PAGE] = Device.RESPONSE_EXPECTED_FALSE;
this.responseExpected[BrickletNFCRFID.FUNCTION_REQUEST_PAGE] = Device.RESPONSE_EXPECTED_FALSE;
this.responseExpected[BrickletNFCRFID.FUNCTION_GET_PAGE] = Device.RESPONSE_EXPECTED_ALWAYS_TRUE;
this.responseExpected[BrickletNFCRFID.CALLBACK_STATE_CHANGED] = Device.RESPONSE_EXPECTED_ALWAYS_FALSE;
this.responseExpected[BrickletNFCRFID.FUNCTION_GET_IDENTITY] = Device.RESPONSE_EXPECTED_ALWAYS_TRUE;
this.callbackFormats[BrickletNFCRFID.CALLBACK_STATE_CHANGED] = 'B ?';
this.requestTagID = function(tagType, returnCallback, errorCallback) {
/*
To read or write a tag that is in proximity of the NFC/RFID Bricklet you
first have to call this function with the expected tag type as parameter.
It is no problem if you don't know the tag type. You can cycle through
the available tag types until the tag gives an answer to the request.
Current the following tag types are supported:
* Mifare Classic (``tag_type`` = 0)
* NFC Forum Type 1 (``tag_type`` = 1)
* NFC Forum Type 2 (``tag_type`` = 2)
After you call :func:`RequestTagID` the NFC/RFID Bricklet will try to read
the tag ID from the tag. After this process is done the state will change.
You can either register the :func:`StateChanged` callback or you can poll
:func:`GetState` to find out about the state change.
If the state changes to *RequestTagIDError* it means that either there was
no tag present or that the tag is of an incompatible type. If the state
changes to *RequestTagIDReady* it means that a compatible tag was found
and that the tag ID could be read out. You can now get the tag ID by
calling :func:`GetTagID`.
If two tags are in the proximity of the NFC/RFID Bricklet, this
function will cycle through the tags. To select a specific tag you have
to call :func:`RequestTagID` until the correct tag id is found.
In case of any *Error* state the selection is lost and you have to
start again by calling :func:`RequestTagID`.
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_REQUEST_TAG_ID, [tagType], 'B', '', returnCallback, errorCallback);
};
this.getTagID = function(returnCallback, errorCallback) {
/*
Returns the tag type, tag ID and the length of the tag ID
(4 or 7 bytes are possible length). This function can only be called if the
NFC/RFID is currently in one of the *Ready* states. The returned ID
is the ID that was saved through the last call of :func:`RequestTagID`.
To get the tag ID of a tag the approach is as follows:
* Call :func:`RequestTagID`
* Wait for state to change to *RequestTagIDReady* (see :func:`GetState` or :func:`StateChanged`)
* Call :func:`GetTagID`
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_GET_TAG_ID, [], '', 'B B B7', returnCallback, errorCallback);
};
this.getState = function(returnCallback, errorCallback) {
/*
Returns the current state of the NFC/RFID Bricklet.
On startup the Bricklet will be in the *Initialization* state. The
initialization will only take about 20ms. After that it changes to *Idle*.
The functions of this Bricklet can be called in the *Idle* state and all of
the *Ready* and *Error* states.
Example: If you call :func:`RequestPage`, the state will change to
*RequestPage* until the reading of the page is finished. Then it will change
to either *RequestPageReady* if it worked or to *RequestPageError* if it
didn't. If the request worked you can get the page by calling :func:`GetPage`.
The same approach is used analogously for the other API functions.
Possible states are:
* Initialization = 0
* Idle = 128
* Error = 192
* RequestTagID = 2
* RequestTagIDReady = 130
* RequestTagIDError = 194
* AuthenticatingMifareClassicPage = 3
* AuthenticatingMifareClassicPageReady = 131
* AuthenticatingMifareClassicPageError = 195
* WritePage = 4
* WritePageReady = 132
* WritePageError = 196
* RequestPage = 5
* RequestPageReady = 133
* RequestPageError = 197
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_GET_STATE, [], '', 'B ?', returnCallback, errorCallback);
};
this.authenticateMifareClassicPage = function(page, keyNumber, key, returnCallback, errorCallback) {
/*
Mifare Classic tags use authentication. If you want to read from or write to
a Mifare Classic page you have to authenticate it beforehand.
Each page can be authenticated with two keys: A (``key_number`` = 0) and B
(``key_number`` = 1). A new Mifare Classic
tag that has not yet been written to can can be accessed with key A
and the default key ``[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]``.
The approach to read or write a Mifare Classic page is as follows:
* Call :func:`RequestTagID`
* Wait for state to change to *RequestTagIDReady* (see :func:`GetState`
or :func:`StateChanged`)
* Call :func:`GetTagID` and check if tag ID is correct
* Call :func:`AuthenticateMifareClassicPage` with page and key for the page
* Wait for state to change to *AuthenticatingMifareClassicPageReady*
* Call :func:`RequestPage` or :func`WritePage` to read/write page
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_AUTHENTICATE_MIFARE_CLASSIC_PAGE, [page, keyNumber, key], 'H B B6', '', returnCallback, errorCallback);
};
this.writePage = function(page, data, returnCallback, errorCallback) {
/*
Writes 16 bytes starting from the given page. How many pages are written
depends on the tag type. The page sizes are as follows:
* Mifare Classic page size: 16 byte (one page is written)
* NFC Forum Type 1 page size: 8 byte (two pages are written)
* NFC Forum Type 2 page size: 4 byte (four pages are written)
The general approach for writing to a tag is as follows:
* Call :func:`RequestTagID`
* Wait for state to change to *RequestTagIDReady* (see :func:`GetState` or :func:`StateChanged`)
* Call :func:`GetTagID` and check if tag ID is correct
* Call :func:`WritePage` with page number and data
* Wait for state to change to *WritePageReady*
If you use a Mifare Classic tag you have to authenticate a page before you
can write to it. See :func:`AuthenticateMifareClassicPage`.
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_WRITE_PAGE, [page, data], 'H B16', '', returnCallback, errorCallback);
};
this.requestPage = function(page, returnCallback, errorCallback) {
/*
Reads 16 bytes starting from the given page and stores them into a buffer.
The buffer can then be read out with :func:`GetPage`.
How many pages are read depends on the tag type. The page sizes are
as follows:
* Mifare Classic page size: 16 byte (one page is read)
* NFC Forum Type 1 page size: 8 byte (two pages are read)
* NFC Forum Type 2 page size: 4 byte (four pages are read)
The general approach for reading a tag is as follows:
* Call :func:`RequestTagID`
* Wait for state to change to *RequestTagIDReady* (see :func:`GetState` or :func:`StateChanged`)
* Call :func:`GetTagID` and check if tag ID is correct
* Call :func:`RequestPage` with page number
* Wait for state to change to *RequestPageReady*
* Call :func:`GetPage` to retrieve the page from the buffer
If you use a Mifare Classic tag you have to authenticate a page before you
can read it. See :func:`AuthenticateMifareClassicPage`.
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_REQUEST_PAGE, [page], 'H', '', returnCallback, errorCallback);
};
this.getPage = function(returnCallback, errorCallback) {
/*
Returns 16 bytes of data from an internal buffer. To fill the buffer
with specific pages you have to call :func:`RequestPage` beforehand.
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_GET_PAGE, [], '', 'B16', returnCallback, errorCallback);
};
this.getIdentity = function(returnCallback, errorCallback) {
/*
Returns the UID, the UID where the Bricklet is connected to,
the position, the hardware and firmware version as well as the
device identifier.
The position can be 'a', 'b', 'c' or 'd'.
The device identifier numbers can be found :ref:`here <device_identifier>`.
|device_identifier_constant|
*/
this.ipcon.sendRequest(this, BrickletNFCRFID.FUNCTION_GET_IDENTITY, [], '', 's8 s8 c B3 B3 H', returnCallback, errorCallback);
};
}
module.exports = BrickletNFCRFID;
|
import moment from 'moment';
export function dateToString(date) {
if (date) {
return moment(date).format('MMM Do [at] h:mm A');
}
return null;
}
|
import React, { Component } from 'react';
import { Grid } from 'semantic-ui-react';
import PropTypes from 'prop-types';
import SocialLinkItem from './SocialLinkItem';
class SocialLinks extends Component {
render() {
const { links } = this.props;
const { only } = this.props;
const { textAlign } = this.props;
return (
<Grid.Column only={only} textAlign={textAlign}>
{links.map(link => {
const { name } = link;
return (
<SocialLinkItem key={name} link={link} />
);
})}
</Grid.Column>
);
}
}
SocialLinks.propTypes = {
links: PropTypes.array.isRequired,
only: PropTypes.string.isRequired,
textAlign: PropTypes.string.isRequired,
};
export default SocialLinks;
|
// Create global ionic obj and its namespaces
// build processes may have already created an ionic obj
window.ionic = window.ionic || {};
window.ionic.views = {};
window.ionic.version = '<%= pkg.version %>';
(function (ionic) {
ionic.DelegateService = function(methodNames) {
if (methodNames.indexOf('$getByHandle') > -1) {
throw new Error("Method '$getByHandle' is implicitly added to each delegate service. Do not list it as a method.");
}
function trueFn() { return true; }
return ['$log', function($log) {
/*
* Creates a new object that will have all the methodNames given,
* and call them on the given the controller instance matching given
* handle.
* The reason we don't just let $getByHandle return the controller instance
* itself is that the controller instance might not exist yet.
*
* We want people to be able to do
* `var instance = $ionicScrollDelegate.$getByHandle('foo')` on controller
* instantiation, but on controller instantiation a child directive
* may not have been compiled yet!
*
* So this is our way of solving this problem: we create an object
* that will only try to fetch the controller with given handle
* once the methods are actually called.
*/
function DelegateInstance(instances, handle) {
this._instances = instances;
this.handle = handle;
}
methodNames.forEach(function(methodName) {
DelegateInstance.prototype[methodName] = instanceMethodCaller(methodName);
});
/**
* The delegate service (eg $ionicNavBarDelegate) is just an instance
* with a non-defined handle, a couple extra methods for registering
* and narrowing down to a specific handle.
*/
function DelegateService() {
this._instances = [];
}
DelegateService.prototype = DelegateInstance.prototype;
DelegateService.prototype._registerInstance = function(instance, handle, filterFn) {
var instances = this._instances;
instance.$$delegateHandle = handle;
instance.$$filterFn = filterFn || trueFn;
instances.push(instance);
return function deregister() {
var index = instances.indexOf(instance);
if (index !== -1) {
instances.splice(index, 1);
}
};
};
DelegateService.prototype.$getByHandle = function(handle) {
return new DelegateInstance(this._instances, handle);
};
return new DelegateService();
function instanceMethodCaller(methodName) {
return function caller() {
var handle = this.handle;
var args = arguments;
var foundInstancesCount = 0;
var returnValue;
this._instances.forEach(function(instance) {
if ((!handle || handle == instance.$$delegateHandle) && instance.$$filterFn(instance)) {
foundInstancesCount++;
var ret = instance[methodName].apply(instance, args);
//Only return the value from the first call
if (foundInstancesCount === 1) {
returnValue = ret;
}
}
});
if (!foundInstancesCount && handle) {
return $log.warn(
'Delegate for handle "' + handle + '" could not find a ' +
'corresponding element with delegate-handle="' + handle + '"! ' +
methodName + '() was not called!\n' +
'Possible cause: If you are calling ' + methodName + '() immediately, and ' +
'your element with delegate-handle="' + handle + '" is a child of your ' +
'controller, then your element may not be compiled yet. Put a $timeout ' +
'around your call to ' + methodName + '() and try again.'
);
}
return returnValue;
};
}
}];
};
})(window.ionic);
(function(window, document, ionic) {
var readyCallbacks = [];
var isDomReady = document.readyState === 'complete' || document.readyState === 'interactive';
function domReady() {
isDomReady = true;
for (var x = 0; x < readyCallbacks.length; x++) {
ionic.requestAnimationFrame(readyCallbacks[x]);
}
readyCallbacks = [];
document.removeEventListener('DOMContentLoaded', domReady);
}
if (!isDomReady) {
document.addEventListener('DOMContentLoaded', domReady);
}
// From the man himself, Mr. Paul Irish.
// The requestAnimationFrame polyfill
// Put it on window just to preserve its context
// without having to use .call
window._rAF = (function() {
return window.requestAnimationFrame ||
window.webkitRequestAnimationFrame ||
window.mozRequestAnimationFrame ||
function(callback) {
window.setTimeout(callback, 16);
};
})();
var cancelAnimationFrame = window.cancelAnimationFrame ||
window.webkitCancelAnimationFrame ||
window.mozCancelAnimationFrame ||
window.webkitCancelRequestAnimationFrame;
/**
* @ngdoc utility
* @name ionic.DomUtil
* @module ionic
*/
ionic.DomUtil = {
//Call with proper context
/**
* @ngdoc method
* @name ionic.DomUtil#requestAnimationFrame
* @alias ionic.requestAnimationFrame
* @description Calls [requestAnimationFrame](https://developer.mozilla.org/en-US/docs/Web/API/window.requestAnimationFrame), or a polyfill if not available.
* @param {function} callback The function to call when the next frame
* happens.
*/
requestAnimationFrame: function(cb) {
return window._rAF(cb);
},
cancelAnimationFrame: function(requestId) {
cancelAnimationFrame(requestId);
},
/**
* @ngdoc method
* @name ionic.DomUtil#animationFrameThrottle
* @alias ionic.animationFrameThrottle
* @description
* When given a callback, if that callback is called 100 times between
* animation frames, adding Throttle will make it only run the last of
* the 100 calls.
*
* @param {function} callback a function which will be throttled to
* requestAnimationFrame
* @returns {function} A function which will then call the passed in callback.
* The passed in callback will receive the context the returned function is
* called with.
*/
animationFrameThrottle: function(cb) {
var args, isQueued, context;
return function() {
args = arguments;
context = this;
if (!isQueued) {
isQueued = true;
ionic.requestAnimationFrame(function() {
cb.apply(context, args);
isQueued = false;
});
}
};
},
contains: function(parentNode, otherNode) {
var current = otherNode;
while (current) {
if (current === parentNode) return true;
current = current.parentNode;
}
},
/**
* @ngdoc method
* @name ionic.DomUtil#getPositionInParent
* @description
* Find an element's scroll offset within its container.
* @param {DOMElement} element The element to find the offset of.
* @returns {object} A position object with the following properties:
* - `{number}` `left` The left offset of the element.
* - `{number}` `top` The top offset of the element.
*/
getPositionInParent: function(el) {
return {
left: el.offsetLeft,
top: el.offsetTop
};
},
/**
* @ngdoc method
* @name ionic.DomUtil#ready
* @description
* Call a function when the DOM is ready, or if it is already ready
* call the function immediately.
* @param {function} callback The function to be called.
*/
ready: function(cb) {
if (isDomReady) {
ionic.requestAnimationFrame(cb);
} else {
readyCallbacks.push(cb);
}
},
/**
* @ngdoc method
* @name ionic.DomUtil#getTextBounds
* @description
* Get a rect representing the bounds of the given textNode.
* @param {DOMElement} textNode The textNode to find the bounds of.
* @returns {object} An object representing the bounds of the node. Properties:
* - `{number}` `left` The left position of the textNode.
* - `{number}` `right` The right position of the textNode.
* - `{number}` `top` The top position of the textNode.
* - `{number}` `bottom` The bottom position of the textNode.
* - `{number}` `width` The width of the textNode.
* - `{number}` `height` The height of the textNode.
*/
getTextBounds: function(textNode) {
if (document.createRange) {
var range = document.createRange();
range.selectNodeContents(textNode);
if (range.getBoundingClientRect) {
var rect = range.getBoundingClientRect();
if (rect) {
var sx = window.scrollX;
var sy = window.scrollY;
return {
top: rect.top + sy,
left: rect.left + sx,
right: rect.left + sx + rect.width,
bottom: rect.top + sy + rect.height,
width: rect.width,
height: rect.height
};
}
}
}
return null;
},
/**
* @ngdoc method
* @name ionic.DomUtil#getChildIndex
* @description
* Get the first index of a child node within the given element of the
* specified type.
* @param {DOMElement} element The element to find the index of.
* @param {string} type The nodeName to match children of element against.
* @returns {number} The index, or -1, of a child with nodeName matching type.
*/
getChildIndex: function(element, type) {
if (type) {
var ch = element.parentNode.children;
var c;
for (var i = 0, k = 0, j = ch.length; i < j; i++) {
c = ch[i];
if (c.nodeName && c.nodeName.toLowerCase() == type) {
if (c == element) {
return k;
}
k++;
}
}
}
return Array.prototype.slice.call(element.parentNode.children).indexOf(element);
},
/**
* @private
*/
swapNodes: function(src, dest) {
dest.parentNode.insertBefore(src, dest);
},
elementIsDescendant: function(el, parent, stopAt) {
var current = el;
do {
if (current === parent) return true;
current = current.parentNode;
} while (current && current !== stopAt);
return false;
},
/**
* @ngdoc method
* @name ionic.DomUtil#getParentWithClass
* @param {DOMElement} element
* @param {string} className
* @returns {DOMElement} The closest parent of element matching the
* className, or null.
*/
getParentWithClass: function(e, className, depth) {
depth = depth || 10;
while (e.parentNode && depth--) {
if (e.parentNode.classList && e.parentNode.classList.contains(className)) {
return e.parentNode;
}
e = e.parentNode;
}
return null;
},
/**
* @ngdoc method
* @name ionic.DomUtil#getParentOrSelfWithClass
* @param {DOMElement} element
* @param {string} className
* @returns {DOMElement} The closest parent or self matching the
* className, or null.
*/
getParentOrSelfWithClass: function(e, className, depth) {
depth = depth || 10;
while (e && depth--) {
if (e.classList && e.classList.contains(className)) {
return e;
}
e = e.parentNode;
}
return null;
},
/**
* @ngdoc method
* @name ionic.DomUtil#rectContains
* @param {number} x
* @param {number} y
* @param {number} x1
* @param {number} y1
* @param {number} x2
* @param {number} y2
* @returns {boolean} Whether {x,y} fits within the rectangle defined by
* {x1,y1,x2,y2}.
*/
rectContains: function(x, y, x1, y1, x2, y2) {
if (x < x1 || x > x2) return false;
if (y < y1 || y > y2) return false;
return true;
},
/**
* @ngdoc method
* @name ionic.DomUtil#blurAll
* @description
* Blurs any currently focused input element
* @returns {DOMElement} The element blurred or null
*/
blurAll: function() {
if (document.activeElement && document.activeElement != document.body) {
document.activeElement.blur();
return document.activeElement;
}
return null;
},
cachedAttr: function(ele, key, value) {
ele = ele && ele.length && ele[0] || ele;
if (ele && ele.setAttribute) {
var dataKey = '$attr-' + key;
if (arguments.length > 2) {
if (ele[dataKey] !== value) {
ele.setAttribute(key, value);
ele[dataKey] = value;
}
} else if (typeof ele[dataKey] == 'undefined') {
ele[dataKey] = ele.getAttribute(key);
}
return ele[dataKey];
}
},
cachedStyles: function(ele, styles) {
ele = ele && ele.length && ele[0] || ele;
if (ele && ele.style) {
for (var prop in styles) {
if (ele['$style-' + prop] !== styles[prop]) {
ele.style[prop] = ele['$style-' + prop] = styles[prop];
}
}
}
}
};
//Shortcuts
ionic.requestAnimationFrame = ionic.DomUtil.requestAnimationFrame;
ionic.cancelAnimationFrame = ionic.DomUtil.cancelAnimationFrame;
ionic.animationFrameThrottle = ionic.DomUtil.animationFrameThrottle;
})(window, document, ionic);
/**
* ion-events.js
*
* Author: Max Lynch <[email protected]>
*
* Framework events handles various mobile browser events, and
* detects special events like tap/swipe/etc. and emits them
* as custom events that can be used in an app.
*
* Portions lovingly adapted from github.com/maker/ratchet and github.com/alexgibson/tap.js - thanks guys!
*/
(function(ionic) {
// Custom event polyfill
ionic.CustomEvent = (function() {
if( typeof window.CustomEvent === 'function' ) return CustomEvent;
var customEvent = function(event, params) {
var evt;
params = params || {
bubbles: false,
cancelable: false,
detail: undefined
};
try {
evt = document.createEvent("CustomEvent");
evt.initCustomEvent(event, params.bubbles, params.cancelable, params.detail);
} catch (error) {
// fallback for browsers that don't support createEvent('CustomEvent')
evt = document.createEvent("Event");
for (var param in params) {
evt[param] = params[param];
}
evt.initEvent(event, params.bubbles, params.cancelable);
}
return evt;
};
customEvent.prototype = window.Event.prototype;
return customEvent;
})();
/**
* @ngdoc utility
* @name ionic.EventController
* @module ionic
*/
ionic.EventController = {
VIRTUALIZED_EVENTS: ['tap', 'swipe', 'swiperight', 'swipeleft', 'drag', 'hold', 'release'],
/**
* @ngdoc method
* @name ionic.EventController#trigger
* @alias ionic.trigger
* @param {string} eventType The event to trigger.
* @param {object} data The data for the event. Hint: pass in
* `{target: targetElement}`
* @param {boolean=} bubbles Whether the event should bubble up the DOM.
* @param {boolean=} cancelable Whether the event should be cancelable.
*/
// Trigger a new event
trigger: function(eventType, data, bubbles, cancelable) {
var event = new ionic.CustomEvent(eventType, {
detail: data,
bubbles: !!bubbles,
cancelable: !!cancelable
});
// Make sure to trigger the event on the given target, or dispatch it from
// the window if we don't have an event target
data && data.target && data.target.dispatchEvent && data.target.dispatchEvent(event) || window.dispatchEvent(event);
},
/**
* @ngdoc method
* @name ionic.EventController#on
* @alias ionic.on
* @description Listen to an event on an element.
* @param {string} type The event to listen for.
* @param {function} callback The listener to be called.
* @param {DOMElement} element The element to listen for the event on.
*/
on: function(type, callback, element) {
var e = element || window;
// Bind a gesture if it's a virtual event
for(var i = 0, j = this.VIRTUALIZED_EVENTS.length; i < j; i++) {
if(type == this.VIRTUALIZED_EVENTS[i]) {
var gesture = new ionic.Gesture(element);
gesture.on(type, callback);
return gesture;
}
}
// Otherwise bind a normal event
e.addEventListener(type, callback);
},
/**
* @ngdoc method
* @name ionic.EventController#off
* @alias ionic.off
* @description Remove an event listener.
* @param {string} type
* @param {function} callback
* @param {DOMElement} element
*/
off: function(type, callback, element) {
element.removeEventListener(type, callback);
},
/**
* @ngdoc method
* @name ionic.EventController#onGesture
* @alias ionic.onGesture
* @description Add an event listener for a gesture on an element.
*
* Available eventTypes (from [hammer.js](http://eightmedia.github.io/hammer.js/)):
*
* `hold`, `tap`, `doubletap`, `drag`, `dragstart`, `dragend`, `dragup`, `dragdown`, <br/>
* `dragleft`, `dragright`, `swipe`, `swipeup`, `swipedown`, `swipeleft`, `swiperight`, <br/>
* `transform`, `transformstart`, `transformend`, `rotate`, `pinch`, `pinchin`, `pinchout`, </br>
* `touch`, `release`
*
* @param {string} eventType The gesture event to listen for.
* @param {function(e)} callback The function to call when the gesture
* happens.
* @param {DOMElement} element The angular element to listen for the event on.
* @param {object} options object.
* @returns {ionic.Gesture} The gesture object (use this to remove the gesture later on).
*/
onGesture: function(type, callback, element, options) {
var gesture = new ionic.Gesture(element, options);
gesture.on(type, callback);
return gesture;
},
/**
* @ngdoc method
* @name ionic.EventController#offGesture
* @alias ionic.offGesture
* @description Remove an event listener for a gesture created on an element.
* @param {ionic.Gesture} gesture The gesture that should be removed.
* @param {string} eventType The gesture event to remove the listener for.
* @param {function(e)} callback The listener to remove.
*/
offGesture: function(gesture, type, callback) {
gesture && gesture.off(type, callback);
},
handlePopState: function() {}
};
// Map some convenient top-level functions for event handling
ionic.on = function() { ionic.EventController.on.apply(ionic.EventController, arguments); };
ionic.off = function() { ionic.EventController.off.apply(ionic.EventController, arguments); };
ionic.trigger = ionic.EventController.trigger;//function() { ionic.EventController.trigger.apply(ionic.EventController.trigger, arguments); };
ionic.onGesture = function() { return ionic.EventController.onGesture.apply(ionic.EventController.onGesture, arguments); };
ionic.offGesture = function() { return ionic.EventController.offGesture.apply(ionic.EventController.offGesture, arguments); };
})(window.ionic);
/* eslint camelcase:0 */
/**
* Simple gesture controllers with some common gestures that emit
* gesture events.
*
* Ported from github.com/EightMedia/hammer.js Gestures - thanks!
*/
(function(ionic) {
/**
* ionic.Gestures
* use this to create instances
* @param {HTMLElement} element
* @param {Object} options
* @returns {ionic.Gestures.Instance}
* @constructor
*/
ionic.Gesture = function(element, options) {
return new ionic.Gestures.Instance(element, options || {});
};
ionic.Gestures = {};
// default settings
ionic.Gestures.defaults = {
// add css to the element to prevent the browser from doing
// its native behavior. this doesnt prevent the scrolling,
// but cancels the contextmenu, tap highlighting etc
// set to false to disable this
stop_browser_behavior: 'disable-user-behavior'
};
// detect touchevents
ionic.Gestures.HAS_POINTEREVENTS = window.navigator.pointerEnabled || window.navigator.msPointerEnabled;
ionic.Gestures.HAS_TOUCHEVENTS = ('ontouchstart' in window);
// dont use mouseevents on mobile devices
ionic.Gestures.MOBILE_REGEX = /mobile|tablet|ip(ad|hone|od)|android|silk/i;
ionic.Gestures.NO_MOUSEEVENTS = ionic.Gestures.HAS_TOUCHEVENTS && window.navigator.userAgent.match(ionic.Gestures.MOBILE_REGEX);
// eventtypes per touchevent (start, move, end)
// are filled by ionic.Gestures.event.determineEventTypes on setup
ionic.Gestures.EVENT_TYPES = {};
// direction defines
ionic.Gestures.DIRECTION_DOWN = 'down';
ionic.Gestures.DIRECTION_LEFT = 'left';
ionic.Gestures.DIRECTION_UP = 'up';
ionic.Gestures.DIRECTION_RIGHT = 'right';
// pointer type
ionic.Gestures.POINTER_MOUSE = 'mouse';
ionic.Gestures.POINTER_TOUCH = 'touch';
ionic.Gestures.POINTER_PEN = 'pen';
// touch event defines
ionic.Gestures.EVENT_START = 'start';
ionic.Gestures.EVENT_MOVE = 'move';
ionic.Gestures.EVENT_END = 'end';
// hammer document where the base events are added at
ionic.Gestures.DOCUMENT = window.document;
// plugins namespace
ionic.Gestures.plugins = {};
// if the window events are set...
ionic.Gestures.READY = false;
/**
* setup events to detect gestures on the document
*/
function setup() {
if(ionic.Gestures.READY) {
return;
}
// find what eventtypes we add listeners to
ionic.Gestures.event.determineEventTypes();
// Register all gestures inside ionic.Gestures.gestures
for(var name in ionic.Gestures.gestures) {
if(ionic.Gestures.gestures.hasOwnProperty(name)) {
ionic.Gestures.detection.register(ionic.Gestures.gestures[name]);
}
}
// Add touch events on the document
ionic.Gestures.event.onTouch(ionic.Gestures.DOCUMENT, ionic.Gestures.EVENT_MOVE, ionic.Gestures.detection.detect);
ionic.Gestures.event.onTouch(ionic.Gestures.DOCUMENT, ionic.Gestures.EVENT_END, ionic.Gestures.detection.detect);
// ionic.Gestures is ready...!
ionic.Gestures.READY = true;
}
/**
* create new hammer instance
* all methods should return the instance itself, so it is chainable.
* @param {HTMLElement} element
* @param {Object} [options={}]
* @returns {ionic.Gestures.Instance}
* @name Gesture.Instance
* @constructor
*/
ionic.Gestures.Instance = function(element, options) {
var self = this;
// A null element was passed into the instance, which means
// whatever lookup was done to find this element failed to find it
// so we can't listen for events on it.
if(element === null) {
console.error('Null element passed to gesture (element does not exist). Not listening for gesture');
return this;
}
// setup ionic.GesturesJS window events and register all gestures
// this also sets up the default options
setup();
this.element = element;
// start/stop detection option
this.enabled = true;
// merge options
this.options = ionic.Gestures.utils.extend(
ionic.Gestures.utils.extend({}, ionic.Gestures.defaults),
options || {});
// add some css to the element to prevent the browser from doing its native behavoir
if(this.options.stop_browser_behavior) {
ionic.Gestures.utils.stopDefaultBrowserBehavior(this.element, this.options.stop_browser_behavior);
}
// start detection on touchstart
ionic.Gestures.event.onTouch(element, ionic.Gestures.EVENT_START, function(ev) {
if(self.enabled) {
ionic.Gestures.detection.startDetect(self, ev);
}
});
// return instance
return this;
};
ionic.Gestures.Instance.prototype = {
/**
* bind events to the instance
* @param {String} gesture
* @param {Function} handler
* @returns {ionic.Gestures.Instance}
*/
on: function onEvent(gesture, handler){
var gestures = gesture.split(' ');
for(var t = 0; t < gestures.length; t++) {
this.element.addEventListener(gestures[t], handler, false);
}
return this;
},
/**
* unbind events to the instance
* @param {String} gesture
* @param {Function} handler
* @returns {ionic.Gestures.Instance}
*/
off: function offEvent(gesture, handler){
var gestures = gesture.split(' ');
for(var t = 0; t < gestures.length; t++) {
this.element.removeEventListener(gestures[t], handler, false);
}
return this;
},
/**
* trigger gesture event
* @param {String} gesture
* @param {Object} eventData
* @returns {ionic.Gestures.Instance}
*/
trigger: function triggerEvent(gesture, eventData){
// create DOM event
var event = ionic.Gestures.DOCUMENT.createEvent('Event');
event.initEvent(gesture, true, true);
event.gesture = eventData;
// trigger on the target if it is in the instance element,
// this is for event delegation tricks
var element = this.element;
if(ionic.Gestures.utils.hasParent(eventData.target, element)) {
element = eventData.target;
}
element.dispatchEvent(event);
return this;
},
/**
* enable of disable hammer.js detection
* @param {Boolean} state
* @returns {ionic.Gestures.Instance}
*/
enable: function enable(state) {
this.enabled = state;
return this;
}
};
/**
* this holds the last move event,
* used to fix empty touchend issue
* see the onTouch event for an explanation
* type {Object}
*/
var last_move_event = null;
/**
* when the mouse is hold down, this is true
* type {Boolean}
*/
var enable_detect = false;
/**
* when touch events have been fired, this is true
* type {Boolean}
*/
var touch_triggered = false;
ionic.Gestures.event = {
/**
* simple addEventListener
* @param {HTMLElement} element
* @param {String} type
* @param {Function} handler
*/
bindDom: function(element, type, handler) {
var types = type.split(' ');
for(var t = 0; t < types.length; t++) {
element.addEventListener(types[t], handler, false);
}
},
/**
* touch events with mouse fallback
* @param {HTMLElement} element
* @param {String} eventType like ionic.Gestures.EVENT_MOVE
* @param {Function} handler
*/
onTouch: function onTouch(element, eventType, handler) {
var self = this;
this.bindDom(element, ionic.Gestures.EVENT_TYPES[eventType], function bindDomOnTouch(ev) {
var sourceEventType = ev.type.toLowerCase();
// onmouseup, but when touchend has been fired we do nothing.
// this is for touchdevices which also fire a mouseup on touchend
if(sourceEventType.match(/mouse/) && touch_triggered) {
return;
}
// mousebutton must be down or a touch event
else if( sourceEventType.match(/touch/) || // touch events are always on screen
sourceEventType.match(/pointerdown/) || // pointerevents touch
(sourceEventType.match(/mouse/) && ev.which === 1) // mouse is pressed
){
enable_detect = true;
}
// mouse isn't pressed
else if(sourceEventType.match(/mouse/) && ev.which !== 1) {
enable_detect = false;
}
// we are in a touch event, set the touch triggered bool to true,
// this for the conflicts that may occur on ios and android
if(sourceEventType.match(/touch|pointer/)) {
touch_triggered = true;
}
// count the total touches on the screen
var count_touches = 0;
// when touch has been triggered in this detection session
// and we are now handling a mouse event, we stop that to prevent conflicts
if(enable_detect) {
// update pointerevent
if(ionic.Gestures.HAS_POINTEREVENTS && eventType != ionic.Gestures.EVENT_END) {
count_touches = ionic.Gestures.PointerEvent.updatePointer(eventType, ev);
}
// touch
else if(sourceEventType.match(/touch/)) {
count_touches = ev.touches.length;
}
// mouse
else if(!touch_triggered) {
count_touches = sourceEventType.match(/up/) ? 0 : 1;
}
// if we are in a end event, but when we remove one touch and
// we still have enough, set eventType to move
if(count_touches > 0 && eventType == ionic.Gestures.EVENT_END) {
eventType = ionic.Gestures.EVENT_MOVE;
}
// no touches, force the end event
else if(!count_touches) {
eventType = ionic.Gestures.EVENT_END;
}
// store the last move event
if(count_touches || last_move_event === null) {
last_move_event = ev;
}
// trigger the handler
handler.call(ionic.Gestures.detection, self.collectEventData(element, eventType, self.getTouchList(last_move_event, eventType), ev));
// remove pointerevent from list
if(ionic.Gestures.HAS_POINTEREVENTS && eventType == ionic.Gestures.EVENT_END) {
count_touches = ionic.Gestures.PointerEvent.updatePointer(eventType, ev);
}
}
//debug(sourceEventType +" "+ eventType);
// on the end we reset everything
if(!count_touches) {
last_move_event = null;
enable_detect = false;
touch_triggered = false;
ionic.Gestures.PointerEvent.reset();
}
});
},
/**
* we have different events for each device/browser
* determine what we need and set them in the ionic.Gestures.EVENT_TYPES constant
*/
determineEventTypes: function determineEventTypes() {
// determine the eventtype we want to set
var types;
// pointerEvents magic
if(ionic.Gestures.HAS_POINTEREVENTS) {
types = ionic.Gestures.PointerEvent.getEvents();
}
// on Android, iOS, blackberry, windows mobile we dont want any mouseevents
else if(ionic.Gestures.NO_MOUSEEVENTS) {
types = [
'touchstart',
'touchmove',
'touchend touchcancel'];
}
// for non pointer events browsers and mixed browsers,
// like chrome on windows8 touch laptop
else {
types = [
'touchstart mousedown',
'touchmove mousemove',
'touchend touchcancel mouseup'];
}
ionic.Gestures.EVENT_TYPES[ionic.Gestures.EVENT_START] = types[0];
ionic.Gestures.EVENT_TYPES[ionic.Gestures.EVENT_MOVE] = types[1];
ionic.Gestures.EVENT_TYPES[ionic.Gestures.EVENT_END] = types[2];
},
/**
* create touchlist depending on the event
* @param {Object} ev
* @param {String} eventType used by the fakemultitouch plugin
*/
getTouchList: function getTouchList(ev/*, eventType*/) {
// get the fake pointerEvent touchlist
if(ionic.Gestures.HAS_POINTEREVENTS) {
return ionic.Gestures.PointerEvent.getTouchList();
}
// get the touchlist
else if(ev.touches) {
return ev.touches;
}
// make fake touchlist from mouse position
else {
ev.identifier = 1;
return [ev];
}
},
/**
* collect event data for ionic.Gestures js
* @param {HTMLElement} element
* @param {String} eventType like ionic.Gestures.EVENT_MOVE
* @param {Object} eventData
*/
collectEventData: function collectEventData(element, eventType, touches, ev) {
// find out pointerType
var pointerType = ionic.Gestures.POINTER_TOUCH;
if(ev.type.match(/mouse/) || ionic.Gestures.PointerEvent.matchType(ionic.Gestures.POINTER_MOUSE, ev)) {
pointerType = ionic.Gestures.POINTER_MOUSE;
}
return {
center: ionic.Gestures.utils.getCenter(touches),
timeStamp: new Date().getTime(),
target: ev.target,
touches: touches,
eventType: eventType,
pointerType: pointerType,
srcEvent: ev,
/**
* prevent the browser default actions
* mostly used to disable scrolling of the browser
*/
preventDefault: function() {
if(this.srcEvent.preventManipulation) {
this.srcEvent.preventManipulation();
}
if(this.srcEvent.preventDefault) {
// this.srcEvent.preventDefault();
}
},
/**
* stop bubbling the event up to its parents
*/
stopPropagation: function() {
this.srcEvent.stopPropagation();
},
/**
* immediately stop gesture detection
* might be useful after a swipe was detected
* @return {*}
*/
stopDetect: function() {
return ionic.Gestures.detection.stopDetect();
}
};
}
};
ionic.Gestures.PointerEvent = {
/**
* holds all pointers
* type {Object}
*/
pointers: {},
/**
* get a list of pointers
* @returns {Array} touchlist
*/
getTouchList: function() {
var self = this;
var touchlist = [];
// we can use forEach since pointerEvents only is in IE10
Object.keys(self.pointers).sort().forEach(function(id) {
touchlist.push(self.pointers[id]);
});
return touchlist;
},
/**
* update the position of a pointer
* @param {String} type ionic.Gestures.EVENT_END
* @param {Object} pointerEvent
*/
updatePointer: function(type, pointerEvent) {
if(type == ionic.Gestures.EVENT_END) {
this.pointers = {};
}
else {
pointerEvent.identifier = pointerEvent.pointerId;
this.pointers[pointerEvent.pointerId] = pointerEvent;
}
return Object.keys(this.pointers).length;
},
/**
* check if ev matches pointertype
* @param {String} pointerType ionic.Gestures.POINTER_MOUSE
* @param {PointerEvent} ev
*/
matchType: function(pointerType, ev) {
if(!ev.pointerType) {
return false;
}
var types = {};
types[ionic.Gestures.POINTER_MOUSE] = (ev.pointerType == ev.MSPOINTER_TYPE_MOUSE || ev.pointerType == ionic.Gestures.POINTER_MOUSE);
types[ionic.Gestures.POINTER_TOUCH] = (ev.pointerType == ev.MSPOINTER_TYPE_TOUCH || ev.pointerType == ionic.Gestures.POINTER_TOUCH);
types[ionic.Gestures.POINTER_PEN] = (ev.pointerType == ev.MSPOINTER_TYPE_PEN || ev.pointerType == ionic.Gestures.POINTER_PEN);
return types[pointerType];
},
/**
* get events
*/
getEvents: function() {
return [
'pointerdown MSPointerDown',
'pointermove MSPointerMove',
'pointerup pointercancel MSPointerUp MSPointerCancel'
];
},
/**
* reset the list
*/
reset: function() {
this.pointers = {};
}
};
ionic.Gestures.utils = {
/**
* extend method,
* also used for cloning when dest is an empty object
* @param {Object} dest
* @param {Object} src
* @param {Boolean} merge do a merge
* @returns {Object} dest
*/
extend: function extend(dest, src, merge) {
for (var key in src) {
if(dest[key] !== undefined && merge) {
continue;
}
dest[key] = src[key];
}
return dest;
},
/**
* find if a node is in the given parent
* used for event delegation tricks
* @param {HTMLElement} node
* @param {HTMLElement} parent
* @returns {boolean} has_parent
*/
hasParent: function(node, parent) {
while(node){
if(node == parent) {
return true;
}
node = node.parentNode;
}
return false;
},
/**
* get the center of all the touches
* @param {Array} touches
* @returns {Object} center
*/
getCenter: function getCenter(touches) {
var valuesX = [], valuesY = [];
for(var t = 0, len = touches.length; t < len; t++) {
valuesX.push(touches[t].pageX);
valuesY.push(touches[t].pageY);
}
return {
pageX: ((Math.min.apply(Math, valuesX) + Math.max.apply(Math, valuesX)) / 2),
pageY: ((Math.min.apply(Math, valuesY) + Math.max.apply(Math, valuesY)) / 2)
};
},
/**
* calculate the velocity between two points
* @param {Number} delta_time
* @param {Number} delta_x
* @param {Number} delta_y
* @returns {Object} velocity
*/
getVelocity: function getVelocity(delta_time, delta_x, delta_y) {
return {
x: Math.abs(delta_x / delta_time) || 0,
y: Math.abs(delta_y / delta_time) || 0
};
},
/**
* calculate the angle between two coordinates
* @param {Touch} touch1
* @param {Touch} touch2
* @returns {Number} angle
*/
getAngle: function getAngle(touch1, touch2) {
var y = touch2.pageY - touch1.pageY,
x = touch2.pageX - touch1.pageX;
return Math.atan2(y, x) * 180 / Math.PI;
},
/**
* angle to direction define
* @param {Touch} touch1
* @param {Touch} touch2
* @returns {String} direction constant, like ionic.Gestures.DIRECTION_LEFT
*/
getDirection: function getDirection(touch1, touch2) {
var x = Math.abs(touch1.pageX - touch2.pageX),
y = Math.abs(touch1.pageY - touch2.pageY);
if(x >= y) {
return touch1.pageX - touch2.pageX > 0 ? ionic.Gestures.DIRECTION_LEFT : ionic.Gestures.DIRECTION_RIGHT;
}
else {
return touch1.pageY - touch2.pageY > 0 ? ionic.Gestures.DIRECTION_UP : ionic.Gestures.DIRECTION_DOWN;
}
},
/**
* calculate the distance between two touches
* @param {Touch} touch1
* @param {Touch} touch2
* @returns {Number} distance
*/
getDistance: function getDistance(touch1, touch2) {
var x = touch2.pageX - touch1.pageX,
y = touch2.pageY - touch1.pageY;
return Math.sqrt((x * x) + (y * y));
},
/**
* calculate the scale factor between two touchLists (fingers)
* no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
* @param {Array} start
* @param {Array} end
* @returns {Number} scale
*/
getScale: function getScale(start, end) {
// need two fingers...
if(start.length >= 2 && end.length >= 2) {
return this.getDistance(end[0], end[1]) /
this.getDistance(start[0], start[1]);
}
return 1;
},
/**
* calculate the rotation degrees between two touchLists (fingers)
* @param {Array} start
* @param {Array} end
* @returns {Number} rotation
*/
getRotation: function getRotation(start, end) {
// need two fingers
if(start.length >= 2 && end.length >= 2) {
return this.getAngle(end[1], end[0]) -
this.getAngle(start[1], start[0]);
}
return 0;
},
/**
* boolean if the direction is vertical
* @param {String} direction
* @returns {Boolean} is_vertical
*/
isVertical: function isVertical(direction) {
return (direction == ionic.Gestures.DIRECTION_UP || direction == ionic.Gestures.DIRECTION_DOWN);
},
/**
* stop browser default behavior with css class
* @param {HtmlElement} element
* @param {Object} css_class
*/
stopDefaultBrowserBehavior: function stopDefaultBrowserBehavior(element, css_class) {
// changed from making many style changes to just adding a preset classname
// less DOM manipulations, less code, and easier to control in the CSS side of things
// hammer.js doesn't come with CSS, but ionic does, which is why we prefer this method
if(element && element.classList) {
element.classList.add(css_class);
element.onselectstart = function() {
return false;
};
}
}
};
ionic.Gestures.detection = {
// contains all registred ionic.Gestures.gestures in the correct order
gestures: [],
// data of the current ionic.Gestures.gesture detection session
current: null,
// the previous ionic.Gestures.gesture session data
// is a full clone of the previous gesture.current object
previous: null,
// when this becomes true, no gestures are fired
stopped: false,
/**
* start ionic.Gestures.gesture detection
* @param {ionic.Gestures.Instance} inst
* @param {Object} eventData
*/
startDetect: function startDetect(inst, eventData) {
// already busy with a ionic.Gestures.gesture detection on an element
if(this.current) {
return;
}
this.stopped = false;
this.current = {
inst: inst, // reference to ionic.GesturesInstance we're working for
startEvent: ionic.Gestures.utils.extend({}, eventData), // start eventData for distances, timing etc
lastEvent: false, // last eventData
name: '' // current gesture we're in/detected, can be 'tap', 'hold' etc
};
this.detect(eventData);
},
/**
* ionic.Gestures.gesture detection
* @param {Object} eventData
*/
detect: function detect(eventData) {
if(!this.current || this.stopped) {
return null;
}
// extend event data with calculations about scale, distance etc
eventData = this.extendEventData(eventData);
// instance options
var inst_options = this.current.inst.options;
// call ionic.Gestures.gesture handlers
for(var g = 0, len = this.gestures.length; g < len; g++) {
var gesture = this.gestures[g];
// only when the instance options have enabled this gesture
if(!this.stopped && inst_options[gesture.name] !== false) {
// if a handler returns false, we stop with the detection
if(gesture.handler.call(gesture, eventData, this.current.inst) === false) {
this.stopDetect();
break;
}
}
}
// store as previous event event
if(this.current) {
this.current.lastEvent = eventData;
}
// endevent, but not the last touch, so dont stop
if(eventData.eventType == ionic.Gestures.EVENT_END && !eventData.touches.length - 1) {
this.stopDetect();
}
return eventData;
},
/**
* clear the ionic.Gestures.gesture vars
* this is called on endDetect, but can also be used when a final ionic.Gestures.gesture has been detected
* to stop other ionic.Gestures.gestures from being fired
*/
stopDetect: function stopDetect() {
// clone current data to the store as the previous gesture
// used for the double tap gesture, since this is an other gesture detect session
this.previous = ionic.Gestures.utils.extend({}, this.current);
// reset the current
this.current = null;
// stopped!
this.stopped = true;
},
/**
* extend eventData for ionic.Gestures.gestures
* @param {Object} ev
* @returns {Object} ev
*/
extendEventData: function extendEventData(ev) {
var startEv = this.current.startEvent;
// if the touches change, set the new touches over the startEvent touches
// this because touchevents don't have all the touches on touchstart, or the
// user must place his fingers at the EXACT same time on the screen, which is not realistic
// but, sometimes it happens that both fingers are touching at the EXACT same time
if(startEv && (ev.touches.length != startEv.touches.length || ev.touches === startEv.touches)) {
// extend 1 level deep to get the touchlist with the touch objects
startEv.touches = [];
for(var i = 0, len = ev.touches.length; i < len; i++) {
startEv.touches.push(ionic.Gestures.utils.extend({}, ev.touches[i]));
}
}
var delta_time = ev.timeStamp - startEv.timeStamp,
delta_x = ev.center.pageX - startEv.center.pageX,
delta_y = ev.center.pageY - startEv.center.pageY,
velocity = ionic.Gestures.utils.getVelocity(delta_time, delta_x, delta_y);
ionic.Gestures.utils.extend(ev, {
deltaTime: delta_time,
deltaX: delta_x,
deltaY: delta_y,
velocityX: velocity.x,
velocityY: velocity.y,
distance: ionic.Gestures.utils.getDistance(startEv.center, ev.center),
angle: ionic.Gestures.utils.getAngle(startEv.center, ev.center),
direction: ionic.Gestures.utils.getDirection(startEv.center, ev.center),
scale: ionic.Gestures.utils.getScale(startEv.touches, ev.touches),
rotation: ionic.Gestures.utils.getRotation(startEv.touches, ev.touches),
startEvent: startEv
});
return ev;
},
/**
* register new gesture
* @param {Object} gesture object, see gestures.js for documentation
* @returns {Array} gestures
*/
register: function register(gesture) {
// add an enable gesture options if there is no given
var options = gesture.defaults || {};
if(options[gesture.name] === undefined) {
options[gesture.name] = true;
}
// extend ionic.Gestures default options with the ionic.Gestures.gesture options
ionic.Gestures.utils.extend(ionic.Gestures.defaults, options, true);
// set its index
gesture.index = gesture.index || 1000;
// add ionic.Gestures.gesture to the list
this.gestures.push(gesture);
// sort the list by index
this.gestures.sort(function(a, b) {
if (a.index < b.index) {
return -1;
}
if (a.index > b.index) {
return 1;
}
return 0;
});
return this.gestures;
}
};
ionic.Gestures.gestures = ionic.Gestures.gestures || {};
/**
* Custom gestures
* ==============================
*
* Gesture object
* --------------------
* The object structure of a gesture:
*
* { name: 'mygesture',
* index: 1337,
* defaults: {
* mygesture_option: true
* }
* handler: function(type, ev, inst) {
* // trigger gesture event
* inst.trigger(this.name, ev);
* }
* }
* @param {String} name
* this should be the name of the gesture, lowercase
* it is also being used to disable/enable the gesture per instance config.
*
* @param {Number} [index=1000]
* the index of the gesture, where it is going to be in the stack of gestures detection
* like when you build an gesture that depends on the drag gesture, it is a good
* idea to place it after the index of the drag gesture.
*
* @param {Object} [defaults={}]
* the default settings of the gesture. these are added to the instance settings,
* and can be overruled per instance. you can also add the name of the gesture,
* but this is also added by default (and set to true).
*
* @param {Function} handler
* this handles the gesture detection of your custom gesture and receives the
* following arguments:
*
* @param {Object} eventData
* event data containing the following properties:
* timeStamp {Number} time the event occurred
* target {HTMLElement} target element
* touches {Array} touches (fingers, pointers, mouse) on the screen
* pointerType {String} kind of pointer that was used. matches ionic.Gestures.POINTER_MOUSE|TOUCH
* center {Object} center position of the touches. contains pageX and pageY
* deltaTime {Number} the total time of the touches in the screen
* deltaX {Number} the delta on x axis we haved moved
* deltaY {Number} the delta on y axis we haved moved
* velocityX {Number} the velocity on the x
* velocityY {Number} the velocity on y
* angle {Number} the angle we are moving
* direction {String} the direction we are moving. matches ionic.Gestures.DIRECTION_UP|DOWN|LEFT|RIGHT
* distance {Number} the distance we haved moved
* scale {Number} scaling of the touches, needs 2 touches
* rotation {Number} rotation of the touches, needs 2 touches *
* eventType {String} matches ionic.Gestures.EVENT_START|MOVE|END
* srcEvent {Object} the source event, like TouchStart or MouseDown *
* startEvent {Object} contains the same properties as above,
* but from the first touch. this is used to calculate
* distances, deltaTime, scaling etc
*
* @param {ionic.Gestures.Instance} inst
* the instance we are doing the detection for. you can get the options from
* the inst.options object and trigger the gesture event by calling inst.trigger
*
*
* Handle gestures
* --------------------
* inside the handler you can get/set ionic.Gestures.detectionic.current. This is the current
* detection sessionic. It has the following properties
* @param {String} name
* contains the name of the gesture we have detected. it has not a real function,
* only to check in other gestures if something is detected.
* like in the drag gesture we set it to 'drag' and in the swipe gesture we can
* check if the current gesture is 'drag' by accessing ionic.Gestures.detectionic.current.name
*
* readonly
* @param {ionic.Gestures.Instance} inst
* the instance we do the detection for
*
* readonly
* @param {Object} startEvent
* contains the properties of the first gesture detection in this sessionic.
* Used for calculations about timing, distance, etc.
*
* readonly
* @param {Object} lastEvent
* contains all the properties of the last gesture detect in this sessionic.
*
* after the gesture detection session has been completed (user has released the screen)
* the ionic.Gestures.detectionic.current object is copied into ionic.Gestures.detectionic.previous,
* this is usefull for gestures like doubletap, where you need to know if the
* previous gesture was a tap
*
* options that have been set by the instance can be received by calling inst.options
*
* You can trigger a gesture event by calling inst.trigger("mygesture", event).
* The first param is the name of your gesture, the second the event argument
*
*
* Register gestures
* --------------------
* When an gesture is added to the ionic.Gestures.gestures object, it is auto registered
* at the setup of the first ionic.Gestures instance. You can also call ionic.Gestures.detectionic.register
* manually and pass your gesture object as a param
*
*/
/**
* Hold
* Touch stays at the same place for x time
* events hold
*/
ionic.Gestures.gestures.Hold = {
name: 'hold',
index: 10,
defaults: {
hold_timeout: 500,
hold_threshold: 1
},
timer: null,
handler: function holdGesture(ev, inst) {
switch(ev.eventType) {
case ionic.Gestures.EVENT_START:
// clear any running timers
clearTimeout(this.timer);
// set the gesture so we can check in the timeout if it still is
ionic.Gestures.detection.current.name = this.name;
// set timer and if after the timeout it still is hold,
// we trigger the hold event
this.timer = setTimeout(function() {
if(ionic.Gestures.detection.current.name == 'hold') {
ionic.tap.cancelClick();
inst.trigger('hold', ev);
}
}, inst.options.hold_timeout);
break;
// when you move or end we clear the timer
case ionic.Gestures.EVENT_MOVE:
if(ev.distance > inst.options.hold_threshold) {
clearTimeout(this.timer);
}
break;
case ionic.Gestures.EVENT_END:
clearTimeout(this.timer);
break;
}
}
};
/**
* Tap/DoubleTap
* Quick touch at a place or double at the same place
* events tap, doubletap
*/
ionic.Gestures.gestures.Tap = {
name: 'tap',
index: 100,
defaults: {
tap_max_touchtime: 250,
tap_max_distance: 10,
tap_always: true,
doubletap_distance: 20,
doubletap_interval: 300
},
handler: function tapGesture(ev, inst) {
if(ev.eventType == ionic.Gestures.EVENT_END && ev.srcEvent.type != 'touchcancel') {
// previous gesture, for the double tap since these are two different gesture detections
var prev = ionic.Gestures.detection.previous,
did_doubletap = false;
// when the touchtime is higher then the max touch time
// or when the moving distance is too much
if(ev.deltaTime > inst.options.tap_max_touchtime ||
ev.distance > inst.options.tap_max_distance) {
return;
}
// check if double tap
if(prev && prev.name == 'tap' &&
(ev.timeStamp - prev.lastEvent.timeStamp) < inst.options.doubletap_interval &&
ev.distance < inst.options.doubletap_distance) {
inst.trigger('doubletap', ev);
did_doubletap = true;
}
// do a single tap
if(!did_doubletap || inst.options.tap_always) {
ionic.Gestures.detection.current.name = 'tap';
inst.trigger('tap', ev);
}
}
}
};
/**
* Swipe
* triggers swipe events when the end velocity is above the threshold
* events swipe, swipeleft, swiperight, swipeup, swipedown
*/
ionic.Gestures.gestures.Swipe = {
name: 'swipe',
index: 40,
defaults: {
// set 0 for unlimited, but this can conflict with transform
swipe_max_touches: 1,
swipe_velocity: 0.4
},
handler: function swipeGesture(ev, inst) {
if(ev.eventType == ionic.Gestures.EVENT_END) {
// max touches
if(inst.options.swipe_max_touches > 0 &&
ev.touches.length > inst.options.swipe_max_touches) {
return;
}
// when the distance we moved is too small we skip this gesture
// or we can be already in dragging
if(ev.velocityX > inst.options.swipe_velocity ||
ev.velocityY > inst.options.swipe_velocity) {
// trigger swipe events
inst.trigger(this.name, ev);
inst.trigger(this.name + ev.direction, ev);
}
}
}
};
/**
* Drag
* Move with x fingers (default 1) around on the page. Blocking the scrolling when
* moving left and right is a good practice. When all the drag events are blocking
* you disable scrolling on that area.
* events drag, drapleft, dragright, dragup, dragdown
*/
ionic.Gestures.gestures.Drag = {
name: 'drag',
index: 50,
defaults: {
drag_min_distance: 10,
// Set correct_for_drag_min_distance to true to make the starting point of the drag
// be calculated from where the drag was triggered, not from where the touch started.
// Useful to avoid a jerk-starting drag, which can make fine-adjustments
// through dragging difficult, and be visually unappealing.
correct_for_drag_min_distance: true,
// set 0 for unlimited, but this can conflict with transform
drag_max_touches: 1,
// prevent default browser behavior when dragging occurs
// be careful with it, it makes the element a blocking element
// when you are using the drag gesture, it is a good practice to set this true
drag_block_horizontal: true,
drag_block_vertical: true,
// drag_lock_to_axis keeps the drag gesture on the axis that it started on,
// It disallows vertical directions if the initial direction was horizontal, and vice versa.
drag_lock_to_axis: false,
// drag lock only kicks in when distance > drag_lock_min_distance
// This way, locking occurs only when the distance has become large enough to reliably determine the direction
drag_lock_min_distance: 25,
// prevent default if the gesture is going the given direction
prevent_default_directions: []
},
triggered: false,
handler: function dragGesture(ev, inst) {
if (ev.srcEvent.type == 'touchstart' || ev.srcEvent.type == 'touchend') {
this.preventedFirstMove = false;
} else if (!this.preventedFirstMove && ev.srcEvent.type == 'touchmove') {
// Prevent gestures that are not intended for this event handler from firing subsequent times
if (inst.options.prevent_default_directions.length > 0
&& inst.options.prevent_default_directions.indexOf(ev.direction) != -1) {
ev.srcEvent.preventDefault();
}
this.preventedFirstMove = true;
}
// current gesture isnt drag, but dragged is true
// this means an other gesture is busy. now call dragend
if(ionic.Gestures.detection.current.name != this.name && this.triggered) {
inst.trigger(this.name + 'end', ev);
this.triggered = false;
return;
}
// max touches
if(inst.options.drag_max_touches > 0 &&
ev.touches.length > inst.options.drag_max_touches) {
return;
}
switch(ev.eventType) {
case ionic.Gestures.EVENT_START:
this.triggered = false;
break;
case ionic.Gestures.EVENT_MOVE:
// when the distance we moved is too small we skip this gesture
// or we can be already in dragging
if(ev.distance < inst.options.drag_min_distance &&
ionic.Gestures.detection.current.name != this.name) {
return;
}
// we are dragging!
if(ionic.Gestures.detection.current.name != this.name) {
ionic.Gestures.detection.current.name = this.name;
if (inst.options.correct_for_drag_min_distance) {
// When a drag is triggered, set the event center to drag_min_distance pixels from the original event center.
// Without this correction, the dragged distance would jumpstart at drag_min_distance pixels instead of at 0.
// It might be useful to save the original start point somewhere
var factor = Math.abs(inst.options.drag_min_distance / ev.distance);
ionic.Gestures.detection.current.startEvent.center.pageX += ev.deltaX * factor;
ionic.Gestures.detection.current.startEvent.center.pageY += ev.deltaY * factor;
// recalculate event data using new start point
ev = ionic.Gestures.detection.extendEventData(ev);
}
}
// lock drag to axis?
if(ionic.Gestures.detection.current.lastEvent.drag_locked_to_axis || (inst.options.drag_lock_to_axis && inst.options.drag_lock_min_distance <= ev.distance)) {
ev.drag_locked_to_axis = true;
}
var last_direction = ionic.Gestures.detection.current.lastEvent.direction;
if(ev.drag_locked_to_axis && last_direction !== ev.direction) {
// keep direction on the axis that the drag gesture started on
if(ionic.Gestures.utils.isVertical(last_direction)) {
ev.direction = (ev.deltaY < 0) ? ionic.Gestures.DIRECTION_UP : ionic.Gestures.DIRECTION_DOWN;
}
else {
ev.direction = (ev.deltaX < 0) ? ionic.Gestures.DIRECTION_LEFT : ionic.Gestures.DIRECTION_RIGHT;
}
}
// first time, trigger dragstart event
if(!this.triggered) {
inst.trigger(this.name + 'start', ev);
this.triggered = true;
}
// trigger normal event
inst.trigger(this.name, ev);
// direction event, like dragdown
inst.trigger(this.name + ev.direction, ev);
// block the browser events
if( (inst.options.drag_block_vertical && ionic.Gestures.utils.isVertical(ev.direction)) ||
(inst.options.drag_block_horizontal && !ionic.Gestures.utils.isVertical(ev.direction))) {
ev.preventDefault();
}
break;
case ionic.Gestures.EVENT_END:
// trigger dragend
if(this.triggered) {
inst.trigger(this.name + 'end', ev);
}
this.triggered = false;
break;
}
}
};
/**
* Transform
* User want to scale or rotate with 2 fingers
* events transform, pinch, pinchin, pinchout, rotate
*/
ionic.Gestures.gestures.Transform = {
name: 'transform',
index: 45,
defaults: {
// factor, no scale is 1, zoomin is to 0 and zoomout until higher then 1
transform_min_scale: 0.01,
// rotation in degrees
transform_min_rotation: 1,
// prevent default browser behavior when two touches are on the screen
// but it makes the element a blocking element
// when you are using the transform gesture, it is a good practice to set this true
transform_always_block: false
},
triggered: false,
handler: function transformGesture(ev, inst) {
// current gesture isnt drag, but dragged is true
// this means an other gesture is busy. now call dragend
if(ionic.Gestures.detection.current.name != this.name && this.triggered) {
inst.trigger(this.name + 'end', ev);
this.triggered = false;
return;
}
// atleast multitouch
if(ev.touches.length < 2) {
return;
}
// prevent default when two fingers are on the screen
if(inst.options.transform_always_block) {
ev.preventDefault();
}
switch(ev.eventType) {
case ionic.Gestures.EVENT_START:
this.triggered = false;
break;
case ionic.Gestures.EVENT_MOVE:
var scale_threshold = Math.abs(1 - ev.scale);
var rotation_threshold = Math.abs(ev.rotation);
// when the distance we moved is too small we skip this gesture
// or we can be already in dragging
if(scale_threshold < inst.options.transform_min_scale &&
rotation_threshold < inst.options.transform_min_rotation) {
return;
}
// we are transforming!
ionic.Gestures.detection.current.name = this.name;
// first time, trigger dragstart event
if(!this.triggered) {
inst.trigger(this.name + 'start', ev);
this.triggered = true;
}
inst.trigger(this.name, ev); // basic transform event
// trigger rotate event
if(rotation_threshold > inst.options.transform_min_rotation) {
inst.trigger('rotate', ev);
}
// trigger pinch event
if(scale_threshold > inst.options.transform_min_scale) {
inst.trigger('pinch', ev);
inst.trigger('pinch' + ((ev.scale < 1) ? 'in' : 'out'), ev);
}
break;
case ionic.Gestures.EVENT_END:
// trigger dragend
if(this.triggered) {
inst.trigger(this.name + 'end', ev);
}
this.triggered = false;
break;
}
}
};
/**
* Touch
* Called as first, tells the user has touched the screen
* events touch
*/
ionic.Gestures.gestures.Touch = {
name: 'touch',
index: -Infinity,
defaults: {
// call preventDefault at touchstart, and makes the element blocking by
// disabling the scrolling of the page, but it improves gestures like
// transforming and dragging.
// be careful with using this, it can be very annoying for users to be stuck
// on the page
prevent_default: false,
// disable mouse events, so only touch (or pen!) input triggers events
prevent_mouseevents: false
},
handler: function touchGesture(ev, inst) {
if(inst.options.prevent_mouseevents && ev.pointerType == ionic.Gestures.POINTER_MOUSE) {
ev.stopDetect();
return;
}
if(inst.options.prevent_default) {
ev.preventDefault();
}
if(ev.eventType == ionic.Gestures.EVENT_START) {
inst.trigger(this.name, ev);
}
}
};
/**
* Release
* Called as last, tells the user has released the screen
* events release
*/
ionic.Gestures.gestures.Release = {
name: 'release',
index: Infinity,
handler: function releaseGesture(ev, inst) {
if(ev.eventType == ionic.Gestures.EVENT_END) {
inst.trigger(this.name, ev);
}
}
};
})(window.ionic);
(function(window, document, ionic) {
function getParameterByName(name) {
name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
var regex = new RegExp("[\\?&]" + name + "=([^&#]*)"),
results = regex.exec(location.search);
return results === null ? "" : decodeURIComponent(results[1].replace(/\+/g, " "));
}
var IOS = 'ios';
var ANDROID = 'android';
var WINDOWS_PHONE = 'windowsphone';
var requestAnimationFrame = ionic.requestAnimationFrame;
/**
* @ngdoc utility
* @name ionic.Platform
* @module ionic
* @description
* A set of utility methods that can be used to retrieve the device ready state and
* various other information such as what kind of platform the app is currently installed on.
*
* @usage
* ```js
* angular.module('PlatformApp', ['ionic'])
* .controller('PlatformCtrl', function($scope) {
*
* ionic.Platform.ready(function(){
* // will execute when device is ready, or immediately if the device is already ready.
* });
*
* var deviceInformation = ionic.Platform.device();
*
* var isWebView = ionic.Platform.isWebView();
* var isIPad = ionic.Platform.isIPad();
* var isIOS = ionic.Platform.isIOS();
* var isAndroid = ionic.Platform.isAndroid();
* var isWindowsPhone = ionic.Platform.isWindowsPhone();
*
* var currentPlatform = ionic.Platform.platform();
* var currentPlatformVersion = ionic.Platform.version();
*
* ionic.Platform.exitApp(); // stops the app
* });
* ```
*/
var self = ionic.Platform = {
// Put navigator on platform so it can be mocked and set
// the browser does not allow window.navigator to be set
navigator: window.navigator,
/**
* @ngdoc property
* @name ionic.Platform#isReady
* @returns {boolean} Whether the device is ready.
*/
isReady: false,
/**
* @ngdoc property
* @name ionic.Platform#isFullScreen
* @returns {boolean} Whether the device is fullscreen.
*/
isFullScreen: false,
/**
* @ngdoc property
* @name ionic.Platform#platforms
* @returns {Array(string)} An array of all platforms found.
*/
platforms: null,
/**
* @ngdoc property
* @name ionic.Platform#grade
* @returns {string} What grade the current platform is.
*/
grade: null,
ua: navigator.userAgent,
/**
* @ngdoc method
* @name ionic.Platform#ready
* @description
* Trigger a callback once the device is ready, or immediately
* if the device is already ready. This method can be run from
* anywhere and does not need to be wrapped by any additonal methods.
* When the app is within a WebView (Cordova), it'll fire
* the callback once the device is ready. If the app is within
* a web browser, it'll fire the callback after `window.load`.
* Please remember that Cordova features (Camera, FileSystem, etc) still
* will not work in a web browser.
* @param {function} callback The function to call.
*/
ready: function(cb) {
// run through tasks to complete now that the device is ready
if (self.isReady) {
cb();
} else {
// the platform isn't ready yet, add it to this array
// which will be called once the platform is ready
readyCallbacks.push(cb);
}
},
/**
* @private
*/
detect: function() {
self._checkPlatforms();
requestAnimationFrame(function() {
// only add to the body class if we got platform info
for (var i = 0; i < self.platforms.length; i++) {
document.body.classList.add('platform-' + self.platforms[i]);
}
});
},
/**
* @ngdoc method
* @name ionic.Platform#setGrade
* @description Set the grade of the device: 'a', 'b', or 'c'. 'a' is the best
* (most css features enabled), 'c' is the worst. By default, sets the grade
* depending on the current device.
* @param {string} grade The new grade to set.
*/
setGrade: function(grade) {
var oldGrade = self.grade;
self.grade = grade;
requestAnimationFrame(function() {
if (oldGrade) {
document.body.classList.remove('grade-' + oldGrade);
}
document.body.classList.add('grade-' + grade);
});
},
/**
* @ngdoc method
* @name ionic.Platform#device
* @description Return the current device (given by cordova).
* @returns {object} The device object.
*/
device: function() {
return window.device || {};
},
_checkPlatforms: function() {
self.platforms = [];
var grade = 'a';
if (self.isWebView()) {
self.platforms.push('webview');
if (!(!window.cordova && !window.PhoneGap && !window.phonegap)) {
self.platforms.push('cordova');
} else if (window.forge) {
self.platforms.push('trigger');
}
} else {
self.platforms.push('browser');
}
if (self.isIPad()) self.platforms.push('ipad');
var platform = self.platform();
if (platform) {
self.platforms.push(platform);
var version = self.version();
if (version) {
var v = version.toString();
if (v.indexOf('.') > 0) {
v = v.replace('.', '_');
} else {
v += '_0';
}
self.platforms.push(platform + v.split('_')[0]);
self.platforms.push(platform + v);
if (self.isAndroid() && version < 4.4) {
grade = (version < 4 ? 'c' : 'b');
} else if (self.isWindowsPhone()) {
grade = 'b';
}
}
}
self.setGrade(grade);
},
/**
* @ngdoc method
* @name ionic.Platform#isWebView
* @returns {boolean} Check if we are running within a WebView (such as Cordova).
*/
isWebView: function() {
return !(!window.cordova && !window.PhoneGap && !window.phonegap && !window.forge);
},
/**
* @ngdoc method
* @name ionic.Platform#isIPad
* @returns {boolean} Whether we are running on iPad.
*/
isIPad: function() {
if (/iPad/i.test(self.navigator.platform)) {
return true;
}
return /iPad/i.test(self.ua);
},
/**
* @ngdoc method
* @name ionic.Platform#isIOS
* @returns {boolean} Whether we are running on iOS.
*/
isIOS: function() {
return self.is(IOS);
},
/**
* @ngdoc method
* @name ionic.Platform#isAndroid
* @returns {boolean} Whether we are running on Android.
*/
isAndroid: function() {
return self.is(ANDROID);
},
/**
* @ngdoc method
* @name ionic.Platform#isWindowsPhone
* @returns {boolean} Whether we are running on Windows Phone.
*/
isWindowsPhone: function() {
return self.is(WINDOWS_PHONE);
},
/**
* @ngdoc method
* @name ionic.Platform#platform
* @returns {string} The name of the current platform.
*/
platform: function() {
// singleton to get the platform name
if (platformName === null) self.setPlatform(self.device().platform);
return platformName;
},
/**
* @private
*/
setPlatform: function(n) {
if (typeof n != 'undefined' && n !== null && n.length) {
platformName = n.toLowerCase();
} else if (getParameterByName('ionicplatform')) {
platformName = getParameterByName('ionicplatform');
} else if (self.ua.indexOf('Android') > 0) {
platformName = ANDROID;
} else if (/iPhone|iPad|iPod/.test(self.ua)) {
platformName = IOS;
} else if (self.ua.indexOf('Windows Phone') > -1) {
platformName = WINDOWS_PHONE;
} else {
platformName = self.navigator.platform && navigator.platform.toLowerCase().split(' ')[0] || '';
}
},
/**
* @ngdoc method
* @name ionic.Platform#version
* @returns {number} The version of the current device platform.
*/
version: function() {
// singleton to get the platform version
if (platformVersion === null) self.setVersion(self.device().version);
return platformVersion;
},
/**
* @private
*/
setVersion: function(v) {
if (typeof v != 'undefined' && v !== null) {
v = v.split('.');
v = parseFloat(v[0] + '.' + (v.length > 1 ? v[1] : 0));
if (!isNaN(v)) {
platformVersion = v;
return;
}
}
platformVersion = 0;
// fallback to user-agent checking
var pName = self.platform();
var versionMatch = {
'android': /Android (\d+).(\d+)?/,
'ios': /OS (\d+)_(\d+)?/,
'windowsphone': /Windows Phone (\d+).(\d+)?/
};
if (versionMatch[pName]) {
v = self.ua.match(versionMatch[pName]);
if (v && v.length > 2) {
platformVersion = parseFloat(v[1] + '.' + v[2]);
}
}
},
/**
* @ngdoc method
* @name ionic.Platform#is
* @param {string} Platform name.
* @returns {boolean} Whether the platform name provided is detected.
*/
is: function(type) {
type = type.toLowerCase();
// check if it has an array of platforms
if (self.platforms) {
for (var x = 0; x < self.platforms.length; x++) {
if (self.platforms[x] === type) return true;
}
}
// exact match
var pName = self.platform();
if (pName) {
return pName === type.toLowerCase();
}
// A quick hack for to check userAgent
return self.ua.toLowerCase().indexOf(type) >= 0;
},
/**
* @ngdoc method
* @name ionic.Platform#exitApp
* @description Exit the app.
*/
exitApp: function() {
self.ready(function() {
navigator.app && navigator.app.exitApp && navigator.app.exitApp();
});
},
/**
* @ngdoc method
* @name ionic.Platform#showStatusBar
* @description Shows or hides the device status bar (in Cordova). Requires `cordova plugin add org.apache.cordova.statusbar`
* @param {boolean} shouldShow Whether or not to show the status bar.
*/
showStatusBar: function(val) {
// Only useful when run within cordova
self._showStatusBar = val;
self.ready(function() {
// run this only when or if the platform (cordova) is ready
requestAnimationFrame(function() {
if (self._showStatusBar) {
// they do not want it to be full screen
window.StatusBar && window.StatusBar.show();
document.body.classList.remove('status-bar-hide');
} else {
// it should be full screen
window.StatusBar && window.StatusBar.hide();
document.body.classList.add('status-bar-hide');
}
});
});
},
/**
* @ngdoc method
* @name ionic.Platform#fullScreen
* @description
* Sets whether the app is fullscreen or not (in Cordova).
* @param {boolean=} showFullScreen Whether or not to set the app to fullscreen. Defaults to true. Requires `cordova plugin add org.apache.cordova.statusbar`
* @param {boolean=} showStatusBar Whether or not to show the device's status bar. Defaults to false.
*/
fullScreen: function(showFullScreen, showStatusBar) {
// showFullScreen: default is true if no param provided
self.isFullScreen = (showFullScreen !== false);
// add/remove the fullscreen classname to the body
ionic.DomUtil.ready(function() {
// run this only when or if the DOM is ready
requestAnimationFrame(function() {
if (self.isFullScreen) {
document.body.classList.add('fullscreen');
} else {
document.body.classList.remove('fullscreen');
}
});
// showStatusBar: default is false if no param provided
self.showStatusBar((showStatusBar === true));
});
}
};
var platformName = null, // just the name, like iOS or Android
platformVersion = null, // a float of the major and minor, like 7.1
readyCallbacks = [],
windowLoadListenderAttached;
// setup listeners to know when the device is ready to go
function onWindowLoad() {
if (self.isWebView()) {
// the window and scripts are fully loaded, and a cordova/phonegap
// object exists then let's listen for the deviceready
document.addEventListener("deviceready", onPlatformReady, false);
} else {
// the window and scripts are fully loaded, but the window object doesn't have the
// cordova/phonegap object, so its just a browser, not a webview wrapped w/ cordova
onPlatformReady();
}
if (windowLoadListenderAttached) {
window.removeEventListener("load", onWindowLoad, false);
}
}
if (document.readyState === 'complete') {
onWindowLoad();
} else {
windowLoadListenderAttached = true;
window.addEventListener("load", onWindowLoad, false);
}
function onPlatformReady() {
// the device is all set to go, init our own stuff then fire off our event
self.isReady = true;
self.detect();
for (var x = 0; x < readyCallbacks.length; x++) {
// fire off all the callbacks that were added before the platform was ready
readyCallbacks[x]();
}
readyCallbacks = [];
ionic.trigger('platformready', { target: document });
requestAnimationFrame(function() {
document.body.classList.add('platform-ready');
});
}
})(this, document, ionic);
(function(document, ionic) {
'use strict';
// Ionic CSS polyfills
ionic.CSS = {};
(function() {
// transform
var i, keys = ['webkitTransform', 'transform', '-webkit-transform', 'webkit-transform',
'-moz-transform', 'moz-transform', 'MozTransform', 'mozTransform', 'msTransform'];
for (i = 0; i < keys.length; i++) {
if (document.documentElement.style[keys[i]] !== undefined) {
ionic.CSS.TRANSFORM = keys[i];
break;
}
}
// transition
keys = ['webkitTransition', 'mozTransition', 'msTransition', 'transition'];
for (i = 0; i < keys.length; i++) {
if (document.documentElement.style[keys[i]] !== undefined) {
ionic.CSS.TRANSITION = keys[i];
break;
}
}
// The only prefix we care about is webkit for transitions.
var isWebkit = ionic.CSS.TRANSITION.indexOf('webkit') > -1;
// transition duration
ionic.CSS.TRANSITION_DURATION = (isWebkit ? '-webkit-' : '') + 'transition-duration';
// To be sure transitionend works everywhere, include *both* the webkit and non-webkit events
ionic.CSS.TRANSITIONEND = (isWebkit ? 'webkitTransitionEnd ' : '') + 'transitionend';
})();
// classList polyfill for them older Androids
// https://gist.github.com/devongovett/1381839
if (!("classList" in document.documentElement) && Object.defineProperty && typeof HTMLElement !== 'undefined') {
Object.defineProperty(HTMLElement.prototype, 'classList', {
get: function() {
var self = this;
function update(fn) {
return function() {
var x, classes = self.className.split(/\s+/);
for (x = 0; x < arguments.length; x++) {
fn(classes, classes.indexOf(arguments[x]), arguments[x]);
}
self.className = classes.join(" ");
};
}
return {
add: update(function(classes, index, value) {
~index || classes.push(value);
}),
remove: update(function(classes, index) {
~index && classes.splice(index, 1);
}),
toggle: update(function(classes, index, value) {
~index ? classes.splice(index, 1) : classes.push(value);
}),
contains: function(value) {
return !!~self.className.split(/\s+/).indexOf(value);
},
item: function(i) {
return self.className.split(/\s+/)[i] || null;
}
};
}
});
}
})(document, ionic);
/**
* @ngdoc page
* @name tap
* @module ionic
* @description
* On touch devices such as a phone or tablet, some browsers implement a 300ms delay between
* the time the user stops touching the display and the moment the browser executes the
* click. This delay was initially introduced so the browser can know whether the user wants to
* double-tap to zoom in on the webpage. Basically, the browser waits roughly 300ms to see if
* the user is double-tapping, or just tapping on the display once.
*
* Out of the box, Ionic automatically removes the 300ms delay in order to make Ionic apps
* feel more "native" like. Resultingly, other solutions such as
* [fastclick](https://github.com/ftlabs/fastclick) and Angular's
* [ngTouch](https://docs.angularjs.org/api/ngTouch) should not be included, to avoid conflicts.
*
* Some browsers already remove the delay with certain settings, such as the CSS property
* `touch-events: none` or with specific meta tag viewport values. However, each of these
* browsers still handle clicks differently, such as when to fire off or cancel the event
* (like scrolling when the target is a button, or holding a button down).
* For browsers that already remove the 300ms delay, consider Ionic's tap system as a way to
* normalize how clicks are handled across the various devices so there's an expected response
* no matter what the device, platform or version. Additionally, Ionic will prevent
* ghostclicks which even browsers that remove the delay still experience.
*
* In some cases, third-party libraries may also be working with touch events which can interfere
* with the tap system. For example, mapping libraries like Google or Leaflet Maps often implement
* a touch detection system which conflicts with Ionic's tap system.
*
* ### Disabling the tap system
*
* To disable the tap for an element and all of its children elements,
* add the attribute `data-tap-disabled="true"`.
*
* ```html
* <div data-tap-disabled="true">
* <div id="google-map"></div>
* </div>
* ```
*
* ### Additional Notes:
*
* - Ionic tap works with Ionic's JavaScript scrolling
* - Elements can come and go from the DOM and Ionic tap doesn't keep adding and removing
* listeners
* - No "tap delay" after the first "tap" (you can tap as fast as you want, they all click)
* - Minimal events listeners, only being added to document
* - Correct focus in/out on each input type (select, textearea, range) on each platform/device
* - Shows and hides virtual keyboard correctly for each platform/device
* - Works with labels surrounding inputs
* - Does not fire off a click if the user moves the pointer too far
* - Adds and removes an 'activated' css class
* - Multiple [unit tests](https://github.com/driftyco/ionic/blob/master/test/unit/utils/tap.unit.js) for each scenario
*
*/
/*
IONIC TAP
---------------
- Both touch and mouse events are added to the document.body on DOM ready
- If a touch event happens, it does not use mouse event listeners
- On touchend, if the distance between start and end was small, trigger a click
- In the triggered click event, add a 'isIonicTap' property
- The triggered click receives the same x,y coordinates as as the end event
- On document.body click listener (with useCapture=true), only allow clicks with 'isIonicTap'
- Triggering clicks with mouse events work the same as touch, except with mousedown/mouseup
- Tapping inputs is disabled during scrolling
*/
var tapDoc; // the element which the listeners are on (document.body)
var tapActiveEle; // the element which is active (probably has focus)
var tapEnabledTouchEvents;
var tapMouseResetTimer;
var tapPointerMoved;
var tapPointerStart;
var tapTouchFocusedInput;
var tapLastTouchTarget;
var tapTouchMoveListener = 'touchmove';
// how much the coordinates can be off between start/end, but still a click
var TAP_RELEASE_TOLERANCE = 12; // default tolerance
var TAP_RELEASE_BUTTON_TOLERANCE = 50; // button elements should have a larger tolerance
var tapEventListeners = {
'click': tapClickGateKeeper,
'mousedown': tapMouseDown,
'mouseup': tapMouseUp,
'mousemove': tapMouseMove,
'touchstart': tapTouchStart,
'touchend': tapTouchEnd,
'touchcancel': tapTouchCancel,
'touchmove': tapTouchMove,
'pointerdown': tapTouchStart,
'pointerup': tapTouchEnd,
'pointercancel': tapTouchCancel,
'pointermove': tapTouchMove,
'MSPointerDown': tapTouchStart,
'MSPointerUp': tapTouchEnd,
'MSPointerCancel': tapTouchCancel,
'MSPointerMove': tapTouchMove,
'focusin': tapFocusIn,
'focusout': tapFocusOut
};
ionic.tap = {
register: function(ele) {
tapDoc = ele;
tapEventListener('click', true, true);
tapEventListener('mouseup');
tapEventListener('mousedown');
if (window.navigator.pointerEnabled) {
tapEventListener('pointerdown');
tapEventListener('pointerup');
tapEventListener('pointcancel');
tapTouchMoveListener = 'pointermove';
} else if (window.navigator.msPointerEnabled) {
tapEventListener('MSPointerDown');
tapEventListener('MSPointerUp');
tapEventListener('MSPointerCancel');
tapTouchMoveListener = 'MSPointerMove';
} else {
tapEventListener('touchstart');
tapEventListener('touchend');
tapEventListener('touchcancel');
}
tapEventListener('focusin');
tapEventListener('focusout');
return function() {
for (var type in tapEventListeners) {
tapEventListener(type, false);
}
tapDoc = null;
tapActiveEle = null;
tapEnabledTouchEvents = false;
tapPointerMoved = false;
tapPointerStart = null;
};
},
ignoreScrollStart: function(e) {
return (e.defaultPrevented) || // defaultPrevented has been assigned by another component handling the event
(/^(file|range)$/i).test(e.target.type) ||
(e.target.dataset ? e.target.dataset.preventScroll : e.target.getAttribute('data-prevent-scroll')) == 'true' || // manually set within an elements attributes
(!!(/^(object|embed)$/i).test(e.target.tagName)) || // flash/movie/object touches should not try to scroll
ionic.tap.isElementTapDisabled(e.target); // check if this element, or an ancestor, has `data-tap-disabled` attribute
},
isTextInput: function(ele) {
return !!ele &&
(ele.tagName == 'TEXTAREA' ||
ele.contentEditable === 'true' ||
(ele.tagName == 'INPUT' && !(/^(radio|checkbox|range|file|submit|reset|color|image|button)$/i).test(ele.type)));
},
isDateInput: function(ele) {
return !!ele &&
(ele.tagName == 'INPUT' && (/^(date|time|datetime-local|month|week)$/i).test(ele.type));
},
isKeyboardElement: function(ele) {
if ( !ionic.Platform.isIOS() || ionic.Platform.isIPad() ) {
return ionic.tap.isTextInput(ele) && !ionic.tap.isDateInput(ele);
} else {
return ionic.tap.isTextInput(ele) || ( !!ele && ele.tagName == "SELECT");
}
},
isLabelWithTextInput: function(ele) {
var container = tapContainingElement(ele, false);
return !!container &&
ionic.tap.isTextInput(tapTargetElement(container));
},
containsOrIsTextInput: function(ele) {
return ionic.tap.isTextInput(ele) || ionic.tap.isLabelWithTextInput(ele);
},
cloneFocusedInput: function(container) {
if (ionic.tap.hasCheckedClone) return;
ionic.tap.hasCheckedClone = true;
ionic.requestAnimationFrame(function() {
var focusInput = container.querySelector(':focus');
if (ionic.tap.isTextInput(focusInput) && !ionic.tap.isDateInput(focusInput)) {
var clonedInput = focusInput.cloneNode(true);
clonedInput.value = focusInput.value;
clonedInput.classList.add('cloned-text-input');
clonedInput.readOnly = true;
if (focusInput.isContentEditable) {
clonedInput.contentEditable = focusInput.contentEditable;
clonedInput.innerHTML = focusInput.innerHTML;
}
focusInput.parentElement.insertBefore(clonedInput, focusInput);
focusInput.classList.add('previous-input-focus');
clonedInput.scrollTop = focusInput.scrollTop;
}
});
},
hasCheckedClone: false,
removeClonedInputs: function(container) {
ionic.tap.hasCheckedClone = false;
ionic.requestAnimationFrame(function() {
var clonedInputs = container.querySelectorAll('.cloned-text-input');
var previousInputFocus = container.querySelectorAll('.previous-input-focus');
var x;
for (x = 0; x < clonedInputs.length; x++) {
clonedInputs[x].parentElement.removeChild(clonedInputs[x]);
}
for (x = 0; x < previousInputFocus.length; x++) {
previousInputFocus[x].classList.remove('previous-input-focus');
previousInputFocus[x].style.top = '';
if ( ionic.keyboard.isOpen && !ionic.keyboard.isClosing ) previousInputFocus[x].focus();
}
});
},
requiresNativeClick: function(ele) {
if (!ele || ele.disabled || (/^(file|range)$/i).test(ele.type) || (/^(object|video)$/i).test(ele.tagName) || ionic.tap.isLabelContainingFileInput(ele)) {
return true;
}
return ionic.tap.isElementTapDisabled(ele);
},
isLabelContainingFileInput: function(ele) {
var lbl = tapContainingElement(ele);
if (lbl.tagName !== 'LABEL') return false;
var fileInput = lbl.querySelector('input[type=file]');
if (fileInput && fileInput.disabled === false) return true;
return false;
},
isElementTapDisabled: function(ele) {
if (ele && ele.nodeType === 1) {
var element = ele;
while (element) {
if ((element.dataset ? element.dataset.tapDisabled : element.getAttribute('data-tap-disabled')) == 'true') {
return true;
}
element = element.parentElement;
}
}
return false;
},
setTolerance: function(releaseTolerance, releaseButtonTolerance) {
TAP_RELEASE_TOLERANCE = releaseTolerance;
TAP_RELEASE_BUTTON_TOLERANCE = releaseButtonTolerance;
},
cancelClick: function() {
// used to cancel any simulated clicks which may happen on a touchend/mouseup
// gestures uses this method within its tap and hold events
tapPointerMoved = true;
},
pointerCoord: function(event) {
// This method can get coordinates for both a mouse click
// or a touch depending on the given event
var c = { x: 0, y: 0 };
if (event) {
var touches = event.touches && event.touches.length ? event.touches : [event];
var e = (event.changedTouches && event.changedTouches[0]) || touches[0];
if (e) {
c.x = e.clientX || e.pageX || 0;
c.y = e.clientY || e.pageY || 0;
}
}
return c;
}
};
function tapEventListener(type, enable, useCapture) {
if (enable !== false) {
tapDoc.addEventListener(type, tapEventListeners[type], useCapture);
} else {
tapDoc.removeEventListener(type, tapEventListeners[type]);
}
}
function tapClick(e) {
// simulate a normal click by running the element's click method then focus on it
var container = tapContainingElement(e.target);
var ele = tapTargetElement(container);
if (ionic.tap.requiresNativeClick(ele) || tapPointerMoved) return false;
var c = ionic.tap.pointerCoord(e);
//console.log('tapClick', e.type, ele.tagName, '('+c.x+','+c.y+')');
triggerMouseEvent('click', ele, c.x, c.y);
// if it's an input, focus in on the target, otherwise blur
tapHandleFocus(ele);
}
function triggerMouseEvent(type, ele, x, y) {
// using initMouseEvent instead of MouseEvent for our Android friends
var clickEvent = document.createEvent("MouseEvents");
clickEvent.initMouseEvent(type, true, true, window, 1, 0, 0, x, y, false, false, false, false, 0, null);
clickEvent.isIonicTap = true;
ele.dispatchEvent(clickEvent);
}
function tapClickGateKeeper(e) {
//console.log('click ' + Date.now() + ' isIonicTap: ' + (e.isIonicTap ? true : false));
if (e.target.type == 'submit' && e.detail === 0) {
// do not prevent click if it came from an "Enter" or "Go" keypress submit
return null;
}
// do not allow through any click events that were not created by ionic.tap
if ((ionic.scroll.isScrolling && ionic.tap.containsOrIsTextInput(e.target)) ||
(!e.isIonicTap && !ionic.tap.requiresNativeClick(e.target))) {
//console.log('clickPrevent', e.target.tagName);
e.stopPropagation();
if (!ionic.tap.isLabelWithTextInput(e.target)) {
// labels clicks from native should not preventDefault othersize keyboard will not show on input focus
e.preventDefault();
}
return false;
}
}
// MOUSE
function tapMouseDown(e) {
//console.log('mousedown ' + Date.now());
if (e.isIonicTap || tapIgnoreEvent(e)) return null;
if (tapEnabledTouchEvents) {
console.log('mousedown', 'stop event');
e.stopPropagation();
if ((!ionic.tap.isTextInput(e.target) || tapLastTouchTarget !== e.target) && !(/^(select|option)$/i).test(e.target.tagName)) {
// If you preventDefault on a text input then you cannot move its text caret/cursor.
// Allow through only the text input default. However, without preventDefault on an
// input the 300ms delay can change focus on inputs after the keyboard shows up.
// The focusin event handles the chance of focus changing after the keyboard shows.
e.preventDefault();
}
return false;
}
tapPointerMoved = false;
tapPointerStart = ionic.tap.pointerCoord(e);
tapEventListener('mousemove');
ionic.activator.start(e);
}
function tapMouseUp(e) {
//console.log("mouseup " + Date.now());
if (tapEnabledTouchEvents) {
e.stopPropagation();
e.preventDefault();
return false;
}
if (tapIgnoreEvent(e) || (/^(select|option)$/i).test(e.target.tagName)) return false;
if (!tapHasPointerMoved(e)) {
tapClick(e);
}
tapEventListener('mousemove', false);
ionic.activator.end();
tapPointerMoved = false;
}
function tapMouseMove(e) {
if (tapHasPointerMoved(e)) {
tapEventListener('mousemove', false);
ionic.activator.end();
tapPointerMoved = true;
return false;
}
}
// TOUCH
function tapTouchStart(e) {
//console.log("touchstart " + Date.now());
if (tapIgnoreEvent(e)) return;
tapPointerMoved = false;
tapEnableTouchEvents();
tapPointerStart = ionic.tap.pointerCoord(e);
tapEventListener(tapTouchMoveListener);
ionic.activator.start(e);
if (ionic.Platform.isIOS() && ionic.tap.isLabelWithTextInput(e.target)) {
// if the tapped element is a label, which has a child input
// then preventDefault so iOS doesn't ugly auto scroll to the input
// but do not prevent default on Android or else you cannot move the text caret
// and do not prevent default on Android or else no virtual keyboard shows up
var textInput = tapTargetElement(tapContainingElement(e.target));
if (textInput !== tapActiveEle) {
// don't preventDefault on an already focused input or else iOS's text caret isn't usable
e.preventDefault();
}
}
}
function tapTouchEnd(e) {
//console.log('touchend ' + Date.now());
if (tapIgnoreEvent(e)) return;
tapEnableTouchEvents();
if (!tapHasPointerMoved(e)) {
tapClick(e);
if ((/^(select|option)$/i).test(e.target.tagName)) {
e.preventDefault();
}
}
tapLastTouchTarget = e.target;
tapTouchCancel();
}
function tapTouchMove(e) {
if (tapHasPointerMoved(e)) {
tapPointerMoved = true;
tapEventListener(tapTouchMoveListener, false);
ionic.activator.end();
return false;
}
}
function tapTouchCancel() {
tapEventListener(tapTouchMoveListener, false);
ionic.activator.end();
tapPointerMoved = false;
}
function tapEnableTouchEvents() {
tapEnabledTouchEvents = true;
clearTimeout(tapMouseResetTimer);
tapMouseResetTimer = setTimeout(function() {
tapEnabledTouchEvents = false;
}, 600);
}
function tapIgnoreEvent(e) {
if (e.isTapHandled) return true;
e.isTapHandled = true;
if (ionic.scroll.isScrolling && ionic.tap.containsOrIsTextInput(e.target)) {
e.preventDefault();
return true;
}
}
function tapHandleFocus(ele) {
tapTouchFocusedInput = null;
var triggerFocusIn = false;
if (ele.tagName == 'SELECT') {
// trick to force Android options to show up
triggerMouseEvent('mousedown', ele, 0, 0);
ele.focus && ele.focus();
triggerFocusIn = true;
} else if (tapActiveElement() === ele) {
// already is the active element and has focus
triggerFocusIn = true;
} else if ((/^(input|textarea)$/i).test(ele.tagName) || ele.isContentEditable) {
triggerFocusIn = true;
ele.focus && ele.focus();
ele.value = ele.value;
if (tapEnabledTouchEvents) {
tapTouchFocusedInput = ele;
}
} else {
tapFocusOutActive();
}
if (triggerFocusIn) {
tapActiveElement(ele);
ionic.trigger('ionic.focusin', {
target: ele
}, true);
}
}
function tapFocusOutActive() {
var ele = tapActiveElement();
if (ele && ((/^(input|textarea|select)$/i).test(ele.tagName) || ele.isContentEditable)) {
console.log('tapFocusOutActive', ele.tagName);
ele.blur();
}
tapActiveElement(null);
}
function tapFocusIn(e) {
//console.log('focusin ' + Date.now());
// Because a text input doesn't preventDefault (so the caret still works) there's a chance
// that its mousedown event 300ms later will change the focus to another element after
// the keyboard shows up.
if (tapEnabledTouchEvents &&
ionic.tap.isTextInput(tapActiveElement()) &&
ionic.tap.isTextInput(tapTouchFocusedInput) &&
tapTouchFocusedInput !== e.target) {
// 1) The pointer is from touch events
// 2) There is an active element which is a text input
// 3) A text input was just set to be focused on by a touch event
// 4) A new focus has been set, however the target isn't the one the touch event wanted
console.log('focusin', 'tapTouchFocusedInput');
tapTouchFocusedInput.focus();
tapTouchFocusedInput = null;
}
ionic.scroll.isScrolling = false;
}
function tapFocusOut() {
//console.log("focusout");
tapActiveElement(null);
}
function tapActiveElement(ele) {
if (arguments.length) {
tapActiveEle = ele;
}
return tapActiveEle || document.activeElement;
}
function tapHasPointerMoved(endEvent) {
if (!endEvent || endEvent.target.nodeType !== 1 || !tapPointerStart || (tapPointerStart.x === 0 && tapPointerStart.y === 0)) {
return false;
}
var endCoordinates = ionic.tap.pointerCoord(endEvent);
var hasClassList = !!(endEvent.target.classList && endEvent.target.classList.contains &&
typeof endEvent.target.classList.contains === 'function');
var releaseTolerance = hasClassList && endEvent.target.classList.contains('button') ?
TAP_RELEASE_BUTTON_TOLERANCE :
TAP_RELEASE_TOLERANCE;
return Math.abs(tapPointerStart.x - endCoordinates.x) > releaseTolerance ||
Math.abs(tapPointerStart.y - endCoordinates.y) > releaseTolerance;
}
function tapContainingElement(ele, allowSelf) {
var climbEle = ele;
for (var x = 0; x < 6; x++) {
if (!climbEle) break;
if (climbEle.tagName === 'LABEL') return climbEle;
climbEle = climbEle.parentElement;
}
if (allowSelf !== false) return ele;
}
function tapTargetElement(ele) {
if (ele && ele.tagName === 'LABEL') {
if (ele.control) return ele.control;
// older devices do not support the "control" property
if (ele.querySelector) {
var control = ele.querySelector('input,textarea,select');
if (control) return control;
}
}
return ele;
}
ionic.DomUtil.ready(function() {
var ng = typeof angular !== 'undefined' ? angular : null;
//do nothing for e2e tests
if (!ng || (ng && !ng.scenario)) {
ionic.tap.register(document);
}
});
(function(document, ionic) {
'use strict';
var queueElements = {}; // elements that should get an active state in XX milliseconds
var activeElements = {}; // elements that are currently active
var keyId = 0; // a counter for unique keys for the above ojects
var ACTIVATED_CLASS = 'activated';
ionic.activator = {
start: function(e) {
var hitX = ionic.tap.pointerCoord(e).x;
if (hitX > 0 && hitX < 30) {
return;
}
// when an element is touched/clicked, it climbs up a few
// parents to see if it is an .item or .button element
ionic.requestAnimationFrame(function() {
if ((ionic.scroll && ionic.scroll.isScrolling) || ionic.tap.requiresNativeClick(e.target)) return;
var ele = e.target;
var eleToActivate;
for (var x = 0; x < 6; x++) {
if (!ele || ele.nodeType !== 1) break;
if (eleToActivate && ele.classList && ele.classList.contains('item')) {
eleToActivate = ele;
break;
}
if (ele.tagName == 'A' || ele.tagName == 'BUTTON' || ele.hasAttribute('ng-click')) {
eleToActivate = ele;
break;
}
if (ele.classList.contains('button')) {
eleToActivate = ele;
break;
}
// no sense climbing past these
if (ele.tagName == 'ION-CONTENT' || (ele.classList && ele.classList.contains('pane')) || ele.tagName == 'BODY') {
break;
}
ele = ele.parentElement;
}
if (eleToActivate) {
// queue that this element should be set to active
queueElements[keyId] = eleToActivate;
// on the next frame, set the queued elements to active
ionic.requestAnimationFrame(activateElements);
keyId = (keyId > 29 ? 0 : keyId + 1);
}
});
},
end: function() {
// clear out any active/queued elements after XX milliseconds
setTimeout(clear, 200);
}
};
function clear() {
// clear out any elements that are queued to be set to active
queueElements = {};
// in the next frame, remove the active class from all active elements
ionic.requestAnimationFrame(deactivateElements);
}
function activateElements() {
// activate all elements in the queue
for (var key in queueElements) {
if (queueElements[key]) {
queueElements[key].classList.add(ACTIVATED_CLASS);
activeElements[key] = queueElements[key];
}
}
queueElements = {};
}
function deactivateElements() {
if (ionic.transition && ionic.transition.isActive) {
setTimeout(deactivateElements, 400);
return;
}
for (var key in activeElements) {
if (activeElements[key]) {
activeElements[key].classList.remove(ACTIVATED_CLASS);
delete activeElements[key];
}
}
}
})(document, ionic);
(function(ionic) {
/* for nextUid function below */
var nextId = 0;
/**
* Various utilities used throughout Ionic
*
* Some of these are adopted from underscore.js and backbone.js, both also MIT licensed.
*/
ionic.Utils = {
arrayMove: function(arr, oldIndex, newIndex) {
if (newIndex >= arr.length) {
var k = newIndex - arr.length;
while ((k--) + 1) {
arr.push(undefined);
}
}
arr.splice(newIndex, 0, arr.splice(oldIndex, 1)[0]);
return arr;
},
/**
* Return a function that will be called with the given context
*/
proxy: function(func, context) {
var args = Array.prototype.slice.call(arguments, 2);
return function() {
return func.apply(context, args.concat(Array.prototype.slice.call(arguments)));
};
},
/**
* Only call a function once in the given interval.
*
* @param func {Function} the function to call
* @param wait {int} how long to wait before/after to allow function calls
* @param immediate {boolean} whether to call immediately or after the wait interval
*/
debounce: function(func, wait, immediate) {
var timeout, args, context, timestamp, result;
return function() {
context = this;
args = arguments;
timestamp = new Date();
var later = function() {
var last = (new Date()) - timestamp;
if (last < wait) {
timeout = setTimeout(later, wait - last);
} else {
timeout = null;
if (!immediate) result = func.apply(context, args);
}
};
var callNow = immediate && !timeout;
if (!timeout) {
timeout = setTimeout(later, wait);
}
if (callNow) result = func.apply(context, args);
return result;
};
},
/**
* Throttle the given fun, only allowing it to be
* called at most every `wait` ms.
*/
throttle: function(func, wait, options) {
var context, args, result;
var timeout = null;
var previous = 0;
options || (options = {});
var later = function() {
previous = options.leading === false ? 0 : Date.now();
timeout = null;
result = func.apply(context, args);
};
return function() {
var now = Date.now();
if (!previous && options.leading === false) previous = now;
var remaining = wait - (now - previous);
context = this;
args = arguments;
if (remaining <= 0) {
clearTimeout(timeout);
timeout = null;
previous = now;
result = func.apply(context, args);
} else if (!timeout && options.trailing !== false) {
timeout = setTimeout(later, remaining);
}
return result;
};
},
// Borrowed from Backbone.js's extend
// Helper function to correctly set up the prototype chain, for subclasses.
// Similar to `goog.inherits`, but uses a hash of prototype properties and
// class properties to be extended.
inherit: function(protoProps, staticProps) {
var parent = this;
var child;
// The constructor function for the new subclass is either defined by you
// (the "constructor" property in your `extend` definition), or defaulted
// by us to simply call the parent's constructor.
if (protoProps && protoProps.hasOwnProperty('constructor')) {
child = protoProps.constructor;
} else {
child = function() { return parent.apply(this, arguments); };
}
// Add static properties to the constructor function, if supplied.
ionic.extend(child, parent, staticProps);
// Set the prototype chain to inherit from `parent`, without calling
// `parent`'s constructor function.
var Surrogate = function() { this.constructor = child; };
Surrogate.prototype = parent.prototype;
child.prototype = new Surrogate();
// Add prototype properties (instance properties) to the subclass,
// if supplied.
if (protoProps) ionic.extend(child.prototype, protoProps);
// Set a convenience property in case the parent's prototype is needed
// later.
child.__super__ = parent.prototype;
return child;
},
// Extend adapted from Underscore.js
extend: function(obj) {
var args = Array.prototype.slice.call(arguments, 1);
for (var i = 0; i < args.length; i++) {
var source = args[i];
if (source) {
for (var prop in source) {
obj[prop] = source[prop];
}
}
}
return obj;
},
nextUid: function() {
return 'ion' + (nextId++);
},
disconnectScope: function disconnectScope(scope) {
if (!scope) return;
if (scope.$root === scope) {
return; // we can't disconnect the root node;
}
var parent = scope.$parent;
scope.$$disconnected = true;
scope.$broadcast('$ionic.disconnectScope', scope);
// See Scope.$destroy
if (parent.$$childHead === scope) {
parent.$$childHead = scope.$$nextSibling;
}
if (parent.$$childTail === scope) {
parent.$$childTail = scope.$$prevSibling;
}
if (scope.$$prevSibling) {
scope.$$prevSibling.$$nextSibling = scope.$$nextSibling;
}
if (scope.$$nextSibling) {
scope.$$nextSibling.$$prevSibling = scope.$$prevSibling;
}
scope.$$nextSibling = scope.$$prevSibling = null;
},
reconnectScope: function reconnectScope(scope) {
if (!scope) return;
if (scope.$root === scope) {
return; // we can't disconnect the root node;
}
if (!scope.$$disconnected) {
return;
}
var parent = scope.$parent;
scope.$$disconnected = false;
scope.$broadcast('$ionic.reconnectScope', scope);
// See Scope.$new for this logic...
scope.$$prevSibling = parent.$$childTail;
if (parent.$$childHead) {
parent.$$childTail.$$nextSibling = scope;
parent.$$childTail = scope;
} else {
parent.$$childHead = parent.$$childTail = scope;
}
},
isScopeDisconnected: function(scope) {
var climbScope = scope;
while (climbScope) {
if (climbScope.$$disconnected) return true;
climbScope = climbScope.$parent;
}
return false;
}
};
// Bind a few of the most useful functions to the ionic scope
ionic.inherit = ionic.Utils.inherit;
ionic.extend = ionic.Utils.extend;
ionic.throttle = ionic.Utils.throttle;
ionic.proxy = ionic.Utils.proxy;
ionic.debounce = ionic.Utils.debounce;
})(window.ionic);
/**
* @ngdoc page
* @name keyboard
* @module ionic
* @description
* On both Android and iOS, Ionic will attempt to prevent the keyboard from
* obscuring inputs and focusable elements when it appears by scrolling them
* into view. In order for this to work, any focusable elements must be within
* a [Scroll View](http://ionicframework.com/docs/api/directive/ionScroll/)
* or a directive such as [Content](http://ionicframework.com/docs/api/directive/ionContent/)
* that has a Scroll View.
*
* It will also attempt to prevent the native overflow scrolling on focus,
* which can cause layout issues such as pushing headers up and out of view.
*
* The keyboard fixes work best in conjunction with the
* [Ionic Keyboard Plugin](https://github.com/driftyco/ionic-plugins-keyboard),
* although it will perform reasonably well without. However, if you are using
* Cordova there is no reason not to use the plugin.
*
* ### Hide when keyboard shows
*
* To hide an element when the keyboard is open, add the class `hide-on-keyboard-open`.
*
* ```html
* <div class="hide-on-keyboard-open">
* <div id="google-map"></div>
* </div>
* ```
*
* Note: For performance reasons, elements will not be hidden for 400ms after the start of the `native.keyboardshow` event
* from the Ionic Keyboard plugin. If you would like them to disappear immediately, you could do something
* like:
*
* ```js
* window.addEventListener('native.keyboardshow', function(){
* document.body.classList.add('keyboard-open');
* });
* ```
* This adds the same `keyboard-open` class that is normally added by Ionic 400ms after the keyboard
* opens. However, bear in mind that adding this class to the body immediately may cause jank in any
* animations on Android that occur when the keyboard opens (for example, scrolling any obscured inputs into view).
*
* ----------
*
* ### Plugin Usage
* Information on using the plugin can be found at
* [https://github.com/driftyco/ionic-plugins-keyboard](https://github.com/driftyco/ionic-plugins-keyboard).
*
* ----------
*
* ### Android Notes
* - If your app is running in fullscreen, i.e. you have
* `<preference name="Fullscreen" value="true" />` in your `config.xml` file
* you will need to set `ionic.Platform.isFullScreen = true` manually.
*
* - You can configure the behavior of the web view when the keyboard shows by setting
* [android:windowSoftInputMode](http://developer.android.com/reference/android/R.attr.html#windowSoftInputMode)
* to either `adjustPan`, `adjustResize` or `adjustNothing` in your app's
* activity in `AndroidManifest.xml`. `adjustResize` is the recommended setting
* for Ionic, but if for some reason you do use `adjustPan` you will need to
* set `ionic.Platform.isFullScreen = true`.
*
* ```xml
* <activity android:windowSoftInputMode="adjustResize">
*
* ```
*
* ### iOS Notes
* - If the content of your app (including the header) is being pushed up and
* out of view on input focus, try setting `cordova.plugins.Keyboard.disableScroll(true)`.
* This does **not** disable scrolling in the Ionic scroll view, rather it
* disables the native overflow scrolling that happens automatically as a
* result of focusing on inputs below the keyboard.
*
*/
/**
* The current viewport height.
*/
var keyboardCurrentViewportHeight = 0;
/**
* The viewport height when in portrait orientation.
*/
var keyboardPortraitViewportHeight = 0;
/**
* The viewport height when in landscape orientation.
*/
var keyboardLandscapeViewportHeight = 0;
/**
* The currently focused input.
*/
var keyboardActiveElement;
/**
* The scroll view containing the currently focused input.
*/
var scrollView;
/**
* Timer for the setInterval that polls window.innerHeight to determine whether
* the layout has updated for the keyboard showing/hiding.
*/
var waitForResizeTimer;
/**
* Sometimes when switching inputs or orientations, focusout will fire before
* focusin, so this timer is for the small setTimeout to determine if we should
* really focusout/hide the keyboard.
*/
var keyboardFocusOutTimer;
/**
* on Android, orientationchange will fire before the keyboard plugin notifies
* the browser that the keyboard will show/is showing, so this flag indicates
* to nativeShow that there was an orientationChange and we should update
* the viewport height with an accurate keyboard height value
*/
var wasOrientationChange = false;
/**
* CSS class added to the body indicating the keyboard is open.
*/
var KEYBOARD_OPEN_CSS = 'keyboard-open';
/**
* CSS class that indicates a scroll container.
*/
var SCROLL_CONTAINER_CSS = 'scroll-content';
/**
* Debounced keyboardFocusIn function
*/
var debouncedKeyboardFocusIn = ionic.debounce(keyboardFocusIn, 200, true);
/**
* Debounced keyboardNativeShow function
*/
var debouncedKeyboardNativeShow = ionic.debounce(keyboardNativeShow, 100, true);
/**
* Ionic keyboard namespace.
* @namespace keyboard
*/
ionic.keyboard = {
/**
* Whether the keyboard is open or not.
*/
isOpen: false,
/**
* Whether the keyboard is closing or not.
*/
isClosing: false,
/**
* Whether the keyboard is opening or not.
*/
isOpening: false,
/**
* The height of the keyboard in pixels, as reported by the keyboard plugin.
* If the plugin is not available, calculated as the difference in
* window.innerHeight after the keyboard has shown.
*/
height: 0,
/**
* Whether the device is in landscape orientation or not.
*/
isLandscape: false,
/**
* Whether the keyboard event listeners have been added or not
*/
isInitialized: false,
/**
* Hide the keyboard, if it is open.
*/
hide: function() {
if (keyboardHasPlugin()) {
cordova.plugins.Keyboard.close();
}
keyboardActiveElement && keyboardActiveElement.blur();
},
/**
* An alias for cordova.plugins.Keyboard.show(). If the keyboard plugin
* is installed, show the keyboard.
*/
show: function() {
if (keyboardHasPlugin()) {
cordova.plugins.Keyboard.show();
}
},
/**
* Remove all keyboard related event listeners, effectively disabling Ionic's
* keyboard adjustments.
*/
disable: function() {
if (keyboardHasPlugin()) {
window.removeEventListener('native.keyboardshow', debouncedKeyboardNativeShow );
window.removeEventListener('native.keyboardhide', keyboardFocusOut);
} else {
document.body.removeEventListener('focusout', keyboardFocusOut);
}
document.body.removeEventListener('ionic.focusin', debouncedKeyboardFocusIn);
document.body.removeEventListener('focusin', debouncedKeyboardFocusIn);
window.removeEventListener('orientationchange', keyboardOrientationChange);
if ( window.navigator.msPointerEnabled ) {
document.removeEventListener("MSPointerDown", keyboardInit);
} else {
document.removeEventListener('touchstart', keyboardInit);
}
ionic.keyboard.isInitialized = false;
},
/**
* Alias for keyboardInit, initialize all keyboard related event listeners.
*/
enable: function() {
keyboardInit();
}
};
// Initialize the viewport height (after ionic.keyboard.height has been
// defined).
keyboardCurrentViewportHeight = getViewportHeight();
/* Event handlers */
/* ------------------------------------------------------------------------- */
/**
* Event handler for first touch event, initializes all event listeners
* for keyboard related events. Also aliased by ionic.keyboard.enable.
*/
function keyboardInit() {
if (ionic.keyboard.isInitialized) return;
if (keyboardHasPlugin()) {
window.addEventListener('native.keyboardshow', debouncedKeyboardNativeShow);
window.addEventListener('native.keyboardhide', keyboardFocusOut);
} else {
document.body.addEventListener('focusout', keyboardFocusOut);
}
document.body.addEventListener('ionic.focusin', debouncedKeyboardFocusIn);
document.body.addEventListener('focusin', debouncedKeyboardFocusIn);
if (window.navigator.msPointerEnabled) {
document.removeEventListener("MSPointerDown", keyboardInit);
} else {
document.removeEventListener('touchstart', keyboardInit);
}
ionic.keyboard.isInitialized = true;
}
/**
* Event handler for 'native.keyboardshow' event, sets keyboard.height to the
* reported height and keyboard.isOpening to true. Then calls
* keyboardWaitForResize with keyboardShow or keyboardUpdateViewportHeight as
* the callback depending on whether the event was triggered by a focusin or
* an orientationchange.
*/
function keyboardNativeShow(e) {
clearTimeout(keyboardFocusOutTimer);
//console.log("keyboardNativeShow fired at: " + Date.now());
//console.log("keyboardNativeshow window.innerHeight: " + window.innerHeight);
if (!ionic.keyboard.isOpen || ionic.keyboard.isClosing) {
ionic.keyboard.isOpening = true;
ionic.keyboard.isClosing = false;
}
ionic.keyboard.height = e.keyboardHeight;
//console.log('nativeshow keyboard height:' + e.keyboardHeight);
if (wasOrientationChange) {
keyboardWaitForResize(keyboardUpdateViewportHeight, true);
} else {
keyboardWaitForResize(keyboardShow, true);
}
}
/**
* Event handler for 'focusin' and 'ionic.focusin' events. Initializes
* keyboard state (keyboardActiveElement and keyboard.isOpening) for the
* appropriate adjustments once the window has resized. If not using the
* keyboard plugin, calls keyboardWaitForResize with keyboardShow as the
* callback or keyboardShow right away if the keyboard is already open. If
* using the keyboard plugin does nothing and lets keyboardNativeShow handle
* adjustments with a more accurate keyboard height.
*/
function keyboardFocusIn(e) {
clearTimeout(keyboardFocusOutTimer);
//console.log("keyboardFocusIn from: " + e.type + " at: " + Date.now());
if (!e.target ||
e.target.readOnly ||
!ionic.tap.isKeyboardElement(e.target) ||
!(scrollView = ionic.DomUtil.getParentWithClass(e.target, SCROLL_CONTAINER_CSS))) {
keyboardActiveElement = null;
return;
}
keyboardActiveElement = e.target;
// if using JS scrolling, undo the effects of native overflow scroll so the
// scroll view is positioned correctly
if (!scrollView.classList.contains("overflow-scroll")) {
document.body.scrollTop = 0;
scrollView.scrollTop = 0;
ionic.requestAnimationFrame(function(){
document.body.scrollTop = 0;
scrollView.scrollTop = 0;
});
// any showing part of the document that isn't within the scroll the user
// could touchmove and cause some ugly changes to the app, so disable
// any touchmove events while the keyboard is open using e.preventDefault()
if (window.navigator.msPointerEnabled) {
document.addEventListener("MSPointerMove", keyboardPreventDefault, false);
} else {
document.addEventListener('touchmove', keyboardPreventDefault, false);
}
}
if (!ionic.keyboard.isOpen || ionic.keyboard.isClosing) {
ionic.keyboard.isOpening = true;
ionic.keyboard.isClosing = false;
}
// attempt to prevent browser from natively scrolling input into view while
// we are trying to do the same (while we are scrolling) if the user taps the
// keyboard
document.addEventListener('keydown', keyboardOnKeyDown, false);
// if we aren't using the plugin and the keyboard isn't open yet, wait for the
// window to resize so we can get an accurate estimate of the keyboard size,
// otherwise we do nothing and let nativeShow call keyboardShow once we have
// an exact keyboard height
// if the keyboard is already open, go ahead and scroll the input into view
// if necessary
if (!ionic.keyboard.isOpen && !keyboardHasPlugin()) {
keyboardWaitForResize(keyboardShow, true);
} else if (ionic.keyboard.isOpen) {
keyboardShow();
}
}
/**
* Event handler for 'focusout' events. Sets keyboard.isClosing to true and
* calls keyboardWaitForResize with keyboardHide as the callback after a small
* timeout.
*/
function keyboardFocusOut() {
clearTimeout(keyboardFocusOutTimer);
//console.log("keyboardFocusOut fired at: " + Date.now());
//console.log("keyboardFocusOut event type: " + e.type);
if (ionic.keyboard.isOpen || ionic.keyboard.isOpening) {
ionic.keyboard.isClosing = true;
ionic.keyboard.isOpening = false;
}
// Call keyboardHide with a slight delay because sometimes on focus or
// orientation change focusin is called immediately after, so we give it time
// to cancel keyboardHide
keyboardFocusOutTimer = setTimeout(function() {
ionic.requestAnimationFrame(function() {
// focusOut during or right after an orientationchange, so we didn't get
// a chance to update the viewport height yet, do it and keyboardHide
//console.log("focusOut, wasOrientationChange: " + wasOrientationChange);
if (wasOrientationChange) {
keyboardWaitForResize(function(){
keyboardUpdateViewportHeight();
keyboardHide();
}, false);
} else {
keyboardWaitForResize(keyboardHide, false);
}
});
}, 50);
}
/**
* Event handler for 'orientationchange' events. If using the keyboard plugin
* and the keyboard is open on Android, sets wasOrientationChange to true so
* nativeShow can update the viewport height with an accurate keyboard height.
* If the keyboard isn't open or keyboard plugin isn't being used,
* waits for the window to resize before updating the viewport height.
*
* On iOS, where orientationchange fires after the keyboard has already shown,
* updates the viewport immediately, regardless of if the keyboard is already
* open.
*/
function keyboardOrientationChange() {
//console.log("orientationchange fired at: " + Date.now());
//console.log("orientation was: " + (ionic.keyboard.isLandscape ? "landscape" : "portrait"));
// toggle orientation
ionic.keyboard.isLandscape = !ionic.keyboard.isLandscape;
// //console.log("now orientation is: " + (ionic.keyboard.isLandscape ? "landscape" : "portrait"));
// no need to wait for resizing on iOS, and orientationchange always fires
// after the keyboard has opened, so it doesn't matter if it's open or not
if (ionic.Platform.isIOS()) {
keyboardUpdateViewportHeight();
}
// On Android, if the keyboard isn't open or we aren't using the keyboard
// plugin, update the viewport height once everything has resized. If the
// keyboard is open and we are using the keyboard plugin do nothing and let
// nativeShow handle it using an accurate keyboard height.
if ( ionic.Platform.isAndroid()) {
if (!ionic.keyboard.isOpen || !keyboardHasPlugin()) {
keyboardWaitForResize(keyboardUpdateViewportHeight, false);
} else {
wasOrientationChange = true;
}
}
}
/**
* Event handler for 'keydown' event. Tries to prevent browser from natively
* scrolling an input into view when a user taps the keyboard while we are
* scrolling the input into view ourselves with JS.
*/
function keyboardOnKeyDown(e) {
if (ionic.scroll.isScrolling) {
keyboardPreventDefault(e);
}
}
/**
* Event for 'touchmove' or 'MSPointerMove'. Prevents native scrolling on
* elements outside the scroll view while the keyboard is open.
*/
function keyboardPreventDefault(e) {
if (e.target.tagName !== 'TEXTAREA') {
e.preventDefault();
}
}
/* Private API */
/* -------------------------------------------------------------------------- */
/**
* Polls window.innerHeight until it has updated to an expected value (or
* sufficient time has passed) before calling the specified callback function.
* Only necessary for non-fullscreen Android which sometimes reports multiple
* window.innerHeight values during interim layouts while it is resizing.
*
* On iOS, the window.innerHeight will already be updated, but we use the 50ms
* delay as essentially a timeout so that scroll view adjustments happen after
* the keyboard has shown so there isn't a white flash from us resizing too
* quickly.
*
* @param {Function} callback the function to call once the window has resized
* @param {boolean} isOpening whether the resize is from the keyboard opening
* or not
*/
function keyboardWaitForResize(callback, isOpening) {
clearInterval(waitForResizeTimer);
var count = 0;
var maxCount;
var initialHeight = getViewportHeight();
var viewportHeight = initialHeight;
//console.log("waitForResize initial viewport height: " + viewportHeight);
//var start = Date.now();
//console.log("start: " + start);
// want to fail relatively quickly on modern android devices, since it's much
// more likely we just have a bad keyboard height
if (ionic.Platform.isAndroid() && ionic.Platform.version() < 4.4) {
maxCount = 30;
} else if (ionic.Platform.isAndroid()) {
maxCount = 10;
} else {
maxCount = 1;
}
// poll timer
waitForResizeTimer = setInterval(function(){
viewportHeight = getViewportHeight();
// height hasn't updated yet, try again in 50ms
// if not using plugin, wait for maxCount to ensure we have waited long enough
// to get an accurate keyboard height
if (++count < maxCount &&
((!isPortraitViewportHeight(viewportHeight) &&
!isLandscapeViewportHeight(viewportHeight)) ||
!ionic.keyboard.height)) {
return;
}
// infer the keyboard height from the resize if not using the keyboard plugin
if (!keyboardHasPlugin()) {
ionic.keyboard.height = Math.abs(initialHeight - window.innerHeight);
}
// set to true if we were waiting for the keyboard to open
ionic.keyboard.isOpen = isOpening;
clearInterval(waitForResizeTimer);
//var end = Date.now();
//console.log("waitForResize count: " + count);
//console.log("end: " + end);
//console.log("difference: " + ( end - start ) + "ms");
//console.log("callback: " + callback.name);
callback();
}, 50);
return maxCount; //for tests
}
/**
* On keyboard close sets keyboard state to closed, resets the scroll view,
* removes CSS from body indicating keyboard was open, removes any event
* listeners for when the keyboard is open and on Android blurs the active
* element (which in some cases will still have focus even if the keyboard
* is closed and can cause it to reappear on subsequent taps).
*/
function keyboardHide() {
clearTimeout(keyboardFocusOutTimer);
//console.log("keyboardHide");
ionic.keyboard.isOpen = false;
ionic.keyboard.isClosing = false;
if (keyboardActiveElement) {
ionic.trigger('resetScrollView', {
target: keyboardActiveElement
}, true);
}
ionic.requestAnimationFrame(function(){
document.body.classList.remove(KEYBOARD_OPEN_CSS);
});
// the keyboard is gone now, remove the touchmove that disables native scroll
if (window.navigator.msPointerEnabled) {
document.removeEventListener("MSPointerMove", keyboardPreventDefault);
} else {
document.removeEventListener('touchmove', keyboardPreventDefault);
}
document.removeEventListener('keydown', keyboardOnKeyDown);
if (ionic.Platform.isAndroid()) {
// on android closing the keyboard with the back/dismiss button won't remove
// focus and keyboard can re-appear on subsequent taps (like scrolling)
if (keyboardHasPlugin()) cordova.plugins.Keyboard.close();
keyboardActiveElement && keyboardActiveElement.blur();
}
keyboardActiveElement = null;
}
/**
* On keyboard open sets keyboard state to open, adds CSS to the body
* indicating the keyboard is open and tells the scroll view to resize and
* the currently focused input into view if necessary.
*/
function keyboardShow() {
ionic.keyboard.isOpen = true;
ionic.keyboard.isOpening = false;
var details = {
keyboardHeight: keyboardGetHeight(),
viewportHeight: keyboardCurrentViewportHeight
};
if (keyboardActiveElement) {
details.target = keyboardActiveElement;
var elementBounds = keyboardActiveElement.getBoundingClientRect();
details.elementTop = Math.round(elementBounds.top);
details.elementBottom = Math.round(elementBounds.bottom);
details.windowHeight = details.viewportHeight - details.keyboardHeight;
//console.log("keyboardShow viewportHeight: " + details.viewportHeight +
//", windowHeight: " + details.windowHeight +
//", keyboardHeight: " + details.keyboardHeight);
// figure out if the element is under the keyboard
details.isElementUnderKeyboard = (details.elementBottom > details.windowHeight);
//console.log("isUnderKeyboard: " + details.isElementUnderKeyboard);
//console.log("elementBottom: " + details.elementBottom);
// send event so the scroll view adjusts
ionic.trigger('scrollChildIntoView', details, true);
}
setTimeout(function(){
document.body.classList.add(KEYBOARD_OPEN_CSS);
}, 400);
return details; //for testing
}
/* eslint no-unused-vars:0 */
function keyboardGetHeight() {
// check if we already have a keyboard height from the plugin or resize calculations
if (ionic.keyboard.height) {
return ionic.keyboard.height;
}
if (ionic.Platform.isAndroid()) {
// should be using the plugin, no way to know how big the keyboard is, so guess
if ( ionic.Platform.isFullScreen ) {
return 275;
}
// otherwise just calculate it
var contentHeight = window.innerHeight;
if (contentHeight < keyboardCurrentViewportHeight) {
return keyboardCurrentViewportHeight - contentHeight;
} else {
return 0;
}
}
// fallback for when it's the webview without the plugin
// or for just the standard web browser
// TODO: have these be based on device
if (ionic.Platform.isIOS()) {
if (ionic.keyboard.isLandscape) {
return 206;
}
if (!ionic.Platform.isWebView()) {
return 216;
}
return 260;
}
// safe guess
return 275;
}
function isPortraitViewportHeight(viewportHeight) {
return !!(!ionic.keyboard.isLandscape &&
keyboardPortraitViewportHeight &&
(Math.abs(keyboardPortraitViewportHeight - viewportHeight) < 2));
}
function isLandscapeViewportHeight(viewportHeight) {
return !!(ionic.keyboard.isLandscape &&
keyboardLandscapeViewportHeight &&
(Math.abs(keyboardLandscapeViewportHeight - viewportHeight) < 2));
}
function keyboardUpdateViewportHeight() {
wasOrientationChange = false;
keyboardCurrentViewportHeight = getViewportHeight();
if (ionic.keyboard.isLandscape && !keyboardLandscapeViewportHeight) {
//console.log("saved landscape: " + keyboardCurrentViewportHeight);
keyboardLandscapeViewportHeight = keyboardCurrentViewportHeight;
} else if (!ionic.keyboard.isLandscape && !keyboardPortraitViewportHeight) {
//console.log("saved portrait: " + keyboardCurrentViewportHeight);
keyboardPortraitViewportHeight = keyboardCurrentViewportHeight;
}
if (keyboardActiveElement) {
ionic.trigger('resetScrollView', {
target: keyboardActiveElement
}, true);
}
if (ionic.keyboard.isOpen && ionic.tap.isTextInput(keyboardActiveElement)) {
keyboardShow();
}
}
function keyboardInitViewportHeight() {
var viewportHeight = getViewportHeight();
//console.log("Keyboard init VP: " + viewportHeight + " " + window.innerWidth);
// can't just use window.innerHeight in case the keyboard is opened immediately
if ((viewportHeight / window.innerWidth) < 1) {
ionic.keyboard.isLandscape = true;
}
//console.log("ionic.keyboard.isLandscape is: " + ionic.keyboard.isLandscape);
// initialize or update the current viewport height values
keyboardCurrentViewportHeight = viewportHeight;
if (ionic.keyboard.isLandscape && !keyboardLandscapeViewportHeight) {
keyboardLandscapeViewportHeight = keyboardCurrentViewportHeight;
} else if (!ionic.keyboard.isLandscape && !keyboardPortraitViewportHeight) {
keyboardPortraitViewportHeight = keyboardCurrentViewportHeight;
}
}
function getViewportHeight() {
var windowHeight = window.innerHeight;
//console.log('window.innerHeight is: ' + windowHeight);
//console.log('kb height is: ' + ionic.keyboard.height);
//console.log('kb isOpen: ' + ionic.keyboard.isOpen);
//TODO: add iPad undocked/split kb once kb plugin supports it
// the keyboard overlays the window on Android fullscreen
if (!(ionic.Platform.isAndroid() && ionic.Platform.isFullScreen) &&
(ionic.keyboard.isOpen || ionic.keyboard.isOpening) &&
!ionic.keyboard.isClosing) {
return windowHeight + keyboardGetHeight();
}
return windowHeight;
}
function keyboardHasPlugin() {
return !!(window.cordova && cordova.plugins && cordova.plugins.Keyboard);
}
ionic.Platform.ready(function() {
keyboardInitViewportHeight();
window.addEventListener('orientationchange', keyboardOrientationChange);
// if orientation changes while app is in background, update on resuming
/*
if ( ionic.Platform.isWebView() ) {
document.addEventListener('resume', keyboardInitViewportHeight);
if (ionic.Platform.isAndroid()) {
//TODO: onbackpressed to detect keyboard close without focusout or plugin
}
}
*/
// if orientation changes while app is in background, update on resuming
/* if ( ionic.Platform.isWebView() ) {
document.addEventListener('pause', function() {
window.removeEventListener('orientationchange', keyboardOrientationChange);
})
document.addEventListener('resume', function() {
keyboardInitViewportHeight();
window.addEventListener('orientationchange', keyboardOrientationChange)
});
}*/
// Android sometimes reports bad innerHeight on window.load
// try it again in a lil bit to play it safe
setTimeout(keyboardInitViewportHeight, 999);
// only initialize the adjustments for the virtual keyboard
// if a touchstart event happens
if (window.navigator.msPointerEnabled) {
document.addEventListener("MSPointerDown", keyboardInit, false);
} else {
document.addEventListener('touchstart', keyboardInit, false);
}
});
var viewportTag;
var viewportProperties = {};
ionic.viewport = {
orientation: function() {
// 0 = Portrait
// 90 = Landscape
// not using window.orientation because each device has a different implementation
return (window.innerWidth > window.innerHeight ? 90 : 0);
}
};
function viewportLoadTag() {
var x;
for (x = 0; x < document.head.children.length; x++) {
if (document.head.children[x].name == 'viewport') {
viewportTag = document.head.children[x];
break;
}
}
if (viewportTag) {
var props = viewportTag.content.toLowerCase().replace(/\s+/g, '').split(',');
var keyValue;
for (x = 0; x < props.length; x++) {
if (props[x]) {
keyValue = props[x].split('=');
viewportProperties[ keyValue[0] ] = (keyValue.length > 1 ? keyValue[1] : '_');
}
}
viewportUpdate();
}
}
function viewportUpdate() {
// unit tests in viewport.unit.js
var initWidth = viewportProperties.width;
var initHeight = viewportProperties.height;
var p = ionic.Platform;
var version = p.version();
var DEVICE_WIDTH = 'device-width';
var DEVICE_HEIGHT = 'device-height';
var orientation = ionic.viewport.orientation();
// Most times we're removing the height and adding the width
// So this is the default to start with, then modify per platform/version/oreintation
delete viewportProperties.height;
viewportProperties.width = DEVICE_WIDTH;
if (p.isIPad()) {
// iPad
if (version > 7) {
// iPad >= 7.1
// https://issues.apache.org/jira/browse/CB-4323
delete viewportProperties.width;
} else {
// iPad <= 7.0
if (p.isWebView()) {
// iPad <= 7.0 WebView
if (orientation == 90) {
// iPad <= 7.0 WebView Landscape
viewportProperties.height = '0';
} else if (version == 7) {
// iPad <= 7.0 WebView Portait
viewportProperties.height = DEVICE_HEIGHT;
}
} else {
// iPad <= 6.1 Browser
if (version < 7) {
viewportProperties.height = '0';
}
}
}
} else if (p.isIOS()) {
// iPhone
if (p.isWebView()) {
// iPhone WebView
if (version > 7) {
// iPhone >= 7.1 WebView
delete viewportProperties.width;
} else if (version < 7) {
// iPhone <= 6.1 WebView
// if height was set it needs to get removed with this hack for <= 6.1
if (initHeight) viewportProperties.height = '0';
} else if (version == 7) {
//iPhone == 7.0 WebView
viewportProperties.height = DEVICE_HEIGHT;
}
} else {
// iPhone Browser
if (version < 7) {
// iPhone <= 6.1 Browser
// if height was set it needs to get removed with this hack for <= 6.1
if (initHeight) viewportProperties.height = '0';
}
}
}
// only update the viewport tag if there was a change
if (initWidth !== viewportProperties.width || initHeight !== viewportProperties.height) {
viewportTagUpdate();
}
}
function viewportTagUpdate() {
var key, props = [];
for (key in viewportProperties) {
if (viewportProperties[key]) {
props.push(key + (viewportProperties[key] == '_' ? '' : '=' + viewportProperties[key]));
}
}
viewportTag.content = props.join(', ');
}
ionic.Platform.ready(function() {
viewportLoadTag();
window.addEventListener("orientationchange", function() {
setTimeout(viewportUpdate, 1000);
}, false);
});
(function(ionic) {
'use strict';
ionic.views.View = function() {
this.initialize.apply(this, arguments);
};
ionic.views.View.inherit = ionic.inherit;
ionic.extend(ionic.views.View.prototype, {
initialize: function() {}
});
})(window.ionic);
/*
* Scroller
* http://github.com/zynga/scroller
*
* Copyright 2011, Zynga Inc.
* Licensed under the MIT License.
* https://raw.github.com/zynga/scroller/master/MIT-LICENSE.txt
*
* Based on the work of: Unify Project (unify-project.org)
* http://unify-project.org
* Copyright 2011, Deutsche Telekom AG
* License: MIT + Apache (V2)
*/
/* jshint eqnull: true */
/**
* Generic animation class with support for dropped frames both optional easing and duration.
*
* Optional duration is useful when the lifetime is defined by another condition than time
* e.g. speed of an animating object, etc.
*
* Dropped frame logic allows to keep using the same updater logic independent from the actual
* rendering. This eases a lot of cases where it might be pretty complex to break down a state
* based on the pure time difference.
*/
var zyngaCore = { effect: {} };
(function(global) {
var time = Date.now || function() {
return +new Date();
};
var desiredFrames = 60;
var millisecondsPerSecond = 1000;
var running = {};
var counter = 1;
zyngaCore.effect.Animate = {
/**
* A requestAnimationFrame wrapper / polyfill.
*
* @param callback {Function} The callback to be invoked before the next repaint.
* @param root {HTMLElement} The root element for the repaint
*/
requestAnimationFrame: (function() {
// Check for request animation Frame support
var requestFrame = global.requestAnimationFrame || global.webkitRequestAnimationFrame || global.mozRequestAnimationFrame || global.oRequestAnimationFrame;
var isNative = !!requestFrame;
if (requestFrame && !/requestAnimationFrame\(\)\s*\{\s*\[native code\]\s*\}/i.test(requestFrame.toString())) {
isNative = false;
}
if (isNative) {
return function(callback, root) {
requestFrame(callback, root);
};
}
var TARGET_FPS = 60;
var requests = {};
var requestCount = 0;
var rafHandle = 1;
var intervalHandle = null;
var lastActive = +new Date();
return function(callback) {
var callbackHandle = rafHandle++;
// Store callback
requests[callbackHandle] = callback;
requestCount++;
// Create timeout at first request
if (intervalHandle === null) {
intervalHandle = setInterval(function() {
var time = +new Date();
var currentRequests = requests;
// Reset data structure before executing callbacks
requests = {};
requestCount = 0;
for(var key in currentRequests) {
if (currentRequests.hasOwnProperty(key)) {
currentRequests[key](time);
lastActive = time;
}
}
// Disable the timeout when nothing happens for a certain
// period of time
if (time - lastActive > 2500) {
clearInterval(intervalHandle);
intervalHandle = null;
}
}, 1000 / TARGET_FPS);
}
return callbackHandle;
};
})(),
/**
* Stops the given animation.
*
* @param id {Integer} Unique animation ID
* @return {Boolean} Whether the animation was stopped (aka, was running before)
*/
stop: function(id) {
var cleared = running[id] != null;
if (cleared) {
running[id] = null;
}
return cleared;
},
/**
* Whether the given animation is still running.
*
* @param id {Integer} Unique animation ID
* @return {Boolean} Whether the animation is still running
*/
isRunning: function(id) {
return running[id] != null;
},
/**
* Start the animation.
*
* @param stepCallback {Function} Pointer to function which is executed on every step.
* Signature of the method should be `function(percent, now, virtual) { return continueWithAnimation; }`
* @param verifyCallback {Function} Executed before every animation step.
* Signature of the method should be `function() { return continueWithAnimation; }`
* @param completedCallback {Function}
* Signature of the method should be `function(droppedFrames, finishedAnimation) {}`
* @param duration {Integer} Milliseconds to run the animation
* @param easingMethod {Function} Pointer to easing function
* Signature of the method should be `function(percent) { return modifiedValue; }`
* @param root {Element} Render root, when available. Used for internal
* usage of requestAnimationFrame.
* @return {Integer} Identifier of animation. Can be used to stop it any time.
*/
start: function(stepCallback, verifyCallback, completedCallback, duration, easingMethod, root) {
var start = time();
var lastFrame = start;
var percent = 0;
var dropCounter = 0;
var id = counter++;
if (!root) {
root = document.body;
}
// Compacting running db automatically every few new animations
if (id % 20 === 0) {
var newRunning = {};
for (var usedId in running) {
newRunning[usedId] = true;
}
running = newRunning;
}
// This is the internal step method which is called every few milliseconds
var step = function(virtual) {
// Normalize virtual value
var render = virtual !== true;
// Get current time
var now = time();
// Verification is executed before next animation step
if (!running[id] || (verifyCallback && !verifyCallback(id))) {
running[id] = null;
completedCallback && completedCallback(desiredFrames - (dropCounter / ((now - start) / millisecondsPerSecond)), id, false);
return;
}
// For the current rendering to apply let's update omitted steps in memory.
// This is important to bring internal state variables up-to-date with progress in time.
if (render) {
var droppedFrames = Math.round((now - lastFrame) / (millisecondsPerSecond / desiredFrames)) - 1;
for (var j = 0; j < Math.min(droppedFrames, 4); j++) {
step(true);
dropCounter++;
}
}
// Compute percent value
if (duration) {
percent = (now - start) / duration;
if (percent > 1) {
percent = 1;
}
}
// Execute step callback, then...
var value = easingMethod ? easingMethod(percent) : percent;
if ((stepCallback(value, now, render) === false || percent === 1) && render) {
running[id] = null;
completedCallback && completedCallback(desiredFrames - (dropCounter / ((now - start) / millisecondsPerSecond)), id, percent === 1 || duration == null);
} else if (render) {
lastFrame = now;
zyngaCore.effect.Animate.requestAnimationFrame(step, root);
}
};
// Mark as running
running[id] = true;
// Init first step
zyngaCore.effect.Animate.requestAnimationFrame(step, root);
// Return unique animation ID
return id;
}
};
})(this);
/*
* Scroller
* http://github.com/zynga/scroller
*
* Copyright 2011, Zynga Inc.
* Licensed under the MIT License.
* https://raw.github.com/zynga/scroller/master/MIT-LICENSE.txt
*
* Based on the work of: Unify Project (unify-project.org)
* http://unify-project.org
* Copyright 2011, Deutsche Telekom AG
* License: MIT + Apache (V2)
*/
(function(ionic) {
var NOOP = function(){};
// Easing Equations (c) 2003 Robert Penner, all rights reserved.
// Open source under the BSD License.
/**
* @param pos {Number} position between 0 (start of effect) and 1 (end of effect)
**/
var easeOutCubic = function(pos) {
return (Math.pow((pos - 1), 3) + 1);
};
/**
* @param pos {Number} position between 0 (start of effect) and 1 (end of effect)
**/
var easeInOutCubic = function(pos) {
if ((pos /= 0.5) < 1) {
return 0.5 * Math.pow(pos, 3);
}
return 0.5 * (Math.pow((pos - 2), 3) + 2);
};
/**
* ionic.views.Scroll
* A powerful scroll view with support for bouncing, pull to refresh, and paging.
* @param {Object} options options for the scroll view
* @class A scroll view system
* @memberof ionic.views
*/
ionic.views.Scroll = ionic.views.View.inherit({
initialize: function(options) {
var self = this;
self.__container = options.el;
self.__content = options.el.firstElementChild;
//Remove any scrollTop attached to these elements; they are virtual scroll now
//This also stops on-load-scroll-to-window.location.hash that the browser does
setTimeout(function() {
if (self.__container && self.__content) {
self.__container.scrollTop = 0;
self.__content.scrollTop = 0;
}
});
self.options = {
/** Disable scrolling on x-axis by default */
scrollingX: false,
scrollbarX: true,
/** Enable scrolling on y-axis */
scrollingY: true,
scrollbarY: true,
startX: 0,
startY: 0,
/** The amount to dampen mousewheel events */
wheelDampen: 6,
/** The minimum size the scrollbars scale to while scrolling */
minScrollbarSizeX: 5,
minScrollbarSizeY: 5,
/** Scrollbar fading after scrolling */
scrollbarsFade: true,
scrollbarFadeDelay: 300,
/** The initial fade delay when the pane is resized or initialized */
scrollbarResizeFadeDelay: 1000,
/** Enable animations for deceleration, snap back, zooming and scrolling */
animating: true,
/** duration for animations triggered by scrollTo/zoomTo */
animationDuration: 250,
/** The velocity required to make the scroll view "slide" after touchend */
decelVelocityThreshold: 4,
/** The velocity required to make the scroll view "slide" after touchend when using paging */
decelVelocityThresholdPaging: 4,
/** Enable bouncing (content can be slowly moved outside and jumps back after releasing) */
bouncing: true,
/** Enable locking to the main axis if user moves only slightly on one of them at start */
locking: true,
/** Enable pagination mode (switching between full page content panes) */
paging: false,
/** Enable snapping of content to a configured pixel grid */
snapping: false,
/** Enable zooming of content via API, fingers and mouse wheel */
zooming: false,
/** Minimum zoom level */
minZoom: 0.5,
/** Maximum zoom level */
maxZoom: 3,
/** Multiply or decrease scrolling speed **/
speedMultiplier: 1,
deceleration: 0.97,
/** Whether to prevent default on a scroll operation to capture drag events **/
preventDefault: false,
/** Callback that is fired on the later of touch end or deceleration end,
provided that another scrolling action has not begun. Used to know
when to fade out a scrollbar. */
scrollingComplete: NOOP,
/** This configures the amount of change applied to deceleration when reaching boundaries **/
penetrationDeceleration: 0.03,
/** This configures the amount of change applied to acceleration when reaching boundaries **/
penetrationAcceleration: 0.08,
// The ms interval for triggering scroll events
scrollEventInterval: 10,
freeze: false,
getContentWidth: function() {
return Math.max(self.__content.scrollWidth, self.__content.offsetWidth);
},
getContentHeight: function() {
return Math.max(self.__content.scrollHeight, self.__content.offsetHeight + (self.__content.offsetTop * 2));
}
};
for (var key in options) {
self.options[key] = options[key];
}
self.hintResize = ionic.debounce(function() {
self.resize();
}, 1000, true);
self.onScroll = function() {
if (!ionic.scroll.isScrolling) {
setTimeout(self.setScrollStart, 50);
} else {
clearTimeout(self.scrollTimer);
self.scrollTimer = setTimeout(self.setScrollStop, 80);
}
};
self.freeze = function(shouldFreeze) {
if (arguments.length) {
self.options.freeze = shouldFreeze;
}
return self.options.freeze;
};
self.setScrollStart = function() {
ionic.scroll.isScrolling = Math.abs(ionic.scroll.lastTop - self.__scrollTop) > 1;
clearTimeout(self.scrollTimer);
self.scrollTimer = setTimeout(self.setScrollStop, 80);
};
self.setScrollStop = function() {
ionic.scroll.isScrolling = false;
ionic.scroll.lastTop = self.__scrollTop;
};
self.triggerScrollEvent = ionic.throttle(function() {
self.onScroll();
ionic.trigger('scroll', {
scrollTop: self.__scrollTop,
scrollLeft: self.__scrollLeft,
target: self.__container
});
}, self.options.scrollEventInterval);
self.triggerScrollEndEvent = function() {
ionic.trigger('scrollend', {
scrollTop: self.__scrollTop,
scrollLeft: self.__scrollLeft,
target: self.__container
});
};
self.__scrollLeft = self.options.startX;
self.__scrollTop = self.options.startY;
// Get the render update function, initialize event handlers,
// and calculate the size of the scroll container
self.__callback = self.getRenderFn();
self.__initEventHandlers();
self.__createScrollbars();
},
run: function() {
this.resize();
// Fade them out
this.__fadeScrollbars('out', this.options.scrollbarResizeFadeDelay);
},
/*
---------------------------------------------------------------------------
INTERNAL FIELDS :: STATUS
---------------------------------------------------------------------------
*/
/** Whether only a single finger is used in touch handling */
__isSingleTouch: false,
/** Whether a touch event sequence is in progress */
__isTracking: false,
/** Whether a deceleration animation went to completion. */
__didDecelerationComplete: false,
/**
* Whether a gesture zoom/rotate event is in progress. Activates when
* a gesturestart event happens. This has higher priority than dragging.
*/
__isGesturing: false,
/**
* Whether the user has moved by such a distance that we have enabled
* dragging mode. Hint: It's only enabled after some pixels of movement to
* not interrupt with clicks etc.
*/
__isDragging: false,
/**
* Not touching and dragging anymore, and smoothly animating the
* touch sequence using deceleration.
*/
__isDecelerating: false,
/**
* Smoothly animating the currently configured change
*/
__isAnimating: false,
/*
---------------------------------------------------------------------------
INTERNAL FIELDS :: DIMENSIONS
---------------------------------------------------------------------------
*/
/** Available outer left position (from document perspective) */
__clientLeft: 0,
/** Available outer top position (from document perspective) */
__clientTop: 0,
/** Available outer width */
__clientWidth: 0,
/** Available outer height */
__clientHeight: 0,
/** Outer width of content */
__contentWidth: 0,
/** Outer height of content */
__contentHeight: 0,
/** Snapping width for content */
__snapWidth: 100,
/** Snapping height for content */
__snapHeight: 100,
/** Height to assign to refresh area */
__refreshHeight: null,
/** Whether the refresh process is enabled when the event is released now */
__refreshActive: false,
/** Callback to execute on activation. This is for signalling the user about a refresh is about to happen when he release */
__refreshActivate: null,
/** Callback to execute on deactivation. This is for signalling the user about the refresh being cancelled */
__refreshDeactivate: null,
/** Callback to execute to start the actual refresh. Call {@link #refreshFinish} when done */
__refreshStart: null,
/** Zoom level */
__zoomLevel: 1,
/** Scroll position on x-axis */
__scrollLeft: 0,
/** Scroll position on y-axis */
__scrollTop: 0,
/** Maximum allowed scroll position on x-axis */
__maxScrollLeft: 0,
/** Maximum allowed scroll position on y-axis */
__maxScrollTop: 0,
/* Scheduled left position (final position when animating) */
__scheduledLeft: 0,
/* Scheduled top position (final position when animating) */
__scheduledTop: 0,
/* Scheduled zoom level (final scale when animating) */
__scheduledZoom: 0,
/*
---------------------------------------------------------------------------
INTERNAL FIELDS :: LAST POSITIONS
---------------------------------------------------------------------------
*/
/** Left position of finger at start */
__lastTouchLeft: null,
/** Top position of finger at start */
__lastTouchTop: null,
/** Timestamp of last move of finger. Used to limit tracking range for deceleration speed. */
__lastTouchMove: null,
/** List of positions, uses three indexes for each state: left, top, timestamp */
__positions: null,
/*
---------------------------------------------------------------------------
INTERNAL FIELDS :: DECELERATION SUPPORT
---------------------------------------------------------------------------
*/
/** Minimum left scroll position during deceleration */
__minDecelerationScrollLeft: null,
/** Minimum top scroll position during deceleration */
__minDecelerationScrollTop: null,
/** Maximum left scroll position during deceleration */
__maxDecelerationScrollLeft: null,
/** Maximum top scroll position during deceleration */
__maxDecelerationScrollTop: null,
/** Current factor to modify horizontal scroll position with on every step */
__decelerationVelocityX: null,
/** Current factor to modify vertical scroll position with on every step */
__decelerationVelocityY: null,
/** the browser-specific property to use for transforms */
__transformProperty: null,
__perspectiveProperty: null,
/** scrollbar indicators */
__indicatorX: null,
__indicatorY: null,
/** Timeout for scrollbar fading */
__scrollbarFadeTimeout: null,
/** whether we've tried to wait for size already */
__didWaitForSize: null,
__sizerTimeout: null,
__initEventHandlers: function() {
var self = this;
// Event Handler
var container = self.__container;
// save height when scroll view is shrunk so we don't need to reflow
var scrollViewOffsetHeight;
/**
* Shrink the scroll view when the keyboard is up if necessary and if the
* focused input is below the bottom of the shrunk scroll view, scroll it
* into view.
*/
self.scrollChildIntoView = function(e) {
//console.log("scrollChildIntoView at: " + Date.now());
// D
var scrollBottomOffsetToTop = container.getBoundingClientRect().bottom;
// D - A
scrollViewOffsetHeight = container.offsetHeight;
var alreadyShrunk = self.isShrunkForKeyboard;
var isModal = container.parentNode.classList.contains('modal');
// 680px is when the media query for 60% modal width kicks in
var isInsetModal = isModal && window.innerWidth >= 680;
/*
* _______
* |---A---| <- top of scroll view
* | |
* |---B---| <- keyboard
* | C | <- input
* |---D---| <- initial bottom of scroll view
* |___E___| <- bottom of viewport
*
* All commented calculations relative to the top of the viewport (ie E
* is the viewport height, not 0)
*/
if (!alreadyShrunk) {
// shrink scrollview so we can actually scroll if the input is hidden
// if it isn't shrink so we can scroll to inputs under the keyboard
// inset modals won't shrink on Android on their own when the keyboard appears
if ( ionic.Platform.isIOS() || ionic.Platform.isFullScreen || isInsetModal ) {
// if there are things below the scroll view account for them and
// subtract them from the keyboard height when resizing
// E - D E D
var scrollBottomOffsetToBottom = e.detail.viewportHeight - scrollBottomOffsetToTop;
// 0 or D - B if D > B E - B E - D
var keyboardOffset = Math.max(0, e.detail.keyboardHeight - scrollBottomOffsetToBottom);
ionic.requestAnimationFrame(function(){
// D - A or B - A if D > B D - A max(0, D - B)
scrollViewOffsetHeight = scrollViewOffsetHeight - keyboardOffset;
container.style.height = scrollViewOffsetHeight + "px";
container.style.overflow = "visible";
//update scroll view
self.resize();
});
}
self.isShrunkForKeyboard = true;
}
/*
* _______
* |---A---| <- top of scroll view
* | * | <- where we want to scroll to
* |--B-D--| <- keyboard, bottom of scroll view
* | C | <- input
* | |
* |___E___| <- bottom of viewport
*
* All commented calculations relative to the top of the viewport (ie E
* is the viewport height, not 0)
*/
// if the element is positioned under the keyboard scroll it into view
if (e.detail.isElementUnderKeyboard) {
ionic.requestAnimationFrame(function(){
container.scrollTop = 0;
// update D if we shrunk
if (self.isShrunkForKeyboard && !alreadyShrunk) {
scrollBottomOffsetToTop = container.getBoundingClientRect().bottom;
}
// middle of the scrollview, this is where we want to scroll to
// (D - A) / 2
var scrollMidpointOffset = scrollViewOffsetHeight * 0.5;
//console.log("container.offsetHeight: " + scrollViewOffsetHeight);
// middle of the input we want to scroll into view
// C
var inputMidpoint = ((e.detail.elementBottom + e.detail.elementTop) / 2);
// distance from middle of input to the bottom of the scroll view
// C - D C D
var inputMidpointOffsetToScrollBottom = inputMidpoint - scrollBottomOffsetToTop;
//C - D + (D - A)/2 C - D (D - A)/ 2
var scrollTop = inputMidpointOffsetToScrollBottom + scrollMidpointOffset;
if ( scrollTop > 0) {
if (ionic.Platform.isIOS()) ionic.tap.cloneFocusedInput(container, self);
self.scrollBy(0, scrollTop, true);
self.onScroll();
}
});
}
// Only the first scrollView parent of the element that broadcasted this event
// (the active element that needs to be shown) should receive this event
e.stopPropagation();
};
self.resetScrollView = function() {
//return scrollview to original height once keyboard has hidden
if ( self.isShrunkForKeyboard ) {
self.isShrunkForKeyboard = false;
container.style.height = "";
container.style.overflow = "";
}
self.resize();
};
//Broadcasted when keyboard is shown on some platforms.
//See js/utils/keyboard.js
container.addEventListener('scrollChildIntoView', self.scrollChildIntoView);
// Listen on document because container may not have had the last
// keyboardActiveElement, for example after closing a modal with a focused
// input and returning to a previously resized scroll view in an ion-content.
// Since we can only resize scroll views that are currently visible, just resize
// the current scroll view when the keyboard is closed.
document.addEventListener('resetScrollView', self.resetScrollView);
function getEventTouches(e) {
return e.touches && e.touches.length ? e.touches : [{
pageX: e.pageX,
pageY: e.pageY
}];
}
self.touchStart = function(e) {
self.startCoordinates = ionic.tap.pointerCoord(e);
if ( ionic.tap.ignoreScrollStart(e) ) {
return;
}
self.__isDown = true;
if ( ionic.tap.containsOrIsTextInput(e.target) || e.target.tagName === 'SELECT' ) {
// do not start if the target is a text input
// if there is a touchmove on this input, then we can start the scroll
self.__hasStarted = false;
return;
}
self.__isSelectable = true;
self.__enableScrollY = true;
self.__hasStarted = true;
self.doTouchStart(getEventTouches(e), e.timeStamp);
e.preventDefault();
};
self.touchMove = function(e) {
if (self.options.freeze || !self.__isDown ||
(!self.__isDown && e.defaultPrevented) ||
(e.target.tagName === 'TEXTAREA' && e.target.parentElement.querySelector(':focus')) ) {
return;
}
if ( !self.__hasStarted && ( ionic.tap.containsOrIsTextInput(e.target) || e.target.tagName === 'SELECT' ) ) {
// the target is a text input and scroll has started
// since the text input doesn't start on touchStart, do it here
self.__hasStarted = true;
self.doTouchStart(getEventTouches(e), e.timeStamp);
e.preventDefault();
return;
}
if (self.startCoordinates) {
// we have start coordinates, so get this touch move's current coordinates
var currentCoordinates = ionic.tap.pointerCoord(e);
if ( self.__isSelectable &&
ionic.tap.isTextInput(e.target) &&
Math.abs(self.startCoordinates.x - currentCoordinates.x) > 20 ) {
// user slid the text input's caret on its x axis, disable any future y scrolling
self.__enableScrollY = false;
self.__isSelectable = true;
}
if ( self.__enableScrollY && Math.abs(self.startCoordinates.y - currentCoordinates.y) > 10 ) {
// user scrolled the entire view on the y axis
// disabled being able to select text on an input
// hide the input which has focus, and show a cloned one that doesn't have focus
self.__isSelectable = false;
ionic.tap.cloneFocusedInput(container, self);
}
}
self.doTouchMove(getEventTouches(e), e.timeStamp, e.scale);
self.__isDown = true;
};
self.touchMoveBubble = function(e) {
if(self.__isDown && self.options.preventDefault) {
e.preventDefault();
}
};
self.touchEnd = function(e) {
if (!self.__isDown) return;
self.doTouchEnd(e, e.timeStamp);
self.__isDown = false;
self.__hasStarted = false;
self.__isSelectable = true;
self.__enableScrollY = true;
if ( !self.__isDragging && !self.__isDecelerating && !self.__isAnimating ) {
ionic.tap.removeClonedInputs(container, self);
}
};
self.mouseWheel = ionic.animationFrameThrottle(function(e) {
var scrollParent = ionic.DomUtil.getParentOrSelfWithClass(e.target, 'ionic-scroll');
if (!self.options.freeze && scrollParent === self.__container) {
self.hintResize();
self.scrollBy(
(e.wheelDeltaX || e.deltaX || 0) / self.options.wheelDampen,
(-e.wheelDeltaY || e.deltaY || 0) / self.options.wheelDampen
);
self.__fadeScrollbars('in');
clearTimeout(self.__wheelHideBarTimeout);
self.__wheelHideBarTimeout = setTimeout(function() {
self.__fadeScrollbars('out');
}, 100);
}
});
if ('ontouchstart' in window) {
// Touch Events
container.addEventListener("touchstart", self.touchStart, false);
if(self.options.preventDefault) container.addEventListener("touchmove", self.touchMoveBubble, false);
document.addEventListener("touchmove", self.touchMove, false);
document.addEventListener("touchend", self.touchEnd, false);
document.addEventListener("touchcancel", self.touchEnd, false);
} else if (window.navigator.pointerEnabled) {
// Pointer Events
container.addEventListener("pointerdown", self.touchStart, false);
if(self.options.preventDefault) container.addEventListener("pointermove", self.touchMoveBubble, false);
document.addEventListener("pointermove", self.touchMove, false);
document.addEventListener("pointerup", self.touchEnd, false);
document.addEventListener("pointercancel", self.touchEnd, false);
document.addEventListener("wheel", self.mouseWheel, false);
} else if (window.navigator.msPointerEnabled) {
// IE10, WP8 (Pointer Events)
container.addEventListener("MSPointerDown", self.touchStart, false);
if(self.options.preventDefault) container.addEventListener("MSPointerMove", self.touchMoveBubble, false);
document.addEventListener("MSPointerMove", self.touchMove, false);
document.addEventListener("MSPointerUp", self.touchEnd, false);
document.addEventListener("MSPointerCancel", self.touchEnd, false);
document.addEventListener("wheel", self.mouseWheel, false);
} else {
// Mouse Events
var mousedown = false;
self.mouseDown = function(e) {
if ( ionic.tap.ignoreScrollStart(e) || e.target.tagName === 'SELECT' ) {
return;
}
self.doTouchStart(getEventTouches(e), e.timeStamp);
if ( !ionic.tap.isTextInput(e.target) ) {
e.preventDefault();
}
mousedown = true;
};
self.mouseMove = function(e) {
if (self.options.freeze || !mousedown || (!mousedown && e.defaultPrevented)) {
return;
}
self.doTouchMove(getEventTouches(e), e.timeStamp);
mousedown = true;
};
self.mouseMoveBubble = function(e) {
if (mousedown && self.options.preventDefault) {
e.preventDefault();
}
};
self.mouseUp = function(e) {
if (!mousedown) {
return;
}
self.doTouchEnd(e, e.timeStamp);
mousedown = false;
};
container.addEventListener("mousedown", self.mouseDown, false);
if(self.options.preventDefault) container.addEventListener("mousemove", self.mouseMoveBubble, false);
document.addEventListener("mousemove", self.mouseMove, false);
document.addEventListener("mouseup", self.mouseUp, false);
document.addEventListener('mousewheel', self.mouseWheel, false);
document.addEventListener('wheel', self.mouseWheel, false);
}
},
__cleanup: function() {
var self = this;
var container = self.__container;
container.removeEventListener('touchstart', self.touchStart);
container.removeEventListener('touchmove', self.touchMoveBubble);
document.removeEventListener('touchmove', self.touchMove);
document.removeEventListener('touchend', self.touchEnd);
document.removeEventListener('touchcancel', self.touchEnd);
container.removeEventListener("pointerdown", self.touchStart);
container.removeEventListener("pointermove", self.touchMoveBubble);
document.removeEventListener("pointermove", self.touchMove);
document.removeEventListener("pointerup", self.touchEnd);
document.removeEventListener("pointercancel", self.touchEnd);
container.removeEventListener("MSPointerDown", self.touchStart);
container.removeEventListener("MSPointerMove", self.touchMoveBubble);
document.removeEventListener("MSPointerMove", self.touchMove);
document.removeEventListener("MSPointerUp", self.touchEnd);
document.removeEventListener("MSPointerCancel", self.touchEnd);
container.removeEventListener("mousedown", self.mouseDown);
container.removeEventListener("mousemove", self.mouseMoveBubble);
document.removeEventListener("mousemove", self.mouseMove);
document.removeEventListener("mouseup", self.mouseUp);
document.removeEventListener('mousewheel', self.mouseWheel);
document.removeEventListener('wheel', self.mouseWheel);
container.removeEventListener('scrollChildIntoView', self.scrollChildIntoView);
document.removeEventListener('resetScrollView', self.resetScrollView);
ionic.tap.removeClonedInputs(container, self);
delete self.__container;
delete self.__content;
delete self.__indicatorX;
delete self.__indicatorY;
delete self.options.el;
self.__callback = self.scrollChildIntoView = self.resetScrollView = NOOP;
self.mouseMove = self.mouseDown = self.mouseUp = self.mouseWheel =
self.touchStart = self.touchMove = self.touchEnd = self.touchCancel = NOOP;
self.resize = self.scrollTo = self.zoomTo =
self.__scrollingComplete = NOOP;
container = null;
},
/** Create a scroll bar div with the given direction **/
__createScrollbar: function(direction) {
var bar = document.createElement('div'),
indicator = document.createElement('div');
indicator.className = 'scroll-bar-indicator scroll-bar-fade-out';
if (direction == 'h') {
bar.className = 'scroll-bar scroll-bar-h';
} else {
bar.className = 'scroll-bar scroll-bar-v';
}
bar.appendChild(indicator);
return bar;
},
__createScrollbars: function() {
var self = this;
var indicatorX, indicatorY;
if (self.options.scrollingX) {
indicatorX = {
el: self.__createScrollbar('h'),
sizeRatio: 1
};
indicatorX.indicator = indicatorX.el.children[0];
if (self.options.scrollbarX) {
self.__container.appendChild(indicatorX.el);
}
self.__indicatorX = indicatorX;
}
if (self.options.scrollingY) {
indicatorY = {
el: self.__createScrollbar('v'),
sizeRatio: 1
};
indicatorY.indicator = indicatorY.el.children[0];
if (self.options.scrollbarY) {
self.__container.appendChild(indicatorY.el);
}
self.__indicatorY = indicatorY;
}
},
__resizeScrollbars: function() {
var self = this;
// Update horiz bar
if (self.__indicatorX) {
var width = Math.max(Math.round(self.__clientWidth * self.__clientWidth / (self.__contentWidth)), 20);
if (width > self.__contentWidth) {
width = 0;
}
if (width !== self.__indicatorX.size) {
ionic.requestAnimationFrame(function(){
self.__indicatorX.indicator.style.width = width + 'px';
});
}
self.__indicatorX.size = width;
self.__indicatorX.minScale = self.options.minScrollbarSizeX / width;
self.__indicatorX.maxPos = self.__clientWidth - width;
self.__indicatorX.sizeRatio = self.__maxScrollLeft ? self.__indicatorX.maxPos / self.__maxScrollLeft : 1;
}
// Update vert bar
if (self.__indicatorY) {
var height = Math.max(Math.round(self.__clientHeight * self.__clientHeight / (self.__contentHeight)), 20);
if (height > self.__contentHeight) {
height = 0;
}
if (height !== self.__indicatorY.size) {
ionic.requestAnimationFrame(function(){
self.__indicatorY && (self.__indicatorY.indicator.style.height = height + 'px');
});
}
self.__indicatorY.size = height;
self.__indicatorY.minScale = self.options.minScrollbarSizeY / height;
self.__indicatorY.maxPos = self.__clientHeight - height;
self.__indicatorY.sizeRatio = self.__maxScrollTop ? self.__indicatorY.maxPos / self.__maxScrollTop : 1;
}
},
/**
* Move and scale the scrollbars as the page scrolls.
*/
__repositionScrollbars: function() {
var self = this,
heightScale, widthScale,
widthDiff, heightDiff,
x, y,
xstop = 0, ystop = 0;
if (self.__indicatorX) {
// Handle the X scrollbar
// Don't go all the way to the right if we have a vertical scrollbar as well
if (self.__indicatorY) xstop = 10;
x = Math.round(self.__indicatorX.sizeRatio * self.__scrollLeft) || 0;
// The the difference between the last content X position, and our overscrolled one
widthDiff = self.__scrollLeft - (self.__maxScrollLeft - xstop);
if (self.__scrollLeft < 0) {
widthScale = Math.max(self.__indicatorX.minScale,
(self.__indicatorX.size - Math.abs(self.__scrollLeft)) / self.__indicatorX.size);
// Stay at left
x = 0;
// Make sure scale is transformed from the left/center origin point
self.__indicatorX.indicator.style[self.__transformOriginProperty] = 'left center';
} else if (widthDiff > 0) {
widthScale = Math.max(self.__indicatorX.minScale,
(self.__indicatorX.size - widthDiff) / self.__indicatorX.size);
// Stay at the furthest x for the scrollable viewport
x = self.__indicatorX.maxPos - xstop;
// Make sure scale is transformed from the right/center origin point
self.__indicatorX.indicator.style[self.__transformOriginProperty] = 'right center';
} else {
// Normal motion
x = Math.min(self.__maxScrollLeft, Math.max(0, x));
widthScale = 1;
}
var translate3dX = 'translate3d(' + x + 'px, 0, 0) scaleX(' + widthScale + ')';
if (self.__indicatorX.transformProp !== translate3dX) {
self.__indicatorX.indicator.style[self.__transformProperty] = translate3dX;
self.__indicatorX.transformProp = translate3dX;
}
}
if (self.__indicatorY) {
y = Math.round(self.__indicatorY.sizeRatio * self.__scrollTop) || 0;
// Don't go all the way to the right if we have a vertical scrollbar as well
if (self.__indicatorX) ystop = 10;
heightDiff = self.__scrollTop - (self.__maxScrollTop - ystop);
if (self.__scrollTop < 0) {
heightScale = Math.max(self.__indicatorY.minScale, (self.__indicatorY.size - Math.abs(self.__scrollTop)) / self.__indicatorY.size);
// Stay at top
y = 0;
// Make sure scale is transformed from the center/top origin point
if (self.__indicatorY.originProp !== 'center top') {
self.__indicatorY.indicator.style[self.__transformOriginProperty] = 'center top';
self.__indicatorY.originProp = 'center top';
}
} else if (heightDiff > 0) {
heightScale = Math.max(self.__indicatorY.minScale, (self.__indicatorY.size - heightDiff) / self.__indicatorY.size);
// Stay at bottom of scrollable viewport
y = self.__indicatorY.maxPos - ystop;
// Make sure scale is transformed from the center/bottom origin point
if (self.__indicatorY.originProp !== 'center bottom') {
self.__indicatorY.indicator.style[self.__transformOriginProperty] = 'center bottom';
self.__indicatorY.originProp = 'center bottom';
}
} else {
// Normal motion
y = Math.min(self.__maxScrollTop, Math.max(0, y));
heightScale = 1;
}
var translate3dY = 'translate3d(0,' + y + 'px, 0) scaleY(' + heightScale + ')';
if (self.__indicatorY.transformProp !== translate3dY) {
self.__indicatorY.indicator.style[self.__transformProperty] = translate3dY;
self.__indicatorY.transformProp = translate3dY;
}
}
},
__fadeScrollbars: function(direction, delay) {
var self = this;
if (!self.options.scrollbarsFade) {
return;
}
var className = 'scroll-bar-fade-out';
if (self.options.scrollbarsFade === true) {
clearTimeout(self.__scrollbarFadeTimeout);
if (direction == 'in') {
if (self.__indicatorX) { self.__indicatorX.indicator.classList.remove(className); }
if (self.__indicatorY) { self.__indicatorY.indicator.classList.remove(className); }
} else {
self.__scrollbarFadeTimeout = setTimeout(function() {
if (self.__indicatorX) { self.__indicatorX.indicator.classList.add(className); }
if (self.__indicatorY) { self.__indicatorY.indicator.classList.add(className); }
}, delay || self.options.scrollbarFadeDelay);
}
}
},
__scrollingComplete: function() {
this.options.scrollingComplete();
ionic.tap.removeClonedInputs(this.__container, this);
this.__fadeScrollbars('out');
},
resize: function(continueScrolling) {
var self = this;
if (!self.__container || !self.options) return;
// Update Scroller dimensions for changed content
// Add padding to bottom of content
self.setDimensions(
self.__container.clientWidth,
self.__container.clientHeight,
self.options.getContentWidth(),
self.options.getContentHeight(),
continueScrolling
);
},
/*
---------------------------------------------------------------------------
PUBLIC API
---------------------------------------------------------------------------
*/
getRenderFn: function() {
var self = this;
var content = self.__content;
var docStyle = document.documentElement.style;
var engine;
if ('MozAppearance' in docStyle) {
engine = 'gecko';
} else if ('WebkitAppearance' in docStyle) {
engine = 'webkit';
} else if (typeof navigator.cpuClass === 'string') {
engine = 'trident';
}
var vendorPrefix = {
trident: 'ms',
gecko: 'Moz',
webkit: 'Webkit',
presto: 'O'
}[engine];
var helperElem = document.createElement("div");
var undef;
var perspectiveProperty = vendorPrefix + "Perspective";
var transformProperty = vendorPrefix + "Transform";
var transformOriginProperty = vendorPrefix + 'TransformOrigin';
self.__perspectiveProperty = transformProperty;
self.__transformProperty = transformProperty;
self.__transformOriginProperty = transformOriginProperty;
if (helperElem.style[perspectiveProperty] !== undef) {
return function(left, top, zoom, wasResize) {
var translate3d = 'translate3d(' + (-left) + 'px,' + (-top) + 'px,0) scale(' + zoom + ')';
if (translate3d !== self.contentTransform) {
content.style[transformProperty] = translate3d;
self.contentTransform = translate3d;
}
self.__repositionScrollbars();
if (!wasResize) {
self.triggerScrollEvent();
}
};
} else if (helperElem.style[transformProperty] !== undef) {
return function(left, top, zoom, wasResize) {
content.style[transformProperty] = 'translate(' + (-left) + 'px,' + (-top) + 'px) scale(' + zoom + ')';
self.__repositionScrollbars();
if (!wasResize) {
self.triggerScrollEvent();
}
};
} else {
return function(left, top, zoom, wasResize) {
content.style.marginLeft = left ? (-left / zoom) + 'px' : '';
content.style.marginTop = top ? (-top / zoom) + 'px' : '';
content.style.zoom = zoom || '';
self.__repositionScrollbars();
if (!wasResize) {
self.triggerScrollEvent();
}
};
}
},
/**
* Configures the dimensions of the client (outer) and content (inner) elements.
* Requires the available space for the outer element and the outer size of the inner element.
* All values which are falsy (null or zero etc.) are ignored and the old value is kept.
*
* @param clientWidth {Integer} Inner width of outer element
* @param clientHeight {Integer} Inner height of outer element
* @param contentWidth {Integer} Outer width of inner element
* @param contentHeight {Integer} Outer height of inner element
*/
setDimensions: function(clientWidth, clientHeight, contentWidth, contentHeight, continueScrolling) {
var self = this;
if (!clientWidth && !clientHeight && !contentWidth && !contentHeight) {
// this scrollview isn't rendered, don't bother
return;
}
// Only update values which are defined
if (clientWidth === +clientWidth) {
self.__clientWidth = clientWidth;
}
if (clientHeight === +clientHeight) {
self.__clientHeight = clientHeight;
}
if (contentWidth === +contentWidth) {
self.__contentWidth = contentWidth;
}
if (contentHeight === +contentHeight) {
self.__contentHeight = contentHeight;
}
// Refresh maximums
self.__computeScrollMax();
self.__resizeScrollbars();
// Refresh scroll position
if (!continueScrolling) {
self.scrollTo(self.__scrollLeft, self.__scrollTop, true, null, true);
}
},
/**
* Sets the client coordinates in relation to the document.
*
* @param left {Integer} Left position of outer element
* @param top {Integer} Top position of outer element
*/
setPosition: function(left, top) {
this.__clientLeft = left || 0;
this.__clientTop = top || 0;
},
/**
* Configures the snapping (when snapping is active)
*
* @param width {Integer} Snapping width
* @param height {Integer} Snapping height
*/
setSnapSize: function(width, height) {
this.__snapWidth = width;
this.__snapHeight = height;
},
/**
* Activates pull-to-refresh. A special zone on the top of the list to start a list refresh whenever
* the user event is released during visibility of this zone. This was introduced by some apps on iOS like
* the official Twitter client.
*
* @param height {Integer} Height of pull-to-refresh zone on top of rendered list
* @param activateCallback {Function} Callback to execute on activation. This is for signalling the user about a refresh is about to happen when he release.
* @param deactivateCallback {Function} Callback to execute on deactivation. This is for signalling the user about the refresh being cancelled.
* @param startCallback {Function} Callback to execute to start the real async refresh action. Call {@link #finishPullToRefresh} after finish of refresh.
* @param showCallback {Function} Callback to execute when the refresher should be shown. This is for showing the refresher during a negative scrollTop.
* @param hideCallback {Function} Callback to execute when the refresher should be hidden. This is for hiding the refresher when it's behind the nav bar.
* @param tailCallback {Function} Callback to execute just before the refresher returns to it's original state. This is for zooming out the refresher.
* @param pullProgressCallback Callback to state the progress while pulling to refresh
*/
activatePullToRefresh: function(height, refresherMethods) {
var self = this;
self.__refreshHeight = height;
self.__refreshActivate = function() { ionic.requestAnimationFrame(refresherMethods.activate); };
self.__refreshDeactivate = function() { ionic.requestAnimationFrame(refresherMethods.deactivate); };
self.__refreshStart = function() { ionic.requestAnimationFrame(refresherMethods.start); };
self.__refreshShow = function() { ionic.requestAnimationFrame(refresherMethods.show); };
self.__refreshHide = function() { ionic.requestAnimationFrame(refresherMethods.hide); };
self.__refreshTail = function() { ionic.requestAnimationFrame(refresherMethods.tail); };
self.__refreshTailTime = 100;
self.__minSpinTime = 600;
},
/**
* Starts pull-to-refresh manually.
*/
triggerPullToRefresh: function() {
// Use publish instead of scrollTo to allow scrolling to out of boundary position
// We don't need to normalize scrollLeft, zoomLevel, etc. here because we only y-scrolling when pull-to-refresh is enabled
this.__publish(this.__scrollLeft, -this.__refreshHeight, this.__zoomLevel, true);
var d = new Date();
this.refreshStartTime = d.getTime();
if (this.__refreshStart) {
this.__refreshStart();
}
},
/**
* Signalizes that pull-to-refresh is finished.
*/
finishPullToRefresh: function() {
var self = this;
// delay to make sure the spinner has a chance to spin for a split second before it's dismissed
var d = new Date();
var delay = 0;
if (self.refreshStartTime + self.__minSpinTime > d.getTime()) {
delay = self.refreshStartTime + self.__minSpinTime - d.getTime();
}
setTimeout(function() {
if (self.__refreshTail) {
self.__refreshTail();
}
setTimeout(function() {
self.__refreshActive = false;
if (self.__refreshDeactivate) {
self.__refreshDeactivate();
}
if (self.__refreshHide) {
self.__refreshHide();
}
self.scrollTo(self.__scrollLeft, self.__scrollTop, true);
}, self.__refreshTailTime);
}, delay);
},
/**
* Returns the scroll position and zooming values
*
* @return {Map} `left` and `top` scroll position and `zoom` level
*/
getValues: function() {
return {
left: this.__scrollLeft,
top: this.__scrollTop,
zoom: this.__zoomLevel
};
},
/**
* Returns the maximum scroll values
*
* @return {Map} `left` and `top` maximum scroll values
*/
getScrollMax: function() {
return {
left: this.__maxScrollLeft,
top: this.__maxScrollTop
};
},
/**
* Zooms to the given level. Supports optional animation. Zooms
* the center when no coordinates are given.
*
* @param level {Number} Level to zoom to
* @param animate {Boolean} Whether to use animation
* @param originLeft {Number} Zoom in at given left coordinate
* @param originTop {Number} Zoom in at given top coordinate
*/
zoomTo: function(level, animate, originLeft, originTop) {
var self = this;
if (!self.options.zooming) {
throw new Error("Zooming is not enabled!");
}
// Stop deceleration
if (self.__isDecelerating) {
zyngaCore.effect.Animate.stop(self.__isDecelerating);
self.__isDecelerating = false;
}
var oldLevel = self.__zoomLevel;
// Normalize input origin to center of viewport if not defined
if (originLeft == null) {
originLeft = self.__clientWidth / 2;
}
if (originTop == null) {
originTop = self.__clientHeight / 2;
}
// Limit level according to configuration
level = Math.max(Math.min(level, self.options.maxZoom), self.options.minZoom);
// Recompute maximum values while temporary tweaking maximum scroll ranges
self.__computeScrollMax(level);
// Recompute left and top coordinates based on new zoom level
var left = ((originLeft + self.__scrollLeft) * level / oldLevel) - originLeft;
var top = ((originTop + self.__scrollTop) * level / oldLevel) - originTop;
// Limit x-axis
if (left > self.__maxScrollLeft) {
left = self.__maxScrollLeft;
} else if (left < 0) {
left = 0;
}
// Limit y-axis
if (top > self.__maxScrollTop) {
top = self.__maxScrollTop;
} else if (top < 0) {
top = 0;
}
// Push values out
self.__publish(left, top, level, animate);
},
/**
* Zooms the content by the given factor.
*
* @param factor {Number} Zoom by given factor
* @param animate {Boolean} Whether to use animation
* @param originLeft {Number} Zoom in at given left coordinate
* @param originTop {Number} Zoom in at given top coordinate
*/
zoomBy: function(factor, animate, originLeft, originTop) {
this.zoomTo(this.__zoomLevel * factor, animate, originLeft, originTop);
},
/**
* Scrolls to the given position. Respect limitations and snapping automatically.
*
* @param left {Number} Horizontal scroll position, keeps current if value is <code>null</code>
* @param top {Number} Vertical scroll position, keeps current if value is <code>null</code>
* @param animate {Boolean} Whether the scrolling should happen using an animation
* @param zoom {Number} Zoom level to go to
*/
scrollTo: function(left, top, animate, zoom, wasResize) {
var self = this;
// Stop deceleration
if (self.__isDecelerating) {
zyngaCore.effect.Animate.stop(self.__isDecelerating);
self.__isDecelerating = false;
}
// Correct coordinates based on new zoom level
if (zoom != null && zoom !== self.__zoomLevel) {
if (!self.options.zooming) {
throw new Error("Zooming is not enabled!");
}
left *= zoom;
top *= zoom;
// Recompute maximum values while temporary tweaking maximum scroll ranges
self.__computeScrollMax(zoom);
} else {
// Keep zoom when not defined
zoom = self.__zoomLevel;
}
if (!self.options.scrollingX) {
left = self.__scrollLeft;
} else {
if (self.options.paging) {
left = Math.round(left / self.__clientWidth) * self.__clientWidth;
} else if (self.options.snapping) {
left = Math.round(left / self.__snapWidth) * self.__snapWidth;
}
}
if (!self.options.scrollingY) {
top = self.__scrollTop;
} else {
if (self.options.paging) {
top = Math.round(top / self.__clientHeight) * self.__clientHeight;
} else if (self.options.snapping) {
top = Math.round(top / self.__snapHeight) * self.__snapHeight;
}
}
// Limit for allowed ranges
left = Math.max(Math.min(self.__maxScrollLeft, left), 0);
top = Math.max(Math.min(self.__maxScrollTop, top), 0);
// Don't animate when no change detected, still call publish to make sure
// that rendered position is really in-sync with internal data
if (left === self.__scrollLeft && top === self.__scrollTop) {
animate = false;
}
// Publish new values
self.__publish(left, top, zoom, animate, wasResize);
},
/**
* Scroll by the given offset
*
* @param left {Number} Scroll x-axis by given offset
* @param top {Number} Scroll y-axis by given offset
* @param animate {Boolean} Whether to animate the given change
*/
scrollBy: function(left, top, animate) {
var self = this;
var startLeft = self.__isAnimating ? self.__scheduledLeft : self.__scrollLeft;
var startTop = self.__isAnimating ? self.__scheduledTop : self.__scrollTop;
self.scrollTo(startLeft + (left || 0), startTop + (top || 0), animate);
},
/*
---------------------------------------------------------------------------
EVENT CALLBACKS
---------------------------------------------------------------------------
*/
/**
* Mouse wheel handler for zooming support
*/
doMouseZoom: function(wheelDelta, timeStamp, pageX, pageY) {
var change = wheelDelta > 0 ? 0.97 : 1.03;
return this.zoomTo(this.__zoomLevel * change, false, pageX - this.__clientLeft, pageY - this.__clientTop);
},
/**
* Touch start handler for scrolling support
*/
doTouchStart: function(touches, timeStamp) {
var self = this;
// remember if the deceleration was just stopped
self.__decStopped = !!(self.__isDecelerating || self.__isAnimating);
self.hintResize();
if (timeStamp instanceof Date) {
timeStamp = timeStamp.valueOf();
}
if (typeof timeStamp !== "number") {
timeStamp = Date.now();
}
// Reset interruptedAnimation flag
self.__interruptedAnimation = true;
// Stop deceleration
if (self.__isDecelerating) {
zyngaCore.effect.Animate.stop(self.__isDecelerating);
self.__isDecelerating = false;
self.__interruptedAnimation = true;
}
// Stop animation
if (self.__isAnimating) {
zyngaCore.effect.Animate.stop(self.__isAnimating);
self.__isAnimating = false;
self.__interruptedAnimation = true;
}
// Use center point when dealing with two fingers
var currentTouchLeft, currentTouchTop;
var isSingleTouch = touches.length === 1;
if (isSingleTouch) {
currentTouchLeft = touches[0].pageX;
currentTouchTop = touches[0].pageY;
} else {
currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;
currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;
}
// Store initial positions
self.__initialTouchLeft = currentTouchLeft;
self.__initialTouchTop = currentTouchTop;
// Store initial touchList for scale calculation
self.__initialTouches = touches;
// Store current zoom level
self.__zoomLevelStart = self.__zoomLevel;
// Store initial touch positions
self.__lastTouchLeft = currentTouchLeft;
self.__lastTouchTop = currentTouchTop;
// Store initial move time stamp
self.__lastTouchMove = timeStamp;
// Reset initial scale
self.__lastScale = 1;
// Reset locking flags
self.__enableScrollX = !isSingleTouch && self.options.scrollingX;
self.__enableScrollY = !isSingleTouch && self.options.scrollingY;
// Reset tracking flag
self.__isTracking = true;
// Reset deceleration complete flag
self.__didDecelerationComplete = false;
// Dragging starts directly with two fingers, otherwise lazy with an offset
self.__isDragging = !isSingleTouch;
// Some features are disabled in multi touch scenarios
self.__isSingleTouch = isSingleTouch;
// Clearing data structure
self.__positions = [];
},
/**
* Touch move handler for scrolling support
*/
doTouchMove: function(touches, timeStamp, scale) {
if (timeStamp instanceof Date) {
timeStamp = timeStamp.valueOf();
}
if (typeof timeStamp !== "number") {
timeStamp = Date.now();
}
var self = this;
// Ignore event when tracking is not enabled (event might be outside of element)
if (!self.__isTracking) {
return;
}
var currentTouchLeft, currentTouchTop;
// Compute move based around of center of fingers
if (touches.length === 2) {
currentTouchLeft = Math.abs(touches[0].pageX + touches[1].pageX) / 2;
currentTouchTop = Math.abs(touches[0].pageY + touches[1].pageY) / 2;
// Calculate scale when not present and only when touches are used
if (!scale && self.options.zooming) {
scale = self.__getScale(self.__initialTouches, touches);
}
} else {
currentTouchLeft = touches[0].pageX;
currentTouchTop = touches[0].pageY;
}
var positions = self.__positions;
// Are we already is dragging mode?
if (self.__isDragging) {
self.__decStopped = false;
// Compute move distance
var moveX = currentTouchLeft - self.__lastTouchLeft;
var moveY = currentTouchTop - self.__lastTouchTop;
// Read previous scroll position and zooming
var scrollLeft = self.__scrollLeft;
var scrollTop = self.__scrollTop;
var level = self.__zoomLevel;
// Work with scaling
if (scale != null && self.options.zooming) {
var oldLevel = level;
// Recompute level based on previous scale and new scale
level = level / self.__lastScale * scale;
// Limit level according to configuration
level = Math.max(Math.min(level, self.options.maxZoom), self.options.minZoom);
// Only do further compution when change happened
if (oldLevel !== level) {
// Compute relative event position to container
var currentTouchLeftRel = currentTouchLeft - self.__clientLeft;
var currentTouchTopRel = currentTouchTop - self.__clientTop;
// Recompute left and top coordinates based on new zoom level
scrollLeft = ((currentTouchLeftRel + scrollLeft) * level / oldLevel) - currentTouchLeftRel;
scrollTop = ((currentTouchTopRel + scrollTop) * level / oldLevel) - currentTouchTopRel;
// Recompute max scroll values
self.__computeScrollMax(level);
}
}
if (self.__enableScrollX) {
scrollLeft -= moveX * self.options.speedMultiplier;
var maxScrollLeft = self.__maxScrollLeft;
if (scrollLeft > maxScrollLeft || scrollLeft < 0) {
// Slow down on the edges
if (self.options.bouncing) {
scrollLeft += (moveX / 2 * self.options.speedMultiplier);
} else if (scrollLeft > maxScrollLeft) {
scrollLeft = maxScrollLeft;
} else {
scrollLeft = 0;
}
}
}
// Compute new vertical scroll position
if (self.__enableScrollY) {
scrollTop -= moveY * self.options.speedMultiplier;
var maxScrollTop = self.__maxScrollTop;
if (scrollTop > maxScrollTop || scrollTop < 0) {
// Slow down on the edges
if (self.options.bouncing || (self.__refreshHeight && scrollTop < 0)) {
scrollTop += (moveY / 2 * self.options.speedMultiplier);
// Support pull-to-refresh (only when only y is scrollable)
if (!self.__enableScrollX && self.__refreshHeight != null) {
// hide the refresher when it's behind the header bar in case of header transparency
if (scrollTop < 0) {
self.__refreshHidden = false;
self.__refreshShow();
} else {
self.__refreshHide();
self.__refreshHidden = true;
}
if (!self.__refreshActive && scrollTop <= -self.__refreshHeight) {
self.__refreshActive = true;
if (self.__refreshActivate) {
self.__refreshActivate();
}
} else if (self.__refreshActive && scrollTop > -self.__refreshHeight) {
self.__refreshActive = false;
if (self.__refreshDeactivate) {
self.__refreshDeactivate();
}
}
}
} else if (scrollTop > maxScrollTop) {
scrollTop = maxScrollTop;
} else {
scrollTop = 0;
}
} else if (self.__refreshHeight && !self.__refreshHidden) {
// if a positive scroll value and the refresher is still not hidden, hide it
self.__refreshHide();
self.__refreshHidden = true;
}
}
// Keep list from growing infinitely (holding min 10, max 20 measure points)
if (positions.length > 60) {
positions.splice(0, 30);
}
// Track scroll movement for decleration
positions.push(scrollLeft, scrollTop, timeStamp);
// Sync scroll position
self.__publish(scrollLeft, scrollTop, level);
// Otherwise figure out whether we are switching into dragging mode now.
} else {
var minimumTrackingForScroll = self.options.locking ? 3 : 0;
var minimumTrackingForDrag = 5;
var distanceX = Math.abs(currentTouchLeft - self.__initialTouchLeft);
var distanceY = Math.abs(currentTouchTop - self.__initialTouchTop);
self.__enableScrollX = self.options.scrollingX && distanceX >= minimumTrackingForScroll;
self.__enableScrollY = self.options.scrollingY && distanceY >= minimumTrackingForScroll;
positions.push(self.__scrollLeft, self.__scrollTop, timeStamp);
self.__isDragging = (self.__enableScrollX || self.__enableScrollY) && (distanceX >= minimumTrackingForDrag || distanceY >= minimumTrackingForDrag);
if (self.__isDragging) {
self.__interruptedAnimation = false;
self.__fadeScrollbars('in');
}
}
// Update last touch positions and time stamp for next event
self.__lastTouchLeft = currentTouchLeft;
self.__lastTouchTop = currentTouchTop;
self.__lastTouchMove = timeStamp;
self.__lastScale = scale;
},
/**
* Touch end handler for scrolling support
*/
doTouchEnd: function(e, timeStamp) {
if (timeStamp instanceof Date) {
timeStamp = timeStamp.valueOf();
}
if (typeof timeStamp !== "number") {
timeStamp = Date.now();
}
var self = this;
// Ignore event when tracking is not enabled (no touchstart event on element)
// This is required as this listener ('touchmove') sits on the document and not on the element itself.
if (!self.__isTracking) {
return;
}
// Not touching anymore (when two finger hit the screen there are two touch end events)
self.__isTracking = false;
// Be sure to reset the dragging flag now. Here we also detect whether
// the finger has moved fast enough to switch into a deceleration animation.
if (self.__isDragging) {
// Reset dragging flag
self.__isDragging = false;
// Start deceleration
// Verify that the last move detected was in some relevant time frame
if (self.__isSingleTouch && self.options.animating && (timeStamp - self.__lastTouchMove) <= 100) {
// Then figure out what the scroll position was about 100ms ago
var positions = self.__positions;
var endPos = positions.length - 1;
var startPos = endPos;
// Move pointer to position measured 100ms ago
for (var i = endPos; i > 0 && positions[i] > (self.__lastTouchMove - 100); i -= 3) {
startPos = i;
}
// If start and stop position is identical in a 100ms timeframe,
// we cannot compute any useful deceleration.
if (startPos !== endPos) {
// Compute relative movement between these two points
var timeOffset = positions[endPos] - positions[startPos];
var movedLeft = self.__scrollLeft - positions[startPos - 2];
var movedTop = self.__scrollTop - positions[startPos - 1];
// Based on 50ms compute the movement to apply for each render step
self.__decelerationVelocityX = movedLeft / timeOffset * (1000 / 60);
self.__decelerationVelocityY = movedTop / timeOffset * (1000 / 60);
// How much velocity is required to start the deceleration
var minVelocityToStartDeceleration = self.options.paging || self.options.snapping ? self.options.decelVelocityThresholdPaging : self.options.decelVelocityThreshold;
// Verify that we have enough velocity to start deceleration
if (Math.abs(self.__decelerationVelocityX) > minVelocityToStartDeceleration || Math.abs(self.__decelerationVelocityY) > minVelocityToStartDeceleration) {
// Deactivate pull-to-refresh when decelerating
if (!self.__refreshActive) {
self.__startDeceleration(timeStamp);
}
}
} else {
self.__scrollingComplete();
}
} else if ((timeStamp - self.__lastTouchMove) > 100) {
self.__scrollingComplete();
}
} else if (self.__decStopped) {
// the deceleration was stopped
// user flicked the scroll fast, and stop dragging, then did a touchstart to stop the srolling
// tell the touchend event code to do nothing, we don't want to actually send a click
e.isTapHandled = true;
self.__decStopped = false;
}
// If this was a slower move it is per default non decelerated, but this
// still means that we want snap back to the bounds which is done here.
// This is placed outside the condition above to improve edge case stability
// e.g. touchend fired without enabled dragging. This should normally do not
// have modified the scroll positions or even showed the scrollbars though.
if (!self.__isDecelerating) {
if (self.__refreshActive && self.__refreshStart) {
// Use publish instead of scrollTo to allow scrolling to out of boundary position
// We don't need to normalize scrollLeft, zoomLevel, etc. here because we only y-scrolling when pull-to-refresh is enabled
self.__publish(self.__scrollLeft, -self.__refreshHeight, self.__zoomLevel, true);
var d = new Date();
self.refreshStartTime = d.getTime();
if (self.__refreshStart) {
self.__refreshStart();
}
// for iOS-ey style scrolling
if (!ionic.Platform.isAndroid())self.__startDeceleration();
} else {
if (self.__interruptedAnimation || self.__isDragging) {
self.__scrollingComplete();
}
self.scrollTo(self.__scrollLeft, self.__scrollTop, true, self.__zoomLevel);
// Directly signalize deactivation (nothing todo on refresh?)
if (self.__refreshActive) {
self.__refreshActive = false;
if (self.__refreshDeactivate) {
self.__refreshDeactivate();
}
}
}
}
// Fully cleanup list
self.__positions.length = 0;
},
/*
---------------------------------------------------------------------------
PRIVATE API
---------------------------------------------------------------------------
*/
/**
* Applies the scroll position to the content element
*
* @param left {Number} Left scroll position
* @param top {Number} Top scroll position
* @param animate {Boolean} Whether animation should be used to move to the new coordinates
*/
__publish: function(left, top, zoom, animate, wasResize) {
var self = this;
// Remember whether we had an animation, then we try to continue based on the current "drive" of the animation
var wasAnimating = self.__isAnimating;
if (wasAnimating) {
zyngaCore.effect.Animate.stop(wasAnimating);
self.__isAnimating = false;
}
if (animate && self.options.animating) {
// Keep scheduled positions for scrollBy/zoomBy functionality
self.__scheduledLeft = left;
self.__scheduledTop = top;
self.__scheduledZoom = zoom;
var oldLeft = self.__scrollLeft;
var oldTop = self.__scrollTop;
var oldZoom = self.__zoomLevel;
var diffLeft = left - oldLeft;
var diffTop = top - oldTop;
var diffZoom = zoom - oldZoom;
var step = function(percent, now, render) {
if (render) {
self.__scrollLeft = oldLeft + (diffLeft * percent);
self.__scrollTop = oldTop + (diffTop * percent);
self.__zoomLevel = oldZoom + (diffZoom * percent);
// Push values out
if (self.__callback) {
self.__callback(self.__scrollLeft, self.__scrollTop, self.__zoomLevel, wasResize);
}
}
};
var verify = function(id) {
return self.__isAnimating === id;
};
var completed = function(renderedFramesPerSecond, animationId, wasFinished) {
if (animationId === self.__isAnimating) {
self.__isAnimating = false;
}
if (self.__didDecelerationComplete || wasFinished) {
self.__scrollingComplete();
}
if (self.options.zooming) {
self.__computeScrollMax();
}
};
// When continuing based on previous animation we choose an ease-out animation instead of ease-in-out
self.__isAnimating = zyngaCore.effect.Animate.start(step, verify, completed, self.options.animationDuration, wasAnimating ? easeOutCubic : easeInOutCubic);
} else {
self.__scheduledLeft = self.__scrollLeft = left;
self.__scheduledTop = self.__scrollTop = top;
self.__scheduledZoom = self.__zoomLevel = zoom;
// Push values out
if (self.__callback) {
self.__callback(left, top, zoom, wasResize);
}
// Fix max scroll ranges
if (self.options.zooming) {
self.__computeScrollMax();
}
}
},
/**
* Recomputes scroll minimum values based on client dimensions and content dimensions.
*/
__computeScrollMax: function(zoomLevel) {
var self = this;
if (zoomLevel == null) {
zoomLevel = self.__zoomLevel;
}
self.__maxScrollLeft = Math.max((self.__contentWidth * zoomLevel) - self.__clientWidth, 0);
self.__maxScrollTop = Math.max((self.__contentHeight * zoomLevel) - self.__clientHeight, 0);
if (!self.__didWaitForSize && !self.__maxScrollLeft && !self.__maxScrollTop) {
self.__didWaitForSize = true;
self.__waitForSize();
}
},
/**
* If the scroll view isn't sized correctly on start, wait until we have at least some size
*/
__waitForSize: function() {
var self = this;
clearTimeout(self.__sizerTimeout);
var sizer = function() {
self.resize(true);
};
sizer();
self.__sizerTimeout = setTimeout(sizer, 500);
},
/*
---------------------------------------------------------------------------
ANIMATION (DECELERATION) SUPPORT
---------------------------------------------------------------------------
*/
/**
* Called when a touch sequence end and the speed of the finger was high enough
* to switch into deceleration mode.
*/
__startDeceleration: function() {
var self = this;
if (self.options.paging) {
var scrollLeft = Math.max(Math.min(self.__scrollLeft, self.__maxScrollLeft), 0);
var scrollTop = Math.max(Math.min(self.__scrollTop, self.__maxScrollTop), 0);
var clientWidth = self.__clientWidth;
var clientHeight = self.__clientHeight;
// We limit deceleration not to the min/max values of the allowed range, but to the size of the visible client area.
// Each page should have exactly the size of the client area.
self.__minDecelerationScrollLeft = Math.floor(scrollLeft / clientWidth) * clientWidth;
self.__minDecelerationScrollTop = Math.floor(scrollTop / clientHeight) * clientHeight;
self.__maxDecelerationScrollLeft = Math.ceil(scrollLeft / clientWidth) * clientWidth;
self.__maxDecelerationScrollTop = Math.ceil(scrollTop / clientHeight) * clientHeight;
} else {
self.__minDecelerationScrollLeft = 0;
self.__minDecelerationScrollTop = 0;
self.__maxDecelerationScrollLeft = self.__maxScrollLeft;
self.__maxDecelerationScrollTop = self.__maxScrollTop;
if (self.__refreshActive) self.__minDecelerationScrollTop = self.__refreshHeight * -1;
}
// Wrap class method
var step = function(percent, now, render) {
self.__stepThroughDeceleration(render);
};
// How much velocity is required to keep the deceleration running
self.__minVelocityToKeepDecelerating = self.options.snapping ? 4 : 0.1;
// Detect whether it's still worth to continue animating steps
// If we are already slow enough to not being user perceivable anymore, we stop the whole process here.
var verify = function() {
var shouldContinue = Math.abs(self.__decelerationVelocityX) >= self.__minVelocityToKeepDecelerating ||
Math.abs(self.__decelerationVelocityY) >= self.__minVelocityToKeepDecelerating;
if (!shouldContinue) {
self.__didDecelerationComplete = true;
//Make sure the scroll values are within the boundaries after a bounce,
//not below 0 or above maximum
if (self.options.bouncing && !self.__refreshActive) {
self.scrollTo(
Math.min( Math.max(self.__scrollLeft, 0), self.__maxScrollLeft ),
Math.min( Math.max(self.__scrollTop, 0), self.__maxScrollTop ),
self.__refreshActive
);
}
}
return shouldContinue;
};
var completed = function() {
self.__isDecelerating = false;
if (self.__didDecelerationComplete) {
self.__scrollingComplete();
}
// Animate to grid when snapping is active, otherwise just fix out-of-boundary positions
if (self.options.paging) {
self.scrollTo(self.__scrollLeft, self.__scrollTop, self.options.snapping);
}
};
// Start animation and switch on flag
self.__isDecelerating = zyngaCore.effect.Animate.start(step, verify, completed);
},
/**
* Called on every step of the animation
*
* @param inMemory {Boolean} Whether to not render the current step, but keep it in memory only. Used internally only!
*/
__stepThroughDeceleration: function(render) {
var self = this;
//
// COMPUTE NEXT SCROLL POSITION
//
// Add deceleration to scroll position
var scrollLeft = self.__scrollLeft + self.__decelerationVelocityX;// * self.options.deceleration);
var scrollTop = self.__scrollTop + self.__decelerationVelocityY;// * self.options.deceleration);
//
// HARD LIMIT SCROLL POSITION FOR NON BOUNCING MODE
//
if (!self.options.bouncing) {
var scrollLeftFixed = Math.max(Math.min(self.__maxDecelerationScrollLeft, scrollLeft), self.__minDecelerationScrollLeft);
if (scrollLeftFixed !== scrollLeft) {
scrollLeft = scrollLeftFixed;
self.__decelerationVelocityX = 0;
}
var scrollTopFixed = Math.max(Math.min(self.__maxDecelerationScrollTop, scrollTop), self.__minDecelerationScrollTop);
if (scrollTopFixed !== scrollTop) {
scrollTop = scrollTopFixed;
self.__decelerationVelocityY = 0;
}
}
//
// UPDATE SCROLL POSITION
//
if (render) {
self.__publish(scrollLeft, scrollTop, self.__zoomLevel);
} else {
self.__scrollLeft = scrollLeft;
self.__scrollTop = scrollTop;
}
//
// SLOW DOWN
//
// Slow down velocity on every iteration
if (!self.options.paging) {
// This is the factor applied to every iteration of the animation
// to slow down the process. This should emulate natural behavior where
// objects slow down when the initiator of the movement is removed
var frictionFactor = self.options.deceleration;
self.__decelerationVelocityX *= frictionFactor;
self.__decelerationVelocityY *= frictionFactor;
}
//
// BOUNCING SUPPORT
//
if (self.options.bouncing) {
var scrollOutsideX = 0;
var scrollOutsideY = 0;
// This configures the amount of change applied to deceleration/acceleration when reaching boundaries
var penetrationDeceleration = self.options.penetrationDeceleration;
var penetrationAcceleration = self.options.penetrationAcceleration;
// Check limits
if (scrollLeft < self.__minDecelerationScrollLeft) {
scrollOutsideX = self.__minDecelerationScrollLeft - scrollLeft;
} else if (scrollLeft > self.__maxDecelerationScrollLeft) {
scrollOutsideX = self.__maxDecelerationScrollLeft - scrollLeft;
}
if (scrollTop < self.__minDecelerationScrollTop) {
scrollOutsideY = self.__minDecelerationScrollTop - scrollTop;
} else if (scrollTop > self.__maxDecelerationScrollTop) {
scrollOutsideY = self.__maxDecelerationScrollTop - scrollTop;
}
// Slow down until slow enough, then flip back to snap position
if (scrollOutsideX !== 0) {
var isHeadingOutwardsX = scrollOutsideX * self.__decelerationVelocityX <= self.__minDecelerationScrollLeft;
if (isHeadingOutwardsX) {
self.__decelerationVelocityX += scrollOutsideX * penetrationDeceleration;
}
var isStoppedX = Math.abs(self.__decelerationVelocityX) <= self.__minVelocityToKeepDecelerating;
//If we're not heading outwards, or if the above statement got us below minDeceleration, go back towards bounds
if (!isHeadingOutwardsX || isStoppedX) {
self.__decelerationVelocityX = scrollOutsideX * penetrationAcceleration;
}
}
if (scrollOutsideY !== 0) {
var isHeadingOutwardsY = scrollOutsideY * self.__decelerationVelocityY <= self.__minDecelerationScrollTop;
if (isHeadingOutwardsY) {
self.__decelerationVelocityY += scrollOutsideY * penetrationDeceleration;
}
var isStoppedY = Math.abs(self.__decelerationVelocityY) <= self.__minVelocityToKeepDecelerating;
//If we're not heading outwards, or if the above statement got us below minDeceleration, go back towards bounds
if (!isHeadingOutwardsY || isStoppedY) {
self.__decelerationVelocityY = scrollOutsideY * penetrationAcceleration;
}
}
}
},
/**
* calculate the distance between two touches
* @param {Touch} touch1
* @param {Touch} touch2
* @returns {Number} distance
*/
__getDistance: function getDistance(touch1, touch2) {
var x = touch2.pageX - touch1.pageX,
y = touch2.pageY - touch1.pageY;
return Math.sqrt((x * x) + (y * y));
},
/**
* calculate the scale factor between two touchLists (fingers)
* no scale is 1, and goes down to 0 when pinched together, and bigger when pinched out
* @param {Array} start
* @param {Array} end
* @returns {Number} scale
*/
__getScale: function getScale(start, end) {
// need two fingers...
if (start.length >= 2 && end.length >= 2) {
return this.__getDistance(end[0], end[1]) /
this.__getDistance(start[0], start[1]);
}
return 1;
}
});
ionic.scroll = {
isScrolling: false,
lastTop: 0
};
})(ionic);
(function(ionic) {
var NOOP = function() {};
var depreciated = function(name) {
console.error('Method not available in native scrolling: ' + name);
};
ionic.views.ScrollNative = ionic.views.View.inherit({
initialize: function(options) {
var self = this;
self.__container = self.el = options.el;
self.__content = options.el.firstElementChild;
self.isNative = true;
self.__scrollTop = self.el.scrollTop;
self.__scrollLeft = self.el.scrollLeft;
self.__clientHeight = self.__content.clientHeight;
self.__clientWidth = self.__content.clientWidth;
self.__maxScrollTop = Math.max((self.__contentHeight) - self.__clientHeight, 0);
self.__maxScrollLeft = Math.max((self.__contentWidth) - self.__clientWidth, 0);
self.options = {
freeze: false,
getContentWidth: function() {
return Math.max(self.__content.scrollWidth, self.__content.offsetWidth);
},
getContentHeight: function() {
return Math.max(self.__content.scrollHeight, self.__content.offsetHeight + (self.__content.offsetTop * 2));
}
};
for (var key in options) {
self.options[key] = options[key];
}
/**
* Sets isScrolling to true, and automatically deactivates if not called again in 80ms.
*/
self.onScroll = function() {
if (!ionic.scroll.isScrolling) {
ionic.scroll.isScrolling = true;
}
clearTimeout(self.scrollTimer);
self.scrollTimer = setTimeout(function() {
ionic.scroll.isScrolling = false;
}, 80);
};
self.freeze = NOOP;
self.__initEventHandlers();
},
/** Methods not used in native scrolling */
__callback: function() { depreciated('__callback'); },
zoomTo: function() { depreciated('zoomTo'); },
zoomBy: function() { depreciated('zoomBy'); },
activatePullToRefresh: function() { depreciated('activatePullToRefresh'); },
/**
* Returns the scroll position and zooming values
*
* @return {Map} `left` and `top` scroll position and `zoom` level
*/
resize: function(continueScrolling) {
var self = this;
if (!self.__container || !self.options) return;
// Update Scroller dimensions for changed content
// Add padding to bottom of content
self.setDimensions(
self.__container.clientWidth,
self.__container.clientHeight,
self.options.getContentWidth(),
self.options.getContentHeight(),
continueScrolling
);
},
/**
* Initialize the scrollview
* In native scrolling, this only means we need to gather size information
*/
run: function() {
this.resize();
},
/**
* Returns the scroll position and zooming values
*
* @return {Map} `left` and `top` scroll position and `zoom` level
*/
getValues: function() {
var self = this;
self.update();
return {
left: self.__scrollLeft,
top: self.__scrollTop,
zoom: 1
};
},
/**
* Updates the __scrollLeft and __scrollTop values to el's current value
*/
update: function() {
var self = this;
self.__scrollLeft = self.el.scrollLeft;
self.__scrollTop = self.el.scrollTop;
},
/**
* Configures the dimensions of the client (outer) and content (inner) elements.
* Requires the available space for the outer element and the outer size of the inner element.
* All values which are falsy (null or zero etc.) are ignored and the old value is kept.
*
* @param clientWidth {Integer} Inner width of outer element
* @param clientHeight {Integer} Inner height of outer element
* @param contentWidth {Integer} Outer width of inner element
* @param contentHeight {Integer} Outer height of inner element
*/
setDimensions: function(clientWidth, clientHeight, contentWidth, contentHeight) {
var self = this;
if (!clientWidth && !clientHeight && !contentWidth && !contentHeight) {
// this scrollview isn't rendered, don't bother
return;
}
// Only update values which are defined
if (clientWidth === +clientWidth) {
self.__clientWidth = clientWidth;
}
if (clientHeight === +clientHeight) {
self.__clientHeight = clientHeight;
}
if (contentWidth === +contentWidth) {
self.__contentWidth = contentWidth;
}
if (contentHeight === +contentHeight) {
self.__contentHeight = contentHeight;
}
// Refresh maximums
self.__computeScrollMax();
},
/**
* Returns the maximum scroll values
*
* @return {Map} `left` and `top` maximum scroll values
*/
getScrollMax: function() {
return {
left: this.__maxScrollLeft,
top: this.__maxScrollTop
};
},
/**
* Scrolls by the given amount in px.
*
* @param left {Number} Horizontal scroll position, keeps current if value is <code>null</code>
* @param top {Number} Vertical scroll position, keeps current if value is <code>null</code>
* @param animate {Boolean} Whether the scrolling should happen using an animation
*/
scrollBy: function(left, top, animate) {
var self = this;
// update scroll vars before refferencing them
self.update();
var startLeft = self.__isAnimating ? self.__scheduledLeft : self.__scrollLeft;
var startTop = self.__isAnimating ? self.__scheduledTop : self.__scrollTop;
self.scrollTo(startLeft + (left || 0), startTop + (top || 0), animate);
},
/**
* Scrolls to the given position in px.
*
* @param left {Number} Horizontal scroll position, keeps current if value is <code>null</code>
* @param top {Number} Vertical scroll position, keeps current if value is <code>null</code>
* @param animate {Boolean} Whether the scrolling should happen using an animation
*/
scrollTo: function(left, top, animate) {
var self = this;
if (!animate) {
self.el.scrollTop = top;
self.el.scrollLeft = left;
self.resize();
return;
}
animateScroll(top, left);
function animateScroll(Y, X) {
// scroll animation loop w/ easing
// credit https://gist.github.com/dezinezync/5487119
var start = Date.now(),
duration = 250, //milliseconds
fromY = self.el.scrollTop,
fromX = self.el.scrollLeft;
if (fromY === Y && fromX === X) {
self.resize();
return; /* Prevent scrolling to the Y point if already there */
}
// decelerating to zero velocity
function easeOutCubic(t) {
return (--t) * t * t + 1;
}
// scroll loop
function animateScrollStep() {
var currentTime = Date.now(),
time = Math.min(1, ((currentTime - start) / duration)),
// where .5 would be 50% of time on a linear scale easedT gives a
// fraction based on the easing method
easedT = easeOutCubic(time);
if (fromY != Y) {
self.el.scrollTop = parseInt((easedT * (Y - fromY)) + fromY, 10);
}
if (fromX != X) {
self.el.scrollLeft = parseInt((easedT * (X - fromX)) + fromX, 10);
}
if (time < 1) {
ionic.requestAnimationFrame(animateScrollStep);
} else {
// done
ionic.tap.removeClonedInputs(self.__container, self);
self.resize();
}
}
// start scroll loop
ionic.requestAnimationFrame(animateScrollStep);
}
},
/*
---------------------------------------------------------------------------
PRIVATE API
---------------------------------------------------------------------------
*/
/**
* If the scroll view isn't sized correctly on start, wait until we have at least some size
*/
__waitForSize: function() {
var self = this;
clearTimeout(self.__sizerTimeout);
var sizer = function() {
self.resize(true);
};
sizer();
self.__sizerTimeout = setTimeout(sizer, 500);
},
/**
* Recomputes scroll minimum values based on client dimensions and content dimensions.
*/
__computeScrollMax: function() {
var self = this;
self.__maxScrollLeft = Math.max((self.__contentWidth) - self.__clientWidth, 0);
self.__maxScrollTop = Math.max((self.__contentHeight) - self.__clientHeight, 0);
if (!self.__didWaitForSize && !self.__maxScrollLeft && !self.__maxScrollTop) {
self.__didWaitForSize = true;
self.__waitForSize();
}
},
__initEventHandlers: function() {
var self = this;
// Event Handler
var container = self.__container;
// save height when scroll view is shrunk so we don't need to reflow
var scrollViewOffsetHeight;
/**
* Shrink the scroll view when the keyboard is up if necessary and if the
* focused input is below the bottom of the shrunk scroll view, scroll it
* into view.
*/
self.scrollChildIntoView = function(e) {
//console.log("scrollChildIntoView at: " + Date.now());
// D
var scrollBottomOffsetToTop = container.getBoundingClientRect().bottom;
// D - A
scrollViewOffsetHeight = container.offsetHeight;
var alreadyShrunk = self.isShrunkForKeyboard;
var isModal = container.parentNode.classList.contains('modal');
// 680px is when the media query for 60% modal width kicks in
var isInsetModal = isModal && window.innerWidth >= 680;
/*
* _______
* |---A---| <- top of scroll view
* | |
* |---B---| <- keyboard
* | C | <- input
* |---D---| <- initial bottom of scroll view
* |___E___| <- bottom of viewport
*
* All commented calculations relative to the top of the viewport (ie E
* is the viewport height, not 0)
*/
if (!alreadyShrunk) {
// shrink scrollview so we can actually scroll if the input is hidden
// if it isn't shrink so we can scroll to inputs under the keyboard
// inset modals won't shrink on Android on their own when the keyboard appears
if ( ionic.Platform.isIOS() || ionic.Platform.isFullScreen || isInsetModal ) {
// if there are things below the scroll view account for them and
// subtract them from the keyboard height when resizing
// E - D E D
var scrollBottomOffsetToBottom = e.detail.viewportHeight - scrollBottomOffsetToTop;
// 0 or D - B if D > B E - B E - D
var keyboardOffset = Math.max(0, e.detail.keyboardHeight - scrollBottomOffsetToBottom);
ionic.requestAnimationFrame(function(){
// D - A or B - A if D > B D - A max(0, D - B)
scrollViewOffsetHeight = scrollViewOffsetHeight - keyboardOffset;
container.style.height = scrollViewOffsetHeight + "px";
//update scroll view
self.resize();
});
}
self.isShrunkForKeyboard = true;
}
/*
* _______
* |---A---| <- top of scroll view
* | * | <- where we want to scroll to
* |--B-D--| <- keyboard, bottom of scroll view
* | C | <- input
* | |
* |___E___| <- bottom of viewport
*
* All commented calculations relative to the top of the viewport (ie E
* is the viewport height, not 0)
*/
// if the element is positioned under the keyboard scroll it into view
if (e.detail.isElementUnderKeyboard) {
ionic.requestAnimationFrame(function(){
// update D if we shrunk
if (self.isShrunkForKeyboard && !alreadyShrunk) {
scrollBottomOffsetToTop = container.getBoundingClientRect().bottom;
}
// middle of the scrollview, this is where we want to scroll to
// (D - A) / 2
var scrollMidpointOffset = scrollViewOffsetHeight * 0.5;
//console.log("container.offsetHeight: " + scrollViewOffsetHeight);
// middle of the input we want to scroll into view
// C
var inputMidpoint = ((e.detail.elementBottom + e.detail.elementTop) / 2);
// distance from middle of input to the bottom of the scroll view
// C - D C D
var inputMidpointOffsetToScrollBottom = inputMidpoint - scrollBottomOffsetToTop;
//C - D + (D - A)/2 C - D (D - A)/ 2
var scrollTop = inputMidpointOffsetToScrollBottom + scrollMidpointOffset;
if ( scrollTop > 0) {
if (ionic.Platform.isIOS()) {
//just shrank scroll view, give it some breathing room before scrolling
setTimeout(function(){
ionic.tap.cloneFocusedInput(container, self);
self.scrollBy(0, scrollTop, true);
self.onScroll();
}, 32);
} else {
self.scrollBy(0, scrollTop, true);
self.onScroll();
}
}
});
}
// Only the first scrollView parent of the element that broadcasted this event
// (the active element that needs to be shown) should receive this event
e.stopPropagation();
};
self.resetScrollView = function() {
//return scrollview to original height once keyboard has hidden
if (self.isShrunkForKeyboard) {
self.isShrunkForKeyboard = false;
container.style.height = "";
}
self.resize();
};
container.addEventListener('scroll', self.onScroll);
//Broadcasted when keyboard is shown on some platforms.
//See js/utils/keyboard.js
container.addEventListener('scrollChildIntoView', self.scrollChildIntoView);
// Listen on document because container may not have had the last
// keyboardActiveElement, for example after closing a modal with a focused
// input and returning to a previously resized scroll view in an ion-content.
// Since we can only resize scroll views that are currently visible, just resize
// the current scroll view when the keyboard is closed.
document.addEventListener('resetScrollView', self.resetScrollView);
},
__cleanup: function() {
var self = this;
var container = self.__container;
container.removeEventListener('resetScrollView', self.resetScrollView);
container.removeEventListener('scroll', self.onScroll);
container.removeEventListener('scrollChildIntoView', self.scrollChildIntoView);
container.removeEventListener('resetScrollView', self.resetScrollView);
ionic.tap.removeClonedInputs(container, self);
delete self.__container;
delete self.__content;
delete self.__indicatorX;
delete self.__indicatorY;
delete self.options.el;
self.resize = self.scrollTo = self.onScroll = self.resetScrollView = NOOP;
self.scrollChildIntoView = NOOP;
container = null;
}
});
})(ionic);
(function(ionic) {
'use strict';
var ITEM_CLASS = 'item';
var ITEM_CONTENT_CLASS = 'item-content';
var ITEM_SLIDING_CLASS = 'item-sliding';
var ITEM_OPTIONS_CLASS = 'item-options';
var ITEM_PLACEHOLDER_CLASS = 'item-placeholder';
var ITEM_REORDERING_CLASS = 'item-reordering';
var ITEM_REORDER_BTN_CLASS = 'item-reorder';
var DragOp = function() {};
DragOp.prototype = {
start: function(){},
drag: function(){},
end: function(){},
isSameItem: function() {
return false;
}
};
var SlideDrag = function(opts) {
this.dragThresholdX = opts.dragThresholdX || 10;
this.el = opts.el;
this.item = opts.item;
this.canSwipe = opts.canSwipe;
};
SlideDrag.prototype = new DragOp();
SlideDrag.prototype.start = function(e) {
var content, buttons, offsetX, buttonsWidth;
if (!this.canSwipe()) {
return;
}
if (e.target.classList.contains(ITEM_CONTENT_CLASS)) {
content = e.target;
} else if (e.target.classList.contains(ITEM_CLASS)) {
content = e.target.querySelector('.' + ITEM_CONTENT_CLASS);
} else {
content = ionic.DomUtil.getParentWithClass(e.target, ITEM_CONTENT_CLASS);
}
// If we don't have a content area as one of our children (or ourselves), skip
if (!content) {
return;
}
// Make sure we aren't animating as we slide
content.classList.remove(ITEM_SLIDING_CLASS);
// Grab the starting X point for the item (for example, so we can tell whether it is open or closed to start)
offsetX = parseFloat(content.style[ionic.CSS.TRANSFORM].replace('translate3d(', '').split(',')[0]) || 0;
// Grab the buttons
buttons = content.parentNode.querySelector('.' + ITEM_OPTIONS_CLASS);
if (!buttons) {
return;
}
buttons.classList.remove('invisible');
buttonsWidth = buttons.offsetWidth;
this._currentDrag = {
buttons: buttons,
buttonsWidth: buttonsWidth,
content: content,
startOffsetX: offsetX
};
};
/**
* Check if this is the same item that was previously dragged.
*/
SlideDrag.prototype.isSameItem = function(op) {
if (op._lastDrag && this._currentDrag) {
return this._currentDrag.content == op._lastDrag.content;
}
return false;
};
SlideDrag.prototype.clean = function(isInstant) {
var lastDrag = this._lastDrag;
if (!lastDrag || !lastDrag.content) return;
lastDrag.content.style[ionic.CSS.TRANSITION] = '';
lastDrag.content.style[ionic.CSS.TRANSFORM] = '';
if (isInstant) {
lastDrag.content.style[ionic.CSS.TRANSITION] = 'none';
makeInvisible();
ionic.requestAnimationFrame(function() {
lastDrag.content.style[ionic.CSS.TRANSITION] = '';
});
} else {
ionic.requestAnimationFrame(function() {
setTimeout(makeInvisible, 250);
});
}
function makeInvisible() {
lastDrag.buttons && lastDrag.buttons.classList.add('invisible');
}
};
SlideDrag.prototype.drag = ionic.animationFrameThrottle(function(e) {
var buttonsWidth;
// We really aren't dragging
if (!this._currentDrag) {
return;
}
// Check if we should start dragging. Check if we've dragged past the threshold,
// or we are starting from the open state.
if (!this._isDragging &&
((Math.abs(e.gesture.deltaX) > this.dragThresholdX) ||
(Math.abs(this._currentDrag.startOffsetX) > 0))) {
this._isDragging = true;
}
if (this._isDragging) {
buttonsWidth = this._currentDrag.buttonsWidth;
// Grab the new X point, capping it at zero
var newX = Math.min(0, this._currentDrag.startOffsetX + e.gesture.deltaX);
// If the new X position is past the buttons, we need to slow down the drag (rubber band style)
if (newX < -buttonsWidth) {
// Calculate the new X position, capped at the top of the buttons
newX = Math.min(-buttonsWidth, -buttonsWidth + (((e.gesture.deltaX + buttonsWidth) * 0.4)));
}
this._currentDrag.content.$$ionicOptionsOpen = newX !== 0;
this._currentDrag.content.style[ionic.CSS.TRANSFORM] = 'translate3d(' + newX + 'px, 0, 0)';
this._currentDrag.content.style[ionic.CSS.TRANSITION] = 'none';
}
});
SlideDrag.prototype.end = function(e, doneCallback) {
var self = this;
// There is no drag, just end immediately
if (!self._currentDrag) {
doneCallback && doneCallback();
return;
}
// If we are currently dragging, we want to snap back into place
// The final resting point X will be the width of the exposed buttons
var restingPoint = -self._currentDrag.buttonsWidth;
// Check if the drag didn't clear the buttons mid-point
// and we aren't moving fast enough to swipe open
if (e.gesture.deltaX > -(self._currentDrag.buttonsWidth / 2)) {
// If we are going left but too slow, or going right, go back to resting
if (e.gesture.direction == "left" && Math.abs(e.gesture.velocityX) < 0.3) {
restingPoint = 0;
} else if (e.gesture.direction == "right") {
restingPoint = 0;
}
}
ionic.requestAnimationFrame(function() {
if (restingPoint === 0) {
self._currentDrag.content.style[ionic.CSS.TRANSFORM] = '';
var buttons = self._currentDrag.buttons;
setTimeout(function() {
buttons && buttons.classList.add('invisible');
}, 250);
} else {
self._currentDrag.content.style[ionic.CSS.TRANSFORM] = 'translate3d(' + restingPoint + 'px,0,0)';
}
self._currentDrag.content.style[ionic.CSS.TRANSITION] = '';
// Kill the current drag
if (!self._lastDrag) {
self._lastDrag = {};
}
ionic.extend(self._lastDrag, self._currentDrag);
if (self._currentDrag) {
self._currentDrag.buttons = null;
self._currentDrag.content = null;
}
self._currentDrag = null;
// We are done, notify caller
doneCallback && doneCallback();
});
};
var ReorderDrag = function(opts) {
var self = this;
self.dragThresholdY = opts.dragThresholdY || 0;
self.onReorder = opts.onReorder;
self.listEl = opts.listEl;
self.el = self.item = opts.el;
self.scrollEl = opts.scrollEl;
self.scrollView = opts.scrollView;
// Get the True Top of the list el http://www.quirksmode.org/js/findpos.html
self.listElTrueTop = 0;
if (self.listEl.offsetParent) {
var obj = self.listEl;
do {
self.listElTrueTop += obj.offsetTop;
obj = obj.offsetParent;
} while (obj);
}
};
ReorderDrag.prototype = new DragOp();
ReorderDrag.prototype._moveElement = function(e) {
var y = e.gesture.center.pageY +
this.scrollView.getValues().top -
(this._currentDrag.elementHeight / 2) -
this.listElTrueTop;
this.el.style[ionic.CSS.TRANSFORM] = 'translate3d(0, ' + y + 'px, 0)';
};
ReorderDrag.prototype.deregister = function() {
this.listEl = this.el = this.scrollEl = this.scrollView = null;
};
ReorderDrag.prototype.start = function(e) {
var startIndex = ionic.DomUtil.getChildIndex(this.el, this.el.nodeName.toLowerCase());
var elementHeight = this.el.scrollHeight;
var placeholder = this.el.cloneNode(true);
placeholder.classList.add(ITEM_PLACEHOLDER_CLASS);
this.el.parentNode.insertBefore(placeholder, this.el);
this.el.classList.add(ITEM_REORDERING_CLASS);
this._currentDrag = {
elementHeight: elementHeight,
startIndex: startIndex,
placeholder: placeholder,
scrollHeight: scroll,
list: placeholder.parentNode
};
this._moveElement(e);
};
ReorderDrag.prototype.drag = ionic.animationFrameThrottle(function(e) {
// We really aren't dragging
var self = this;
if (!this._currentDrag) {
return;
}
var scrollY = 0;
var pageY = e.gesture.center.pageY;
var offset = this.listElTrueTop;
//If we have a scrollView, check scroll boundaries for dragged element and scroll if necessary
if (this.scrollView) {
var container = this.scrollView.__container;
scrollY = this.scrollView.getValues().top;
var containerTop = container.offsetTop;
var pixelsPastTop = containerTop - pageY + this._currentDrag.elementHeight / 2;
var pixelsPastBottom = pageY + this._currentDrag.elementHeight / 2 - containerTop - container.offsetHeight;
if (e.gesture.deltaY < 0 && pixelsPastTop > 0 && scrollY > 0) {
this.scrollView.scrollBy(null, -pixelsPastTop);
//Trigger another drag so the scrolling keeps going
ionic.requestAnimationFrame(function() {
self.drag(e);
});
}
if (e.gesture.deltaY > 0 && pixelsPastBottom > 0) {
if (scrollY < this.scrollView.getScrollMax().top) {
this.scrollView.scrollBy(null, pixelsPastBottom);
//Trigger another drag so the scrolling keeps going
ionic.requestAnimationFrame(function() {
self.drag(e);
});
}
}
}
// Check if we should start dragging. Check if we've dragged past the threshold,
// or we are starting from the open state.
if (!this._isDragging && Math.abs(e.gesture.deltaY) > this.dragThresholdY) {
this._isDragging = true;
}
if (this._isDragging) {
this._moveElement(e);
this._currentDrag.currentY = scrollY + pageY - offset;
// this._reorderItems();
}
});
// When an item is dragged, we need to reorder any items for sorting purposes
ReorderDrag.prototype._getReorderIndex = function() {
var self = this;
var siblings = Array.prototype.slice.call(self._currentDrag.placeholder.parentNode.children)
.filter(function(el) {
return el.nodeName === self.el.nodeName && el !== self.el;
});
var dragOffsetTop = self._currentDrag.currentY;
var el;
for (var i = 0, len = siblings.length; i < len; i++) {
el = siblings[i];
if (i === len - 1) {
if (dragOffsetTop > el.offsetTop) {
return i;
}
} else if (i === 0) {
if (dragOffsetTop < el.offsetTop + el.offsetHeight) {
return i;
}
} else if (dragOffsetTop > el.offsetTop - el.offsetHeight / 2 &&
dragOffsetTop < el.offsetTop + el.offsetHeight) {
return i;
}
}
return self._currentDrag.startIndex;
};
ReorderDrag.prototype.end = function(e, doneCallback) {
if (!this._currentDrag) {
doneCallback && doneCallback();
return;
}
var placeholder = this._currentDrag.placeholder;
var finalIndex = this._getReorderIndex();
// Reposition the element
this.el.classList.remove(ITEM_REORDERING_CLASS);
this.el.style[ionic.CSS.TRANSFORM] = '';
placeholder.parentNode.insertBefore(this.el, placeholder);
placeholder.parentNode.removeChild(placeholder);
this.onReorder && this.onReorder(this.el, this._currentDrag.startIndex, finalIndex);
this._currentDrag = {
placeholder: null,
content: null
};
this._currentDrag = null;
doneCallback && doneCallback();
};
/**
* The ListView handles a list of items. It will process drag animations, edit mode,
* and other operations that are common on mobile lists or table views.
*/
ionic.views.ListView = ionic.views.View.inherit({
initialize: function(opts) {
var self = this;
opts = ionic.extend({
onReorder: function() {},
virtualRemoveThreshold: -200,
virtualAddThreshold: 200,
canSwipe: function() {
return true;
}
}, opts);
ionic.extend(self, opts);
if (!self.itemHeight && self.listEl) {
self.itemHeight = self.listEl.children[0] && parseInt(self.listEl.children[0].style.height, 10);
}
self.onRefresh = opts.onRefresh || function() {};
self.onRefreshOpening = opts.onRefreshOpening || function() {};
self.onRefreshHolding = opts.onRefreshHolding || function() {};
var gestureOpts = {};
// don't prevent native scrolling
if (ionic.DomUtil.getParentOrSelfWithClass(self.el, 'overflow-scroll')) {
gestureOpts.prevent_default_directions = ['left', 'right'];
}
window.ionic.onGesture('release', function(e) {
self._handleEndDrag(e);
}, self.el, gestureOpts);
window.ionic.onGesture('drag', function(e) {
self._handleDrag(e);
}, self.el, gestureOpts);
// Start the drag states
self._initDrag();
},
/**
* Be sure to cleanup references.
*/
deregister: function() {
this.el = this.listEl = this.scrollEl = this.scrollView = null;
// ensure no scrolls have been left frozen
if (this.isScrollFreeze) {
self.scrollView.freeze(false);
}
},
/**
* Called to tell the list to stop refreshing. This is useful
* if you are refreshing the list and are done with refreshing.
*/
stopRefreshing: function() {
var refresher = this.el.querySelector('.list-refresher');
refresher.style.height = '0';
},
/**
* If we scrolled and have virtual mode enabled, compute the window
* of active elements in order to figure out the viewport to render.
*/
didScroll: function(e) {
var self = this;
if (self.isVirtual) {
var itemHeight = self.itemHeight;
// Grab the total height of the list
var scrollHeight = e.target.scrollHeight;
// Get the viewport height
var viewportHeight = self.el.parentNode.offsetHeight;
// High water is the pixel position of the first element to include (everything before
// that will be removed)
var highWater = Math.max(0, e.scrollTop + self.virtualRemoveThreshold);
// Low water is the pixel position of the last element to include (everything after
// that will be removed)
var lowWater = Math.min(scrollHeight, Math.abs(e.scrollTop) + viewportHeight + self.virtualAddThreshold);
// Get the first and last elements in the list based on how many can fit
// between the pixel range of lowWater and highWater
var first = parseInt(Math.abs(highWater / itemHeight), 10);
var last = parseInt(Math.abs(lowWater / itemHeight), 10);
// Get the items we need to remove
self._virtualItemsToRemove = Array.prototype.slice.call(self.listEl.children, 0, first);
self.renderViewport && self.renderViewport(highWater, lowWater, first, last);
}
},
didStopScrolling: function() {
if (this.isVirtual) {
for (var i = 0; i < this._virtualItemsToRemove.length; i++) {
//el.parentNode.removeChild(el);
this.didHideItem && this.didHideItem(i);
}
// Once scrolling stops, check if we need to remove old items
}
},
/**
* Clear any active drag effects on the list.
*/
clearDragEffects: function(isInstant) {
if (this._lastDragOp) {
this._lastDragOp.clean && this._lastDragOp.clean(isInstant);
this._lastDragOp.deregister && this._lastDragOp.deregister();
this._lastDragOp = null;
}
},
_initDrag: function() {
// Store the last one
if (this._lastDragOp) {
this._lastDragOp.deregister && this._lastDragOp.deregister();
}
this._lastDragOp = this._dragOp;
this._dragOp = null;
},
// Return the list item from the given target
_getItem: function(target) {
while (target) {
if (target.classList && target.classList.contains(ITEM_CLASS)) {
return target;
}
target = target.parentNode;
}
return null;
},
_startDrag: function(e) {
var self = this;
self._isDragging = false;
var lastDragOp = self._lastDragOp;
var item;
// If we have an open SlideDrag and we're scrolling the list. Clear it.
if (self._didDragUpOrDown && lastDragOp instanceof SlideDrag) {
lastDragOp.clean && lastDragOp.clean();
}
// Check if this is a reorder drag
if (ionic.DomUtil.getParentOrSelfWithClass(e.target, ITEM_REORDER_BTN_CLASS) && (e.gesture.direction == 'up' || e.gesture.direction == 'down')) {
item = self._getItem(e.target);
if (item) {
self._dragOp = new ReorderDrag({
listEl: self.el,
el: item,
scrollEl: self.scrollEl,
scrollView: self.scrollView,
onReorder: function(el, start, end) {
self.onReorder && self.onReorder(el, start, end);
}
});
self._dragOp.start(e);
e.preventDefault();
}
}
// Or check if this is a swipe to the side drag
else if (!self._didDragUpOrDown && (e.gesture.direction == 'left' || e.gesture.direction == 'right') && Math.abs(e.gesture.deltaX) > 5) {
// Make sure this is an item with buttons
item = self._getItem(e.target);
if (item && item.querySelector('.item-options')) {
self._dragOp = new SlideDrag({
el: self.el,
item: item,
canSwipe: self.canSwipe
});
self._dragOp.start(e);
e.preventDefault();
self.isScrollFreeze = self.scrollView.freeze(true);
}
}
// If we had a last drag operation and this is a new one on a different item, clean that last one
if (lastDragOp && self._dragOp && !self._dragOp.isSameItem(lastDragOp) && e.defaultPrevented) {
lastDragOp.clean && lastDragOp.clean();
}
},
_handleEndDrag: function(e) {
var self = this;
if (self.scrollView) {
self.isScrollFreeze = self.scrollView.freeze(false);
}
self._didDragUpOrDown = false;
if (!self._dragOp) {
return;
}
self._dragOp.end(e, function() {
self._initDrag();
});
},
/**
* Process the drag event to move the item to the left or right.
*/
_handleDrag: function(e) {
var self = this;
if (Math.abs(e.gesture.deltaY) > 5) {
self._didDragUpOrDown = true;
}
// If we get a drag event, make sure we aren't in another drag, then check if we should
// start one
if (!self.isDragging && !self._dragOp) {
self._startDrag(e);
}
// No drag still, pass it up
if (!self._dragOp) {
return;
}
e.gesture.srcEvent.preventDefault();
self._dragOp.drag(e);
}
});
})(ionic);
(function(ionic) {
'use strict';
ionic.views.Modal = ionic.views.View.inherit({
initialize: function(opts) {
opts = ionic.extend({
focusFirstInput: false,
unfocusOnHide: true,
focusFirstDelay: 600,
backdropClickToClose: true,
hardwareBackButtonClose: true,
}, opts);
ionic.extend(this, opts);
this.el = opts.el;
},
show: function() {
var self = this;
if(self.focusFirstInput) {
// Let any animations run first
window.setTimeout(function() {
var input = self.el.querySelector('input, textarea');
input && input.focus && input.focus();
}, self.focusFirstDelay);
}
},
hide: function() {
// Unfocus all elements
if(this.unfocusOnHide) {
var inputs = this.el.querySelectorAll('input, textarea');
// Let any animations run first
window.setTimeout(function() {
for(var i = 0; i < inputs.length; i++) {
inputs[i].blur && inputs[i].blur();
}
});
}
}
});
})(ionic);
(function(ionic) {
'use strict';
/**
* The side menu view handles one of the side menu's in a Side Menu Controller
* configuration.
* It takes a DOM reference to that side menu element.
*/
ionic.views.SideMenu = ionic.views.View.inherit({
initialize: function(opts) {
this.el = opts.el;
this.isEnabled = (typeof opts.isEnabled === 'undefined') ? true : opts.isEnabled;
this.setWidth(opts.width);
},
getFullWidth: function() {
return this.width;
},
setWidth: function(width) {
this.width = width;
this.el.style.width = width + 'px';
},
setIsEnabled: function(isEnabled) {
this.isEnabled = isEnabled;
},
bringUp: function() {
if(this.el.style.zIndex !== '0') {
this.el.style.zIndex = '0';
}
},
pushDown: function() {
if(this.el.style.zIndex !== '-1') {
this.el.style.zIndex = '-1';
}
}
});
ionic.views.SideMenuContent = ionic.views.View.inherit({
initialize: function(opts) {
ionic.extend(this, {
animationClass: 'menu-animated',
onDrag: function() {},
onEndDrag: function() {}
}, opts);
ionic.onGesture('drag', ionic.proxy(this._onDrag, this), this.el);
ionic.onGesture('release', ionic.proxy(this._onEndDrag, this), this.el);
},
_onDrag: function(e) {
this.onDrag && this.onDrag(e);
},
_onEndDrag: function(e) {
this.onEndDrag && this.onEndDrag(e);
},
disableAnimation: function() {
this.el.classList.remove(this.animationClass);
},
enableAnimation: function() {
this.el.classList.add(this.animationClass);
},
getTranslateX: function() {
return parseFloat(this.el.style[ionic.CSS.TRANSFORM].replace('translate3d(', '').split(',')[0]);
},
setTranslateX: ionic.animationFrameThrottle(function(x) {
this.el.style[ionic.CSS.TRANSFORM] = 'translate3d(' + x + 'px, 0, 0)';
})
});
})(ionic);
/*
* Adapted from Swipe.js 2.0
*
* Brad Birdsall
* Copyright 2013, MIT License
*
*/
(function(ionic) {
'use strict';
ionic.views.Slider = ionic.views.View.inherit({
initialize: function (options) {
var slider = this;
// utilities
var noop = function() {}; // simple no operation function
var offloadFn = function(fn) { setTimeout(fn || noop, 0); }; // offload a functions execution
// check browser capabilities
var browser = {
addEventListener: !!window.addEventListener,
touch: ('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch,
transitions: (function(temp) {
var props = ['transitionProperty', 'WebkitTransition', 'MozTransition', 'OTransition', 'msTransition'];
for ( var i in props ) if (temp.style[ props[i] ] !== undefined) return true;
return false;
})(document.createElement('swipe'))
};
var container = options.el;
// quit if no root element
if (!container) return;
var element = container.children[0];
var slides, slidePos, width, length;
options = options || {};
var index = parseInt(options.startSlide, 10) || 0;
var speed = options.speed || 300;
options.continuous = options.continuous !== undefined ? options.continuous : true;
function setup() {
// do not setup if the container has no width
if (!container.offsetWidth) {
return;
}
// cache slides
slides = element.children;
length = slides.length;
// set continuous to false if only one slide
if (slides.length < 2) options.continuous = false;
//special case if two slides
if (browser.transitions && options.continuous && slides.length < 3) {
element.appendChild(slides[0].cloneNode(true));
element.appendChild(element.children[1].cloneNode(true));
slides = element.children;
}
// create an array to store current positions of each slide
slidePos = new Array(slides.length);
// determine width of each slide
width = container.offsetWidth || container.getBoundingClientRect().width;
element.style.width = (slides.length * width) + 'px';
// stack elements
var pos = slides.length;
while(pos--) {
var slide = slides[pos];
slide.style.width = width + 'px';
slide.setAttribute('data-index', pos);
if (browser.transitions) {
slide.style.left = (pos * -width) + 'px';
move(pos, index > pos ? -width : (index < pos ? width : 0), 0);
}
}
// reposition elements before and after index
if (options.continuous && browser.transitions) {
move(circle(index - 1), -width, 0);
move(circle(index + 1), width, 0);
}
if (!browser.transitions) element.style.left = (index * -width) + 'px';
container.style.visibility = 'visible';
options.slidesChanged && options.slidesChanged();
}
function prev(slideSpeed) {
if (options.continuous) slide(index - 1, slideSpeed);
else if (index) slide(index - 1, slideSpeed);
}
function next(slideSpeed) {
if (options.continuous) slide(index + 1, slideSpeed);
else if (index < slides.length - 1) slide(index + 1, slideSpeed);
}
function circle(index) {
// a simple positive modulo using slides.length
return (slides.length + (index % slides.length)) % slides.length;
}
function slide(to, slideSpeed) {
// do nothing if already on requested slide
if (index == to) return;
if (browser.transitions) {
var direction = Math.abs(index - to) / (index - to); // 1: backward, -1: forward
// get the actual position of the slide
if (options.continuous) {
var naturalDirection = direction;
direction = -slidePos[circle(to)] / width;
// if going forward but to < index, use to = slides.length + to
// if going backward but to > index, use to = -slides.length + to
if (direction !== naturalDirection) to = -direction * slides.length + to;
}
var diff = Math.abs(index - to) - 1;
// move all the slides between index and to in the right direction
while (diff--) move( circle((to > index ? to : index) - diff - 1), width * direction, 0);
to = circle(to);
move(index, width * direction, slideSpeed || speed);
move(to, 0, slideSpeed || speed);
if (options.continuous) move(circle(to - direction), -(width * direction), 0); // we need to get the next in place
} else {
to = circle(to);
animate(index * -width, to * -width, slideSpeed || speed);
//no fallback for a circular continuous if the browser does not accept transitions
}
index = to;
offloadFn(options.callback && options.callback(index, slides[index]));
}
function move(index, dist, speed) {
translate(index, dist, speed);
slidePos[index] = dist;
}
function translate(index, dist, speed) {
var slide = slides[index];
var style = slide && slide.style;
if (!style) return;
style.webkitTransitionDuration =
style.MozTransitionDuration =
style.msTransitionDuration =
style.OTransitionDuration =
style.transitionDuration = speed + 'ms';
style.webkitTransform = 'translate(' + dist + 'px,0)' + 'translateZ(0)';
style.msTransform =
style.MozTransform =
style.OTransform = 'translateX(' + dist + 'px)';
}
function animate(from, to, speed) {
// if not an animation, just reposition
if (!speed) {
element.style.left = to + 'px';
return;
}
var start = +new Date();
var timer = setInterval(function() {
var timeElap = +new Date() - start;
if (timeElap > speed) {
element.style.left = to + 'px';
if (delay) begin();
options.transitionEnd && options.transitionEnd.call(event, index, slides[index]);
clearInterval(timer);
return;
}
element.style.left = (( (to - from) * (Math.floor((timeElap / speed) * 100) / 100) ) + from) + 'px';
}, 4);
}
// setup auto slideshow
var delay = options.auto || 0;
var interval;
function begin() {
interval = setTimeout(next, delay);
}
function stop() {
delay = options.auto || 0;
clearTimeout(interval);
}
// setup initial vars
var start = {};
var delta = {};
var isScrolling;
// setup event capturing
var events = {
handleEvent: function(event) {
if(event.type == 'mousedown' || event.type == 'mouseup' || event.type == 'mousemove') {
event.touches = [{
pageX: event.pageX,
pageY: event.pageY
}];
}
switch (event.type) {
case 'mousedown': this.start(event); break;
case 'touchstart': this.start(event); break;
case 'touchmove': this.touchmove(event); break;
case 'mousemove': this.touchmove(event); break;
case 'touchend': offloadFn(this.end(event)); break;
case 'mouseup': offloadFn(this.end(event)); break;
case 'webkitTransitionEnd':
case 'msTransitionEnd':
case 'oTransitionEnd':
case 'otransitionend':
case 'transitionend': offloadFn(this.transitionEnd(event)); break;
case 'resize': offloadFn(setup); break;
}
if (options.stopPropagation) event.stopPropagation();
},
start: function(event) {
var touches = event.touches[0];
// measure start values
start = {
// get initial touch coords
x: touches.pageX,
y: touches.pageY,
// store time to determine touch duration
time: +new Date()
};
// used for testing first move event
isScrolling = undefined;
// reset delta and end measurements
delta = {};
// attach touchmove and touchend listeners
if(browser.touch) {
element.addEventListener('touchmove', this, false);
element.addEventListener('touchend', this, false);
} else {
element.addEventListener('mousemove', this, false);
element.addEventListener('mouseup', this, false);
document.addEventListener('mouseup', this, false);
}
},
touchmove: function(event) {
// ensure swiping with one touch and not pinching
// ensure sliding is enabled
if (event.touches.length > 1 ||
event.scale && event.scale !== 1 ||
slider.slideIsDisabled) {
return;
}
if (options.disableScroll) event.preventDefault();
var touches = event.touches[0];
// measure change in x and y
delta = {
x: touches.pageX - start.x,
y: touches.pageY - start.y
};
// determine if scrolling test has run - one time test
if ( typeof isScrolling == 'undefined') {
isScrolling = !!( isScrolling || Math.abs(delta.x) < Math.abs(delta.y) );
}
// if user is not trying to scroll vertically
if (!isScrolling) {
// prevent native scrolling
event.preventDefault();
// stop slideshow
stop();
// increase resistance if first or last slide
if (options.continuous) { // we don't add resistance at the end
translate(circle(index - 1), delta.x + slidePos[circle(index - 1)], 0);
translate(index, delta.x + slidePos[index], 0);
translate(circle(index + 1), delta.x + slidePos[circle(index + 1)], 0);
} else {
delta.x =
delta.x /
( (!index && delta.x > 0 || // if first slide and sliding left
index == slides.length - 1 && // or if last slide and sliding right
delta.x < 0 // and if sliding at all
) ?
( Math.abs(delta.x) / width + 1 ) // determine resistance level
: 1 ); // no resistance if false
// translate 1:1
translate(index - 1, delta.x + slidePos[index - 1], 0);
translate(index, delta.x + slidePos[index], 0);
translate(index + 1, delta.x + slidePos[index + 1], 0);
}
options.onDrag && options.onDrag();
}
},
end: function() {
// measure duration
var duration = +new Date() - start.time;
// determine if slide attempt triggers next/prev slide
var isValidSlide =
Number(duration) < 250 && // if slide duration is less than 250ms
Math.abs(delta.x) > 20 || // and if slide amt is greater than 20px
Math.abs(delta.x) > width / 2; // or if slide amt is greater than half the width
// determine if slide attempt is past start and end
var isPastBounds = (!index && delta.x > 0) || // if first slide and slide amt is greater than 0
(index == slides.length - 1 && delta.x < 0); // or if last slide and slide amt is less than 0
if (options.continuous) isPastBounds = false;
// determine direction of swipe (true:right, false:left)
var direction = delta.x < 0;
// if not scrolling vertically
if (!isScrolling) {
if (isValidSlide && !isPastBounds) {
if (direction) {
if (options.continuous) { // we need to get the next in this direction in place
move(circle(index - 1), -width, 0);
move(circle(index + 2), width, 0);
} else {
move(index - 1, -width, 0);
}
move(index, slidePos[index] - width, speed);
move(circle(index + 1), slidePos[circle(index + 1)] - width, speed);
index = circle(index + 1);
} else {
if (options.continuous) { // we need to get the next in this direction in place
move(circle(index + 1), width, 0);
move(circle(index - 2), -width, 0);
} else {
move(index + 1, width, 0);
}
move(index, slidePos[index] + width, speed);
move(circle(index - 1), slidePos[circle(index - 1)] + width, speed);
index = circle(index - 1);
}
options.callback && options.callback(index, slides[index]);
} else {
if (options.continuous) {
move(circle(index - 1), -width, speed);
move(index, 0, speed);
move(circle(index + 1), width, speed);
} else {
move(index - 1, -width, speed);
move(index, 0, speed);
move(index + 1, width, speed);
}
}
}
// kill touchmove and touchend event listeners until touchstart called again
if(browser.touch) {
element.removeEventListener('touchmove', events, false);
element.removeEventListener('touchend', events, false);
} else {
element.removeEventListener('mousemove', events, false);
element.removeEventListener('mouseup', events, false);
document.removeEventListener('mouseup', events, false);
}
options.onDragEnd && options.onDragEnd();
},
transitionEnd: function(event) {
if (parseInt(event.target.getAttribute('data-index'), 10) == index) {
if (delay) begin();
options.transitionEnd && options.transitionEnd.call(event, index, slides[index]);
}
}
};
// Public API
this.update = function() {
setTimeout(setup);
};
this.setup = function() {
setup();
};
this.loop = function(value) {
if (arguments.length) options.continuous = !!value;
return options.continuous;
};
this.enableSlide = function(shouldEnable) {
if (arguments.length) {
this.slideIsDisabled = !shouldEnable;
}
return !this.slideIsDisabled;
};
this.slide = this.select = function(to, speed) {
// cancel slideshow
stop();
slide(to, speed);
};
this.prev = this.previous = function() {
// cancel slideshow
stop();
prev();
};
this.next = function() {
// cancel slideshow
stop();
next();
};
this.stop = function() {
// cancel slideshow
stop();
};
this.start = function() {
begin();
};
this.autoPlay = function(newDelay) {
if (!delay || delay < 0) {
stop();
} else {
delay = newDelay;
begin();
}
};
this.currentIndex = this.selected = function() {
// return current index position
return index;
};
this.slidesCount = this.count = function() {
// return total number of slides
return length;
};
this.kill = function() {
// cancel slideshow
stop();
// reset element
element.style.width = '';
element.style.left = '';
// reset slides so no refs are held on to
slides && (slides = []);
// removed event listeners
if (browser.addEventListener) {
// remove current event listeners
element.removeEventListener('touchstart', events, false);
element.removeEventListener('webkitTransitionEnd', events, false);
element.removeEventListener('msTransitionEnd', events, false);
element.removeEventListener('oTransitionEnd', events, false);
element.removeEventListener('otransitionend', events, false);
element.removeEventListener('transitionend', events, false);
window.removeEventListener('resize', events, false);
}
else {
window.onresize = null;
}
};
this.load = function() {
// trigger setup
setup();
// start auto slideshow if applicable
if (delay) begin();
// add event listeners
if (browser.addEventListener) {
// set touchstart event on element
if (browser.touch) {
element.addEventListener('touchstart', events, false);
} else {
element.addEventListener('mousedown', events, false);
}
if (browser.transitions) {
element.addEventListener('webkitTransitionEnd', events, false);
element.addEventListener('msTransitionEnd', events, false);
element.addEventListener('oTransitionEnd', events, false);
element.addEventListener('otransitionend', events, false);
element.addEventListener('transitionend', events, false);
}
// set resize event on window
window.addEventListener('resize', events, false);
} else {
window.onresize = function () { setup(); }; // to play nice with old IE
}
};
}
});
})(ionic);
(function(ionic) {
'use strict';
ionic.views.Toggle = ionic.views.View.inherit({
initialize: function(opts) {
var self = this;
this.el = opts.el;
this.checkbox = opts.checkbox;
this.track = opts.track;
this.handle = opts.handle;
this.openPercent = -1;
this.onChange = opts.onChange || function() {};
this.triggerThreshold = opts.triggerThreshold || 20;
this.dragStartHandler = function(e) {
self.dragStart(e);
};
this.dragHandler = function(e) {
self.drag(e);
};
this.holdHandler = function(e) {
self.hold(e);
};
this.releaseHandler = function(e) {
self.release(e);
};
this.dragStartGesture = ionic.onGesture('dragstart', this.dragStartHandler, this.el);
this.dragGesture = ionic.onGesture('drag', this.dragHandler, this.el);
this.dragHoldGesture = ionic.onGesture('hold', this.holdHandler, this.el);
this.dragReleaseGesture = ionic.onGesture('release', this.releaseHandler, this.el);
},
destroy: function() {
ionic.offGesture(this.dragStartGesture, 'dragstart', this.dragStartGesture);
ionic.offGesture(this.dragGesture, 'drag', this.dragGesture);
ionic.offGesture(this.dragHoldGesture, 'hold', this.holdHandler);
ionic.offGesture(this.dragReleaseGesture, 'release', this.releaseHandler);
},
tap: function() {
if(this.el.getAttribute('disabled') !== 'disabled') {
this.val( !this.checkbox.checked );
}
},
dragStart: function(e) {
if(this.checkbox.disabled) return;
this._dragInfo = {
width: this.el.offsetWidth,
left: this.el.offsetLeft,
right: this.el.offsetLeft + this.el.offsetWidth,
triggerX: this.el.offsetWidth / 2,
initialState: this.checkbox.checked
};
// Stop any parent dragging
e.gesture.srcEvent.preventDefault();
// Trigger hold styles
this.hold(e);
},
drag: function(e) {
var self = this;
if(!this._dragInfo) { return; }
// Stop any parent dragging
e.gesture.srcEvent.preventDefault();
ionic.requestAnimationFrame(function () {
if (!self._dragInfo) { return; }
var px = e.gesture.touches[0].pageX - self._dragInfo.left;
var mx = self._dragInfo.width - self.triggerThreshold;
// The initial state was on, so "tend towards" on
if(self._dragInfo.initialState) {
if(px < self.triggerThreshold) {
self.setOpenPercent(0);
} else if(px > self._dragInfo.triggerX) {
self.setOpenPercent(100);
}
} else {
// The initial state was off, so "tend towards" off
if(px < self._dragInfo.triggerX) {
self.setOpenPercent(0);
} else if(px > mx) {
self.setOpenPercent(100);
}
}
});
},
endDrag: function() {
this._dragInfo = null;
},
hold: function() {
this.el.classList.add('dragging');
},
release: function(e) {
this.el.classList.remove('dragging');
this.endDrag(e);
},
setOpenPercent: function(openPercent) {
// only make a change if the new open percent has changed
if(this.openPercent < 0 || (openPercent < (this.openPercent - 3) || openPercent > (this.openPercent + 3) ) ) {
this.openPercent = openPercent;
if(openPercent === 0) {
this.val(false);
} else if(openPercent === 100) {
this.val(true);
} else {
var openPixel = Math.round( (openPercent / 100) * this.track.offsetWidth - (this.handle.offsetWidth) );
openPixel = (openPixel < 1 ? 0 : openPixel);
this.handle.style[ionic.CSS.TRANSFORM] = 'translate3d(' + openPixel + 'px,0,0)';
}
}
},
val: function(value) {
if(value === true || value === false) {
if(this.handle.style[ionic.CSS.TRANSFORM] !== "") {
this.handle.style[ionic.CSS.TRANSFORM] = "";
}
this.checkbox.checked = value;
this.openPercent = (value ? 100 : 0);
this.onChange && this.onChange();
}
return this.checkbox.checked;
}
});
})(ionic);
//# sourceMappingURL=ionic.js.map
|
/**
* This file/module contains all configuration for the build process.
*/
module.exports = {
/**
* The `build_dir` folder is where our projects are compiled during
* development and the `compile_dir` folder is where our app resides once it's
* completely built.
*/
src_dir: '../client',
build_dir: '../build',
compile_dir: '../www',
port: '63342',
/**
* This is a collection of file patterns that refer to our app code (the
* stuff in `src/`). These file paths are used in the configuration of
* build tasks. `js` is all project javascript, less tests. `ctpl` contains
* our reusable components' (`src/common`) template HTML files, while
* `atpl` contains the same, but for our app's code. `html` is just our
* main HTML file, `less` is our main stylesheet, and `unit` contains our
* app's unit tests.
*/
app_files: {
js: [
'<%= src_dir %>/**/*.js',
'!<%= src_dir %>/assets/**/*.js',
'!<%= src_dir %>/vendor/**/*.js'
],
atpl: ['<%= src_dir %>/eendragt/**/*.html'],
ctpl: ['<%= src_dir %>/lib/**/*.html'],
html: ['<%= src_dir %>/index.html'],
less: [
'<%= src_dir %>/assets/less/**/*.less',
'<%= src_dir %>/lib/**/*.less',
'<%= src_dir %>/**/*.less',
'!<%= src_dir %>/**/*-ty.less',
'!<%= src_dir %>/**/*-sm.less',
'!<%= src_dir %>/**/*-md.less',
'!<%= src_dir %>/**/*-lg.less',
'!<%= src_dir %>/vendor/**/*.less'
]
},
/**
* This is the same as `app_files`, except it contains patterns that
* reference vendor code (`vendor/`) that we need to place into the build
* process somewhere. While the `app_files` property ensures all
* standardized files are collected for compilation, it is the user's job
* to ensure non-standardized (i.e. vendor-related) files are handled
* appropriately in `vendor_files.js`.
*
* The `vendor_files.js` property holds files to be automatically
* concatenated and minified with our project source files.
*
* The `vendor_files.css` property holds any CSS files to be automatically
* included in our app.
*
* The `vendor_files.assets` property holds any assets to be copied along
* with our app's assets. This structure is flattened, so it is not
* recommended that you use wildcards.
*/
vendor_files: {
js: [
'<%= src_dir %>/vendor/jquery/dist/jquery.js',
'<%= src_dir %>/vendor/angular/angular.js',
'<%= src_dir %>/vendor/angular-route/angular-route.js',
'<%= src_dir %>/vendor/angular-animate/angular-animate.js',
'<%= src_dir %>/vendor/localforage/dist/localforage.js',
'<%= src_dir %>/vendor/angular-localForage/dist/angular-localForage.js',
'<%= src_dir %>/vendor/ngCordova/dist/ng-cordova.js'
],
css: [
],
assets: [
]
}
}; |
/*
* provider
*
* Copyright Cahoots.pw
* MIT Licensed
*
*/
/**
* @author André König <[email protected]>
*
*/
'use strict';
var util = require('util');
var debug = require('debug')('cahoots:provider:person');
var mandatory = require('mandatory');
var VError = require('verror');
var BaseService = require('./base');
module.exports = function instantiate (providers) {
var service = new PersonService(providers);
return {
findAll: service.findAll.bind(service),
findById: service.findById.bind(service)
};
};
function PersonService (providers) {
this.$type = 'person';
BaseService.call(this, providers);
}
util.inherits(PersonService, BaseService);
PersonService.prototype.findAll = function findAll (callback) {
mandatory(callback).is('function', 'Please provide a proper callback function');
function onQuery (err, persons) {
if (err) {
debug('[ERROR] failed to find all persons via all providers');
return callback(new VError(err, 'failed to find all persons via all providers'));
}
debug('received all persons (found %d person(s))', persons.length);
callback(null, persons);
}
let query = {};
debug('request all persons');
this.$query(this.$type, query, onQuery);
};
PersonService.prototype.findById = function findById (id, callback) {
mandatory(id).is('string', 'Please provide a proper person id');
mandatory(callback).is('function', 'Please provide a proper callback function');
function onQuery (err, persons) {
if (err) {
debug('[ERROR] failed to find the person with the id "%s" from all providers', id);
return callback(new VError(err, 'failed to find the person with the id "%s" from all providers', id));
}
if (persons.length > 1) {
debug('Autsch! Found multiple persons with the id "%s". That should not be possible!', id);
}
debug('received person with the id "%s"', id);
callback(null, persons[0]);
}
let query = {id: id};
debug('request the person with the id "%s"', id);
this.$query(this.$type, query, onQuery);
};
|
import React, { Component } from 'react';
import { Field, reduxForm } from 'redux-form';
import LANGUAGES from './LANGUAGES';
import validate from './validate';
import MultiSelect from '../MultiSelect/MultiSelect';
import s from './styles.css';
const OPTIONS = [
{ label: 'From Birth', value: 0 },
];
for (let i = 1; i <= 100; i++) {
OPTIONS.push({
label: i,
value: i,
});
}
class CommentFormPart1 extends Component {
render() {
const { handleSubmit, pristine, reset, submitting } = this.props;
return (
<div>
<div className="row">
<div className="col-xs-12">
<h2>How Did we Do</h2>
</div>
</div>
<form
onSubmit={this.props.handleSubmit}
>
<div className="row">
<div className="col-xs-12">
<label
htmlFor="learn_age"
>
When did you start learning english?
<Field
name="learnAge"
defaultValue=""
component={learnAge =>
<div>
<select {...learnAge.input} >
<option value="" disabled>Select an Age</option>
{OPTIONS.map(option => <option value={option.value} key={option.value}>{option.label}</option>)}
</select>
{learnAge.meta.touched && learnAge.meta.error ? <span className={s.validationMessage}>{learnAge.meta.error}</span> : null}
</div>
}
/>
</label>
</div>
</div>
<div className="row">
<div className="col-xs-12 col-sm-6">
<label>List all <strong>native</strong> language(s) <em>learned from birth</em></label>
<Field
name="nativeLanguages"
defaultValue={['']}
component={nativeLanguages =>
<div>
<MultiSelect
defaultMessage={'Please Select a Language'}
{...nativeLanguages.input}
options={LANGUAGES.filter(lang => nativeLanguages.input.value.indexOf(lang) < 0)}
/>
{nativeLanguages.meta.touched && nativeLanguages.meta.error ? <span className={s.validationMessage}>{nativeLanguages.meta.error}</span> : null}
</div>
}
/>
</div>
<div className="col-xs-12 col-sm-6">
<label>List all <strong>primary</strong> language(s) <em>learned from birth</em></label>
<Field
name="primaryLanguages"
defaultValue={[]}
component={primaryLanguages =>
<div>
<MultiSelect
defaultMessage={'Please Select a Language'}
{...primaryLanguages.input}
options={LANGUAGES.filter(lang => primaryLanguages.input.value.indexOf(lang) < 0)}
/>
{primaryLanguages.meta.touched && primaryLanguages.meta.error ? <span className={s.validationMessage}>{primaryLanguages.meta.error}</span> : null}
</div>
}
/>
</div>
</div>
<div className="row">
<div className="col-xs-12">
<button
className={"btn btn-success " + s.nextbutton}
type="submit"
disabled={pristine || submitting}
>
Next
</button>
</div>
</div>
</form>
</div>
);
}
}
export default reduxForm({
form: 'comments', // <------ same form name
destroyOnUnmount: false, // <------ preserve form data
validate,
// enableReinitialize: true,
})(CommentFormPart1)
;
|
import React, {Component} from 'react'
import SectionMain from '../components/SectionMain'
import styles from '../sass/App'
import Actionbar from '../../shared/components/Actionbar'
class App extends Component {
constructor() {
super()
}
componentDidMount() {
const {actions, cats} = this.props
actions.updateActionbar({
title: '商品分类',
action: '',
back: false
})
actions.getCats()
}
componentWillUnmount() {
const {actions} = this.props
actions.replaceItems([])
}
render() {
const {actions, actionbar, cats, items, cart} = this.props
return (
<div className={styles.app}>
<Actionbar title={actionbar.title} back={actionbar.back} action={actionbar.action}/>
<SectionMain cats={cats} items={items} actions={actions} cart={cart}></SectionMain>
</div>
)
}
}
export default App
|
require.define({
"program": function(require, exports, module) {
var test = require('test');
test.assert(typeof require == 'function', 'require is a function');
test.assert(typeof exports == 'object', 'exports is an object');
test.assert(module.id == 'program', 'module.id is program');
require('a');
test.print('DONE', 'info');
},
"a": {
injects: ['require'],
factory: function(require, exports, module) {
var test = require('test');
test.assert(typeof require == 'function', 'require is a function');
test.assert(typeof exports == 'undefined', 'exports is undefined');
test.assert(typeof modules == 'undefined', 'module is undefined');
}
}
}, ['test']); |
module.exports =
class Provider {
constructor(data) {
this.name = data.name;
this.url = data.url;
}
};
|
import 'normalize.css/normalize.css';
import React, { Component } from 'react';
import FontFaceObserver from 'fontfaceobserver';
import classnames from 'classnames';
import './assets/base_scss/__base.scss';
import MosaicContainer from './components/Mosaic/MosaicContainer';
import ContentGridContainer from './components/ContentGrid/ContentGridContainer';
import ContentRowContainer from './components/ContentRow/ContentRowContainer';
import Card from './components/Card/Card';
import Icons from './components/Icons';
import ProgressTimer from './components/ProgressTimer/ProgressTimer';
import LastDay from './components/LastDay/LastDay';
import Remove from './components/Remove/Remove';
import styles from './index.scss';
class RenderingEngine extends Component {
componentDidMount() {
// FontFaceObserver
// Loading web font asynchronously
// --------------------------------------------------
const observer = new FontFaceObserver('Open Sans');
// Cache Web fonts, this way our visitors will
// experience 'FOUT' only the first time they visit the site
// If fontsLoaded is present in localStorage
// Add 'font-loaded' class on the body otherwise load fonts asynchronously
if (window.localStorage.fontsLoaded) {
document.body.classList.add('fonts-loaded');
} else {
const body = document.body;
observer
.load()
.then(() => {
window.localStorage.fontsLoaded = true;
body.classList.add('fonts-loaded');
})
.catch((err) => {
window.localStorage.fontsLoaded = false;
body.classList.remove('fonts-loaded');
// eslint-disable-next-line no-console
console.error(err);
});
}
}
render() {
return (
<span>
<h1 style={{ textAlign: 'center' }}>TMS RenderingEngine</h1>
<h2 style={{ textAlign: 'center' }}>Components</h2>
<ul>
<li key={1}>
<h3>Card</h3>
<Card
title="Card title"
subtitle="Card subtitle"
logoChannel="https://thumb.canalplus.pro/http/unsafe/{resolutionXY}/image.canal-plus.com/media_cpa/img/channel/white/288_218/png/40052_288_218.png"
image="https://thumb.canalplus.pro/bddpe/unsafe/%7BresolutionXY%7D/54125687"
ratio={169}
onClick={() => {
console.log('onClickCard');
}} // eslint-disable-line no-console
isRemovableItem
onClickCrossButton={() => {
console.log('onClickCrossButton');
}} // eslint-disable-line no-console
actionBar={() =>
(<span>
<Icons.Close svgClass={classnames(styles.icon, styles.right)} />
<Icons.CarouselArrow svgClass={classnames(styles.icon, styles.right)} />
<Icons.Check svgClass={classnames(styles.icon, styles.right)} />
<Icons.Allocine svgClass={classnames(styles.icon, styles.right)} />
<Icons.Arrow svgClass={classnames(styles.icon, styles.right)} />
</span>)}
dark={false}
displaySubtitlePlaceholder={false}
availabilityEndDate={0}
label={{ position: 'top-left', text: 'Dernier jour' }}
/>
</li>
<li key={2}>
<h3>Icons</h3>
<Icons.Close svgClass={classnames(styles.icon, styles.right)} />
<Icons.CarouselArrow svgClass={classnames(styles.icon, styles.right)} />
<Icons.Check svgClass={classnames(styles.icon, styles.right)} />
<Icons.Allocine svgClass={classnames(styles.icon, styles.right)} />
<Icons.Arrow svgClass={classnames(styles.icon, styles.right)} />
<Icons.Favorite svgClass={classnames(styles.icon, styles.right)} />
<Icons.HistoryOn svgClass={classnames(styles.icon, styles.right)} />
<Icons.Download svgClass={classnames(styles.icon, styles.right)} />
<Icons.MoodDislike svgClass={classnames(styles.icon, styles.right)} />
<Icons.MoodLike svgClass={classnames(styles.icon, styles.right)} />
<Icons.MoodNeutral svgClass={classnames(styles.icon, styles.right)} />
<Icons.Play svgClass={classnames(styles.icon, styles.right)} />
<Icons.Playlist svgClass={classnames(styles.icon, styles.right)} />
<Icons.Restart svgClass={classnames(styles.icon, styles.right)} />
<Icons.Start svgClass={classnames(styles.icon, styles.right)} />
<Icons.User svgClass={classnames(styles.icon, styles.right)} />
</li>
<li>
<h3>Other stuff</h3>
<div style={{ position: 'relative', height: '3rem' }} className={styles.top}>
<Remove />
</div>
<div className={styles.top}>
<ProgressTimer isInHistory={false} userProgress={89} />
</div>
<div className={styles.top}>
<ProgressTimer className={styles.top} isInHistory={false} userProgress={87} />
</div>
<div className={styles.top}>
<LastDay text="label" />
</div>
</li>
</ul>
<h2 style={{ textAlign: 'center' }}>Templates</h2>
<ul>
<li key={1}>
<h3>ContentRow</h3>
<ContentRowContainer />
</li>
<li key={2}>
<h3>Mosaic</h3>
<MosaicContainer />
</li>
<li key={3}>
<h3>ContentGrid</h3>
<ContentGridContainer />
</li>
</ul>
</span>
);
}
}
export default RenderingEngine;
|
import React from 'react';
function Tip(props) {
return (
<div className="Tip">
<span className="label">
{props.label}
</span>
<span className="value">
{props.value}
</span>
</div>
);
}
export default Tip;
|
import Vue from 'vue';
import { mountComponentWithStore } from 'helpers/vue_mount_component_helper';
import DraftsCount from '~/batch_comments/components/drafts_count.vue';
import { createStore } from '~/batch_comments/stores';
describe('Batch comments drafts count component', () => {
let vm;
let Component;
beforeAll(() => {
Component = Vue.extend(DraftsCount);
});
beforeEach(() => {
const store = createStore();
store.state.batchComments.drafts.push('comment');
vm = mountComponentWithStore(Component, { store });
});
afterEach(() => {
vm.$destroy();
});
it('renders count', () => {
expect(vm.$el.textContent).toContain('1');
});
it('renders screen reader text', done => {
const el = vm.$el.querySelector('.sr-only');
expect(el.textContent).toContain('draft');
vm.$store.state.batchComments.drafts.push('comment 2');
vm.$nextTick(() => {
expect(el.textContent).toContain('drafts');
done();
});
});
});
|
/*! Copyright (c) 2009 Brandon Aaron (http://brandonaaron.net)
* Dual licensed under the MIT (http://www.opensource.org/licenses/mit-license.php)
* and GPL (http://www.opensource.org/licenses/gpl-license.php) licenses.
*
* Version: 1.1.0-pre
* Requires jQuery 1.3+
* Docs: http://docs.jquery.com/Plugins/livequery
*/
(function($) {
$.extend($.fn, {
livequery: function(type, fn, fn2) {
var self = this, q;
// Handle different call patterns
if ($.isFunction(type))
fn2 = fn, fn = type, type = undefined;
// See if Live Query already exists
$.each( $.livequery.queries, function(i, query) {
if ( self.selector == query.selector && self.context == query.context &&
type == query.type && (!fn || fn.$lqguid == query.fn.$lqguid) && (!fn2 || fn2.$lqguid == query.fn2.$lqguid) )
// Found the query, exit the each loop
return (q = query) && false;
});
// Create new Live Query if it wasn't found
q = q || new $.livequery(this.selector, this.context, type, fn, fn2);
// Make sure it is running
q.stopped = false;
// Run it immediately for the first time
q.run();
// Contnue the chain
return this;
},
expire: function(type, fn, fn2) {
var self = this;
// Handle different call patterns
if ($.isFunction(type))
fn2 = fn, fn = type, type = undefined;
// Find the Live Query based on arguments and stop it
$.each( $.livequery.queries, function(i, query) {
if ( self.selector == query.selector && self.context == query.context &&
(!type || type == query.type) && (!fn || fn.$lqguid == query.fn.$lqguid) && (!fn2 || fn2.$lqguid == query.fn2.$lqguid) && !this.stopped )
$.livequery.stop(query.id);
});
// Continue the chain
return this;
}
});
$.livequery = function(selector, context, type, fn, fn2) {
this.selector = selector;
this.context = context;
this.type = type;
this.fn = fn;
this.fn2 = fn2;
this.elements = [];
this.stopped = false;
// The id is the index of the Live Query in $.livequery.queries
this.id = $.livequery.queries.push(this)-1;
// Mark the functions for matching later on
fn.$lqguid = fn.$lqguid || $.livequery.guid++;
if (fn2) fn2.$lqguid = fn2.$lqguid || $.livequery.guid++;
// Return the Live Query
return this;
};
$.livequery.prototype = {
stop: function() {
var query = this;
if ( this.type )
// Unbind all bound events
this.elements.unbind(this.type, this.fn);
else if (this.fn2)
// Call the second function for all matched elements
this.elements.each(function(i, el) {
query.fn2.apply(el);
});
// Clear out matched elements
this.elements = [];
// Stop the Live Query from running until restarted
this.stopped = true;
},
run: function() {
// Short-circuit if stopped
if ( this.stopped ) return;
var query = this;
var oEls = this.elements,
els = $(this.selector, this.context),
nEls = els.not(oEls);
// Set elements to the latest set of matched elements
this.elements = els;
if (this.type) {
// Bind events to newly matched elements
nEls.bind(this.type, this.fn);
// Unbind events to elements no longer matched
if (oEls.length > 0)
$.each(oEls, function(i, el) {
if ( $.inArray(el, els) < 0 )
$.event.remove(el, query.type, query.fn);
});
}
else {
// Call the first function for newly matched elements
nEls.each(function() {
query.fn.apply(this);
});
// Call the second function for elements no longer matched
if ( this.fn2 && oEls.length > 0 )
$.each(oEls, function(i, el) {
if ( $.inArray(el, els) < 0 )
query.fn2.apply(el);
});
}
}
};
$.extend($.livequery, {
guid: 0,
queries: [],
queue: [],
running: false,
timeout: null,
checkQueue: function() {
if ( $.livequery.running && $.livequery.queue.length ) {
var length = $.livequery.queue.length;
// Run each Live Query currently in the queue
while ( length-- )
$.livequery.queries[ $.livequery.queue.shift() ].run();
}
},
pause: function() {
// Don't run anymore Live Queries until restarted
$.livequery.running = false;
},
play: function() {
// Restart Live Queries
$.livequery.running = true;
// Request a run of the Live Queries
$.livequery.run();
},
registerPlugin: function() {
$.each( arguments, function(i,n) {
// Short-circuit if the method doesn't exist
if (!$.fn[n]) return;
// Save a reference to the original method
var old = $.fn[n];
// Create a new method
$.fn[n] = function() {
// Call the original method
var r = old.apply(this, arguments);
// Request a run of the Live Queries
$.livequery.run();
// Return the original methods result
return r;
}
});
},
run: function(id) {
if (id != undefined) {
// Put the particular Live Query in the queue if it doesn't already exist
if ( $.inArray(id, $.livequery.queue) < 0 )
$.livequery.queue.push( id );
}
else
// Put each Live Query in the queue if it doesn't already exist
$.each( $.livequery.queries, function(id) {
if ( $.inArray(id, $.livequery.queue) < 0 )
$.livequery.queue.push( id );
});
// Clear timeout if it already exists
if ($.livequery.timeout) clearTimeout($.livequery.timeout);
// Create a timeout to check the queue and actually run the Live Queries
$.livequery.timeout = setTimeout($.livequery.checkQueue, 20);
},
stop: function(id) {
if (id != undefined)
// Stop are particular Live Query
$.livequery.queries[ id ].stop();
else
// Stop all Live Queries
$.each( $.livequery.queries, function(id) {
$.livequery.queries[ id ].stop();
});
}
});
// Register core DOM manipulation methods
$.livequery.registerPlugin('append', 'prepend', 'after', 'before', 'wrap', 'attr', 'removeAttr', 'addClass', 'removeClass', 'toggleClass', 'empty', 'remove');
// Run Live Queries when the Document is ready
$(function() { $.livequery.play(); });
})(jQuery);
|
module.exports = require('./lib/scotty')
|
var mongoose = require('../../lib/mongodb');
const tools=require('../../lib/tools');
const coupon={
id: {type: Number, required: true, unique: true},//主键
cId:{type:Number,required:true,default:0},//优惠券ID
code:{type:String,required:true,default:'',unique:true},//优惠码(加密)
name:{type:String,required:true,default:''},//名称
scope:{type:String,required:true,default:'0',enum:['0','1','2','3','4']},//适用范围：0：全品类 1：限单品 2：限品类 3：限品牌 4：限商家
type:{type:String,required:true,default:'0',enum:['0','1','2','3']},//类型 0：代金券 1：折扣券 2：免邮券 3：免单券
kind:{type:String,required:true,default:'1',enum:['0','1']},//性质 0：排他 1：叠加 2：
share:{type:Boolean,required:true,default:true},//能否分享
targetTxt:{type:String,required:true,default:''},//适用对象说明
target:{type:Array,required:false,default:[]},//适用对象
conTxt:{type:String,required:true,default:''},//使用条件说明
condition:{type:String,required:true,default:''},//使用条件
validity:{type:Date,required:true,default:''},//生效日期
expiry:{type:Date,required:true,default:''},//失效日期
deno:{type:Number,required:true,default:0},//面额
amount:{type:Number,required:false,default:0},//适用金额
status:{type:String,required:true,default:'0',enum:['0','1','2','3']},//状态：0：待使用 1：已使用 2：已失效 3：已分享
lotNo:{type:String,required:true,default:''},//产生批次
source:{type:String,required:true,default:'0',enum:['0','1','2']},//来源：0：领取 1：分享 2：赠送
memId:{type:String,required:true,default:''},//会员ID
remark:{type:String,required:false,default:''},//使用说明（明细）
rtype:{type:String,required:true,default:'0'},//生成规则：0：:手动 1：自动
rule:{type:String,required:false,default:''},//自动生成的规则corn表达式
cdate:{type:Date,required:true,default:''},//领用日期
udate:{type:Date,required:false,default:''}//使用日期
}
var couponSchema=new mongoose.Schema(coupon,{id:false});
// expRuleSchema.index();
var Coupon=mongoose.model('Coupon',couponSchema,'prom_coupon');
module.exports=Coupon;
|
'use strict';
describe('Controller: MainController', function() {
// load the controller's module
beforeEach(module('voteroidApp'));
beforeEach(module('socketMock'));
var scope;
var MainController;
var $httpBackend;
// Initialize the controller and a mock scope
beforeEach(inject(function(_$httpBackend_, $controller, $rootScope) {
$httpBackend = _$httpBackend_;
$httpBackend.expectGET('/api/polls')
.respond(['HTML5 Boilerplate', 'AngularJS', 'Karma', 'Express']);
scope = $rootScope.$new();
MainController = $controller('MainController', {
$scope: scope
});
}));
it('should attach a list of polls to the controller', function() {
$httpBackend.flush();
expect(MainController.polls.length).toBe(4);
});
});
|
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
require('../src/ar-scene.js');
require('../src/ar-components.js');
require('../src/ar-referenceframe.js');
require('../src/css-object.js');
require('../src/ar-vuforia.js');
require('../src/panorama-reality.js');
},{"../src/ar-components.js":6,"../src/ar-referenceframe.js":7,"../src/ar-scene.js":8,"../src/ar-vuforia.js":9,"../src/css-object.js":10,"../src/panorama-reality.js":11}],2:[function(require,module,exports){
/**
* Animation configuration options for TWEEN.js animations.
* Used by `<a-animation>`.
*/
var TWEEN = require('tween.js');
var DIRECTIONS = {
alternate: 'alternate',
alternateReverse: 'alternate-reverse',
normal: 'normal',
reverse: 'reverse'
};
var EASING_FUNCTIONS = {
'linear': TWEEN.Easing.Linear.None,
'ease': TWEEN.Easing.Cubic.InOut,
'ease-in': TWEEN.Easing.Cubic.In,
'ease-out': TWEEN.Easing.Cubic.Out,
'ease-in-out': TWEEN.Easing.Cubic.InOut,
'ease-cubic': TWEEN.Easing.Cubic.In,
'ease-in-cubic': TWEEN.Easing.Cubic.In,
'ease-out-cubic': TWEEN.Easing.Cubic.Out,
'ease-in-out-cubic': TWEEN.Easing.Cubic.InOut,
'ease-quad': TWEEN.Easing.Quadratic.InOut,
'ease-in-quad': TWEEN.Easing.Quadratic.In,
'ease-out-quad': TWEEN.Easing.Quadratic.Out,
'ease-in-out-quad': TWEEN.Easing.Quadratic.InOut,
'ease-quart': TWEEN.Easing.Quartic.InOut,
'ease-in-quart': TWEEN.Easing.Quartic.In,
'ease-out-quart': TWEEN.Easing.Quartic.Out,
'ease-in-out-quart': TWEEN.Easing.Quartic.InOut,
'ease-quint': TWEEN.Easing.Quintic.InOut,
'ease-in-quint': TWEEN.Easing.Quintic.In,
'ease-out-quint': TWEEN.Easing.Quintic.Out,
'ease-in-out-quint': TWEEN.Easing.Quintic.InOut,
'ease-sine': TWEEN.Easing.Sinusoidal.InOut,
'ease-in-sine': TWEEN.Easing.Sinusoidal.In,
'ease-out-sine': TWEEN.Easing.Sinusoidal.Out,
'ease-in-out-sine': TWEEN.Easing.Sinusoidal.InOut,
'ease-expo': TWEEN.Easing.Exponential.InOut,
'ease-in-expo': TWEEN.Easing.Exponential.In,
'ease-out-expo': TWEEN.Easing.Exponential.Out,
'ease-in-out-expo': TWEEN.Easing.Exponential.InOut,
'ease-circ': TWEEN.Easing.Circular.InOut,
'ease-in-circ': TWEEN.Easing.Circular.In,
'ease-out-circ': TWEEN.Easing.Circular.Out,
'ease-in-out-circ': TWEEN.Easing.Circular.InOut,
'ease-elastic': TWEEN.Easing.Elastic.InOut,
'ease-in-elastic': TWEEN.Easing.Elastic.In,
'ease-out-elastic': TWEEN.Easing.Elastic.Out,
'ease-in-out-elastic': TWEEN.Easing.Elastic.InOut,
'ease-back': TWEEN.Easing.Back.InOut,
'ease-in-back': TWEEN.Easing.Back.In,
'ease-out-back': TWEEN.Easing.Back.Out,
'ease-in-out-back': TWEEN.Easing.Back.InOut,
'ease-bounce': TWEEN.Easing.Bounce.InOut,
'ease-in-bounce': TWEEN.Easing.Bounce.In,
'ease-out-bounce': TWEEN.Easing.Bounce.Out,
'ease-in-out-bounce': TWEEN.Easing.Bounce.InOut
};
var FILLS = {
backwards: 'backwards',
both: 'both',
forwards: 'forwards',
none: 'none'
};
var REPEATS = {
indefinite: 'indefinite'
};
var DEFAULTS = {
attribute: 'rotation',
begin: '',
end: '',
delay: 0,
dur: 1000,
easing: 'ease',
direction: DIRECTIONS.normal,
fill: FILLS.forwards,
from: undefined,
repeat: 0,
to: undefined
};
module.exports.defaults = DEFAULTS;
module.exports.directions = DIRECTIONS;
module.exports.easingFunctions = EASING_FUNCTIONS;
module.exports.fills = FILLS;
module.exports.repeats = REPEATS;
},{"tween.js":5}],3:[function(require,module,exports){
module.exports = {
AFRAME_INJECTED: 'aframe-injected',
animation: require('./animation'),
keyboardevent: require('./keyboardevent')
};
},{"./animation":2,"./keyboardevent":4}],4:[function(require,module,exports){
module.exports = {
// Tiny KeyboardEvent.code polyfill.
KEYCODE_TO_CODE: {
'38': 'ArrowUp',
'37': 'ArrowLeft',
'40': 'ArrowDown',
'39': 'ArrowRight',
'87': 'KeyW',
'65': 'KeyA',
'83': 'KeyS',
'68': 'KeyD'
}
};
},{}],5:[function(require,module,exports){
/**
* Tween.js - Licensed under the MIT license
* https://github.com/sole/tween.js
* ----------------------------------------------
*
* See https://github.com/sole/tween.js/graphs/contributors for the full list of contributors.
* Thank you all, you're awesome!
*/
// performance.now polyfill
( function ( root ) {
if ( 'performance' in root === false ) {
root.performance = {};
}
// IE 8
Date.now = ( Date.now || function () {
return new Date().getTime();
} );
if ( 'now' in root.performance === false ) {
var offset = root.performance.timing && root.performance.timing.navigationStart ? performance.timing.navigationStart
: Date.now();
root.performance.now = function () {
return Date.now() - offset;
};
}
} )( this );
var TWEEN = TWEEN || ( function () {
var _tweens = [];
return {
REVISION: '14',
getAll: function () {
return _tweens;
},
removeAll: function () {
_tweens = [];
},
add: function ( tween ) {
_tweens.push( tween );
},
remove: function ( tween ) {
var i = _tweens.indexOf( tween );
if ( i !== -1 ) {
_tweens.splice( i, 1 );
}
},
update: function ( time ) {
if ( _tweens.length === 0 ) return false;
var i = 0;
time = time !== undefined ? time : window.performance.now();
while ( i < _tweens.length ) {
if ( _tweens[ i ].update( time ) ) {
i++;
} else {
_tweens.splice( i, 1 );
}
}
return true;
}
};
} )();
TWEEN.Tween = function ( object ) {
var _object = object;
var _valuesStart = {};
var _valuesEnd = {};
var _valuesStartRepeat = {};
var _duration = 1000;
var _repeat = 0;
var _yoyo = false;
var _isPlaying = false;
var _reversed = false;
var _delayTime = 0;
var _startTime = null;
var _easingFunction = TWEEN.Easing.Linear.None;
var _interpolationFunction = TWEEN.Interpolation.Linear;
var _chainedTweens = [];
var _onStartCallback = null;
var _onStartCallbackFired = false;
var _onUpdateCallback = null;
var _onCompleteCallback = null;
var _onStopCallback = null;
// Set all starting values present on the target object
for ( var field in object ) {
_valuesStart[ field ] = parseFloat(object[field], 10);
}
this.to = function ( properties, duration ) {
if ( duration !== undefined ) {
_duration = duration;
}
_valuesEnd = properties;
return this;
};
this.start = function ( time ) {
TWEEN.add( this );
_isPlaying = true;
_onStartCallbackFired = false;
_startTime = time !== undefined ? time : window.performance.now();
_startTime += _delayTime;
for ( var property in _valuesEnd ) {
// check if an Array was provided as property value
if ( _valuesEnd[ property ] instanceof Array ) {
if ( _valuesEnd[ property ].length === 0 ) {
continue;
}
// create a local copy of the Array with the start value at the front
_valuesEnd[ property ] = [ _object[ property ] ].concat( _valuesEnd[ property ] );
}
_valuesStart[ property ] = _object[ property ];
if( ( _valuesStart[ property ] instanceof Array ) === false ) {
_valuesStart[ property ] *= 1.0; // Ensures we're using numbers, not strings
}
_valuesStartRepeat[ property ] = _valuesStart[ property ] || 0;
}
return this;
};
this.stop = function () {
if ( !_isPlaying ) {
return this;
}
TWEEN.remove( this );
_isPlaying = false;
if ( _onStopCallback !== null ) {
_onStopCallback.call( _object );
}
this.stopChainedTweens();
return this;
};
this.stopChainedTweens = function () {
for ( var i = 0, numChainedTweens = _chainedTweens.length; i < numChainedTweens; i++ ) {
_chainedTweens[ i ].stop();
}
};
this.delay = function ( amount ) {
_delayTime = amount;
return this;
};
this.repeat = function ( times ) {
_repeat = times;
return this;
};
this.yoyo = function( yoyo ) {
_yoyo = yoyo;
return this;
};
this.easing = function ( easing ) {
_easingFunction = easing;
return this;
};
this.interpolation = function ( interpolation ) {
_interpolationFunction = interpolation;
return this;
};
this.chain = function () {
_chainedTweens = arguments;
return this;
};
this.onStart = function ( callback ) {
_onStartCallback = callback;
return this;
};
this.onUpdate = function ( callback ) {
_onUpdateCallback = callback;
return this;
};
this.onComplete = function ( callback ) {
_onCompleteCallback = callback;
return this;
};
this.onStop = function ( callback ) {
_onStopCallback = callback;
return this;
};
this.update = function ( time ) {
var property;
if ( time < _startTime ) {
return true;
}
if ( _onStartCallbackFired === false ) {
if ( _onStartCallback !== null ) {
_onStartCallback.call( _object );
}
_onStartCallbackFired = true;
}
var elapsed = ( time - _startTime ) / _duration;
elapsed = elapsed > 1 ? 1 : elapsed;
var value = _easingFunction( elapsed );
for ( property in _valuesEnd ) {
var start = _valuesStart[ property ] || 0;
var end = _valuesEnd[ property ];
if ( end instanceof Array ) {
_object[ property ] = _interpolationFunction( end, value );
} else {
// Parses relative end values with start as base (e.g.: +10, -3)
if ( typeof(end) === "string" ) {
end = start + parseFloat(end, 10);
}
// protect against non numeric properties.
if ( typeof(end) === "number" ) {
_object[ property ] = start + ( end - start ) * value;
}
}
}
if ( _onUpdateCallback !== null ) {
_onUpdateCallback.call( _object, value );
}
if ( elapsed == 1 ) {
if ( _repeat > 0 ) {
if( isFinite( _repeat ) ) {
_repeat--;
}
// reassign starting values, restart by making startTime = now
for( property in _valuesStartRepeat ) {
if ( typeof( _valuesEnd[ property ] ) === "string" ) {
_valuesStartRepeat[ property ] = _valuesStartRepeat[ property ] + parseFloat(_valuesEnd[ property ], 10);
}
if (_yoyo) {
var tmp = _valuesStartRepeat[ property ];
_valuesStartRepeat[ property ] = _valuesEnd[ property ];
_valuesEnd[ property ] = tmp;
}
_valuesStart[ property ] = _valuesStartRepeat[ property ];
}
if (_yoyo) {
_reversed = !_reversed;
}
_startTime = time + _delayTime;
return true;
} else {
if ( _onCompleteCallback !== null ) {
_onCompleteCallback.call( _object );
}
for ( var i = 0, numChainedTweens = _chainedTweens.length; i < numChainedTweens; i++ ) {
_chainedTweens[ i ].start( time );
}
return false;
}
}
return true;
};
};
TWEEN.Easing = {
Linear: {
None: function ( k ) {
return k;
}
},
Quadratic: {
In: function ( k ) {
return k * k;
},
Out: function ( k ) {
return k * ( 2 - k );
},
InOut: function ( k ) {
if ( ( k *= 2 ) < 1 ) return 0.5 * k * k;
return - 0.5 * ( --k * ( k - 2 ) - 1 );
}
},
Cubic: {
In: function ( k ) {
return k * k * k;
},
Out: function ( k ) {
return --k * k * k + 1;
},
InOut: function ( k ) {
if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k;
return 0.5 * ( ( k -= 2 ) * k * k + 2 );
}
},
Quartic: {
In: function ( k ) {
return k * k * k * k;
},
Out: function ( k ) {
return 1 - ( --k * k * k * k );
},
InOut: function ( k ) {
if ( ( k *= 2 ) < 1) return 0.5 * k * k * k * k;
return - 0.5 * ( ( k -= 2 ) * k * k * k - 2 );
}
},
Quintic: {
In: function ( k ) {
return k * k * k * k * k;
},
Out: function ( k ) {
return --k * k * k * k * k + 1;
},
InOut: function ( k ) {
if ( ( k *= 2 ) < 1 ) return 0.5 * k * k * k * k * k;
return 0.5 * ( ( k -= 2 ) * k * k * k * k + 2 );
}
},
Sinusoidal: {
In: function ( k ) {
return 1 - Math.cos( k * Math.PI / 2 );
},
Out: function ( k ) {
return Math.sin( k * Math.PI / 2 );
},
InOut: function ( k ) {
return 0.5 * ( 1 - Math.cos( Math.PI * k ) );
}
},
Exponential: {
In: function ( k ) {
return k === 0 ? 0 : Math.pow( 1024, k - 1 );
},
Out: function ( k ) {
return k === 1 ? 1 : 1 - Math.pow( 2, - 10 * k );
},
InOut: function ( k ) {
if ( k === 0 ) return 0;
if ( k === 1 ) return 1;
if ( ( k *= 2 ) < 1 ) return 0.5 * Math.pow( 1024, k - 1 );
return 0.5 * ( - Math.pow( 2, - 10 * ( k - 1 ) ) + 2 );
}
},
Circular: {
In: function ( k ) {
return 1 - Math.sqrt( 1 - k * k );
},
Out: function ( k ) {
return Math.sqrt( 1 - ( --k * k ) );
},
InOut: function ( k ) {
if ( ( k *= 2 ) < 1) return - 0.5 * ( Math.sqrt( 1 - k * k) - 1);
return 0.5 * ( Math.sqrt( 1 - ( k -= 2) * k) + 1);
}
},
Elastic: {
In: function ( k ) {
var s, a = 0.1, p = 0.4;
if ( k === 0 ) return 0;
if ( k === 1 ) return 1;
if ( !a || a < 1 ) { a = 1; s = p / 4; }
else s = p * Math.asin( 1 / a ) / ( 2 * Math.PI );
return - ( a * Math.pow( 2, 10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) );
},
Out: function ( k ) {
var s, a = 0.1, p = 0.4;
if ( k === 0 ) return 0;
if ( k === 1 ) return 1;
if ( !a || a < 1 ) { a = 1; s = p / 4; }
else s = p * Math.asin( 1 / a ) / ( 2 * Math.PI );
return ( a * Math.pow( 2, - 10 * k) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) + 1 );
},
InOut: function ( k ) {
var s, a = 0.1, p = 0.4;
if ( k === 0 ) return 0;
if ( k === 1 ) return 1;
if ( !a || a < 1 ) { a = 1; s = p / 4; }
else s = p * Math.asin( 1 / a ) / ( 2 * Math.PI );
if ( ( k *= 2 ) < 1 ) return - 0.5 * ( a * Math.pow( 2, 10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) );
return a * Math.pow( 2, -10 * ( k -= 1 ) ) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) * 0.5 + 1;
}
},
Back: {
In: function ( k ) {
var s = 1.70158;
return k * k * ( ( s + 1 ) * k - s );
},
Out: function ( k ) {
var s = 1.70158;
return --k * k * ( ( s + 1 ) * k + s ) + 1;
},
InOut: function ( k ) {
var s = 1.70158 * 1.525;
if ( ( k *= 2 ) < 1 ) return 0.5 * ( k * k * ( ( s + 1 ) * k - s ) );
return 0.5 * ( ( k -= 2 ) * k * ( ( s + 1 ) * k + s ) + 2 );
}
},
Bounce: {
In: function ( k ) {
return 1 - TWEEN.Easing.Bounce.Out( 1 - k );
},
Out: function ( k ) {
if ( k < ( 1 / 2.75 ) ) {
return 7.5625 * k * k;
} else if ( k < ( 2 / 2.75 ) ) {
return 7.5625 * ( k -= ( 1.5 / 2.75 ) ) * k + 0.75;
} else if ( k < ( 2.5 / 2.75 ) ) {
return 7.5625 * ( k -= ( 2.25 / 2.75 ) ) * k + 0.9375;
} else {
return 7.5625 * ( k -= ( 2.625 / 2.75 ) ) * k + 0.984375;
}
},
InOut: function ( k ) {
if ( k < 0.5 ) return TWEEN.Easing.Bounce.In( k * 2 ) * 0.5;
return TWEEN.Easing.Bounce.Out( k * 2 - 1 ) * 0.5 + 0.5;
}
}
};
TWEEN.Interpolation = {
Linear: function ( v, k ) {
var m = v.length - 1, f = m * k, i = Math.floor( f ), fn = TWEEN.Interpolation.Utils.Linear;
if ( k < 0 ) return fn( v[ 0 ], v[ 1 ], f );
if ( k > 1 ) return fn( v[ m ], v[ m - 1 ], m - f );
return fn( v[ i ], v[ i + 1 > m ? m : i + 1 ], f - i );
},
Bezier: function ( v, k ) {
var b = 0, n = v.length - 1, pw = Math.pow, bn = TWEEN.Interpolation.Utils.Bernstein, i;
for ( i = 0; i <= n; i++ ) {
b += pw( 1 - k, n - i ) * pw( k, i ) * v[ i ] * bn( n, i );
}
return b;
},
CatmullRom: function ( v, k ) {
var m = v.length - 1, f = m * k, i = Math.floor( f ), fn = TWEEN.Interpolation.Utils.CatmullRom;
if ( v[ 0 ] === v[ m ] ) {
if ( k < 0 ) i = Math.floor( f = m * ( 1 + k ) );
return fn( v[ ( i - 1 + m ) % m ], v[ i ], v[ ( i + 1 ) % m ], v[ ( i + 2 ) % m ], f - i );
} else {
if ( k < 0 ) return v[ 0 ] - ( fn( v[ 0 ], v[ 0 ], v[ 1 ], v[ 1 ], -f ) - v[ 0 ] );
if ( k > 1 ) return v[ m ] - ( fn( v[ m ], v[ m ], v[ m - 1 ], v[ m - 1 ], f - m ) - v[ m ] );
return fn( v[ i ? i - 1 : 0 ], v[ i ], v[ m < i + 1 ? m : i + 1 ], v[ m < i + 2 ? m : i + 2 ], f - i );
}
},
Utils: {
Linear: function ( p0, p1, t ) {
return ( p1 - p0 ) * t + p0;
},
Bernstein: function ( n , i ) {
var fc = TWEEN.Interpolation.Utils.Factorial;
return fc( n ) / fc( i ) / fc( n - i );
},
Factorial: ( function () {
var a = [ 1 ];
return function ( n ) {
var s = 1, i;
if ( a[ n ] ) return a[ n ];
for ( i = n; i > 1; i-- ) s *= i;
return a[ n ] = s;
};
} )(),
CatmullRom: function ( p0, p1, p2, p3, t ) {
var v0 = ( p2 - p0 ) * 0.5, v1 = ( p3 - p1 ) * 0.5, t2 = t * t, t3 = t * t2;
return ( 2 * p1 - 2 * p2 + v0 + v1 ) * t3 + ( - 3 * p1 + 3 * p2 - 2 * v0 - v1 ) * t2 + v0 * t + p1;
}
}
};
// UMD (Universal Module Definition)
( function ( root ) {
if ( typeof define === 'function' && define.amd ) {
// AMD
define( [], function () {
return TWEEN;
} );
} else if ( typeof exports === 'object' ) {
// Node.js
module.exports = TWEEN;
} else {
// Global variable
root.TWEEN = TWEEN;
}
} )( this );
},{}],6:[function(require,module,exports){
var zeroScale = 0.00001;
AFRAME.registerComponent('fixedsize', {
schema: {
default: 1
},
init: function () {
this.scale = 1;
this.factor = 1;
},
update: function () {
var data = this.data;
this.scale = data === 0 ? zeroScale : data;
},
tick: function (t) {
var object3D = this.el.object3D;
var camera = this.el.sceneEl.camera;
if (!camera) {return;}
var cameraPos = camera.getWorldPosition();
var thisPos = object3D.getWorldPosition();
var distance = thisPos.distanceTo(cameraPos);
// base the factor on the viewport height
var viewport = this.el.sceneEl.argonApp.view.getViewport();
this.factor = 2 * (this.scale / viewport.height);
// let's get the fov scale factor from the camera
fovScale = Math.tan(THREE.Math.degToRad(camera.fov) / 2) * 2;
// if distance < near clipping plane, just use scale. Don't go any bigger
var factor = fovScale * (distance < camera.near ? this.factor : distance * this.factor);
object3D.scale.set(factor, factor, factor);
}
});
AFRAME.registerComponent('trackvisibility', {
schema: {
default: true
},
init: function () {
var self = this;
this.el.addEventListener('referenceframe-statuschanged', function(evt) {
self.updateVisibility(evt);
});
},
updateVisibility: function (evt) {
console.log("visibility changed: " + evt.detail.found)
if (this.data && evt.detail.target === this.el) {
this.el.object3D.visible = evt.detail.found;
}
},
update: function () {
}
});
AFRAME.registerComponent('desiredreality', {
schema: {
src: {type: 'src'},
name: {default: "Custom Reality"}
},
init: function () {
var el = this.el;
if (!el.isArgon) {
console.warn('vuforiadataset should be attached to an <ar-scene>.');
}
},
remove: function () {
var el = this.el;
if (el.isArgon) {
el.argonApp.reality.setDesired(undefined);
}
},
update: function () {
var el = this.el;
var data = this.data;
if (el.isArgon) {
el.argonApp.reality.setDesired({
title: data.name,
uri: Argon.resolveURL(data.src)
});
}
}
});
/**
* based on https://github.com/Utopiah/aframe-triggerbox-component
*
* Usage <a-entity radius=10 trigger="event: mytrigger" /> will make a 10 unit
* trigger region around the entity that emits the event mytrigger_entered once
* the camera moves in and event mytrigger_exited once the camera leaves it.
*
* It can also be used on other entity e.g. an enemy or a bonus.
*
* inspired by https://github.com/atomicguy/aframe-fence-component/
*
*/
AFRAME.registerComponent('trigger', {
multiple: true,
schema: {
radius: {default: 1},
event: {default: 'trigger'}
},
init: function() {
// we don't know yet where we are
this.teststateset = false;
this.laststateinthetrigger = false;
this.name = "";
},
update: function (oldData) {
this.radiusSquared = this.data.radius * this.data.radius;
this.name = this.id ? this.id : "";
},
tick: function() {
// gathering all the data
var data = this.data;
var thisradiusSquared = this.radiusSquared;
var triggereventname = data.event;
var laststateset = this.laststateset;
var laststateinthetrigger = this.laststateinthetrigger;
var camera = this.el.sceneEl.camera;
// camera might not be set immediately
if (!camera) { return; }
var cameraPosition = camera.position;
//var position = this.el.getComputedAttribute('position');
// we don't want the attribute value, we want the "real" value
var distanceSquared = this.el.object3D.position.distanceToSquared(cameraPosition);
if (distanceSquared <= thisradiusSquared) {
// we are in
if (laststateset){
// we were not before
if (!laststateinthetrigger) {
this.el.emit(triggereventname, {name: this.name, inside: true, distanceSquared: distanceSquared});
}
}
this.laststateinthetrigger = true;
} else {
// we are out
if (laststateset){
if (laststateinthetrigger) {
// we were not before
this.el.emit(triggereventname, {name: this.name, inside: false, distanceSquared: distanceSquared});
}
}
this.laststateinthetrigger = false;
}
this.laststateset = true;
},
});
},{}],7:[function(require,module,exports){
var Cesium = Argon.Cesium;
var Cartesian3 = Cesium.Cartesian3;
var ConstantPositionProperty = Cesium.ConstantPositionProperty;
var ReferenceFrame = Cesium.ReferenceFrame;
var ReferenceEntity = Cesium.ReferenceEntity;
var degToRad = THREE.Math.degToRad;
/**
* referenceframe component for A-Frame.
*
* Use an Argon reference frame as the coordinate system for the position and
* orientation for this entity. The position and orientation components are
* expressed relative to this frame.
*
* By default, it uses both the position and orientation of the reference frame
* to define a coordinate frame for this entity, but either may be ignored, in which
* case the identity will be used. This is useful, for example, if you wish to have
* this entity follow the position of a referenceframe but be oriented in the
* coordinates of its parent (typically scene coordinates).
*
* Known frames include ar.user, ar.device, ar.localENU, ar.localEUS,
* ar.device.orientation, ar.device.geolocation, ar.device.display
*/
AFRAME.registerComponent('referenceframe', {
schema: {
lla: { type: 'vec3'},
parent: { default: "FIXED" },
userotation: { default: true},
useposition: { default: true}
},
/**
* Nothing to do
*/
init: function () {
var el = this.el; // entity
var self = this;
this.update = this.update.bind(this);
if (!el.sceneEl) {
console.warn('referenceFrame initialized but no sceneEl');
this.finishedInit = false;
} else {
this.finishedInit = true;
}
// this component only works with an Argon Scene
// (sometimes, el.sceneEl is undefined when we get here. weird)
if (el.sceneEl && !el.sceneEl.isArgon) {
console.warn('referenceframe must be used on a child of a <ar-scene>.');
}
this.localRotationEuler = new THREE.Euler(0,0,0,'XYZ');
this.localPosition = { x: 0, y: 0, z: 0 };
this.localScale = { x: 1, y: 1, z: 1 };
this.knownFrame = false;
el.addEventListener('componentchanged', this.updateLocalTransform.bind(this));
if (el.sceneEl) {
el.sceneEl.addEventListener('argon-initialized', function() {
self.update(self.data);
});
}
},
checkFinished: function () {
if (!this.finishedInit) {
this.finishedInit = true;
this.update(this.data);
}
},
/**
* Update
*/
update: function (oldData) {
if (!this.el.sceneEl) { return; }
var el = this.el;
var argonApp = this.el.sceneEl.argonApp;
var data = this.data;
var lp = el.getAttribute('position');
if (lp) {
this.localPosition.x = lp.x;
this.localPosition.y = lp.y;
this.localPosition.z = lp.z;
} else {
this.localPosition.x = 0;
this.localPosition.y = 0;
this.localPosition.z = 0;
}
var lo = el.getAttribute('rotation');
if (lo) {
this.localRotationEuler.x = degToRad(lo.x);
this.localRotationEuler.y = degToRad(lo.y);
this.localRotationEuler.z = degToRad(lo.z);
} else {
this.localRotationEuler.x = 0;
this.localRotationEuler.y = 0;
this.localRotationEuler.z = 0;
}
var ls = el.getAttribute('scale');
if (ls) {
this.localScale.x = ls.x;
this.localScale.y = ls.y;
this.localScale.z = ls.z;
} else {
this.localScale.x = 1;
this.localScale.y = 1;
this.localScale.z = 1;
}
if (!argonApp) {
return;
}
var cesiumPosition = null;
if (this.attrValue.hasOwnProperty('lla')) {
if (data.parent !== 'FIXED') {
console.warn("Using 'lla' with a 'parent' other than 'FIXED' is invalid. Ignoring parent value.");
data.parent = 'FIXED';
}
cesiumPosition = Cartesian3.fromDegrees(data.lla.x, data.lla.y, data.lla.z);
} else {
cesiumPosition = Cartesian3.ZERO;
}
// parentEntity is either FIXED or another Entity or ReferenceEntity
var parentEntity = this.getParentEntity(data.parent);
// The first time here, we'll create a cesium Entity. If the id has changed,
// we'll recreate a new entity with the new id.
// Otherwise, we just update the entity's position.
if (this.cesiumEntity == null || (el.id !== "" && el.id !== this.cesiumEntity.id)) {
var options = {
position: new ConstantPositionProperty(cesiumPosition, parentEntity),
orientation: Cesium.Quaternion.IDENTITY
}
if (el.id !== '') {
options.id = el.id;
}
this.cesiumEntity = new Cesium.Entity(options);
} else {
this.cesiumEntity.position.setValue(cesiumPosition, parentEntity);
}
},
getParentEntity: function (parent) {
var el = this.el;
var self = this;
var argonApp = this.el.sceneEl.argonApp;
var parentEntity = null;
if (parent === 'FIXED') {
parentEntity = ReferenceFrame.FIXED;
} else {
var vuforia = el.sceneEl.systems["vuforia"];
if (vuforia) {
var parts = parent.split(".");
if (parts.length === 3 && parts[0] === "vuforia") {
// see if it's already a known target entity
console.log("looking for target '" + parent + "'");
parentEntity = vuforia.getTargetEntity(parts[1], parts[2]);
// if not known, subscribe to it
if (parentEntity === null) {
console.log("not found, subscribing to target '" + parent + "'");
parentEntity = vuforia.subscribeToTarget(parts[1], parts[2]);
}
// if still not known, try again when our dataset is loaded
if (parentEntity === null) {
console.log("not loaded, waiting for dataset for target '" + parent + "'");
var name = parts[1];
el.sceneEl.addEventListener('argon-vuforia-dataset-loaded', function(evt) {
console.log('dataset loaded.');
console.log("dataset name '" + evt.detail.target.name + "', our name '" + name + "'");
if (evt.detail.target.name === name) {
self.update(self.data);
}
});
console.log("finished setting up to wait for dataset for target '" + parent + "'");
}
}
}
// if it's a vuforia refernece frame, we might have found it above. Otherwise, look for
// an entity with the parent ID
if (!parentEntity) {
parentEntity = argonApp.context.entities.getById(parent);
}
// If we didn't find the entity at all, create it
if (!parentEntity) {
parentEntity = new ReferenceEntity(argonApp.context.entities, parent);
}
}
return parentEntity;
},
convertReferenceFrame: function (newParent) {
var el = this.el; // entity
// can't do anything without a cesium entity
if (!this.cesiumEntity) {
console.warn("Tried to convertReferenceFrame on element '" + el.id + "' but no cesiumEntity initialized on that element");
return;
}
// eventually we'll convert the current reference frame to a new one, keeping the pose the same
// but a bunch of changes are needed above to make this work
},
updateLocalTransform: function (evt) {
var data = evt.detail.newData;
if (evt.target != this.el) { return; }
if (evt.detail.name == 'rotation') {
this.localRotationEuler.x = degToRad(data.x);
this.localRotationEuler.y = degToRad(data.y);
this.localRotationEuler.z = degToRad(data.z);
} else if (evt.detail.name == 'position') {
this.localPosition.x = data.x;
this.localPosition.y = data.y;
this.localPosition.z = data.z;
} else if (evt.detail.name == 'scale') {
this.localScale.x = data.x;
this.localScale.y = data.y;
this.localScale.z = data.z;
}
},
/**
* update each time step.
*/
tick: function () {
var m1 = new THREE.Matrix4();
return function(t) {
this.checkFinished();
var data = this.data; // parameters
var el = this.el; // entity
var object3D = el.object3D;
var matrix = object3D.matrix;
var argonApp = el.sceneEl.argonApp;
var isNestedEl = !el.parentEl.isScene;
if (!argonApp) { return };
if (this.cesiumEntity) {
var entityPos = argonApp.context.getEntityPose(this.cesiumEntity);
if (entityPos.poseStatus & Argon.PoseStatus.KNOWN) {
this.knownFrame = true;
if (data.userotation) {
object3D.quaternion.copy(entityPos.orientation);
} else if (isNestedEl) {
object3D.rotation.copy(this.localRotationEuler);
object3D.rotation.order = 'YXZ';
}
if (data.useposition) {
object3D.position.copy(entityPos.position);
} else if (isNestedEl) {
object3D.position.copy(this.localPosition);
}
if (entityPos.poseStatus & Argon.PoseStatus.FOUND) {
console.log("reference frame changed to FOUND");
el.emit('referenceframe-statuschanged', {
target: this.el,
found: true
});
}
// if this isn't a child of the scene, move it to world coordinates
if (!el.parentEl.isScene) {
object3D.scale.set(1,1,1);
el.parentEl.object3D.updateMatrixWorld();
m1.getInverse(el.parentEl.object3D.matrixWorld);
matrix.premultiply(m1);
matrix.decompose(object3D.position, object3D.quaternion, object3D.scale );
object3D.updateMatrixWorld();
}
} else {
this.knownFrame = false;
if (entityPos.poseStatus & Argon.PoseStatus.LOST) {
console.log("reference frame changed to LOST");
el.emit('referenceframe-statuschanged', {
target: this.el,
found: false
});
}
}
}
};
}()
});
AFRAME.registerPrimitive('ar-geopose', {
defaultComponents: {
referenceframe: {}
},
mappings: {
lla: 'referenceframe.lla',
userotation: 'referenceframe.userotation',
useposition: 'referenceframe.useposition'
}
});
AFRAME.registerPrimitive('ar-frame', {
defaultComponents: {
referenceframe: {}
},
mappings: {
parent: 'referenceframe.parent',
userotation: 'referenceframe.userotation',
useposition: 'referenceframe.useposition'
}
});
},{}],8:[function(require,module,exports){
var AEntity = AFRAME.AEntity;
var ANode = AFRAME.ANode;
var constants = require('../node_modules/aframe/src/constants/');
var AR_CAMERA_ATTR = "data-aframe-argon-camera";
var style = document.createElement("style");
style.type = 'text/css';
document.head.insertBefore(style, document.head.firstChild);
var sheet = style.sheet;
sheet.insertRule('ar-scene {\n' +
' display: block;\n' +
' position: relative;\n' +
' height: 100%;\n' +
' width: 100%;\n' +
'}\n', 0);
sheet.insertRule('\n' +
'ar-scene video,\n' +
'ar-scene img,\n' +
'ar-scene audio {\n' +
' display: none;\n' +
'}\n', 1);
// want to know when the document is loaded
document.DOMReady = function () {
return new Promise(function(resolve, reject) {
if (document.readyState != 'loading') {
resolve(document);
} else {
document.addEventListener('DOMContentLoaded', function() {
resolve(document);
});
}
});
};
AFRAME.registerElement('ar-scene', {
prototype: Object.create(AEntity.prototype, {
defaultComponents: {
value: {
'canvas': '',
'inspector': '',
'keyboard-shortcuts': ''
}
},
createdCallback: {
value: function () {
this.isMobile = AFRAME.utils.isMobile();
this.isIOS = AFRAME.utils.isIOS();
this.isScene = true;
this.isArgon = true;
this.object3D = new THREE.Scene();
this.systems = {};
this.time = 0;
this.argonApp = null;
this.renderer = null;
this.canvas = null;
// finish initializing
this.init();
}
},
init: {
value: function () {
this.behaviors = [];
this.hasLoaded = false;
this.isPlaying = false;
this.originalHTML = this.innerHTML;
// let's initialize argon immediately, but wait till the document is
// loaded to set up the DOM parts.
//
// Check if Argon is already initialized, don't call init() again if so
if (!Argon.ArgonSystem.instance) {
this.argonApp = Argon.init();
} else {
this.argonApp = Argon.ArgonSystem.instance;
}
this.argonApp.context.setDefaultReferenceFrame(this.argonApp.context.localOriginEastUpSouth);
this.argonRender = this.argonRender.bind(this);
this.argonUpdate = this.argonUpdate.bind(this);
this.initializeArgonView = this.initializeArgonView.bind(this);
this.addEventListener('render-target-loaded', function () {
this.setupRenderer();
// run this whenever the document is loaded, which might be now
document.DOMReady().then(this.initializeArgonView);
});
},
writable: true
},
setupRenderer: {
value: function () {
var canvas = this.canvas;
var antialias = this.getAttribute('antialias') === 'true';
if (THREE.CSS3DArgonRenderer) {
this.cssRenderer = new THREE.CSS3DArgonRenderer();
} else {
this.cssRenderer = null;
}
if (THREE.CSS3DArgonHUD) {
this.hud = new THREE.CSS3DArgonHUD();
} else {
this.hud = null;
}
this.renderer = new THREE.WebGLRenderer({
canvas: canvas,
alpha: true,
antialias: antialias,
logarithmicDepthBuffer: true
});
this.renderer.setPixelRatio(window.devicePixelRatio);
},
writable: true
},
initializeArgonView: {
value: function () {
// need to do this AFTER the DOM is initialized because
// the argon div may not be created yet, which will pull these
// elements out of the DOM, when they might be needed
this.argonApp.view.element.appendChild(this.renderer.domElement);
if (this.cssRenderer) {
this.argonApp.view.element.appendChild(this.cssRenderer.domElement);
}
if (this.hud) {
this.argonApp.view.element.appendChild(this.hud.domElement);
}
this.emit('argon-initialized', {
target: this.argonApp
});
},
writable: true
},
/**
* Handler attached to elements to help scene know when to kick off.
* Scene waits for all entities to load.
*/
attachedCallback: {
value: function () {
this.initSystems();
this.play();
},
writable: window.debug
},
addEventListeners: {
value: function () {
this.argonApp.renderEvent.addEventListener(this.argonRender);
this.argonApp.updateEvent.addEventListener(this.argonUpdate);
},
writable: true
},
removeEventListeners: {
value: function () {
this.argonApp.updateEvent.removeEventListener(this.argonUpdate);
this.argonApp.renderEvent.removeEventListener(this.argonRender);
},
writable: true
},
play: {
value: function () {
var self = this;
if (this.renderStarted) {
AEntity.prototype.play.call(this);
return;
}
this.addEventListener('loaded', function () {
if (this.renderStarted) { return; }
var fixCamera = function () {
var arCameraEl = null;
var cameraEls = self.querySelectorAll('[camera]');
for (i = 0; i < cameraEls.length; i++) {
cameraEl = cameraEls[i];
if (cameraEl.tagName === "AR-CAMERA") {
arCameraEl = cameraEl;
continue;
}
// work around the issue where if this entity was added during
// this sequence of loaded listeners, it will not yet have had
// it's attachedCallback called, which means sceneEl won't yet
// have been added in a-node.js. When it's eventually added,
// a-node will fire nodeready.
if (cameraEl.sceneEl) {
cameraEl.setAttribute('camera', 'active', false);
cameraEl.pause();
} else {
var cameraToDeactivate = cameraEl;
cameraEl.addEventListener('nodeready', function() {
cameraToDeactivate.setAttribute('camera', 'active', false);
cameraToDeactivate.pause();
});
}
}
if (arCameraEl == null) {
var defaultCameraEl = document.createElement('ar-camera');
defaultCameraEl.setAttribute(AR_CAMERA_ATTR, '');
defaultCameraEl.setAttribute(constants.AFRAME_INJECTED, '');
self.appendChild(defaultCameraEl);
}
}
// if there are any cameras aside from the AR-CAMERA loaded,
// make them inactive.
this.addEventListener('camera-set-active', fixCamera);
fixCamera();
if (this.argonApp) {
self.addEventListeners();
} else {
this.addEventListener('argon-initialized', function() {
self.addEventListeners();
});
}
AEntity.prototype.play.call(this);
if (window.performance) {
window.performance.mark('render-started');
}
this.renderStarted = true;
this.emit('renderstart');
});
// setTimeout to wait for all nodes to attach and run their callbacks.
setTimeout(function () {
AEntity.prototype.load.call(self);
});
}
},
/**
* Shuts down scene on detach.
*/
detachedCallback: {
value: function () {
if (this.animationFrameID) {
cancelAnimationFrame(this.animationFrameID);
this.animationFrameID = null;
}
this.removeEventListeners();
}
},
/**
* Reload the scene to the original DOM content.
*
* @param {bool} doPause - Whether to reload the scene with all dynamic behavior paused.
*/
reload: {
value: function (doPause) {
var self = this;
if (doPause) { this.pause(); }
this.innerHTML = this.originalHTML;
this.init();
ANode.prototype.load.call(this, play);
function play () {
if (!self.isPlaying) { return; }
AEntity.prototype.play.call(self);
}
}
},
/**
* Behavior-updater meant to be called from scene render.
* Abstracted to a different function to facilitate unit testing (`scene.tick()`) without
* needing to render.
*/
argonUpdate: {
value: function (frame) {
var time = frame.systemTime;
var timeDelta = frame.deltaTime;
if (this.isPlaying) {
this.tick(time, timeDelta);
}
this.time = time;
},
writable: true
},
tick: {
value: function (time, timeDelta) {
var systems = this.systems;
// Animations.
TWEEN.update(time);
// Components.
this.behaviors.forEach(function (component) {
if (!component.el.isPlaying) { return; }
component.tick(time, timeDelta);
});
// Systems.
Object.keys(systems).forEach(function (key) {
if (!systems[key].tick) { return; }
systems[key].tick(time, timeDelta);
});
}
},
/**
* The render loop.
*
* Updates animations.
* Updates behaviors.
* Renders with request animation frame.
*/
argonRender: {
value: function (frame) {
if (!this.animationFrameID) {
var app = this.argonApp;
this.rAFviewport = app.view.getViewport();
this.rAFsubViews = app.view.getSubviews();
this.animationFrameID = requestAnimationFrame(this.rAFRenderFunc.bind(this));
}
},
writable: true
},
rAFviewport: {
value: null,
writable: true
},
rAFsubViews: {
value: null,
writable: true
},
rAFRenderFunc: {
value: function () {
var scene = this.object3D;
var renderer = this.renderer;
var cssRenderer = this.cssRenderer;
var hud = this.hud;
var camera = this.camera;
if (!this.renderer || !this.camera) {
// renderer hasn't been setup yet
this.animationFrameID = null;
return;
}
// the camera object is created from a camera property on an entity. This should be
// an ar-camera, which will have the entity position and orientation set to the pose
// of the user. We want to make the camera pose
var camEntityPos = null;
var camEntityRot = null;
var camEntityInv = new THREE.Matrix4();
if (camera.parent) {
camera.parent.updateMatrixWorld();
camEntityInv.getInverse(camera.parent.matrixWorld);
// camEntityPos = camera.parent.position.clone().negate();
// camEntityRot = camera.parent.quaternion.clone().inverse();
}
//var viewport = app.view.getViewport()
var viewport = this.rAFviewport;
renderer.setSize(viewport.width, viewport.height);
if (this.cssRenderer) {
cssRenderer.setSize(viewport.width, viewport.height);
}
if (this.hud) {
hud.setSize(viewport.width, viewport.height);
}
// leverage vr-mode. Question: perhaps we shouldn't, perhaps we should use ar-mode?
// unclear right now how much of the components that use vr-mode are re-purposable
//var _a = app.view.getSubviews();
var _a = this.rAFsubViews;
if (this.is('vr-mode')) {
if (_a.length == 1) {
this.removeState('vr-mode');
this.emit('exit-vr', {target: this});
}
} else {
if (_a.length > 1) {
this.addState('vr-mode');
this.emit('enter-vr', {target: this});
}
}
// set the camera properties to the values of the 1st subview.
// While this is arbitrary, it's likely many of these will be the same
// across all subviews, and it's better than leaving them at the
// defaults, which are almost certainly incorrect
camera.near = _a[0].frustum.near;
camera.far = _a[0].frustum.far;
camera.aspect = _a[0].frustum.aspect;
// there is 1 subview in monocular mode, 2 in stereo mode
for (var _i = 0; _i < _a.length; _i++) {
var subview = _a[_i];
var frustum = subview.frustum;
// set the position and orientation of the camera for
// this subview
camera.position.copy(subview.pose.position);
//if (camEntityPos) { camera.position.add(camEntityPos); }
camera.quaternion.copy(subview.pose.orientation);
//if (camEntityRot) { camera.quaternion.multiply(camEntityRot); }
camera.updateMatrix();
camera.matrix.premultiply(camEntityInv);
camera.matrix.decompose(camera.position, camera.quaternion, camera.scale );
// the underlying system provide a full projection matrix
// for the camera.
camera.projectionMatrix.fromArray(subview.projectionMatrix);
// set the viewport for this view
var _b = subview.viewport, x = _b.x, y = _b.y, width = _b.width, height = _b.height;
// set the CSS rendering up, by computing the FOV, and render this view
if (this.cssRenderer) {
//cssRenderer.updateCameraFOVFromProjection(camera);
camera.fov = THREE.Math.radToDeg(frustum.fovy);
cssRenderer.setViewport(x, y, width, height, subview.index);
cssRenderer.render(scene, camera, subview.index);
}
// set the webGL rendering parameters and render this view
renderer.setViewport(x, y, width, height);
renderer.setScissor(x, y, width, height);
renderer.setScissorTest(true);
renderer.render(scene, camera);
if (this.hud) {
// adjust the hud
hud.setViewport(x, y, width, height, subview.index);
hud.render(subview.index);
}
}
this.animationFrameID = null;
},
writable: true
},
/**
* Some mundane functions below here
*/
initSystems: {
value: function () {
var systemsKeys = Object.keys(AFRAME.systems);
systemsKeys.forEach(this.initSystem.bind(this));
}
},
initSystem: {
value: function (name) {
var system;
if (this.systems[name]) { return; }
system = this.systems[name] = new AFRAME.systems[name](this);
system.init();
}
},
/**
* @param {object} behavior - Generally a component. Must implement a .update() method to
* be called on every tick.
*/
addBehavior: {
value: function (behavior) {
var behaviors = this.behaviors;
if (behaviors.indexOf(behavior) !== -1) { return; }
behaviors.push(behavior);
}
},
/**
* Wraps Entity.getAttribute to take into account for systems.
* If system exists, then return system data rather than possible component data.
*/
getAttribute: {
value: function (attr) {
var system = this.systems[attr];
if (system) { return system.data; }
return AEntity.prototype.getAttribute.call(this, attr);
}
},
/**
* `getAttribute` used to be `getDOMAttribute` and `getComputedAttribute` used to be
* what `getAttribute` is now. Now legacy code.
*/
getComputedAttribute: {
value: function (attr) {
warn('`getComputedAttribute` is deprecated. Use `getAttribute` instead.');
this.getAttribute(attr);
}
},
/**
* Wraps Entity.getDOMAttribute to take into account for systems.
* If system exists, then return system data rather than possible component data.
*/
getDOMAttribute: {
value: function (attr) {
var system = this.systems[attr];
if (system) { return system.data; }
return AEntity.prototype.getDOMAttribute.call(this, attr);
}
},
/**
* Wraps Entity.setAttribute to take into account for systems.
* If system exists, then skip component initialization checks and do a normal
* setAttribute.
*/
setAttribute: {
value: function (attr, value, componentPropValue) {
var system = this.systems[attr];
if (system) {
ANode.prototype.setAttribute.call(this, attr, value);
return;
}
AEntity.prototype.setAttribute.call(this, attr, value, componentPropValue);
}
},
/**
* @param {object} behavior - Generally a component. Has registered itself to behaviors.
*/
removeBehavior: {
value: function (behavior) {
var behaviors = this.behaviors;
var index = behaviors.indexOf(behavior);
if (index === -1) { return; }
behaviors.splice(index, 1);
}
},
resize: {
value: function () {
// don't need to do anything, just don't want components who call this to fail
},
writable: window.debug
}
})
});
AFRAME.registerPrimitive('ar-camera', {
defaultComponents: {
camera: {active: true},
referenceframe: {parent: 'ar.user'}
}
});
},{"../node_modules/aframe/src/constants/":3}],9:[function(require,module,exports){
AFRAME.registerSystem('vuforia', {
init: function () {
this.key = "";
this.api = null;
this.datasetMap = {};
this.available = false;
this.sceneEl.addEventListener('argon-initialized', this.startVuforia.bind(this));
},
setKey: function (key) {
this.key = key;
if (this.sceneEl.argonApp) {
this.startVuforia();
}
},
startVuforia: function() {
var self = this;
var sceneEl = this.sceneEl;
var argonApp = sceneEl.argonApp;
// need argon
if (!argonApp) { return; }
// if there is no vuforia API, bye bye
if (!argonApp.vuforia) { return; }
// if already initialized, bye bye
if (this.api) { return; }
// can't initialize if we don't have the key yet
if (this.key === "") { return; }
// try to initialize
argonApp.vuforia.isAvailable().then(function(available) {
if (self.available) {
// this code has already run, through to telling argon to initialize vuforia!
return;
}
// vuforia not available on this platform
if (!available) {
self.available = false;
console.warn('vuforia not available on this platform.');
// in case an application wants to take action when vuforia isn't supported
sceneEl.emit('argon-vuforia-not-available', {
target: sceneEl
});
return;
}
// vuforia is available!
self.available = true;
// try to initialize with our key
argonApp.vuforia.init({
//licenseKey: self.key
encryptedLicenseData: self.key
}).then(function(api) {
// worked! Save the API
self.api = api;
console.log("vuforia initialized!")
// re-call createOrUpdateDataset to create datasets already requested
Object.keys(self.datasetMap).forEach(function(key,index) {
var dataset = self.datasetMap[key];
console.log("re-initializing dataset " + key + " as active=" + dataset.active);
self.createOrUpdateDataset(dataset.component, key, dataset.url, dataset.active)
});
// tell everyone the good news
sceneEl.emit('argon-vuforia-initialized', {
target: sceneEl
});
}).catch(function(err) {
console.log("vuforia failed to initialize: " + err.message);
sceneEl.emit('argon-vuforia-initialization-failed', {
target: sceneEl,
error: err
});
});
});
},
// create an empty dataset
createEmptyDatasetObject: function () {
return {
component: null,
api: null,
url: null,
fetched: false,
loaded: false,
active: false,
targets: {},
trackables: null,
initInProgress: false
};
},
// create a new dataset or update one currently created.
createOrUpdateDataset: function (component, name, url, active) {
var self = this;
var api = this.api;
var dataset = this.datasetMap[name];
// if dataset exists, and matches the previous element, it's because targets were registered before the
// dataset was set up, which is fine. Otherwise, its a duplicate dataset name, which isn't allowed!
if (dataset) {
if (dataset.component) {
if (dataset.component != component) {
console.warn('vuforia.createOrUpdateDataset called multiple times for id=' + name + ', ignoring extra datasets');
return;
}
if (dataset.url != url) {
console.warn("can't change the url for a vuforia dataset once it's created. Ignoring new URL '" + url + "' for dataset '" + name + "'")
return;
}
} else {
// first time this has been called, the dataset is there
// because of calls to set up targets, etc.
dataset.component = component;
dataset.url = url;
}
} else {
// set up the mapping if not there
dataset = this.datasetMap[name] = this.createEmptyDatasetObject();
dataset.component = component;
dataset.url = url;
}
dataset.active = active;
console.log("creating dataset " + name + " active=" + active );
// if vuforia has not yet initialized, return.
if (!api) {
return;
}
if (dataset.initInProgress) {
// just update the active flag, will get dealt with when fetch is done
dataset.active = active;
return;
}
// if the api is initialized, deal with the active state
if (dataset.api) {
dataset.active = active;
// if already fetched, update the active state
if (fetched) {
self.setDatasetActive(name, dataset.active);
}
return;
}
console.log("objectTracker.createDataSet " + name );
dataset.initInProgress = true;
// should have both vuforia and argon initialized by now
api.objectTracker.createDataSet(url).then(function (data) {
console.log("created dataset " + name );
dataset.initInProgress = false;
dataset.api = data;
data.fetch().then(function () {
console.log("fetched dataset " + name );
dataset.fetched = true;
console.log("now, re-activate dataset " + name + " active=" + dataset.active );
self.setDatasetActive(name, dataset.active);
dataset.component.datasetLoaded = true;
console.log("re-activated dataset " + name + " active=" + dataset.active );
// tell everyone the good news
self.sceneEl.emit('argon-vuforia-dataset-downloaded', {
target: dataset.component
});
}).catch(function(err) {
console.log("couldn't download dataset: " + err.message);
sceneEl.emit('argon-vuforia-dataset-download-failed', {
target: sceneEl,
error: err
});
});
});
},
setDatasetActive: function (name, active) {
var self = this;
var api = this.api;
var dataset = this.datasetMap[name];
console.log("make dataset " + name + " active=" +active );
if (!api) {
if (dataset) {
dataset.active = active;
return;
} else {
throw new Error('vuforia.setDatsetActive call before dataset initialized');
}
}
if (!dataset) {
throw new Error('ar-vuforia-dataset "' + name + '" should have been created before being activated');
}
console.log("really making dataset " + name + " active=" +active );
if (!dataset.loaded && active) {
console.log("loading dataset " + name + " active=" +active );
dataset.api.load().then(function () {
console.log("loaded dataset " + name + " active=" +active );
if (dataset.loaded) { return; }
dataset.loaded = true;
dataset.fetched = true;
dataset.trackables = dataset.api.getTrackables();
if (active) {
dataset.active = true;
api.objectTracker.activateDataSet(dataset.api);
}
// re-call subscribeToTarget to subscribe the targets already requested
Object.keys(dataset.targets).forEach(function(key,index) {
console.log("re-subscribing to target " + name + "." + key );
self.subscribeToTarget(name, key, true);
});
// tell everyone the good news. Include the trackables.
self.sceneEl.emit('argon-vuforia-dataset-loaded', {
target: dataset.component,
trackables: dataset.trackables
});
console.log("dataset " + name + " loaded, ready to go");
}).catch(function(err) {
console.log("couldn't load dataset: " + err.message);
sceneEl.emit('argon-vuforia-dataset-load-failed', {
target: sceneEl,
error: err
});
});
} else {
if (dataset.active != active) {
dataset.active = active;
if (active) {
api.objectTracker.activateDataSet(dataset.api);
} else {
api.objectTracker.deactivateDataSet(dataset.api);
}
}
}
},
subscribeToTarget: function (name, target, postLoad) {
var api = this.api;
var dataset = this.datasetMap[name];
// set up the mapping if not there
if (!dataset) {
dataset = this.datasetMap[name] = this.createEmptyDatasetObject();
}
// either create a new target entry and set the count, or add the count to an existing one
var targetItem = dataset.targets[target];
if (!targetItem) {
dataset.targets[target] = 1;
} else if (!postLoad) {
dataset.targets[target] += 1;
}
console.log("subscribe to " + name + "." + target)
if (!api) { return null; }
if (dataset.loaded) {
var tracker = dataset.trackables[target];
console.log("dataset loaded, subscribe to " + name + "." + target)
if (tracker && tracker.id) {
console.log("subscribed to " + name + "." + target + " as " + tracker.id)
return this.sceneEl.argonApp.context.subscribeToEntityById(tracker.id);
} else {
console.warn("can't subscribe to target '" + target + "' does not exist in dataset '" + name + "'");
return null;
}
}
// not loaded yet
return null;
},
getTargetEntity: function (name, target) {
var api = this.api;
var dataset = this.datasetMap[name];
console.log("getTargetEntity " + name + "." + target)
// set up the mapping if not there
if (!api || !dataset || !dataset.loaded) {
return null;
}
// check if we've subscribed. If we haven't, bail out, because we need to
var targetItem = dataset.targets[target];
if (!targetItem) {
return null;
}
var tracker = dataset.trackables[target];
console.log("everything loaded, get " + name + "." + target)
if (tracker && tracker.id) {
console.log("retrieved " + name + "." + target + " as " + tracker.id)
return this.sceneEl.argonApp.context.entities.getById(tracker.id);
} else {
console.warn("can't get target '" + target + "', does not exist in dataset '" + name + "'");
}
return null;
}
});
// the parameter to vuforia is a reference to a element.
// If the element is an a-asset-item, the key should have been downloaded into its data property
// Otherwise, assume the key is in the innerHTML (contents) of the element
AFRAME.registerComponent('vuforiakey', {
schema: {
default: " "
},
/**
* Nothing to do
*/
init: function () {
this.key = null;
},
/**
* Update: first time in, we initialize vuforia
*/
update: function (oldData) {
var el = this.el;
var sceneEl = this.el.sceneEl;
var system = sceneEl.systems["vuforia"];
if (!el.isArgon) {
console.warn('vuforia component can only be applied to <ar-scene>');
return;
}
var keyAsset = el.querySelector(this.data);
if (keyAsset) {
if (keyAsset.isAssetItem) {
this.key = keyAsset.data;
system.setKey(keyAsset.data);
} else {
this.key = keyAsset.innerHTML;
system.setKey(keyAsset.innerHTML);
}
} else {
console.warn('vuforia component cannot find asset "' + this.data + '"');
return;
}
}
});
AFRAME.registerComponent('vuforiadataset', {
multiple: true,
schema: {
src: {type: 'src'},
active: {default: true}
},
init: function () {
var el = this.el;
this.name = "default_dataset";
this.active = false;
this.datasetLoaded = false;
if (!el.isArgon) {
console.warn('vuforiadataset should be attached to an <ar-scene>.');
}
},
remove: function () {
if (this.active) {
var sceneEl = this.el.sceneEl;
var vuforia = sceneEl.systems["vuforia"];
vuforia.setDatasetActive(this.name, false);
}
// remove dataset from system, when argon supports that
},
update: function (oldData) {
var sceneEl = this.el.sceneEl;
this.name = this.id ? this.id : "default_dataset";
var vuforia = sceneEl.systems["vuforia"];
vuforia.createOrUpdateDataset(this, this.name, this.data.src, this.data.active);
}
});
},{}],10:[function(require,module,exports){
AFRAME.registerComponent('css-object', {
schema: {
div: { default: '' },
div2: { default: ''}
},
init: function () {
this.div = null;
this.div2 = null;
},
update: function () {
var data = this.data;
if (data.div === "") { return; }
this.div = document.querySelector(data.div);
if (data.div2 !== "") {
this.div2 = document.querySelector(data.div2);
}
if (this.div) {
if (THREE.CSS3DObject) {
if (this.div2 === null) {
this.el.setObject3D('div', new THREE.CSS3DObject(this.div));
} else {
this.el.setObject3D('div', new THREE.CSS3DObject([this.div, this.div2]));
}
}
}
},
remove: function () {
if (!this.div) { return; }
if (THREE.CSS3DObject) {
this.el.removeObject3D('div');
}
}
});
},{}],11:[function(require,module,exports){
AFRAME.registerComponent('panorama', {
multiple: true,
schema: {
src: {type: 'src'},
lla: {type: 'vec3'},
initial: {default: false},
offsetdegrees: {default: 0},
easing: {default: "Quadratic.InOut"},
duration: {default: 500}
},
init: function () {
var el = this.el;
this.name = "default";
this.active = false;
this.panoRealitySession = undefined;
this.panorama = undefined;
this.showOptions = undefined;
if (!el.isArgon) {
console.warn('panorama should be attached to an <ar-scene>.');
} else {
el.argonApp.reality.connectEvent.addEventListener(this.realityWatcher.bind(this));
el.addEventListener("showpanorama", this.showPanorama.bind(this));
}
},
update: function (oldData) {
this.name = this.id ? this.id : "default";
this.panorama = {
name: this.name,
url: Argon.resolveURL(this.data.src),
longitude: this.data.lla.x,
latitude: this.data.lla.y,
height: this.data.lla.z,
offsetDegrees: this.data.offsetdegrees
};
this.showOptions = {
url: Argon.resolveURL(this.data.src),
transition: {
easing: this.data.easing,
duration: this.data.duration
}
}
},
realityWatcher: function(session) {
// check if the connected supports our panorama protocol
if (session.supportsProtocol('edu.gatech.ael.panorama')) {
// save a reference to this session so our buttons can send messages
this.panoRealitySession = session
// load our panorama
this.panoRealitySession.request('edu.gatech.ael.panorama.loadPanorama', this.panorama);
if (this.data.initial) {
// show yourself!
this.el.emit("showpanorama", {name: this.name});
}
var self = this;
session.closeEvent.addEventListener(function(){
self.panoRealitySession = undefined;
})
}
},
showPanorama: function(evt) {
if (evt.detail.name === this.name) {
this.active = true;
var self = this;
if (this.panoRealitySession) {
this.panoRealitySession.request('edu.gatech.ael.panorama.showPanorama', this.showOptions).then(function(){
console.log("showing panorama: " + self.name);
self.el.emit('showpanorama-success', {
name: self.name
});
}).catch(function(err) {
console.log("couldn't show panorama: " + err.message);
self.el.emit('showpanorama-failed', {
name: self.name,
error: err
});
});
}
} else {
this.active = false;
}
}
});
},{}]},{},[1]);
|
//PageHandlerSpec.js
'use strict';
describe('PageHandler', function(){
beforeEach(module('app.pagehandler'));
var PageHandler;
var randomFloat;
beforeEach(inject(function (_PageHandler_) {
PageHandler = _PageHandler_;
randomFloat = Math.random();
}));
it('should load the module', function(){
expect(!!PageHandler).toBe(true);
});
});
|
'use strict';
$(document).ready(function(){
var $slide1 = $("#slide1"),
$slide1Header = $("#slide1 h1"),
$slide1Img = $('#slide1 img'),
$slide1Text = $('#slide1 p'),
$slide2 = $("#slide2"),
$slide2Header = $("#slide2 h1"),
$slide2Img = $('#slide2 img'),
$slide2Text = $('#slide2 p'),
$slide3 = $("#slide3"),
$slide3Header = $("#slide3 h1"),
$slide4 = $("#slide4"),
$slide4Header = $("#slide4 h1"),
$slide4Img = $('#slide4 img'),
$slide4Legal = $('#legal_copy2'),
$slide4Div = $('#learnMore'),
$slide5 = $('#slide5'),
$slide5Exit = $('#slide5 span'),
$logo = $('#logo');
var mainTimeline = new TimelineLite({onComplete:function(){
// this.restart();
}});
var rollOver = new TimelineLite();
var rollBack = new TimelineLite();
$('#frame').css('display', 'block');
mainTimeline.set($slide5, {autoAlpha: 0, y: '+=1000'})
.from($slide1Header, 0.5, {x: '+=1000', autoAlpha:0, ease:Circ.easeInOut})
.from($slide1Img, 0.5, {x: '-=500', autoAlpha:0, ease:Circ.easeInOut})
.from($slide1Text, 1, {autoAlpha:0, ease:SlowMo.easeInOut})
.to($slide1Header, 0.5, {autoAlpha:0, x: '-=1000', ease:Circ.easeInOut, delay: 3, onComplete: displayNone})
.to($slide1Text, 0.5, {autoAlpha:0, ease:SlowMo.easeInOut}, "-=0.5")
.to($slide1Img, 0.75, {onUpdate: upAndLeft})
.from($slide2Img, 0.5, {autoAlpha:0, ease:Circ.easeInOut}, "-=0.75")
.from($slide2Header, 0.5, {x: '+=1000', autoAlpha:0, ease:Circ.easeInOut})
.from($slide2Text, 0.5, {scale:0.5, autoAlpha:0, ease:SlowMo.easeInOut}, "-=0.5")
.to($slide2, 1, {autoAlpha:0, x: '-=1000', ease:Circ.easeInOut, delay: 3})
.from($slide3Header, 1, {x: '+=1000', autoAlpha:0, ease:Back.easeInOut}, "-=1")
.to($slide3, 1, {autoAlpha:0, x: '-=1000', ease:Circ.easeInOut, delay: 3})
.from($slide4Img, 1, {x: '+=1000', autoAlpha:0, ease:Circ.easeInOut})
.from($slide4Header, 1, {x: '-=1000', autoAlpha:0, ease:Circ.easeInOut}, '-=1')
.from($slide4Legal, 1, {y: '+=1000', autoAlpha:0, ease:SlowMo.easeOut, delay: 0.5})
.from($slide4Div, 1, {y: '+=1000', autoAlpha:0, ease:SlowMo.easeOut}, "-=1");
$slide4Legal.on('click', function(){
rollOver.to($slide4, 1, {autoAlpha:0, y: '-=1000', ease:SlowMo.easeInOut})
.to($logo, 0.5, {autoAlpha: 0}, '-=1')
.to($slide5, 1, {autoAlpha:1, y: '-=1000', ease:SlowMo.easeInOut}, '-=1.2');
});
$slide5Exit.on('click', function(){
rollBack.to($slide5, 1, {autoAlpha:0, y: '+=1000', ease:SlowMo.easeInOut})
.to($slide4, 1, {autoAlpha:1, y: '+=1000', ease:SlowMo.easeInOut}, '-=1.2')
.to($logo, 0.5, {autoAlpha: 1}, '-=1.2');
});
function displayNone() {
$("#slide1 h1").css("display", "none");
}
function upAndLeft() {
$('#phone1').css('top', '35%');
$('#phone1').addClass('animated rotateOutUpLeft');
}
});
|
(function (angular, _, moment) {
'use strict';
angular.module('aif-boolean-input', []).directive('aifBooleanInput', [
function () {
return {
restrict: 'A',
replace: true,
templateUrl: 'templates/aif/boolean-input.html',
scope: {
model: '=',
disable: '=?'
},
link: function (scope, element, attrs) {
scope.$watch('boolValue', function () {
var value = false;
if (scope.boolValue === 'true') {
value = true;
}
scope.model = value;
});
}
};
}
]);
}(window.angular, window._, window.moment));
|
/**
*
* COMPUTE: nanmean
*
*
* DESCRIPTION:
* - Computes the arithmetic mean over an array of values ignoring any values which are not numeric.
*
*
* NOTES:
* [1]
*
*
* TODO:
* [1]
*
*
* LICENSE:
* MIT
*
* Copyright (c) 2014. Athan Reines.
*
*
* AUTHOR:
* Athan Reines. [email protected]. 2014.
*
*/
(function() {
'use strict';
// NANMEAN //
/**
* FUNCTION: nanmean( arr )
* Computes the arithmetic mean over an array of values ignoring any non-numeric values.
*
* @param {Array} arr - array of values
* @returns {Number} mean value
*/
function nanmean( arr ) {
if ( !Array.isArray( arr ) ) {
throw new TypeError( 'mean()::invalid input argument. Must provide an array.' );
}
var len = arr.length,
N = 0,
mu = 0,
diff = 0,
val;
for ( var i = 0; i < len; i++ ) {
val = arr[ i ];
if ( typeof val !== 'number' || val !== val ) {
continue;
}
N += 1;
diff = val - mu;
mu += diff / N;
}
return mu;
} // end FUNCTION nanmean()
// EXPORTS //
module.exports = nanmean;
})(); |
// directive skeleton
taClassified.directive('ta-angry', function(){
return {
restrict: 'E',
template: '>:( <span ng-transclude></span> !!',
transclude: true,
link: function($scope, element, attrs) {
element.css({
'background-color': 'yellow',
color: 'red',
padding: '10px',
'font-weight': 'bold'
});
}
};
});
taClassified.directive('topNav',['settings', function(settings) {
return {
restrict: 'E',
replace: true,
templateUrl: settings.urlTopNavigation
};
}]); |
module.exports = config = function() {
this.port = 3000;
this.startSeed = "";
this.recacheIntervalInSeconds = "60";
this.isDebug = false;
};
|
'use strict';
module.exports = function(app) {
var photos = require('../controllers/photos.server.controller');
var photosPolicy = require('../policies/photos.server.policy');
// Photos Routes
app.route('/api/photos').all()
.get(photos.list).all(photosPolicy.isAllowed)
.post(photos.create);
app.route('/api/photos/:photoId').all(photosPolicy.isAllowed)
.get(photos.read)
.put(photos.update)
.delete(photos.delete);
// Finish by binding the Photo middleware
app.param('photoId', photos.photoByID);
};
|
var should = require( 'should' );
var _ = require( 'underscore' );
var testConfig = require( './config' );
var rongSDK = require( '../index' );
var chatroomIDs = _.keys( testConfig.chatroom.chatroomIdNamePairs );
var chatroomNames = _.values( testConfig.chatroom.chatroomIdNamePairs );
describe( 'Chatroom Test', function() {
before( function( done ) {
// Init the SDK before testing.
rongSDK.init( testConfig.appKey, testConfig.appSecret );
done();
} );
after( function( done ) {
done();
} );
describe( 'Create Chatroom', function() {
it( 'Create chatroom: should return OK', function( done ) {
var chatroomIdNamePairsArray = [];
_.each( chatroomIDs, function( chatroomId ) {
chatroomIdNamePairsArray.push( { id : chatroomId, name : testConfig.chatroom.chatroomIdNamePairs[ chatroomId ] } );
} );
rongSDK.chatroom.create( chatroomIdNamePairsArray , function( err, resultText ) {
should.not.exists( err );
var result = JSON.parse( resultText );
result.code.should.equal( 200 );
done();
} );
} );
} );
describe( 'Destroy Chatroom', function() {
it( 'Destroy a single chatroom: should return OK', function( done ) {
rongSDK.chatroom.destroy( chatroomIDs.pop(), function( err, resultText ) {
should.not.exists( err );
var result = JSON.parse( resultText );
result.code.should.equal( 200 );
done();
} );
} );
it( 'Destroy chatrooms: should return OK', function( done ) {
rongSDK.chatroom.destroy( chatroomIDs.splice( 0, 2 ), function( err, resultText ) {
should.not.exists( err );
var result = JSON.parse( resultText );
result.code.should.equal( 200 );
done();
} );
} );
} );
describe( 'Query Chatroom', function() {
it( 'Query a single chatroom: should return OK', function( done ) {
rongSDK.chatroom.query( chatroomIDs[0], function( err, resultText ) {
should.not.exists( err );
var result = JSON.parse( resultText );
result.code.should.equal( 200 );
var found = _.findWhere( result.chatRooms, { chrmId : chatroomIDs[0] } );
found.should.not.be.undefined;
found.should.have.property( 'chrmId', chatroomIDs[0] );
done();
} );
} );
} );
describe( 'Query Chatroom Users', function() {
it( 'Query the users of a chatroom: should return OK', function( done ) {
rongSDK.chatroom.user.query( chatroomIDs[0], function( err, resultText ) {
should.not.exists( err );
var result = JSON.parse( resultText );
result.code.should.equal( 200 );
done();
} );
} );
} );
} );
|
var assert = require('assert');
var checkval = require('../src/checkval');
describe('Validate alphaNumeric', function() {
it('Throwing errors', function() {
var value, isValid;
value = '1234TeSt';
isValid = true;
try {
checkval().add(value, 'field').alphaNumeric().throw(); // valid
} catch (err) {
isValid = false;
}
assert(isValid);
value = undefined;
isValid = true;
try {
checkval().add(value, 'field').alphaNumeric().throw(); // invalid
} catch (err) {
isValid = false;
}
assert(!isValid);
value = '1234';
isValid = true;
try {
checkval().add(value, 'field').alphaNumeric().throw(); // valid
} catch (err) {
isValid = false;
}
assert(isValid);
value = 'Test';
isValid = true;
try {
checkval().add(value, 'field').alphaNumeric().throw(); // valid
} catch (err) {
isValid = false;
}
assert(isValid);
value = 50;
isValid = true;
try {
checkval().add(value, 'field').alphaNumeric().throw(); // valid
} catch (err) {
isValid = false;
}
assert(isValid);
});
}); |
var express = require('express');
var router = express.Router();
var bodyParser = require('body-parser');
var crypto = require('crypto');
var pool = app.get('pool');
router.use(bodyParser.json());
router.use(bodyParser.urlencoded({ extended: false }));
function hash(password) {
var key = crypto.pbkdf2Sync(password, 'VzSalt', 10000, 512, 'sha512');
return key.toString('hex');
}
function makeLoginPage(data) {
var userName = data.userName;
var pageTitle = data.pageTitle;
var msg = data.msg;
var loginHTML = `
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="apple-touch-icon-precomposed" href="favicon.png">
<link rel="icon" href="/favicon.png">
<title>VzBlog - ${pageTitle}</title>
<meta name="description" content="IMAD NPTEL online course 2016 web app" />
<meta name="keywords" content="Vatsal, imad, nptel, VaTz88" />
<meta name="author" content="Vatsal Joshi" />
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/css/bootstrap.min.css" />
<link href="/css/common.css" rel="stylesheet">
<link href="/css/login.css" rel="stylesheet">
</head>
<body>
<header>
<nav class="navbar navbar-default navbar-static-top">
<div class="container-fluid">
<div class="navbar-header">`;
if (userName) {
loginHTML += `<button type="button" class="navbar-toggle" data-toggle="collapse" data-target="#mainNavBar"><span class="icon-bar"></span><span class="icon-bar"></span><span class="icon-bar"></span></button>`;
}
loginHTML += `<a class="navbar-brand" href="/">VzBlog</a></div>`;
if (userName) {
loginHTML += `<div class="collapse navbar-collapse" id="mainNavBar">
<ul class="nav navbar-nav">
<li id="blogNavButton"><a href="/">Home</a></li>
</ul>
<form id="searchBlog-form" class="navbar-form navbar-left">
<div class="form-group">
<input id="searchBlog-value" type="text" class="form-control" name="searchBlog" placeholder="Search articles, authors" required>
<button id="searchBlog-btn" type="submit" class="btn btn-default">Search</button>
</div>
</form>
<ul class="nav navbar-nav navbar-right">
<li class="dropdown"><a href="#" class="dropdown-toggle" data-toggle="dropdown"><span class="glyphicon glyphicon-user"></span> ${userName}<span class="caret"></span></a>
<ul class="dropdown-menu">
<li><a href="/profile">Profile</a></li>
<li><a href="/dashboard">Dashboard</a></li>
<li><a href="/logout">Log Out</a></li>
</ul>
</li>
</ul>
</div>`;
}
loginHTML += `</div>
</nav>
<div id="loader" style="display:none;"></div>
</header>
<main>
<div class="container">`;
if (msg) {
loginHTML += `<div class="alert alert-info alert-dismissible" role="alert">
<button type="button" class="close" data-dismiss="alert" aria-label="Close"><span aria-hidden="true">×</span></button>
${msg}
</div>`;
}
loginHTML += `<form method="POST" action="/login">
<div class="form-group">
<div class="form-group">
<label for="email">Email address</label>
<input type="email" class="form-control" name="email" id="email" placeholder="Your email id here" required>
</div>
<div class="form-group">
<label for="password">Password</label>
<input type="password" class="form-control" name="password" id="password" placeholder="At least 4 characters long" pattern=".{4,}" required title="Password must be at least 4 characters long">
</div>
</div>
<button type="submit" class="btn btn-default">Log In / Sign Up</button>
</form>
</div>
</main>
<footer class="container-fluid">
<div class="text-center">
<span>Made with ♥ by <a href="http://vatz88.in/" target="_blank">Vatsal</a></span>
</div>
</footer>
<!-- JavaScript -->
<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.1.1/jquery.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/3.3.7/js/bootstrap.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/Readmore.js/2.2.0/readmore.min.js"></script>
<!-- common js -->
<script src="/js/common.js"></script>
<script src="/js/login.js"></script>
</body>
</html>
`;
return loginHTML;
}
router.post('/login', function (req, res) {
var email = req.body.email;
var password = hash(req.body.password);
var re = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
if (!(req.body.password.length >= 4 && re.test(email))) {
res.status(403).send(makeLoginPage(
{
pageTitle: "Login",
userName: false,
msg: "Please give a valid email id and password"
}
));
} else {
pool.connect(function (err, client, done) {
if (err) {
res.status(500).send(err.toString());
}
else {
client.query('SELECT * FROM "user" WHERE UPPER(email_id) = UPPER($1)', [email], function (err, result) {
if (err) {
res.status(500).send(err.toString());
}
if (result.rows.length == 1) {
// user exist
if (password == result.rows[0].password) {
// set session
req.session.auth = { userId: result.rows[0].user_id, username: result.rows[0].username };
res.redirect('/');
} else {
res.status(403).send(makeLoginPage(
{
pageTitle: "Login",
userName: false,
msg: "Email id / Password incorrect. Please try again."
}
));
}
} else if (result.rows.length == 0) {
// create user
var newusername = email.split('@')[0];
client.query('INSERT INTO "user" ("email_id", "password", "username") VALUES ($1, $2, $3)', [(email), (password), (newusername)], function (err, result) {
if (err) {
res.status(500).send(err.toString());
} else {
client.query('SELECT * FROM "user" WHERE UPPER(email_id) = UPPER($1)', [email], function (err, result) {
client.query('INSERT INTO "user_details" ("user_id", "first_name") VALUES ($1, $2)', [result.rows[0].user_id, (newusername)], function (err, result) {
if (err) {
res.status(500).send(err.toString());
}
});
req.session.auth = { userId: result.rows[0].user_id, username: result.rows[0].username };
res.redirect('/profile');
});
}
});
}
done();
});
}
});
}
});
router.get('/login', function (req, res) {
if (req.session && req.session.auth && req.session.auth.userId) {
res.redirect('/');
} else {
res.send(makeLoginPage(
{
pageTitle: "Login",
userName: false,
msg: false
}
));
}
});
router.get('/logout', function (req, res) {
if (req.session && req.session.auth && req.session.auth.userId) {
delete req.session.auth;
}
res.redirect('/login');
});
module.exports = router; |
import mongoose from 'mongoose';
import config from '../config';
import {logDBStartUp} from './loggerService';
export function startDBLink() {
const url = config.dbUrl;
const options = {promiseLibrary: global.Promise};
mongoose.Promise = global.Promise;
mongoose.connect(url, options, err => logDBStartUp(err));
}
|
import chai from 'chai';
import MessageFactory from '../../src/services/message-factory.js';
import { Future } from 'ramda-fantasy';
import { SmsMessage } from '../../src/messages';
import { Typed } from 'typed-immutable';
chai.expect();
const expect = chai.expect;
const assert = chai.assert;
var reader, factory;
const message = {to:'to',message:'msg', from:'me'};
describe("Given a MessageFactory",function(){
before(() => {
reader = MessageFactory();
});
it("should be a Reader", () => expect(reader).to.respondTo('run'));
describe("when run against an environment",function(){
before(() => {
const api = { next: () => '12345' };
const env = { idGenerator: api };
factory = reader.run(env);
});
it("should return an instantiated api",() => expect(factory).to.respondTo('create'));
describe("MessageFactory ~> create", function() {
it("should return an Observable", () => {
expect(factory.create(SmsMessage, 'id', message)).to.respondTo('subscribe');
});
it("should create an SmsMessage", (done) => {
factory.create(SmsMessage, 'id', message).subscribe(
(resp) => {
expect(resp[Typed.typeName]()).to.equal('SmsMessage');
done();
}
);
});
it("should generate the id", (done) => {
factory.create(SmsMessage, 'id', message).subscribe(
(resp) => {
expect(resp.id).to.equal('12345');
done();
}
);
});
it("should fail the future if given bad data", (done) => {
factory.create(SmsMessage, 'id', {}).subscribeOnError(
(err) => {
expect(err.toString()).to.contain("Invalid value");
done();
}
);
});
})
});
}); |
#!/usr/bin/env node
var port = 8594;
var url = "http://127.0.0.1:" + port ;
const socket = require('socket.io-client')(url);
console.log(process.argv);
var args = process.argv;
socket.on('connect', function(){
console.log('connected');
socket.emit('transcodeJob', args);
socket.on('jobComplete', function(){
process.exit(0);
});
});
|
/**
* DevExtreme (ui/slide_out_view.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"),
fx = require("../animation/fx"),
clickEvent = require("../events/click"),
translator = require("../animation/translator"),
hideTopOverlayCallback = require("../mobile/hide_top_overlay").hideCallback,
registerComponent = require("../core/component_registrator"),
Widget = require("./widget/ui.widget"),
Swipeable = require("../events/gesture/swipeable"),
EmptyTemplate = require("./widget/empty_template");
var SLIDEOUTVIEW_CLASS = "dx-slideoutview",
SLIDEOUTVIEW_WRAPPER_CLASS = "dx-slideoutview-wrapper",
SLIDEOUTVIEW_MENU_CONTENT_CLASS = "dx-slideoutview-menu-content",
SLIDEOUTVIEW_CONTENT_CLASS = "dx-slideoutview-content",
SLIDEOUTVIEW_SHIELD_CLASS = "dx-slideoutview-shield",
INVISIBLE_STATE_CLASS = "dx-state-invisible",
ANONYMOUS_TEMPLATE_NAME = "content",
ANIMATION_DURATION = 400;
var animation = {
moveTo: function($element, position, completeAction) {
fx.animate($element, {
type: "slide",
to: {
left: position
},
duration: ANIMATION_DURATION,
complete: completeAction
})
},
complete: function($element) {
fx.stop($element, true)
}
};
var SlideOutView = Widget.inherit({
_getDefaultOptions: function() {
return $.extend(this.callBase(), {
menuPosition: "normal",
menuVisible: false,
swipeEnabled: true,
menuTemplate: "menu",
contentTemplate: "content",
contentOffset: 45
})
},
_defaultOptionsRules: function() {
return this.callBase().concat([{
device: {
android: true
},
options: {
contentOffset: 54
}
}, {
device: function(device) {
return "generic" === device.platform && "desktop" !== device.deviceType
},
options: {
contentOffset: 56
}
}, {
device: {
win: true,
phone: false
},
options: {
contentOffset: 76
}
}])
},
_getAnonymousTemplateName: function() {
return ANONYMOUS_TEMPLATE_NAME
},
_init: function() {
this.callBase();
this.element().addClass(SLIDEOUTVIEW_CLASS);
this._deferredAnimate = void 0;
this._initHideTopOverlayHandler()
},
_initHideTopOverlayHandler: function() {
this._hideMenuHandler = $.proxy(this.hideMenu, this)
},
_initTemplates: function() {
this.callBase();
this._defaultTemplates.menu = new EmptyTemplate(this);
this._defaultTemplates.content = new EmptyTemplate(this)
},
_render: function() {
this.callBase();
this._renderShield();
this._toggleMenuPositionClass();
this._initSwipeHandlers();
this._dimensionChanged()
},
_renderContentImpl: function() {
this._renderMarkup();
var menuTemplate = this._getTemplate(this.option("menuTemplate")),
contentTemplate = this._getTemplate(this.option("contentTemplate"));
menuTemplate && menuTemplate.render({
container: this.menuContent()
});
contentTemplate && contentTemplate.render({
container: this.content(),
noModel: true
})
},
_renderMarkup: function() {
var $wrapper = $("<div>").addClass(SLIDEOUTVIEW_WRAPPER_CLASS);
this._$menu = $("<div>").addClass(SLIDEOUTVIEW_MENU_CONTENT_CLASS);
this._$container = $("<div>").addClass(SLIDEOUTVIEW_CONTENT_CLASS);
$wrapper.append(this._$menu);
$wrapper.append(this._$container);
this.element().append($wrapper);
this._$container.on("MSPointerDown", $.noop)
},
_renderShield: function() {
this._$shield = this._$shield || $("<div>").addClass(SLIDEOUTVIEW_SHIELD_CLASS);
this._$shield.appendTo(this.content());
this._$shield.off(clickEvent.name).on(clickEvent.name, $.proxy(this.hideMenu, this));
this._toggleShieldVisibility(this.option("menuVisible"))
},
_initSwipeHandlers: function() {
this._createComponent(this.content(), Swipeable, {
disabled: !this.option("swipeEnabled"),
elastic: false,
itemSizeFunc: $.proxy(this._getMenuWidth, this),
onStart: $.proxy(this._swipeStartHandler, this),
onUpdated: $.proxy(this._swipeUpdateHandler, this),
onEnd: $.proxy(this._swipeEndHandler, this)
})
},
_isRightMenuPosition: function() {
var invertedPosition = "inverted" === this.option("menuPosition"),
rtl = this.option("rtlEnabled");
return rtl && !invertedPosition || !rtl && invertedPosition
},
_swipeStartHandler: function(e) {
animation.complete(this.content());
var event = e.jQueryEvent,
menuVisible = this.option("menuVisible"),
rtl = this._isRightMenuPosition();
event.maxLeftOffset = +(rtl ? !menuVisible : menuVisible);
event.maxRightOffset = +(rtl ? menuVisible : !menuVisible);
this._toggleShieldVisibility(true)
},
_swipeUpdateHandler: function(e) {
var event = e.jQueryEvent,
offset = this.option("menuVisible") ? event.offset + 1 * this._getRTLSignCorrection() : event.offset;
offset *= this._getRTLSignCorrection();
this._renderPosition(offset, false)
},
_swipeEndHandler: function(e) {
var targetOffset = e.jQueryEvent.targetOffset * this._getRTLSignCorrection() + this.option("menuVisible"),
menuVisible = 0 !== targetOffset;
if (this.option("menuVisible") === menuVisible) {
this._renderPosition(this.option("menuVisible"), true)
} else {
this.option("menuVisible", menuVisible)
}
},
_toggleMenuPositionClass: function() {
var left = SLIDEOUTVIEW_CLASS + "-left",
right = SLIDEOUTVIEW_CLASS + "-right",
menuPosition = this._isRightMenuPosition() ? "right" : "left";
this._$menu.removeClass(left + " " + right);
this._$menu.addClass(SLIDEOUTVIEW_CLASS + "-" + menuPosition)
},
_renderPosition: function(offset, animate) {
var pos = this._calculatePixelOffset(offset) * this._getRTLSignCorrection();
this._toggleHideMenuCallback(offset);
if (animate) {
this._toggleShieldVisibility(true);
animation.moveTo(this.content(), pos, $.proxy(this._animationCompleteHandler, this))
} else {
translator.move(this.content(), {
left: pos
})
}
},
_calculatePixelOffset: function(offset) {
offset = offset || 0;
return offset * this._getMenuWidth()
},
_getMenuWidth: function() {
if (!this._menuWidth) {
var maxMenuWidth = this.element().width() - this.option("contentOffset");
this.menuContent().css("max-width", maxMenuWidth);
var currentMenuWidth = this.menuContent().width();
this._menuWidth = Math.min(currentMenuWidth, maxMenuWidth)
}
return this._menuWidth
},
_animationCompleteHandler: function() {
this._toggleShieldVisibility(this.option("menuVisible"));
if (this._deferredAnimate) {
this._deferredAnimate.resolveWith(this)
}
},
_toggleHideMenuCallback: function(subscribe) {
if (subscribe) {
hideTopOverlayCallback.add(this._hideMenuHandler)
} else {
hideTopOverlayCallback.remove(this._hideMenuHandler)
}
},
_getRTLSignCorrection: function() {
return this._isRightMenuPosition() ? -1 : 1
},
_dispose: function() {
animation.complete(this.content());
this._toggleHideMenuCallback(false);
this.callBase()
},
_visibilityChanged: function(visible) {
if (visible) {
this._dimensionChanged()
}
},
_dimensionChanged: function() {
delete this._menuWidth;
this._renderPosition(this.option("menuVisible"), false)
},
_toggleShieldVisibility: function(visible) {
this._$shield.toggleClass(INVISIBLE_STATE_CLASS, !visible)
},
_optionChanged: function(args) {
switch (args.name) {
case "width":
this.callBase(args);
this._dimensionChanged();
break;
case "contentOffset":
this._dimensionChanged();
break;
case "menuVisible":
this._renderPosition(args.value, true);
break;
case "menuPosition":
this._renderPosition(this.option("menuVisible"), true);
this._toggleMenuPositionClass();
break;
case "swipeEnabled":
this._initSwipeHandlers();
break;
case "contentTemplate":
case "menuTemplate":
this._invalidate();
break;
default:
this.callBase(args)
}
},
menuContent: function() {
return this._$menu
},
content: function() {
return this._$container
},
showMenu: function() {
return this.toggleMenuVisibility(true)
},
hideMenu: function() {
return this.toggleMenuVisibility(false)
},
toggleMenuVisibility: function(showing) {
showing = void 0 === showing ? !this.option("menuVisible") : showing;
this._deferredAnimate = $.Deferred();
this.option("menuVisible", showing);
return this._deferredAnimate.promise()
}
});
registerComponent("dxSlideOutView", SlideOutView);
module.exports = SlideOutView;
module.exports.default = module.exports;
|
'use strict';
var getDomjs = require('es5-ext/function/pluck')('_domjs')
, assign = require('es5-ext/object/assign')
, forEach = require('es5-ext/object/for-each')
, d = require('d')
, autoBind = require('d/auto-bind')
, lazy = require('d/lazy')
, memoizeMethods = require('memoizee/methods-plain')
, validDocument = require('dom-ext/document/valid-document')
, normalize = require('dom-ext/document/#/normalize')
, normalizeRaw = require('dom-ext/document/#/normalize-raw')
, validNode = require('dom-ext/node/valid-node')
, ext = require('./ext')
, construct = require('./_construct-element')
, isArray = Array.isArray, slice = Array.prototype.slice
, create = Object.create, defineProperty = Object.defineProperty
, defineProperties = Object.defineProperties
, getPrototypeOf = Object.getPrototypeOf, Base;
module.exports = Base = function (document) {
if (!(this instanceof Base)) return new Base(document);
this.document = validDocument(document);
defineProperties(this, {
_current: d(document.createDocumentFragment()),
_directives: d(create(null, {
_element: d(create(null))
})),
ns: d(create(this.ns, { _domjs: d(this) }))
});
};
Object.defineProperties(Base.prototype, assign({
collect: d(function (fn) {
var previous = this._current
, current = (this._current = this.document.createDocumentFragment());
fn();
this._current = previous;
return current;
}),
safeCollect: d(function (fn) { return normalize.call(this.document, this.safeCollectRaw(fn)); }),
safeCollectRaw: d(function (fn) {
var direct, result;
result = this.collect(function () { direct = fn(); });
return normalizeRaw.call(this.document, (direct === undefined) ? result : direct);
})
}, lazy({
_commentProto: d(function self() {
var proto = create(getPrototypeOf(this.document.createComment('')), {
domjs: d(this)
});
forEach(ext._comment, function (value, name) {
defineProperty(proto, name, d(value));
});
return proto;
}),
_textProto: d(function () {
var proto = create(getPrototypeOf(this.document.createTextNode('')), {
domjs: d(this)
});
forEach(ext._text, function (value, name) {
defineProperty(proto, name, d(value));
});
return proto;
})
}), memoizeMethods({
_elementProto: d(function (name) {
var proto = create(getPrototypeOf(this.document.createElement(name)));
if (ext[name]) {
forEach(ext[name], function (value, name) {
if (name in proto) return;
defineProperty(proto, name, d(value));
});
}
forEach(ext._element, function (value, name) {
if (name in proto) return;
defineProperty(proto, name, d(value));
});
defineProperties(proto, {
domjs: d(this),
_directives: d(this.getDirectives(name))
});
return proto;
}),
getDirectives: d(function (name) {
return (this._directives[name] = create(this._directives._element));
})
}), {
ns: d(create(null, autoBind({
comment: d('cew', function (data) {
var el = this._current.appendChild(this.document.createComment(data));
el.__proto__ = this._commentProto;
if (el._construct) el._construct.apply(el, slice.call(arguments, 1));
return el;
}),
text: d('cew', function (data/* …data*/) {
var el = this._current.appendChild(this.document.createTextNode(data));
el.__proto__ = this._textProto;
if (el._construct) el._construct.apply(el, slice.call(arguments, 1));
return el;
}),
element: d('cew', function (name/*[, attributes], …content*/) {
var el = this._current.appendChild(this.document.createElement(name));
el.__proto__ = this._elementProto(name);
construct(el, slice.call(arguments, 1));
return el;
}),
normalize: d('cew', function (node) {
var name = validNode(node).nodeName.toLowerCase();
if (name === '#text') node.__proto__ = this._textProto;
else if (name === '#comment') node.__proto__ = this._commentProto;
else if (name[0] !== '#') node.__proto__ = this._elementProto(name);
else throw new TypeError("Unsupported node type");
return node;
}),
insert: d('cew', function (node/*, …nodes*/) {
var dom = normalize.apply(this.document, arguments);
if (isArray(dom)) dom.forEach(this._current.appendChild, this._current);
else if (dom != null) this._current.appendChild(dom);
return dom;
})
}, { resolveContext: getDomjs })))
}));
|
import { testSaga } from 'redux-saga-test-plan';
import { logoutSaga, watchLogoutSaga, logout } from '../logout.module';
import * as api from '../../../core/api';
import { setLocation } from '../../../../common/core/location';
import * as routes from '../../../../../common/routes';
test('logoutSaga should call signInSuccessSaga if login was successful', () => {
testSaga(logoutSaga)
.next()
.call(api.logout)
.next()
.call(setLocation, routes.home)
.next()
.isDone();
});
test('watchLogoutSaga should have proper composition', () => {
testSaga(watchLogoutSaga)
.next()
.takeEveryEffect(logout.getType(), logoutSaga)
.finish()
.isDone();
});
|
var audioCtx = new (window.AudioContext || window.webkitAudioContext || window.audioContext);
// use web audio context api to play sound of notification
var beep = function(duration, frequency, volume, type, callback) {
var oscillator = audioCtx.createOscillator();
var gainNode = audioCtx.createGain();
oscillator.connect(gainNode);
gainNode.connect(audioCtx.destination);
if (volume){gainNode.gain.value = volume;}
if (frequency){oscillator.frequency.value = frequency;}
if (type){oscillator.type = type;}
if (callback){oscillator.onended = callback;}
oscillator.start();
setTimeout(function(){oscillator.stop()}, (duration ? duration : 500));
};
/**
* Show notifications in webpage title
* @param num int
*/
var setNotificationNumber = function (num)
{
if (isNaN(num)) {
return;
}
var regx = /^\@\(\d*\+?\)-> /;
if (num < 1) {
document.title = document.title.replace(regx, '');
return;
}
if (regx.exec(document.title)) {
document.title = document.title.replace(regx, "@(" + num + ")-> ");
} else {
document.title = "@(" + num + ")-> " + document.title;
}
};
if (typeof(CKEDITOR) !== 'undefined') {
CKEDITOR.on('dialogDefinition', function (ev) {
// Take the dialog name and its definition from the event data.
var dialogName = ev.data.name;
var dialogDefinition = ev.data.definition;
// Check if the definition is from the dialog window you are interested in (the "Link" dialog window).
if (dialogName == 'link') {
// Get a reference to the "Link Info" tab.
var infoTab = dialogDefinition.getContents('target');
// Set the default value for the URL field.
var targetField = infoTab.get('linkTargetType');
targetField['default'] = '_blank';
}
});
}
// jquery features
$(document).ready(function(){
// notification function for user pm count block (class="pm-count-block")
var loadPmInterval = false;
var soundPlayed = false;
var summaryBlock = $('#summary-count-block');
var msgBlock = $('#pm-count-block');
var notifyBlock = $('#notify-count-block');
function ajaxNotify() {
$.getJSON(script_url+'/api/profile/notifications?lang='+script_lang, function(resp){
if (resp.status === 1) {
if (resp.summary > 0) {
// play sound notification
if (!soundPlayed) {
// todo: code here
beep(150, 150, 0.6, "triangle");
soundPlayed = true;
}
summaryBlock.addClass('alert-danger', 1000).text(resp.summary);
// set new messages count
if (resp.messages > 0) {
msgBlock.text(resp.messages).addClass('alert-danger', 1000);
} else {
msgBlock.removeClass('alert-danger', 1000).text(0);
}
// set new notifications count
if (resp.notify > 0) {
notifyBlock.text(resp.notify).addClass('alert-danger', 1000);
} else {
notifyBlock.removeClass('alert-danger', 1000).text(0);
}
} else {
summaryBlock.removeClass('alert-danger', 1000).text(0);
}
setNotificationNumber(resp.summary);
} else if (loadPmInterval !== false) { // remove autorefresh
clearInterval(loadPmInterval);
}
}).fail(function(){
if (loadPmInterval !== false) {
clearInterval(loadPmInterval);
}
});
}
// instantly run counter
ajaxNotify();
// make autorefresh every 10 seconds
loadPmInterval = setInterval(ajaxNotify, 10000);
var timer = 0;
// make live search on user keypress in search input
$('#search-line').keypress(function(e){
// bind key code
var keycode = ((typeof e.keyCode != 'undefined' && e.keyCode) ? e.keyCode : e.which);
// check if pressed ESC button to hide dropdown results
if (keycode === 27) {
$('#ajax-result-container').addClass('hidden');
return;
}
// define timer on key press delay to execute
if (timer) {
clearTimeout(timer);
}
timer = setTimeout(makeSearch, 1000);
});
// detect search cancel by pushing esc key
$('#search-line').keydown(function(e){
e = e || window.event;
var isCanceled = false;
// browser 2017 feature for esc key
if ("key" in e) {
isCanceled = (e.key == "Escape" || e.key == "Esc");
} else {
isCanceled = e.keyCode == 27;
}
if (isCanceled) {
// if escape pushed - remove search results & cleanup search input
$('#ajax-result-container').addClass('hidden');
$(this).val('');
}
});
// execute search query by defined timer
function makeSearch() {
var query = $('#search-line').val();
if (query.length < 2) {
return null;
}
// cleanup & make AJAX query with building response
$('#ajax-result-items').empty();
$.getJSON(script_url+'/api/search/index?query='+query+'&lang='+script_lang, function (resp) {
if (resp.status !== 1 || resp.count < 1)
return;
var searchHtml = $('#ajax-carcase-item').clone().removeClass('hidden');
$.each(resp.data, function(relevance, item) {
var searchItem = searchHtml.clone();
searchItem.find('#ajax-search-link').attr('href', site_url + item.uri);
searchItem.find('#ajax-search-title').text(item.title);
searchItem.find('#ajax-search-snippet').text(item.snippet);
$('#ajax-result-items').append(searchItem.html());
searchItem = null;
});
$('#ajax-result-container').removeClass('hidden');
});
}
}); |
"use strict";
const log = require("npmlog");
const dedent = require("dedent");
const getFilteredPackages = require("./lib/get-filtered-packages");
module.exports = filterOptions;
module.exports.getFilteredPackages = getFilteredPackages;
function filterOptions(yargs) {
// Only for 'run', 'exec', 'clean', 'ls', and 'bootstrap' commands
const opts = {
scope: {
describe: "Include only packages with names matching the given glob.",
type: "string",
requiresArg: true,
},
ignore: {
describe: "Exclude packages with names matching the given glob.",
type: "string",
requiresArg: true,
},
"no-private": {
describe: 'Exclude packages with { "private": true } in their package.json.',
type: "boolean",
},
private: {
// proxy for --no-private
hidden: true,
type: "boolean",
},
since: {
describe: dedent`
Only include packages that have been changed since the specified [ref].
If no ref is passed, it defaults to the most-recent tag.
`,
type: "string",
},
"exclude-dependents": {
describe: dedent`
Exclude all transitive dependents when running a command
with --since, overriding the default "changed" algorithm.
`,
conflicts: "include-dependents",
type: "boolean",
},
"include-dependents": {
describe: dedent`
Include all transitive dependents when running a command
regardless of --scope, --ignore, or --since.
`,
conflicts: "exclude-dependents",
type: "boolean",
},
"include-dependencies": {
describe: dedent`
Include all transitive dependencies when running a command
regardless of --scope, --ignore, or --since.
`,
type: "boolean",
},
"include-merged-tags": {
describe: "Include tags from merged branches when running a command with --since.",
type: "boolean",
},
"continue-if-no-match": {
describe: "Don't fail if no package is matched",
hidden: true,
type: "boolean",
},
};
return yargs
.options(opts)
.group(Object.keys(opts), "Filter Options:")
.option("include-filtered-dependents", {
// TODO: remove in next major release
hidden: true,
conflicts: ["exclude-dependents", "include-dependents"],
type: "boolean",
})
.option("include-filtered-dependencies", {
// TODO: remove in next major release
hidden: true,
conflicts: "include-dependencies",
type: "boolean",
})
.check(argv => {
/* eslint-disable no-param-reassign */
if (argv.includeFilteredDependents) {
argv.includeDependents = true;
argv["include-dependents"] = true;
delete argv.includeFilteredDependents;
delete argv["include-filtered-dependents"];
log.warn("deprecated", "--include-filtered-dependents has been renamed --include-dependents");
}
if (argv.includeFilteredDependencies) {
argv.includeDependencies = true;
argv["include-dependencies"] = true;
delete argv.includeFilteredDependencies;
delete argv["include-filtered-dependencies"];
log.warn("deprecated", "--include-filtered-dependencies has been renamed --include-dependencies");
}
/* eslint-enable no-param-reassign */
return argv;
});
}
|
// @flow
import React from 'react'
import { merge } from 'lodash'
import Form from './Form'
import Code from './Code'
import type { ConfigData } from '../types/ConfigData.type'
import '../scss/index.scss'
type State = {
formData: ConfigData
}
class App extends React.Component<{}, State> {
state = {
formData: {
entry: './src/index.js',
output: {
path: 'dist',
filename: 'bundle.js'
},
loaders: {
es6: false,
react: false,
style: null
},
plugins: {
extract: false,
extractFile: 'css/styles.css'
}
}
}
handleFormChange = (data: ConfigData) => {
this.setState(prevState => ({
formData: merge({}, prevState.formData, data)
}))
}
render() {
return (
<div>
<header>
<div className="container">
<h1 className="title">Webpack Config Generator</h1>
<p className="description">
Use it as a starting point for your project, or to just learn how
different options reflect on the configuration.
</p>
</div>
</header>
<main>
<div className="container row">
<div className="col">
<Form
data={this.state.formData}
onChange={this.handleFormChange}
/>
</div>
<div className="col">
<Code data={this.state.formData} />
</div>
</div>
</main>
<footer>
<div className="container">
<p>
<strong>Webpack Config Generator</strong> by Douglas Matoso (
<a
href="https://twitter.com/doug2k1"
target="_blank"
rel="noopener noreferrer"
>
@doug2k1
</a>)
</p>
<p>
Source-code on{' '}
<a
href="https://github.com/doug2k1/webpack-generator"
target="_blank"
rel="noopener noreferrer"
>
GitHub
</a>
</p>
</div>
</footer>
</div>
)
}
}
export default App
|
import Client from './client'
import Utils from './utils'
import Storage from './storage'
var Marketcloud = Marketcloud || {}
// The client class
Marketcloud.Client = Client
// Interface to browser storage methods
Marketcloud.Storage = Storage
// Utility functions
Marketcloud.Utils = Utils
// Exporting to the window object for compatibility
if ("undefined" !== typeof window)
window.Marketcloud = Marketcloud
// Exporting to commonjs
if ("undefined" !== typeof module)
module.exports = Marketcloud;
// exporting to ES6
export default Marketcloud
export {
Client,
Storage,
Utils
}
|
// ==UserScript==
// @name Kykyruza EAN Saver
// @namespace https://github.com/alezhu/kykyryza_ean_saver
// @version 1.1.1
// @description Manage kykyruza EAN on login page
// @author alezhu
// @match https://oplata.kykyryza.ru/personal/pub/Entrance*
// @match https://classic.oplata.kykyryza.ru/personal/pub/Entrance*
// @grant none
// @source https://raw.githubusercontent.com/alezhu/kykyryza_ean_saver/master/kykyryza_ean_saver.user.js
// @updateURL https://raw.githubusercontent.com/alezhu/kykyryza_ean_saver/master/kykyryza_ean_saver.user.js
// @downloadURL https://raw.githubusercontent.com/alezhu/kykyryza_ean_saver/master/kykyryza_ean_saver.user.js
// ==/UserScript==
(function(){
var STORAGE_NAME = "alezhu.kykyryza.cards";
this.form = null;
this.input_ean = null;
this.cards = [];
this._editable_loaded = false;
this.load_cards = function( ){
var cards_str = "";
cards_str = localStorage[STORAGE_NAME];
//chrome.storage.sync.get("data", function(object) { cards_str = object.data; });
if(cards_str) {
var cards_pair = cards_str.split("\n");
for(var index = 0; index < cards_pair.length;index++){
var pair = cards_pair[index].split("|");
cards.push( { ean : pair[0] , comment : pair[1] } );
}
}
};
this.save_cards = function() {
var cards_pair= [];
for(var index = 0; index < cards.length;index++){
var card = cards[index];
var pair = card.ean + '|' + card.comment;
cards_pair.push(pair);
}
var cards_str = cards_pair.join("\n");
localStorage[STORAGE_NAME] = cards_str;
//chrome.storage.sync.set({ data: cards_str} );
};
this.add_cards2page = function( ) {
var last_div = form.find("div:last");
for(var index = 0; index < cards.length;index++){
var card = cards[index];
var div = add_card2page(card);
last_div.after(div);
last_div = div;
}
};
this.is_ean_exists = function(ean) {
for(var index = 0; index < cards.length;index++){
if(cards[index].ean === ean) return true;
}
return false;
};
this.add_card2page = function(card) {
load_editable( );
return $("<div></div>")
.attr("id",card.ean)
.append(
$('<a href="#" target="_blank" class="pseudo-link" style="display:inline-block">[X]</a>')
.click(function(event) {
event.preventDefault( );
delete_card($(this).data("ean"));
return false;
}).data("ean",card.ean)
)
.append(
$('<a href="#" target="_blank" class="pseudo-link" style="display:inline-block;width:8em;margin: 0em 1em"></a>')
.text(card.ean)
.click(function(event) {
event.preventDefault( );
input_ean.val( $( this ).data("ean"));
return false;
}).data("ean",card.ean)
)
.append(
$('<a href="#" class="pseudo-link editable" style="display:inline-block;"></a>')
.text( getComment(card.comment) )
.myeditable( )
.click(function(event) {
event.preventDefault( );
return false;
})
.data("ean",card.ean)
)
;
};
this.add_card = function(ean,comment) {
var card = { ean : ean , comment : comment } ;
cards.push( card );
save_cards( );
return add_card2page(card);
};
this.delete_card = function(ean) {
for(var index = 0; index < cards.length;index++){
var card = cards[index];
if(card.ean == ean) {
cards.splice(index,1);
break;
}
}
save_cards( );
delete_card_from_page( ean );
};
this.delete_card_from_page = function(ean) {
$("div#"+ean).remove( );
};
this.load_editable = function( ){
if(_editable_loaded) return;
$.getScript("https://rawgit.com/tuupola/jquery_jeditable/master/jquery.jeditable.js", function() {
_editable_loaded = true;
$(".editable").myeditable( );
});
};
this.getComment = function ( comment ){
return (comment == "undefined" || comment === "")?"<Комментарий>":comment;
};
//-------------
load_cards( );
$.fn.myeditable = function() {
if(this.editable) this.editable( function(value, settings) {
console.log(this);
console.log(value);
console.log(settings);
value = value.replace("/\|/gi", '');
var ean = $(this).text(value).data("ean");
for(var index = 0; index < cards.length;index++){
var card = cards[index];
if(card.ean == ean) {
card.comment = value;
break;
}
}
save_cards( );
},{
style : "inherit",
data: function(value, settings) {
var retval = value.replace(/[<>|]/gi, '').replace(/<Комментарий>/gi,"");
return retval;
}
});
return this;
};
$(document).ready(function(){
form = $('form[name="login"]');
input_ean = form.find("input#ean");
if(cards.length > 0)add_cards2page( );
var last_div = form.find("div:last");
var add_link = $('<a href="#" target="_blank" class="pseudo-link js-popup">Добавить карту из поля ввода</a>');
add_link.click(function(event) {
event.preventDefault( );
ean = input_ean.val();
if(!is_ean_exists(ean)){
form.find("div:last").after(add_card(ean,""));
}
return false;
});
last_div.after(add_link);
add_link.insertAfter(last_div);
});
})();
|
import pickBy from 'lodash/pickBy';
import uniq from 'lodash/uniq';
import unionBy from 'lodash/unionBy';
import union from 'lodash/union';
import shuffled from 'kolibri.utils.shuffled';
import { assessmentMetaDataState } from 'kolibri.coreVue.vuex.mappers';
import { ContentNodeResource, ContentNodeSearchResource } from 'kolibri.resources';
import { getContentNodeThumbnail } from 'kolibri.utils.contentNode';
import router from 'kolibri.coreVue.router';
import { ContentNodeKinds } from 'kolibri.coreVue.vuex.constants';
import { PageNames } from '../../constants';
import { MAX_QUESTIONS } from '../../constants/examConstants';
import { createExam } from '../examShared/exams';
import selectQuestions from './selectQuestions';
export function resetExamCreationState(store) {
store.commit('RESET_STATE');
}
export function addToSelectedExercises(store, exercises) {
store.commit('ADD_TO_SELECTED_EXERCISES', exercises);
return updateAvailableQuestions(store);
}
export function removeFromSelectedExercises(store, exercises) {
store.commit('REMOVE_FROM_SELECTED_EXERCISES', exercises);
return updateAvailableQuestions(store);
}
export function updateAvailableQuestions(store) {
const { selectedExercises } = store.state;
// Only bother checking this if there is any doubt that we have sufficient
// questions available. If we have selected more exercises than we allow questions
// then we are sure to have this.
if (Object.keys(selectedExercises).length > 0) {
if (MAX_QUESTIONS > Object.keys(selectedExercises).length) {
return ContentNodeResource.fetchNodeAssessments(Object.keys(selectedExercises)).then(resp => {
store.commit('SET_AVAILABLE_QUESTIONS', resp.data);
});
} else {
store.commit('SET_AVAILABLE_QUESTIONS', MAX_QUESTIONS);
return Promise.resolve();
}
}
store.commit('SET_AVAILABLE_QUESTIONS', 0);
return Promise.resolve();
}
export function fetchAdditionalSearchResults(store, params) {
let kinds;
if (params.kind) {
kinds = [params.kind];
} else {
kinds = [ContentNodeKinds.EXERCISE, ContentNodeKinds.TOPIC];
}
return ContentNodeSearchResource.fetchCollection({
getParams: {
...pickBy({
search: params.searchTerm,
channel_id: params.channelId,
exclude_content_ids: store.state.searchResults.contentIdsFetched,
}),
kind_in: kinds,
},
}).then(results => {
return filterAndAnnotateContentList(results.results).then(contentList => {
const updatedChannelIds = union(store.state.searchResults.channel_ids, results.channel_ids);
const updatedContentKinds = union(
store.state.searchResults.content_kinds,
results.content_kinds
).filter(kind => [ContentNodeKinds.TOPIC, ContentNodeKinds.EXERCISE].includes(kind));
const updatedResults = unionBy([...store.state.searchResults.results, ...contentList], 'id');
const updatedContentIdsFetched = uniq([
...store.state.searchResults.contentIdsFetched,
...results.results.map(({ content_id }) => content_id),
]);
const searchResults = {
total_results: store.state.searchResults.total_results,
channel_ids: updatedChannelIds,
content_kinds: updatedContentKinds,
results: updatedResults,
contentIdsFetched: updatedContentIdsFetched,
};
store.commit('SET_SEARCH_RESULTS', searchResults);
});
});
}
export function createExamAndRoute(store, { classId }) {
const exam = {
collection: classId,
title: store.state.title,
seed: store.state.seed,
question_count: store.state.selectedQuestions.length,
question_sources: store.state.selectedQuestions,
assignments: [classId],
learners_see_fixed_order: store.state.learnersSeeFixedOrder,
date_archived: null,
date_activated: null,
};
return createExam(store, exam).then(() => {
return router.push({ name: PageNames.EXAMS });
});
}
function _getTopicsWithExerciseDescendants(topicIds = []) {
return new Promise(resolve => {
if (!topicIds.length) {
resolve([]);
return;
}
const topicsNumAssessmentDescendantsPromise = ContentNodeResource.fetchDescendantsAssessments(
topicIds
);
topicsNumAssessmentDescendantsPromise.then(response => {
const topicsWithExerciseDescendants = [];
response.data.forEach(descendantAssessments => {
if (descendantAssessments.num_assessments > 0) {
topicsWithExerciseDescendants.push({
id: descendantAssessments.id,
numAssessments: descendantAssessments.num_assessments,
exercises: [],
});
}
});
ContentNodeResource.fetchDescendants(
topicsWithExerciseDescendants.map(topic => topic.id),
{
descendant_kind: ContentNodeKinds.EXERCISE,
}
).then(response => {
response.data.forEach(exercise => {
const topic = topicsWithExerciseDescendants.find(t => t.id === exercise.ancestor_id);
topic.exercises.push(exercise);
});
resolve(topicsWithExerciseDescendants);
});
});
});
}
export function filterAndAnnotateContentList(childNodes) {
return new Promise(resolve => {
const childTopics = childNodes.filter(({ kind }) => kind === ContentNodeKinds.TOPIC);
const topicIds = childTopics.map(({ id }) => id);
const topicsThatHaveExerciseDescendants = _getTopicsWithExerciseDescendants(topicIds);
topicsThatHaveExerciseDescendants.then(topics => {
const childNodesWithExerciseDescendants = childNodes
.map(childNode => {
const index = topics.findIndex(topic => topic.id === childNode.id);
if (index !== -1) {
return { ...childNode, ...topics[index] };
}
return childNode;
})
.filter(childNode => {
if (childNode.kind === ContentNodeKinds.TOPIC && (childNode.numAssessments || 0) < 1) {
return false;
}
return true;
});
const contentList = childNodesWithExerciseDescendants.map(node => ({
...node,
thumbnail: getContentNodeThumbnail(node),
}));
resolve(contentList);
});
});
}
export function updateSelectedQuestions(store) {
if (!Object.keys(store.state.selectedExercises).length) {
store.commit('SET_SELECTED_QUESTIONS', []);
return Promise.resolve();
}
return new Promise(resolve => {
// If there are more exercises than questions, no need to fetch them all so
// choose N at random where N is the the number of questions.
const exerciseIds = shuffled(
Object.keys(store.state.selectedExercises),
store.state.seed
).slice(0, store.state.numberOfQuestions);
store.commit('LOADING_NEW_QUESTIONS', true);
// The selectedExercises don't have the assessment metadata yet so fetch that
ContentNodeResource.fetchCollection({
getParams: { ids: exerciseIds },
}).then(contentNodes => {
store.commit('UPDATE_SELECTED_EXERCISES', contentNodes); // update with full metadata
const exercises = {};
contentNodes.forEach(exercise => {
exercises[exercise.id] = exercise;
});
const availableExercises = exerciseIds.filter(id => exercises[id]);
const exerciseTitles = availableExercises.map(id => exercises[id].title);
const questionIdArrays = availableExercises.map(
id => assessmentMetaDataState(exercises[id]).assessmentIds
);
store.commit(
'SET_SELECTED_QUESTIONS',
selectQuestions(
store.state.numberOfQuestions,
availableExercises,
exerciseTitles,
questionIdArrays,
store.state.seed
)
);
store.commit('LOADING_NEW_QUESTIONS', false);
resolve();
});
});
}
|
// good/index/index.js
var app = getApp();
Page({
/**
* 页面的初始数据
*/
data: {
good_list_url:"api/good/list",//商品列表--分页获取
aside_nav:"api/good/category",//侧栏分类导航栏
good_list_obj:{//分页获取商品的参数
page:1,//当前页默认1开始
dataCount:10,//每页显示的数据
sort: 1, //排序，sort=1：升序 ， sort=0：降序
flag: 0, //flag=0综合， flag=1销量， flag=2价格
keyword: "",//搜索关键词，如果没有默认为空
good_class_id: 0,//商品分类ID，如果没有选择分类good_class_id默认设置为0
open_id: app.get_openid(),//消费者微信公众号open_id
},
good_list_info:[],//商品列表信息
aside_nav_info:[],//侧栏导航栏
good_list_isloading:-1,//订单数据是否加载完成1是0否
price_sort:1,//升序 0降序---价格排序控制
sort_style:1,//当前的排序方式 1综合2销量3价格-- 控制字体的颜色
list_type:2,//列表排序方式1单列2多列
is_show_mask:false,//是否隐藏遮罩层
mask_data: { //遮罩层过渡样式
mask_style: "opacity:0"
},
head_position_style: 0,//搜索栏的定位方式是否为fixed 1是0否 在侧栏滑出时定位为fixed
window_height:0,//窗口的可用高度 用来计算二级导航栏的高度
aside_style:"display:none",//侧栏滑出的高度
is_show_aside:0,//侧栏是否滑出1是0否
sec_nav:"",//二级导航栏控制
search_keyword:"",//搜索的关键字
},
/**
* 生命周期函数--监听页面加载
*/
onLoad: function (options) {
// 获取商品列表的排列方式 有缓存获取缓存的排列方式 没有缓存默认两列
try {
var list_type = wx.getStorageSync("list_show_type");
if(list_type==1||list_type==2){
this.setData({
list_type: list_type
})
}
} catch (e) { }
},
/**
* 生命周期函数--监听页面初次渲染完成
*/
onReady: function () {
var that = this;
this.get_aside_nav();//获取导航信息
wx.getSystemInfo({
success: function(res) {
that.setData({
window_height: res.windowHeight,
})
},
});
console.log("read");
},
/**
* 生命周期函数--监听页面显示
*/
onShow: function () {
try {
var keyword = wx.getStorageSync("search_keyword");
console.log(keyword, "word");
if (keyword != undefined) {
this.setData({
search_keyword: keyword,
'good_list_obj.keyword': keyword
})
}
} catch (e) { }
this.get_good_list(); //获取商品列表信息
},
/**
* 生命周期函数--监听页面隐藏
*/
onHide: function () {
},
/**
* 生命周期函数--监听页面卸载
*/
onUnload: function () {
},
/**
* 页面相关事件处理函数--监听用户下拉动作
*/
onPullDownRefresh: function () {
},
/**
* 页面上拉触底事件的处理函数
*/
onReachBottom: function (event) {
if (this.data.good_list_isloading == 0) {
this.get_good_list(1);
}
},
/**
* 用户点击右上角分享
*/
onShareAppMessage: function () {
},
//单列和两列的切换
nav_tab:function(){
if (this.data.list_type == 1) {
this.setData({
list_type: 2
})
}else{
this.setData({
list_type: 1
})
}
try{
wx.setStorageSync("list_show_type", this.data.list_type);
}catch(e){}
},
//显示侧栏
show_aside:function(){
var id = wx.createSelectorQuery();
var id_height = 0;
var that = this;
id.select('#search_head').boundingClientRect();
id.exec(function(res){
console.log(res[0].height);
id_height = res[0].height;
var h = that.data.window_height - id_height;
if (that.data.is_show_aside==0){
that.setData({
aside_style: "height:" + h + "px;display:block;top:" + id_height + "px;",
is_show_mask: true,
head_position_style: 1,
is_show_aside: 1
})
setTimeout(function () {
that.setData({
aside_style: "height:" + h + "px;display:block;left:0;top:" + id_height + "px;",
'mask_data.mask_style': "opacity:1"
})
}, 50)
}else{
that.setData({
aside_style: "height:" + h + "px;display:block;left:-550rpx;top:" + id_height + "px;",
'mask_data.mask_style': "opacity:0",
})
setTimeout(function () {
that.setData({
is_show_mask: false,
head_position_style: 0,
is_show_aside: 0
})
}, 500)
}
});
},
mask_hide: function () {
this.show_aside();
},
//获取商品列表
get_good_list:function(i){
var that = this;
var a=i;
if(i==1){
var page = that.data.good_list_obj.page+1;
that.setData({
"good_list_obj.page":page
})
console.log(i);
}
//获取列表
wx.request({
url: app.reqUrl(that.data.good_list_url),
data: that.data.good_list_obj,
success: function (res) {
console.log(res, "user/info",a);
if (res.statusCode!="200"){
wx.showLoading({
title: 'get_list_info 错误',
mask: true
})
return;
}
var len = res.data.Data.length;
if (len < that.data.good_list_obj.dataCount){//获取的数据数量小于每页的数量---商品已经获取完毕
that.setData({
good_list_isloading:1 //商品获取完成
})
}else{
that.setData({
good_list_isloading: 0 //商品没有全部获取
})
}
if(a==1){ //再次加载数据--滑到底部
var arr = that.data.good_list_info;
var info = res.data.Data;
for (var i = 0; i < info.length; i++) {
arr.push(info[i]);
}
console.log(arr,"arr");
that.setData({
good_list_info: arr
})
}else{ //首次加载数据--
that.setData({
good_list_info: res.data.Data
})
}
},
fail:function(res){
app.load_fail("err:get_good_list");
}
})
},
//获取侧栏导航分类
get_aside_nav:function(){
var that = this;
wx.request({
url: app.reqUrl(that.data.aside_nav),
data:{
parent_id:0
},
success:function(res){
if (res.statusCode != "200") {
wx.showLoading({
title: 'get_aside_nav 错误',
mask: true
})
return;
}
that.setData({
aside_nav_info:res.data.Data
})
console.log(that.data.aside_nav_info,"导航")
},
fail:function(){
app.load_fail("err:get_aside_nav");
}
})
},
//综合排序
click_flat_sort:function(){
var that = this;
that.setData({
'good_list_obj.page': 1,//默认当天页为1
'good_list_obj.sort': 1,//升序
'good_list_obj.flag': 0,//综合
sort_style:1,//颜色控制器
price_sort:1
})
that.get_good_list();//获取数据
},
//销量排序
click_sale_sort:function(){
var that = this;
that.setData({
'good_list_obj.page': 1,//默认当天页为1
'good_list_obj.sort': 0,//降序
'good_list_obj.flag': 1,//销量
sort_style:2,
price_sort:1,
})
that.get_good_list();//获取数据
},
//价格排序
click_price_sort:function(){
var that = this;
if (that.data.price_sort==1){
that.setData({
price_sort:0,
'good_list_obj.page':1,//默认当天页为1
'good_list_obj.sort': 0,//默认当天页为降序
'good_list_obj.flag':2,//价格排序
sort_style:3,
})
}else{
that.setData({
price_sort: 1,
'good_list_obj.page': 1,//默认当天页为1
'good_list_obj.sort': 1,//升序
'good_list_obj.flag': 2,
sort_style: 3,
})
}
that.get_good_list();//获取数据
},
//展开二级导航栏
click_aside_nav:function(event){
var that = this;
var sec = event.currentTarget.dataset.sec;
if (sec == that.data.sec_nav) {//再次点击如果已经展开则合并
that.setData({
sec_nav: ""
});
} else {//展开当前选项
that.setData({
sec_nav: sec
});
}
},
//点击分类
click_sec_nav:function(event){
var that = this;
var name = event.currentTarget.dataset.name;//当前导航的名称
var id = event.currentTarget.dataset.id;//分类id
var t = event.currentTarget.dataset.type;//当前是一级分类还是二级分类t=1 一级分类 2二级分类
that.setData({
search_keyword:name
})
if(t==1){
name="";
that.click_aside_nav_search(name, id);
}else{
that.click_aside_nav_search(name, id);
}
that.show_aside();
},
//执行搜索
click_aside_nav_search:function(value,id){
var that = this;
that.setData({
'good_list_obj.page': 1,//当前页默认1开始
'good_list_obj.sort': 1,//排序，sort=1：升序 ， sort=0：降序
'good_list_obj.flag': 0, //flag=0综合， flag=1销量， flag=2价格
'good_list_obj.keyword': value,//搜索关键词，如果没有默认为空
'good_list_obj.good_class_id': id,//商品分类ID，如果没有选择分类good_class_id默认设置为0
'good_list_obj.open_id': app.get_openid(),//消费者微信公众号open_id
sort_style: 1,//颜色控制器
price_sort: 1,
});
that.get_good_list();//获取数据
},
//初始搜索--
def_search:function(){
var that = this;
that.setData({
"good_list_obj.page":1,
"good_list_obj.dataCount":10,
"good_list_obj.sort":1,
"good_list_obj.flag":0,
"good_list_obj.keyword":"",
"good_list_obj.good_class_id":0,
"good_list_obj.open_id":app.get_openid(),
search_keyword: "",//关键字
sort_style: 1,//颜色控制器
price_sort: 1,
});
that.get_good_list();//获取数据
wx.setStorageSync("search_keyword", "");
},
}) |
var express = require('express');
var router = express.Router();
var tool = require('../utility/tool');
var path = require('path');
var passport = require('passport');
var Strategy = require('passport-local').Strategy;
var logger = require('../utility/logger');
passport.use(new Strategy(
{
usernameField: 'UserName',//页面上的用户名字段的name属性值
passwordField: 'Password'//页面上的密码字段的name属性值
},
function (username, password, cb) {
var account = require('/data/ginnier/account');
//自己判断用户是否有效
if (username === account.UserName && password === account.Password) {
//验证通过
return cb(null, account);
} else {
//验证失败
return cb(null, false);
}
}));
passport.serializeUser(function (user, cb) {
cb(null, user.Id);
});
passport.deserializeUser(function (id, cb) {
var account = require('/data/ginnier/account');
if (account.Id === id) {
return cb(null, account);
} else {
return cb(err);
}
});
//后台登录页面
router.get('/login', function (req, res, next) {
tool.getConfig(path.join(__dirname, '../config/settings.json'), function (err, settings) {
if (err) {
next(err);
} else {
res.render('auth/login', {
config: settings,
title: settings['SiteName'] + ' - ' + res.__("auth.title")
});
}
});
});
//提交登录请求
router.post('/login', function (req, res, next) {
passport.authenticate('local', function (err, user, info) {
if (err) {
next(err);
} else if (!user) {
logger.errLogger(req, new Error(res.__("auth.wrong_info")));
res.json({
valid: false
});
} else {
//登录操作
req.logIn(user, function (err) {
var returnTo = '/admin';
if (err) {
next(err);
} else {
//尝试跳转之前的页面
if (req.session.returnTo) {
returnTo = req.session.returnTo;
}
res.json({
valid: true,
returnTo: returnTo
});
}
});
}
})(req, res, next);
});
//退出登录
router.post('/logout',
function (req, res) {
req.logout();
res.redirect('/login');
});
module.exports = router;
|
var gulp = require('gulp'),
less = require('gulp-less'),
rename = require('gulp-rename');
gulp.task('js', function () {
gulp.src('src/**/*.js')
.pipe(rename('popper.js'))
.pipe(gulp.dest('dist/'));
});
gulp.task('less', function () {
gulp.src('src/**/*.less')
.pipe(less())
.pipe(gulp.dest('dist/'));
});
gulp.task('build', ['js', 'less']);
gulp.task('default', ['build']);
gulp.task('watch', ['build'], function () {
gulp.watch('src/**/*.js', ['js']);
gulp.watch('src/**/*.less', ['less']);
});
|
// ==UserScript==
// @name Myoot
// @description Prevents any stray audio clips from automatically playing on AIM games.
// @namespace [email protected]
// @include http://aimgames.forummotion.com/*
// @version 1.9
// @icon http://www.mediafire.com/convkey/c313/jnx13q9ha6j01w9zg.jpg
// ==/UserScript==
var loaded = false;
var poster = [];
var clips_stopped = 0;
if (!loaded) {
for (var mute = 0; mute < document.getElementsByTagName('audio').length; mute++) {
document.getElementsByTagName('audio')[mute].muted = 1; //mute
document.getElementsByTagName('audio')[mute].loop = false; //disable loop
try { //no way to be sure with html
poster[mute] = document.getElementsByTagName('audio')[mute].parentElement.parentElement.parentElement.parentElement.parentElement.parentElement.parentElement.parentElement.parentElement.parentElement.parentElement.parentElement.children[0].children[0].children[1].children[0].children[0].children[0].innerHTML;
} catch (err) {
console.log('audio ' + mute + ' not in post');
}
clips_stopped++;
}
}
loaded = true;
console.log(clips_stopped + ' clips stopped!');
if (clips_stopped == 1 && poster.length > 0) { // not in a preview page and audio is in a spoiler
window.alert(clips_stopped + ' clips stopped!\nThe URL for the clip is: ' + document.getElementsByTagName('audio')[0].currentSrc + '\nThe asshole cunt dickbag motherfucker is: ' + poster[0]);
} else if (clips_stopped > 1 && poster.length > 0) { // not in a preview page and audio is in a spoiler
var asshole_dickbag_cunt_motherfucker = '';
for (var i in poster) { // add every dickbag motherfucker to the list
asshole_dickbag_cunt_motherfucker += poster[mute];
if (i != poster.length)
asshole_dickbag_cunt_motherfucker += ', '; // make it look shiny
}
window.alert(clips_stopped + ' clips stopped!\nThe URL for the first clip is: ' + document.getElementsByTagName('audio')[0].currentSrc + '\nThe asshole cunt dickbag motherfuckers are: ' + asshole_dickbag_cunt_motherfucker);
} else if (clips_stopped > 1) { // in a preview page or audio isn't in a spoiler
window.alert(clips_stopped + " clips stopped! Couldn't automatically identify the asshat.");
} else {
//what
} |
/**
* @license Copyright (c) 2003-2013, CKSource - Frederico Knabben. All rights reserved.
* For licensing, see LICENSE.md or http://ckeditor.com/license
*/
CKEDITOR.editorConfig = function( config ) {
// Define changes to default configuration here.
// For the complete reference:
// http://docs.ckeditor.com/#!/api/CKEDITOR.config
// The toolbar groups arrangement, optimized for two toolbar rows.
config.toolbarGroups = [
{ name: 'clipboard', groups: [ 'clipboard', 'undo' ] },
{ name: 'editing', groups: [ 'find', 'selection', 'spellchecker' ] },
{ name: 'links' },
{ name: 'insert' },
{ name: 'forms' },
{ name: 'tools' },
{ name: 'document', groups: [ 'mode', 'document', 'doctools' ] },
{ name: 'others' },
'/',
{ name: 'basicstyles', groups: [ 'basicstyles', 'cleanup' ] },
{ name: 'paragraph', groups: [ 'list', 'indent', 'blocks', 'align', 'bidi' ] },
{ name: 'styles' },
{ name: 'colors' },
{ name: 'about' }
];
// Remove some buttons, provided by the standard plugins, which we don't
// need to have in the Standard(s) toolbar.
config.removeButtons = '';
// Se the most common block elements.
config.format_tags = 'p;h1;h2;h3;h4;h5;h6';
// Make dialogs simpler.
config.removeDialogTabs = 'image:advanced;link:advanced';
config.allowedContent = true;
};
|
// Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
// MIT License. See license.txt
// -------------
// Menu Display
// -------------
// $(cur_frm.wrapper).on("grid-row-render", function(e, grid_row) {
// if(grid_row.doc && grid_row.doc.fieldtype=="Section Break") {
// $(grid_row.row).css({"font-weight": "bold"});
// }
// })
frappe.ui.form.on('DocType', {
refresh: function(frm) {
if(frm.is_new() && (user !== "Administrator" || !frappe.boot.developer_mode)) {
frm.set_value("custom", 1);
frm.toggle_enable("custom", 0);
}
if(!frappe.boot.developer_mode && !frm.doc.custom) {
// make the document read-only
frm.set_read_only();
}
if(frm.is_new()) {
if (!(frm.doc.permissions && frm.doc.permissions.length)) {
frm.add_child('permissions', {role: 'System Manager'});
}
} else {
frm.toggle_enable("engine", 0);
}
// set label for "In List View" for child tables
frm.get_docfield('fields', 'in_list_view').label = frm.doc.istable ?
__('In Grid View') : __('In List View');
}
})
// for legacy... :)
cur_frm.cscript.validate = function(doc, cdt, cdn) {
doc.server_code_compiled = null;
}
|
'use strict';
/* Directives */
var app = angular.module('guestBook.directives', []);
app.directive('message', function() {
return {
restrict: 'EA',
scope: {
from: '@',
text: '@',
date: '@',
modDate: '@'
},
replace: true,
template: '<div>' +
'<p>From: {{ from }}</p>' +
'<p class="messageText">{{ text }}</p>' +
'<p>' +
' <span>Date: {{ date | date : "yyyy-MM-dd HH:mm:ss" }}</span>' +
' <span class="modDate" ng-show="modDate">| ' +
'Modified by admin: {{ modDate | date : "yyyy-MM-dd HH:mm:ss"}}' +
' </span>' +
'</p>' +
'</div>'
}
}).directive('adminMessage', function() {
var deleteMessageID,
editMessageID;
function showDelete(id) {
return id === deleteMessageID;
}
function showEdit(id) {
return id === editMessageID;
}
function cancelDelete() {
deleteMessageID = "";
}
function promptDelete(id) {
deleteMessageID = id;
}
function promptEdit(id, text) {
editMessageID = id;
}
return {
restrict: 'EA',
scope: {
id: '@',
from: '@',
text: '@',
date: '@',
modDate: '@'
},
replace: true,
template: '<div class="admin-msg">' +
'<div class="admin_btns">' +
' <span ng-show="!showDelete(id) && !showEdit(id)"">' +
' <a href="#" ng-click="promptDelete(id)">Delete</a> | ' +
' <a href="#" ng-click="promptEdit(id, text)">Edit</a>' +
' </span>' +
' <span ng-show="showDelete(id)">Are you sure? ' +
' <a href="#" ng-click="delete(id)">Yes</a> | ' +
' <a href="#" ng-click="cancelDelete()">No</a>' +
' </span>' +
' <span ng-show="showEdit(id)">' +
' <a href="#" ng-click="saveEdit()">Save</a> | ' +
' <a href="#" ng-click="cancelEdit()">Cancel</a>' +
' </span>' +
'</div>' +
'<p>From: {{ from }}</p>' +
'<textarea class="form-control" rows="3" ng-show="showEdit(id)"' +
'ng-model="editText"></textarea>' +
'<p class="messageText" ng-show="!showEdit(id)">{{ text }}</p>' +
'<p>' +
' <span>Date: {{ date | date : "yyyy-MM-dd HH:mm:ss" }}</span>' +
' <span class="modDate" ng-show="modDate">| ' +
'Modified by admin: {{ modDate | date : "yyyy-MM-dd HH:mm:ss"}}' +
' </span>' +
'</p>' +
'</div>',
link: function(scope, element, attrs) {
scope.showDelete = showDelete;
scope.showEdit = showEdit;
scope.cancelDelete = cancelDelete;
scope.promptDelete = promptDelete;
scope.promptEdit = promptEdit;
scope.editText = attrs.text;
scope.delete = scope.$parent.delete;
scope.cancelEdit = function() {
scope.editText = attrs.text;
editMessageID = "";
};
scope.saveEdit = function() {
scope.$parent.saveEdit(scope.id, scope.editText);
editMessageID = "";
};
}
}
}); |
import EmberObject from '@ember/object';
import RSVP from 'rsvp';
import {defineProperty} from '@ember/object';
import {describe, it} from 'mocha';
import {expect} from 'chai';
import {settled} from '@ember/test-helpers';
import {setupTest} from 'ember-mocha';
import {task} from 'ember-concurrency';
describe('Unit: Controller: editor', function () {
setupTest();
describe('generateSlug', function () {
it('should generate a slug and set it on the post', async function () {
let controller = this.owner.lookup('controller:editor');
controller.set('slugGenerator', EmberObject.create({
generateSlug(slugType, str) {
return RSVP.resolve(`${str}-slug`);
}
}));
controller.set('post', EmberObject.create({slug: ''}));
controller.set('post.titleScratch', 'title');
await settled();
expect(controller.get('post.slug')).to.equal('');
await controller.get('generateSlug').perform();
expect(controller.get('post.slug')).to.equal('title-slug');
});
it('should not set the destination if the title is "(Untitled)" and the post already has a slug', async function () {
let controller = this.owner.lookup('controller:editor');
controller.set('slugGenerator', EmberObject.create({
generateSlug(slugType, str) {
return RSVP.resolve(`${str}-slug`);
}
}));
controller.set('post', EmberObject.create({slug: 'whatever'}));
expect(controller.get('post.slug')).to.equal('whatever');
controller.set('post.titleScratch', '(Untitled)');
await controller.get('generateSlug').perform();
expect(controller.get('post.slug')).to.equal('whatever');
});
});
describe('saveTitle', function () {
beforeEach(function () {
this.controller = this.owner.lookup('controller:editor');
this.controller.set('target', {send() {}});
});
it('should invoke generateSlug if the post is new and a title has not been set', async function () {
let {controller} = this;
controller.set('target', {send() {}});
defineProperty(controller, 'generateSlug', task(function * () {
this.set('post.slug', 'test-slug');
yield RSVP.resolve();
}));
controller.set('post', EmberObject.create({isNew: true}));
expect(controller.get('post.isNew')).to.be.true;
expect(controller.get('post.titleScratch')).to.not.be.ok;
controller.set('post.titleScratch', 'test');
await controller.get('saveTitle').perform();
expect(controller.get('post.titleScratch')).to.equal('test');
expect(controller.get('post.slug')).to.equal('test-slug');
});
it('should invoke generateSlug if the post is not new and it\'s title is "(Untitled)"', async function () {
let {controller} = this;
controller.set('target', {send() {}});
defineProperty(controller, 'generateSlug', task(function * () {
this.set('post.slug', 'test-slug');
yield RSVP.resolve();
}));
controller.set('post', EmberObject.create({isNew: false, title: '(Untitled)'}));
expect(controller.get('post.isNew')).to.be.false;
expect(controller.get('post.titleScratch')).to.not.be.ok;
controller.set('post.titleScratch', 'New Title');
await controller.get('saveTitle').perform();
expect(controller.get('post.titleScratch')).to.equal('New Title');
expect(controller.get('post.slug')).to.equal('test-slug');
});
it('should not invoke generateSlug if the post is new but has a title', async function () {
let {controller} = this;
controller.set('target', {send() {}});
defineProperty(controller, 'generateSlug', task(function * () {
expect(false, 'generateSlug should not be called').to.equal(true);
yield RSVP.resolve();
}));
controller.set('post', EmberObject.create({
isNew: true,
title: 'a title'
}));
expect(controller.get('post.isNew')).to.be.true;
expect(controller.get('post.title')).to.equal('a title');
expect(controller.get('post.titleScratch')).to.not.be.ok;
controller.set('post.titleScratch', 'test');
await controller.get('saveTitle').perform();
expect(controller.get('post.titleScratch')).to.equal('test');
expect(controller.get('post.slug')).to.not.be.ok;
});
it('should not invoke generateSlug if the post is not new and the title is not "(Untitled)"', async function () {
let {controller} = this;
controller.set('target', {send() {}});
defineProperty(controller, 'generateSlug', task(function * () {
expect(false, 'generateSlug should not be called').to.equal(true);
yield RSVP.resolve();
}));
controller.set('post', EmberObject.create({isNew: false}));
expect(controller.get('post.isNew')).to.be.false;
expect(controller.get('post.title')).to.not.be.ok;
controller.set('post.titleScratch', 'title');
await controller.get('saveTitle').perform();
expect(controller.get('post.titleScratch')).to.equal('title');
expect(controller.get('post.slug')).to.not.be.ok;
});
});
});
|
module.exports = ({
platosPorPromos
}) => {
return Promise.all(
platosPorPromos.upsert({
platoId: 4,
promoId: 1,
}),
platosPorPromos.upsert({
platoId: 3,
promoId: 2,
})
);
};
|
import { expect } from 'chai';
import {
describeModule,
it
} from 'ember-mocha';
describeModule(
'route:characters/edit',
'CharactersEditRoute',
{
// Specify the other units that are required for this test.
// needs: ['controller:foo']
},
function() {
it('exists', function() {
let route = this.subject();
expect(route).to.be.ok;
});
}
);
|
'use strict';
var React = require('react');
var validator = require('../validation');
var formValidation = new validator();
var Radio = React.createClass({ displayName: 'Radio',
propTypes: {
required: React.PropTypes.bool,
name: React.PropTypes.string.isRequired,
label: React.PropTypes.string,
groupClassName: React.PropTypes.string,
labelClassName: React.PropTypes.string,
errorClassName: React.PropTypes.string,
fieldClassName: React.PropTypes.string,
validationEvent: React.PropTypes.string,
readOnly: React.PropTypes.bool,
disabled: React.PropTypes.bool,
checked: React.PropTypes.bool,
id: React.PropTypes.string,
swagger: React.PropTypes.shape({
schema: React.PropTypes.object.isRequired,
definition: React.PropTypes.string.isRequired }),
field: React.PropTypes.string
},
getDefaultProps: function getDefaultProps() {
return {
checked: false
};
},
getInitialState: function getInitialState() {
return {
errors: '',
isValid: this.props.value ? true : false,
checked: this.props.defaultChecked ? true : false
};
},
onChange: function onChange(event) {
this.setState({
checked: this.state.checked ? false : true
});
// Run the parent onChange if it exists
if (this.props.onChange) {
this.props.onChange(this);
}
// Validate on onChange if explicitely set
if (this.props.validationEvent && this.props.validationEvent.toLowerCase() === 'change') {
this.validate(this.state.value, event.target.dataset);
}
},
getSwaggerProperties: function getSwaggerProperties(schema, definition) {
if (!schema || !definition) {
return null;
}
var definitions = schema.definitions;
var properties = {};
Object.keys(definitions).map(function (def) {
if (def === definition.replace('#/definitions/', '')) {
properties = definitions[def].properties;
}
});
return properties;
},
validate: function validate(value, dataset) {
var results = [];
var messages = [];
var swagger = this.props.swagger;
if (swagger && swagger.schema && swagger.definition) {
if (this.props.field) {
var properties = this.getSwaggerProperties(swagger.schema, swagger.definition);
if (properties) {
results = formValidation.swaggerValidate(value, this.props.field, swagger.schema, properties, swagger.definition);
}
} else {
console.warn('The property \'field\' must be part of this.props for swagger validation. Check if this.props.field is defined.');
}
} else {
results = formValidation.validate(value, dataset);
}
results.forEach(function (result) {
if (result.error) {
messages.push(result.message);
}
});
this.setState({
errors: messages,
isValid: messages.length === 0 ? true : false
});
},
render: function render() {
var _this = this;
var preLabel = undefined;
var postLabel = undefined;
var errors = [];
if (this.props.preLabel || this.props.label) {
preLabel = React.createElement('label', { htmlFor: this.props.id, className: this.props.labelClassName }, this.props.preLabel || this.props.label);
} else if (this.props.postLabel) {
postLabel = React.createElement('label', { htmlFor: this.props.id, className: this.props.labelClassName }, this.props.postLabel);
}
if (this.state.errors.length > 0) {
this.state.errors.forEach(function (error, i) {
// used an arrow function to keep the context of this
errors.push(React.createElement('span', { key: 'errmessage' + i, className: _this.props.errorClassName }, error));
});
}
return React.createElement('div', { className: this.props.groupClassName }, preLabel, React.createElement('input', {
id: this.props.id,
type: 'radio',
name: this.props.name,
'data-validate-required': this.props.required,
'data-isvalid': this.state.isValid,
onChange: this._onChange,
value: this.props.value,
fieldClassName: this.props.fieldClassName,
readOnly: this.props.readOnly,
disabled: this.props.disabled,
checked: this.state.checked }), postLabel, errors);
}
});
module.exports = Radio; |
import webpack from 'webpack';
import ExtractTextPlugin from 'extract-text-webpack-plugin';
import config from '../../config';
import _debug from 'debug';
const debug = _debug('app:webpack:production');
export default (webpackConfig) => {
debug('Create configuration.');
if (config.compiler_source_maps) {
debug('Source maps enabled for production.');
webpackConfig.devtool = 'source-map';
} else {
debug('Source maps are disabled in production.');
}
debug('Apply ExtractTextPlugin to CSS loaders.');
webpackConfig.module.loaders = webpackConfig.module.loaders.map(loader => {
if (!loader.loaders ||
!loader.loaders.find(name => /css/.test(name.split('?')[0]))) {
return loader;
}
const [first, ...rest] = loader.loaders;
loader.loader = ExtractTextPlugin.extract(first, rest.join('!'));
delete loader.loaders;
return loader;
});
debug('Inject ExtractText and UglifyJS plugins.');
webpackConfig.plugins.push(
new ExtractTextPlugin('[name].[contenthash].css', {
allChunks: true,
}),
new webpack.optimize.UglifyJsPlugin({
compress: {
unused: true,
dead_code: true,
},
})
);
return webpackConfig;
};
|
/*
* GET home page.
*/
module.exports = function(app) {
app.get('/', function(req, res) {
console.log('inside app.get("/")');
res.render('index', {
title: 'The web app running Express Node Jade MongoDB'
});
});
}; |
/*
* ***** BEGIN LICENSE BLOCK *****
* Copyright (c) 2011-2012 VMware, Inc.
*
* For the license see COPYING.
* ***** END LICENSE BLOCK *****
*/
var AjaxBasedTransport = function() {};
AjaxBasedTransport.prototype = new BufferedSender();
AjaxBasedTransport.prototype.run = function(ri, trans_url,
url_suffix, Receiver, AjaxObject) {
var that = this;
that.ri = ri;
that.trans_url = trans_url;
that.send_constructor(createAjaxSender(AjaxObject));
that.poll = new Polling(ri, Receiver,
trans_url + url_suffix, AjaxObject);
};
AjaxBasedTransport.prototype.doCleanup = function() {
var that = this;
if (that.poll) {
that.poll.abort();
that.poll = null;
}
that.send_destructor();
};
|
export const root = (typeof self === 'object' && self.self === self && self) ||
(typeof global === 'object' && global.global === global && global) ||
this
|
'use strict';
var should = require('should');
var gutil = require('gulp-util');
var path = require('path');
var fs = require('fs');
var sass = require('../index');
var rimraf = require('rimraf');
var gulp = require('gulp');
var sourcemaps = require('gulp-sourcemaps');
var postcss = require('gulp-postcss');
var autoprefixer = require('autoprefixer-core');
var tap = require('gulp-tap');
var globule = require('globule');
var createVinyl = function createVinyl(filename, contents) {
var base = path.join(__dirname, 'scss');
var filePath = path.join(base, filename);
return new gutil.File({
'cwd': __dirname,
'base': base,
'path': filePath,
'contents': contents || fs.readFileSync(filePath)
});
};
describe('gulp-sass -- async compile', function() {
it('should pass file when it isNull()', function(done) {
var stream = sass();
var emptyFile = {
'isNull': function () {
return true;
}
};
stream.on('data', function(data) {
data.should.equal(emptyFile);
done();
});
stream.write(emptyFile);
});
it('should emit error when file isStream()', function (done) {
var stream = sass();
var streamFile = {
'isNull': function () {
return false;
},
'isStream': function () {
return true;
}
};
stream.on('error', function(err) {
err.message.should.equal('Streaming not supported');
done();
});
stream.write(streamFile);
});
it('should compile an empty sass file', function(done) {
var sassFile = createVinyl('empty.scss');
var stream = sass();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
should.equal(path.basename(cssFile.path), 'empty.css');
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, 'expected/empty.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should compile a single sass file', function(done) {
var sassFile = createVinyl('mixins.scss');
var stream = sass();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, 'expected/mixins.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should compile multiple sass files', function(done) {
var files = [
createVinyl('mixins.scss'),
createVinyl('variables.scss')
];
var stream = sass();
var mustSee = files.length;
var expectedPath = 'expected/mixins.css';
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
if (cssFile.path.indexOf('variables') !== -1) {
expectedPath = 'expected/variables.css';
}
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, expectedPath), 'utf8')
);
mustSee--;
if (mustSee <= 0) {
done();
}
});
files.forEach(function (file) {
stream.write(file);
});
});
it('should compile files with partials in another folder', function(done) {
var sassFile = createVinyl('inheritance.scss');
var stream = sass();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, 'expected/inheritance.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should handle sass errors', function(done) {
var errorFile = createVinyl('error.scss');
var stream = sass();
stream.on('error', function(err) {
// Error must include message body
err.message.indexOf('property "font" must be followed by a \':\'').should.not.equal(-1);
// Error must include file error occurs in
err.message.indexOf('test/scss/error.scss').should.not.equal(-1);
// Error must include line and column error occurs on
err.message.indexOf('on line 2').should.not.equal(-1);
// Error must include relativePath property
err.relativePath.should.equal('test/scss/error.scss');
done();
});
stream.write(errorFile);
});
it('should preserve the original sass error message', function(done) {
var errorFile = createVinyl('error.scss');
var stream = sass();
stream.on('error', function(err) {
// Error must include original error message
err.messageOriginal.indexOf('property "font" must be followed by a \':\'').should.not.equal(-1);
// Error must not format or change the original error message
err.messageOriginal.indexOf('on line 2').should.equal(-1);
done();
});
stream.write(errorFile);
});
it('should compile a single sass file if the file name has been changed in the stream', function(done) {
var sassFile = createVinyl('mixins.scss');
var stream;
// Transform file name
sassFile.path = path.join(path.join(__dirname, 'scss'), 'mixin--changed.scss');
stream = sass();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
cssFile.path.split('/').pop().should.equal('mixin--changed.css');
should.exist(cssFile.relative);
should.exist(cssFile.contents);
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, 'expected/mixins.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should preserve changes made in-stream to a Sass file', function(done) {
var sassFile = createVinyl('mixins.scss');
var stream;
// Transform file name
sassFile.contents = new Buffer('/* Added Dynamically */' + sassFile.contents.toString());
stream = sass();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
String(cssFile.contents).should.equal('/* Added Dynamically */\n' +
fs.readFileSync(path.join(__dirname, 'expected/mixins.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should work with gulp-sourcemaps', function(done) {
var sassFile = createVinyl('inheritance.scss');
// Expected sources are relative to file.base
var expectedSources = [
'includes/_cats.scss',
'includes/_dogs.sass',
'inheritance.scss'
];
var stream;
sassFile.sourceMap = '{' +
'"version": 3,' +
'"file": "scss/subdir/multilevelimport.scss",' +
'"names": [],' +
'"mappings": "",' +
'"sources": [ "scss/subdir/multilevelimport.scss" ],' +
'"sourcesContent": [ "@import ../inheritance;" ]' +
'}';
stream = sass();
stream.on('data', function(cssFile) {
should.exist(cssFile.sourceMap);
cssFile.sourceMap.sources.should.eql(expectedSources);
done();
});
stream.write(sassFile);
});
it('should compile a single indented sass file', function(done) {
var sassFile = createVinyl('indent.sass');
var stream = sass();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, 'expected/indent.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should parse files in sass and scss', function(done) {
var files = [
createVinyl('mixins.scss'),
createVinyl('indent.sass')
];
var stream = sass();
var mustSee = files.length;
var expectedPath = 'expected/mixins.css';
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
if (cssFile.path.indexOf('indent') !== -1) {
expectedPath = 'expected/indent.css';
}
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, expectedPath), 'utf8')
);
mustSee--;
if (mustSee <= 0) {
done();
}
});
files.forEach(function (file) {
stream.write(file);
});
});
});
describe('gulp-sass -- sync compile', function() {
beforeEach(function(done) {
rimraf(path.join(__dirname, '/results/'), done);
});
it('should pass file when it isNull()', function(done) {
var stream = sass.sync();
var emptyFile = {
'isNull': function () {
return true;
}
};
stream.on('data', function(data) {
data.should.equal(emptyFile);
done();
});
stream.write(emptyFile);
});
it('should emit error when file isStream()', function (done) {
var stream = sass.sync();
var streamFile = {
'isNull': function () {
return false;
},
'isStream': function () {
return true;
}
};
stream.on('error', function(err) {
err.message.should.equal('Streaming not supported');
done();
});
stream.write(streamFile);
});
it('should compile a single sass file', function(done) {
var sassFile = createVinyl('mixins.scss');
var stream = sass.sync();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, 'expected/mixins.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should compile multiple sass files', function(done) {
var files = [
createVinyl('mixins.scss'),
createVinyl('variables.scss')
];
var stream = sass.sync();
var mustSee = files.length;
var expectedPath = 'expected/mixins.css';
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
if (cssFile.path.indexOf('variables') !== -1) {
expectedPath = 'expected/variables.css';
}
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, expectedPath), 'utf8')
);
mustSee--;
if (mustSee <= 0) {
done();
}
});
files.forEach(function (file) {
stream.write(file);
});
});
it('should compile files with partials in another folder', function(done) {
var sassFile = createVinyl('inheritance.scss');
var stream = sass.sync();
stream.on('data', function(cssFile) {
should.exist(cssFile);
should.exist(cssFile.path);
should.exist(cssFile.relative);
should.exist(cssFile.contents);
String(cssFile.contents).should.equal(
fs.readFileSync(path.join(__dirname, 'expected/inheritance.css'), 'utf8')
);
done();
});
stream.write(sassFile);
});
it('should handle sass errors', function(done) {
var errorFile = createVinyl('error.scss');
var stream = sass.sync();
stream.on('error', function(err) {
err.message.indexOf('property "font" must be followed by a \':\'').should.not.equal(-1);
err.relativePath.should.equal('test/scss/error.scss');
done();
});
stream.write(errorFile);
});
it('should work with gulp-sourcemaps', function(done) {
var sassFile = createVinyl('inheritance.scss');
// Expected sources are relative to file.base
var expectedSources = [
'includes/_cats.scss',
'includes/_dogs.sass',
'inheritance.scss'
];
var stream;
sassFile.sourceMap = '{' +
'"version": 3,' +
'"file": "scss/subdir/multilevelimport.scss",' +
'"names": [],' +
'"mappings": "",' +
'"sources": [ "scss/subdir/multilevelimport.scss" ],' +
'"sourcesContent": [ "@import ../inheritance;" ]' +
'}';
stream = sass.sync();
stream.on('data', function(cssFile) {
should.exist(cssFile.sourceMap);
cssFile.sourceMap.sources.should.eql(expectedSources);
done();
});
stream.write(sassFile);
});
it('should work with gulp-sourcemaps and autoprefixer', function(done) {
var expectedSources = [
'includes/_cats.scss',
'includes/_dogs.sass',
'inheritance.scss'
];
gulp.src(path.join(__dirname, '/scss/inheritance.scss'))
.pipe(sourcemaps.init())
.pipe(sass.sync())
.pipe(tap(function(file) {
should.exist(file.sourceMap);
file.sourceMap.sources.should.eql(expectedSources);
}))
.pipe(postcss([autoprefixer()]))
.pipe(sourcemaps.write())
.pipe(gulp.dest(path.join(__dirname, '/results/')))
.pipe(tap(function(file) {
should.exist(file.sourceMap);
file.sourceMap.sources.should.eql(expectedSources);
}))
.on('end', done);
});
it('should work with gulp-sourcemaps and a globbed source', function(done) {
var files, filesContent, actualContent, expectedContent, globPath;
files = globule.find(path.join(__dirname, '/scss/globbed/**/*.scss'));
filesContent = {};
files.forEach(function(file) {
globPath = file.replace(path.join(__dirname, '/scss/globbed/'), '');
filesContent[globPath] = fs.readFileSync(file, 'utf8');
});
gulp.src(path.join(__dirname, '/scss/globbed/**/*.scss'))
.pipe(sourcemaps.init())
.pipe(sass.sync())
.pipe(tap(function(file) {
should.exist(file.sourceMap);
actualContent = file.sourceMap.sourcesContent[0];
expectedContent = filesContent[file.sourceMap.sources[0]];
actualContent.should.eql(expectedContent);
}))
.on('end', done);
});
it('should work with gulp-sourcemaps and autoprefixer with different file.base', function(done) {
var expectedSources = [
'scss/includes/_cats.scss',
'scss/includes/_dogs.sass',
'scss/inheritance.scss'
];
gulp.src(path.join(__dirname, '/scss/inheritance.scss'), { 'base': 'test' })
.pipe(sourcemaps.init())
.pipe(sass.sync())
.pipe(tap(function(file) {
should.exist(file.sourceMap);
file.sourceMap.sources.should.eql(expectedSources);
}))
.pipe(postcss([autoprefixer()]))
.pipe(tap(function(file) {
should.exist(file.sourceMap);
file.sourceMap.sources.should.eql(expectedSources);
}))
.on('end', done);
});
it('should work with empty files', function(done) {
gulp.src(path.join(__dirname, '/scss/empty.scss'))
.pipe(sass.sync())
.pipe(gulp.dest(path.join(__dirname, '/results/')))
.pipe(tap(function() {
try {
fs.statSync(path.join(__dirname, '/results/empty.css'));
}
catch (e) {
should.fail(false, true, 'Empty file was produced');
}
}))
.on('end', done);
});
});
|
import DefaultHandler from './default';
import constants from '../../constants';
export const supportedPages = constants.PAGE_NAMES
.filter((p) => p.includes('.json'))
.map((p) => p.replace('.json', ''));
export const pageNameMap = {
guardian_multifactor: 'guardian_mfa_page',
password_reset: 'change_password',
error_page: 'error_page'
};
// With this schema, we can only validate property types but not valid properties on per type basis
export const schema = {
type: 'array',
items: {
type: 'object',
properties: {
name: { type: 'string', enum: supportedPages },
html: { type: 'string', default: '' },
url: { type: 'string' },
show_log_link: { type: 'boolean' },
enabled: { type: 'boolean' }
},
required: [ 'name' ]
}
};
export default class PageHandler extends DefaultHandler {
constructor(options) {
super({
...options,
type: 'pages'
});
}
objString(page) {
return super.objString({ name: page.name, enabled: page.enabled });
}
async updateLoginPage(page) {
const globalClient = await this.client.clients.getAll({ is_global: true, paginate: true });
if (!globalClient[0]) {
throw new Error('Unable to find global client id when trying to update the login page');
}
await this.client.clients.update(
{ client_id: globalClient[0].client_id },
{
custom_login_page: page.html,
custom_login_page_on: page.enabled
}
);
this.updated += 1;
this.didUpdate(page);
}
async updatePages(pages) {
const toUpdate = pages.filter((p) => supportedPages.includes(p.name));
const update = toUpdate.reduce((accum, page) => {
if (supportedPages.includes(page.name)) {
const pageName = pageNameMap[page.name];
if (!pageName) {
throw new Error(`Unable to map page ${page.name} into tenant level page setting`);
}
accum[pageName] = { ...page };
delete accum[pageName].name;
}
return accum;
}, {});
if (Object.keys(update).length) {
await this.client.tenant.updateSettings(update);
}
toUpdate.forEach((page) => {
this.updated += 1;
this.didUpdate(page);
});
}
async getType() {
const pages = [];
// Login page is handled via the global client
const globalClient = await this.client.clients.getAll({ is_global: true, paginate: true });
if (!globalClient[0]) {
throw new Error('Unable to find global client id when trying to dump the login page');
}
if (globalClient[0].custom_login_page) {
pages.push({
name: 'login',
enabled: globalClient[0].custom_login_page_on,
html: globalClient[0].custom_login_page
});
}
const tenantSettings = await this.client.tenant.getSettings();
Object.entries(pageNameMap).forEach(([ key, name ]) => {
const page = tenantSettings[name];
if (tenantSettings[name]) {
pages.push({
...page,
name: key
});
}
});
return pages;
}
async processChanges(assets) {
const { pages } = assets;
// Do nothing if not set
if (!pages) return;
// Login page is handled via the global client
const loginPage = pages.find((p) => p.name === 'login');
if (loginPage) {
await this.updateLoginPage(loginPage);
}
// Rest of pages are on tenant level settings
await this.updatePages(pages.filter((p) => p.name !== 'login'));
}
}
|
// This file configures the development web server
// which supports hot reloading and synchronized testing.
// Require Browsersync along with webpack and middleware for it
import browserSync from 'browser-sync';
// Required for react-router browserHistory
// see https://github.com/BrowserSync/browser-sync/issues/204#issuecomment-102623643
import historyApiFallback from 'connect-history-api-fallback';
import webpack from 'webpack';
import webpackDevMiddleware from 'webpack-dev-middleware';
import webpackHotMiddleware from 'webpack-hot-middleware';
import config from '../webpack.config.dev';
const bundler = webpack(config);
// Run Browsersync and use middleware for Hot Module Replacement
browserSync({
port: 3000,
ui: {
port: 3001
},
server: {
baseDir: 'src',
https: true,
middleware: [
historyApiFallback(),
webpackDevMiddleware(bundler, {
// Dev middleware can't access config, so we provide publicPath
publicPath: config.output.publicPath,
// These settings suppress noisy webpack output so only errors are displayed to the console.
noInfo: false,
quiet: false,
stats: {
assets: false,
colors: true,
version: false,
hash: false,
timings: false,
chunks: false,
chunkModules: false
},
// for other settings see
// http://webpack.github.io/docs/webpack-dev-middleware.html
}),
// bundler should be the same as above
webpackHotMiddleware(bundler)
]
},
// no need to watch '*.js' here, webpack will take care of it for us,
// including full page reloads if HMR won't work
files: [
'src/*.html'
]
});
|
import Ajax from './libs/ajax';
/**
* Class for a sample page - Register.
* @constructor
*/
class Register {
constructor() {
this.ajaxToForm();
}
ajaxToForm() {
const register = document.querySelector('form#register');
if (register) {
const ajax = new Ajax(register);
ajax.run();
}
}
}
export default new Register; |
var model = require("./loginModel");
exports.login = function (source) {
// check if user is already logged in
if (source.req.session.role) {
return source.res.status(400).send("Already logged in");
}
// get username and password
var username = source.data.username;
var password = source.data.password;
// find user
model.findUser({
username: username,
password: password
}, function (err, user) {
// handle error
if (err) {
return source.res.status(500).send(err.toString());
}
// user not found
if (!user) {
return source.res.status(400).send("Invalid login credentials");
}
// get the user role (if it exists)
var role = (user.role) ? user.role : null;
// set session
source.req.session.login = {
user: user.username,
role: role
};
// end request
source.res.writeHead(302, {"location": "http://" + source.req.headers.host + "/"});
source.res.end();
});
} |
#!/usr/bin/env node
'use strict'
const ratio = require('..')
const cli = require('meow')({
pkg: '../package.json',
help: [
'Usage',
' $ aspect-ratio <width><height>[options]',
'\n options:',
"\t -s\t specified a separator. (by default is ':').",
'\t --version output the current version.',
'\n examples:',
'\t aspect-ratio 1920 1080',
'\t aspect-ratio 800 600 -s /'
].join('\n')
})
const width = cli.input[0]
const height = cli.input[1]
const separator = cli.flags.s || ':'
if (!height) cli.showHelp()
else console.log(ratio(width, height, separator))
|
/**
* Utility functions for dealing with DICOM
*/
var dicomParser = (function (dicomParser)
{
"use strict";
if(dicomParser === undefined)
{
dicomParser = {};
}
// algorithm based on http://stackoverflow.com/questions/1433030/validate-number-of-days-in-a-given-month
function daysInMonth(m, y) { // m is 0 indexed: 0-11
switch (m) {
case 2 :
return (y % 4 == 0 && y % 100) || y % 400 == 0 ? 29 : 28;
case 9 : case 4 : case 6 : case 11 :
return 30;
default :
return 31
}
}
function isValidDate(d, m, y) {
// make year is a number
if(isNaN(y)) {
return false;
}
return m > 0 && m <= 12 && d > 0 && d <= daysInMonth(m, y);
}
/**
* Parses a DA formatted string into a Javascript object
* @param {string} date a string in the DA VR format
* @param {boolean} [validate] - true if an exception should be thrown if the date is invalid
* @returns {*} Javascript object with properties year, month and day or undefined if not present or not 8 bytes long
*/
dicomParser.parseDA = function(date, validate)
{
if(date && date.length === 8)
{
var yyyy = parseInt(date.substring(0, 4), 10);
var mm = parseInt(date.substring(4, 6), 10);
var dd = parseInt(date.substring(6, 8), 10);
if(validate) {
if (isValidDate(dd, mm, yyyy) !== true) {
throw "invalid DA '" + date + "'";
}
}
return {
year: yyyy,
month: mm,
day: dd
};
}
if(validate) {
throw "invalid DA '" + date + "'";
}
return undefined;
};
return dicomParser;
}(dicomParser)); |
Subsets and Splits