code stringlengths 2 1.05M |
|---|
/* jshint node:true */
module.exports = function (grunt) {
'use strict';
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
assemble: {
// options: {
// postprocess: require('pretty')
// },
demo: {
options: {
partials: ['templates/includes/*.hbs'],
layoutdir: 'templates',
layout: 'index.html'
},
src: ['*.md'],
dest: './'
}
},
sass: {
options: {
includePaths: ['bower_components/foundation/scss']
},
dist: {
options: {
outputStyle: 'compressed'
},
files: {
'css/app.css': 'scss/app.scss'
}
}
},
watch: {
grunt: { files: ['Gruntfile.js'] },
sass: {
options: { livereload: true },
files: 'scss/**/*.scss',
tasks: ['sass']
},
html_source: {
files: ['**/*.md', 'templates/**'],
tasks: ['assemble']
},
html: {
options: { livereload: true },
files: ['*.html']
},
js: {
options: { livereload: true },
files: 'js-source/**/*.js',
tasks: ['uglify']
}
},
open: {
server: {
path: 'http://localhost:9000'
}
},
connect: {
server: {
options: {
port: 9000,
hostname: '*',
base: './',
middleware: function (connect, options) {
var path = require('path');
return [
require('connect-livereload')(),
connect.static(path.resolve('.'))
];
}
}
}
},
uglify: {
js: {
options: {
sourceMap: 'app.js.map',
sourceMapRoot: '../js/'
},
files: {
'js/app.js': ['js-source/app.js']
}
}
},
favicons: {
options: {},
icons: {
src: 'assets/HTML5_Styling_512.png',
dest: './'
}
}
});
grunt.loadNpmTasks('assemble');
grunt.loadNpmTasks('grunt-contrib-connect');
grunt.loadNpmTasks('grunt-open');
grunt.loadNpmTasks('grunt-sass');
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.loadNpmTasks('grunt-contrib-uglify');
grunt.loadNpmTasks('grunt-favicons');
grunt.registerTask('build', ['assemble', 'sass', 'uglify']);
grunt.registerTask('default', ['build', 'connect', 'open', 'watch']);
} |
import mongoose from "mongoose";
import config from "config";
import getLogger from "./log";
const logger = getLogger(module);
const log = logger.debug;
const lerr = logger.error;
const conf = config.get('db');
let db = null;
const initDb = () => {
if (db !== null) return db;
if (process.env.NODE_ENV === "development") {
mongoose.set("debug", true);
}
const opts = {
poolSize: 2,
promiseLibrary: global.Promise,
user: conf.user,
pass: conf.password,
useNewUrlParser: true,
useUnifiedTopology: true,
useCreateIndex: true
};
db = mongoose.createConnection(conf.path, opts);
db.on("error", err => {
lerr(err);
});
db.once("open", callback => {
log("onOpen", callback);
if (callback && typeof callback === "function") {
callback.apply(this, arguments);
}
});
return db;
};
const getDb = () => db;
export default {
initDb,
getDb
};
|
var sellerCache = {};
moment.locale(chrome.i18n.getMessage('@@ui_locale'));
function updatePageContent(data, seller_id) {
var $tree = $(data),
seller_id = $($tree.find('.nav.main-tabs a')[0]).attr('href').match(/uid=(\d+)/i)[1],
$user_info = $tree.find('.extendedHeader h2 > span'),
$summary = $tree.find('.summaryBox');
// create abhbox
var abhbox = $('<div />', {
class: 'abhbox vela'
}),
user_info = $('<div />', {
class: 'abhbox-user-info'
}).data('user', seller_id),
rating = $('<div />', {
class: 'abhbox-rating'
}),
summary = $('<div />', {
class: 'abhbox-summary'
});
$($user_info.html()).appendTo(user_info);
user_info.find('.uname').each(function(num, el) {
// add 'user' to user data
$(el).text(chrome.i18n.getMessage('abh_user') + ' ' + $(el).text());
});
var $additionalInfo = $summary.find('.additionalInfoBox ul');
$additionalInfo.find('li').each(function(num, el) {
// replace date in user_info
var date = $(el).text().match(/: ([0-9\.\,\/\\:\s]+)/i)[1];
if (date) {
$(el).html($(el).text().replace(date, '<strong>' + moment(date, "DD.MM.YYYY, HH:mm:ss").fromNow() + '</strong>'));
}
});
$additionalInfo.appendTo(user_info);
$($summary.find('.feedbacksSummary')).appendTo(summary);
$summary.find('.innerGreenBox').appendTo(rating);
$summary.find('.ratingSummary').appendTo(rating);
user_info.appendTo(abhbox);
rating.appendTo(abhbox);
summary.appendTo(abhbox.find('.innerGreenBox'));
var metr = $('<div />', {
class: 'abhbox-metr'
}),
metr_scale = $('<div />', {
class: 'abhbox-metr-scale'
});
abhbox.find('.innerGreenBox .igbCol1').wrap(metr);
abhbox.find('.abhbox-rating .igbCol1').clone()
.addClass('scale')
.appendTo(abhbox.find('.abhbox-metr'));
abhbox.find('.abhbox-metr .scale').wrap(metr_scale);
abhbox.find('.abhbox-metr-scale').css('width', parseFloat(abhbox.find('.igbCol1 span').text()) + '%');
var ratingWrapper = $('<div />', {
class: 'abhbox-rating-wrapper'
});
abhbox.find('.starsWrapper').wrap(ratingWrapper);
abhbox.appendTo($('section.offers article.abh-seller-' + seller_id + ' .details'));
}
function getSellerInfo(sellers, current) {
if (sellers[current] in sellerCache) {
updatePageContent(sellerCache[sellers[current]], sellers[current]);
}
else {
// now find seller info, like this http://aukro.ua/show_user.php?uid=24743331
$.ajax({
url: '/show_user.php',
data: {'uid': sellers[current]},
datatype: 'html',
success: function(data) {
sellerCache[sellers[current]] = data;
updatePageContent(data, sellers[current]);
},
complete: function() {
getSellerInfo(sellers, current + 1);
}
});
}
}
function addSellerInfo() {
if ($('section.offers article:not(.abh-set)').length) {
var sellers = [];
// find seller id on catalog page for all offers
$('section.offers article:not(.abh-set)').each(function(num, el) {
var seller_id = $(el).find('.photo').data('popup')['s'];
// append seller id to each offer
$(el).addClass('abh-set abh-seller-' + seller_id);
if (sellers.indexOf(seller_id) < 0) {
sellers.push(seller_id);
}
});
getSellerInfo(sellers, 0);
}
}
var checkTimeout = null;
document.addEventListener('DOMSubtreeModified', function (e) {
clearTimeout(checkTimeout);
checkTimeout = setTimeout(addSellerInfo, 100);
}, false);
|
/* jshint node: true */
'use strict';
module.exports = {
name: 'ember-ika-forms',
included: function(app) {
this._super.included(app);
app.import(app.bowerDirectory + '/ember/ember-template-compiler.js');
app.import(app.bowerDirectory + '/select2/dist/css/select2.css');
app.import(app.bowerDirectory + '/select2/dist/js/select2.js');
}
};
|
version https://git-lfs.github.com/spec/v1
oid sha256:d182cad30987cc07ab562144ef752b385178e823c5593cf6679b9ff53a12c03d
size 487520
|
import KeyboardModule from '../keyboard';
import SelectionModule from '../selection';
import KeyboardMoveSelection from './KeyboardMoveSelection';
export default {
__depends__: [
KeyboardModule,
SelectionModule
],
__init__: [
'keyboardMoveSelection'
],
keyboardMoveSelection: [ 'type', KeyboardMoveSelection ]
};
|
Example['home'] = (function() {
var module = {exports: {}};
var exports = module.exports;
Example['home'] = exports;
/* router : home */
module.name = "home";
module.routes = {"":"home","home":"home"};
/* handsfree : templates/home/footer.handlebars*/
Example.templates['templates/home/footer.handlebars'] = Handlebars.compile('<div>Footer</div>\n');
/* handsfree : templates/home/home.handlebars*/
Example.templates['templates/home/home.handlebars'] = Handlebars.compile('Home\n ');
Example.Views.Home = Backbone.View.extend({
el: ".layout",
render: function() {
$(this.el).html(Example.templates('templates/home/home.handlebars'));
$(this.el).append(Example.templates('templates/home/footer.handlebars'));
}
});
;;
Example.Router.create(module, {
home: function() {
var home = new Example.Views.Home();
home.render();
}
});
;;
if (Example['home'] !== module.exports) {
console.warn("Example['home'] internally differs from global");
}
return module.exports;
}).call(this);
|
import { expect } from 'chai';
import { describe, it } from 'mocha';
import EmberObject, { computed } from '@ember/object';
import DefaultAttrsMixin from 'virtual-each/mixins/default-attrs';
describe('Default Attrs Mixin', function() {
it('gets a value from plain object', function() {
let mixin = EmberObject.extend(DefaultAttrsMixin).create();
mixin.defaultAttrs.positionIndex = 5;
expect(mixin.getAttr('positionIndex')).to.equal(5);
});
it('gets a value from computed property', function() {
let mixin = EmberObject.extend(DefaultAttrsMixin, {
defaultAttrs: computed(function() {
return {
positionIndex: 5
};
})
}).create();
expect(mixin.getAttr('positionIndex')).to.equal(5);
});
});
|
// @flow
import type { EntityList } from 'types/EntityList';
export type EntityIndexResult = {
data: EntityList,
existingCount: number,
};
|
/*global define*/
define([
'./defined',
'./getTimestamp'
], function(
defined,
getTimestamp) {
'use strict';
if (typeof window === 'undefined') {
return;
}
var implementation = window.requestAnimationFrame;
(function() {
// look for vendor prefixed function
if (!defined(implementation)) {
var vendors = ['webkit', 'moz', 'ms', 'o'];
var i = 0;
var len = vendors.length;
while (i < len && !defined(implementation)) {
implementation = window[vendors[i] + 'RequestAnimationFrame'];
++i;
}
}
// build an implementation based on setTimeout
if (!defined(implementation)) {
var msPerFrame = 1000.0 / 60.0;
var lastFrameTime = 0;
implementation = function(callback) {
var currentTime = getTimestamp();
// schedule the callback to target 60fps, 16.7ms per frame,
// accounting for the time taken by the callback
var delay = Math.max(msPerFrame - (currentTime - lastFrameTime), 0);
lastFrameTime = currentTime + delay;
return setTimeout(function() {
callback(lastFrameTime);
}, delay);
};
}
})();
/**
* A browser-independent function to request a new animation frame. This is used to create
* an application's draw loop as shown in the example below.
*
* @exports requestAnimationFrame
*
* @param {requestAnimationFrame~Callback} callback The function to call when the next frame should be drawn.
* @returns An ID that can be passed to {@link cancelAnimationFrame} to cancel the request.
*
*
* @example
* // Create a draw loop using requestAnimationFrame. The
* // tick callback function is called for every animation frame.
* function tick() {
* scene.render();
* Cesium.requestAnimationFrame(tick);
* }
* tick();
*
* @see {@link http://www.w3.org/TR/animation-timing/#the-WindowAnimationTiming-interface|The WindowAnimationTiming interface}
*/
function requestAnimationFrame(callback) {
// we need this extra wrapper function because the native requestAnimationFrame
// functions must be invoked on the global scope (window), which is not the case
// if invoked as Cesium.requestAnimationFrame(callback)
return implementation(callback);
}
/**
* A function that will be called when the next frame should be drawn.
* @callback requestAnimationFrame~Callback
*
* @param {Number} timestamp A timestamp for the frame, in milliseconds.
*/
return requestAnimationFrame;
});
|
(function() {
'use strict';
angular
.module('Scheduler.Filters.Boolean', [])
.filter('boolean', function() {
return function(input) {
return input ? 'Da' : 'Nu';
};
});
})(); |
/**
* Created by asafdavid on 01/03/2017.
*/
import Promise from 'bluebird';
import _ from 'lodash';
import BaseService from '../baseService';
export const NOOP = res => Promise.resolve(res);
/**
* Creates a Middleware decorator
* @param pre
* @param post
* @constructor
*/
export default function Middleware(name, pre = NOOP, post = NOOP, options = {}) {
if (!name) throw new TypeError('name is required');
if (!_.isFunction(pre)) throw new TypeError('pre is required and must be a function');
if (!_.isFunction(post)) throw new TypeError('post is required and must be a function');
return function middlewareDecorator(target, key, descriptor) {
// Check if a task is defined within a service
if (!(target instanceof BaseService)) {
throw SyntaxError('@task must be defined within a service');
}
if (!_.isFunction(descriptor.value)) {
throw SyntaxError(`@Middleware(${name}) must be defined on a function`);
}
// Check if it was defined on a task
if (!target._tasks || !target._tasks[key]) {
throw SyntaxError(
`@Middleware(${name}) must be defined on a task, use @Task before @Middleware`
);
}
// Add the middleware by order
target._tasks[key].middleware.pre.push(pre);
target._tasks[key].middleware.post.push(post);
target._tasks[key].options[name] = options;
};
}
|
/*global expect*/
describe('to be a/an assertion', function() {
var circular = {};
circular.self = circular;
it('asserts typeof with support for array type and instanceof', function() {
expect(5, 'to be a', 'number');
expect(5, 'to be a number');
expect('abc', 'to be a', 'string');
expect('', 'to be a string');
expect('', 'to be the empty string');
expect('', 'to be an empty string');
expect('abc', 'to be a non-empty string');
expect([], 'to be an', 'array');
expect([], 'to be an array');
expect([], 'to be an empty array');
expect({}, 'to be an', Object);
expect([123], 'to be a non-empty array');
expect([], 'to be an', 'object');
expect([], 'to be an object');
expect([], 'to be an', Array);
expect(/ab/, 'to be a', RegExp);
expect(/ab/, 'to be a regexp');
expect(123, 'not to be a regex');
expect(/ab/, 'to be a regex');
expect(/ab/, 'to be a regular expression');
expect(123, 'not to be a regular expression');
expect(null, 'not to be an', 'object');
expect(null, 'not to be an object');
expect(true, 'to be a', 'boolean');
expect(true, 'to be a boolean');
expect(expect, 'to be a', 'function');
expect(expect, 'to be a function');
expect(circular, 'to be an object');
expect(new Date(), 'to be a', 'date');
expect(new Date(), 'to be a date');
expect({}, 'not to be a date');
expect(new Date().toISOString(), 'not to be a date');
});
it('should support type objects', function() {
expect('foo', 'to be a', expect.getType('string'));
});
describe('with a type name', function() {
it('should succeed when the subject is recognized as having the type', function() {
expect(new Error('foo'), 'to be an', 'Error');
});
it('should fail when the subject is not recognized as having the type', function() {
expect(
function() {
expect(123, 'to be an', 'Error');
},
'to throw',
'expected 123 to be an Error'
);
});
// Maybe better: throw a non-Unexpected error
it('should fail when the type is not defined', function() {
expect(
function() {
expect(123, 'to be a', 'FoopQuuxDoop');
},
'to throw',
'expected 123 to be a FoopQuuxDoop\n' + ' Unknown type: FoopQuuxDoop'
);
});
it('should fail when the type is not defined in the "not" case', function() {
expect(
function() {
expect(123, 'not to be a', 'FoopQuuxDoop');
},
'to throw',
'expected 123 not to be a FoopQuuxDoop\n' +
' Unknown type: FoopQuuxDoop'
);
});
});
it('formats Error instances correctly when an assertion fails', function() {
expect(
function() {
var error = new Error('error message');
error.data = 'extra';
expect(error, 'to be a number');
},
'to throw',
"expected Error({ message: 'error message', data: 'extra' }) to be a number"
);
});
it('should fail with the correct error message if the type is given as an anonymous function', function() {
expect(
function() {
expect('foo', 'to be a', function() {});
},
'to throw',
"expected 'foo' to be a function () {}"
);
});
it('should throw when the type is specified as undefined', function() {
expect(
function() {
expect('foo', 'to be an', undefined);
},
'to throw',
"expected 'foo' to be an undefined\n" +
' The assertion does not have a matching signature for:\n' +
' <string> to be an <undefined>\n' +
' did you mean:\n' +
' <any> [not] to be (a|an) <function>\n' +
' <any> [not] to be (a|an) <string>\n' +
' <any> [not] to be (a|an) <type>'
);
});
it('should throw when the type is specified as null', function() {
expect(
function() {
expect('foo', 'to be a', null);
},
'to throw',
"expected 'foo' to be a null\n" +
' The assertion does not have a matching signature for:\n' +
' <string> to be a <null>\n' +
' did you mean:\n' +
' <any> [not] to be (a|an) <function>\n' +
' <any> [not] to be (a|an) <string>\n' +
' <any> [not] to be (a|an) <type>'
);
});
it('should not consider a string a to be an instance of an object without a name property', function() {
expect(
function() {
expect('foo', 'to be a', {});
},
'to throw',
"expected 'foo' to be a {}\n" +
' The assertion does not have a matching signature for:\n' +
' <string> to be a <object>\n' +
' did you mean:\n' +
' <any> [not] to be (a|an) <function>\n' +
' <any> [not] to be (a|an) <string>\n' +
' <any> [not] to be (a|an) <type>'
);
});
it('should throw when the type is specified as an object without an identify function', function() {
expect(
function() {
expect('foo', 'to be a', { name: 'bar' });
},
'to throw',
"expected 'foo' to be a { name: 'bar' }\n" +
' The assertion does not have a matching signature for:\n' +
' <string> to be a <object>\n' +
' did you mean:\n' +
' <any> [not] to be (a|an) <function>\n' +
' <any> [not] to be (a|an) <string>\n' +
' <any> [not] to be (a|an) <type>'
);
});
it('should throw when the type is specified as an object with an identify function, but without a name property', function() {
expect(
function() {
expect('foo', 'to be a', {
// prettier-ignore
identify: function () {
return true;
}
});
},
'to throw',
function(err) {
// Compensate for V8 5.1+ setting { identify: function () {} }.identify.name === 'identify'
// http://v8project.blogspot.dk/2016/04/v8-release-51.html
expect(
err
.getErrorMessage('text')
.toString()
.replace('function identify', 'function '),
'to satisfy',
"expected 'foo' to be a { identify: function () { return true; } }\n" +
' The assertion does not have a matching signature for:\n' +
' <string> to be a <object>\n' +
' did you mean:\n' +
' <any> [not] to be (a|an) <function>\n' +
' <any> [not] to be (a|an) <string>\n' +
' <any> [not] to be (a|an) <type>'
);
}
);
});
it('throws when the assertion fails', function() {
expect(
function() {
expect(5, 'to be an', Array);
},
'to throw exception',
'expected 5 to be an Array'
);
expect(
function() {
expect([], 'not to be an', 'array');
},
'to throw exception',
'expected [] not to be an array'
);
expect(
function() {
expect(circular, 'not to be an object');
},
'to throw exception',
'expected { self: [Circular] } not to be an object'
);
});
it('throws an error a diff when comparing string and not negated', function() {
expect(
function() {
expect('foo', 'to be', 'bar');
},
'to throw exception',
"expected 'foo' to be 'bar'\n" + '\n' + '-foo\n' + '+bar'
);
});
it('throws an error without actual and expected when comparing string and negated', function() {
expect(
function() {
expect('foo', 'not to be', 'foo');
},
'to throw exception',
function(e) {
expect(e, 'not to have property', 'actual');
expect(e, 'not to have property', 'expected');
}
);
});
it('throws an error without actual and expected when not comparing string and not negated', function() {
expect(
function() {
expect('foo', 'to be', {});
},
'to throw exception',
function(e) {
expect(e, 'not to have property', 'actual');
expect(e, 'not to have property', 'expected');
}
);
});
});
|
var nodemailer = require('nodemailer');
var gmail = require('../devday-keys/gmail.json');
let send = function (data) {
// create reusable transporter object using the default SMTP transport
var transporter = nodemailer.createTransport('smtps://' + gmail.username + ':' + gmail.password + '@smtp.gmail.com');
// setup e-mail data with unicode symbols
var mailOptions = {
to: 'devday.chn@gmail.com', // list of receivers
subject: 'New speaker registration' + (!!data.event_url ? (' for ' + data.event_url) : ''), // Subject line
text: JSON.stringify(data), // plaintext body
html: JSON.stringify(data).replace(/,/g, ',<br />').replace('{', '{<br/>').replace('}', '<br />}') // html body
};
// send mail with defined transport object
transporter.sendMail(mailOptions, function (error, info) {
if (error) {
console.log("error sending email")
return console.log(error);
}
});
};
module.exports = {
send: send
}
|
import _each from 'lodash/each';
function onMergeDefinitions(targetDefinition, sourceDefinition, ClassName) {
_each(sourceDefinition.indexes, function(index, indexName) {
targetDefinition.indexes[indexName] = index;
});
};
export default onMergeDefinitions; |
'use strict';
var assert = require('assert');
var shared = require('./shared');
assert.deepEqual(shared, ['foo', 'bar']);
process.send({
passed: 'child-2',
shared: shared
});
|
import devshare from './connect'
import reduxDevshare, { getDevshare } from './compose'
import reducer from './reducer'
import constants, { actionTypes } from './constants'
import * as helpers from './helpers'
export { devshare, reducer, reduxDevshare, helpers }
export default {
devshare,
devshareConnect: devshare,
reducer,
reduxDevshare,
constants,
actionTypes,
getDevshare,
...helpers
}
|
'use strict';
const getErrorResponses = require('./error-responses');
const getResponses = require('./responses');
const errorDefinitions = require('./error-definitions');
const searchProperties = require('./search-control-properties');
module.exports = {
entity: {
name: 'please-specify-the-entity-name',
path: null,
schema: {
type: 'object',
properties: {}
}
},
pathPrefix: { read: '', write: '' },
tag: {
read: { name: null, description: null },
write: { name: null, description: null }
},
reqParamId: '_id',
getErrorResponses,
getResponses,
errorDefinitions,
searchProperties,
useControlsFromQuery: false,
};
|
var http = require('http');
var phantom = require('node-phantom');
var ipaddress = "127.0.0.1";
var port = "8123";
var server = http.createServer(function(req, res) {
var Harvest = {
data: "",
url: "",
selector: "",
delay: 0,
result: "",
callback: "callBack",
error: "",
exit: 0,
jQuery: "jquery.min.js",
harvestAssist: "harvest-assist.js",
isEmpty: function(object) {
for (var i in object) {
return false;
}
return true;
},
onExit: function() {
if (Harvest.error) {
console.log("The following error occurred: " + Harvest.error);
} else {
console.log("Selections retuned: " + Harvest.result);
var start = Harvest.callback + '({"harvest":';
start += '[';
var end = ']})';
res.write(start + Harvest.result + end);
this.exit = 1;
res.end();
}
}
};
res.writeHead(200, {
'Content-Type': 'text/javascript;charset=UTF-8;charset=iso-8859-1'
});
var parts = require('url')
.parse(req.url, true);
if (!(Harvest.isEmpty(parts.query))) {
console.log("Parameters supplied in request: ");
for (var key in parts.query) {
console.log("Parameter: " + key + ", value: " + parts.query[key]);
try {
if (key === "data") {
Harvest.data = unescape(parts.query[key]);
Harvest.data = JSON.parse(Harvest.data);
Harvest.url = Harvest.data.url;
Harvest.selector = Harvest.data.selector;
Harvest.delay = Harvest.data.delay;
}
if (key === "callBack") {
Harvest.callback = parts.query[key];
}
} catch (e) {
console.log("Error: " + e);
}
}
} else {
res.write("<p>There were no parameters received in your request or they were not formatted properly.</p>");
}
phantom.create(function(err, ph) {
return ph.createPage(function(err, page) {
page.selector = Harvest.selector;
page.delay = Harvest.delay;
console.log("URL provided in request: " + Harvest.url);
return page.open(Harvest.url, function(err, status) {
console.log("Did the request for the URL succeed?: ", status);
if (status !== 'success') {
console.log("The following error occurred: ", err);
} else {
console.log("URL opened successfully.");
console.log("Injecting jQuery and harvest-assist.js");
page.injectJs(Harvest.jQuery);
page.injectJs(Harvest.harvestAssist);
if (typeof page.selector !== "undefined") {
console.log("Executing jQuery selection...");
eval("var pageEvaluateFunction = function() {return getSelector('" + page.selector + "')}");
setTimeout(function() {
return page.evaluate(pageEvaluateFunction,
function(err, result) {
Harvest.error = err;
Harvest.result = result;
Harvest.onExit();
return ph.exit();
});
}, page.delay);
}
}
});
});
});
})
.listen(port, ipaddress);
|
// Copyright 2015
/**
*
* @author Sam Reid
*/
define( function( require ) {
'use strict';
// modules
var cupcakeSnake = require( 'CUPCAKE_SNAKE/cupcakeSnake' );
var CupcakeSnakeConstants = {
};
cupcakeSnake.register( 'CupcakeSnakeConstants', CupcakeSnakeConstants );
return CupcakeSnakeConstants;
} ); |
/**
* @param {WorkerConnection} connection
* @param {Object} data
* @constructor
*/
function Subscriber(connection, data) {
/** @type {WorkerConnection} */
this.connection = connection;
/** @type {Object} */
this.data = data;
/** @type {Number} */
this.createStamp = new Date().getTime();
}
module.exports = Subscriber;
|
angular.module('myBlog')
.service('contactService', ['baasicApiHttp', 'baasicDynamicResourceService',
function baasicBlogService(baasicApiHttp, dynamincService) {
'use strict';
var resourceName = 'contacts';
this.get = function get(id, options) {
return dynamincService.get(resourceName, id, options);
};
this.find = function find(options) {
return dynamincService.find(resourceName, options);
};
this.create = function create(contactData) {
return dynamincService.create(resourceName, contactData);
};
this.update = function update(contactData) {
contactData.createDate = new Date();
return dynamincService.update(contactData);
};
this.remove = function remove(contactData) {
return dynamincService.remove(contactData);
};
this.next = function next(contactDataList) {
var nextLink = contactDataList.links('next');
if (nextLink) {
return baasicApiHttp.get(nextLink.href);
}
};
this.previous = function previous(contactDataList) {
var prevLink = contactDataList.links('previous');
if (prevLink) {
return baasicApiHttp.get(prevLink.href);
}
};
}
]
); |
var util = require("util");
var choreography = require("temboo/core/choreography");
/*
ConvertCurrency
Converts a payment amount from one currency to another.
*/
var ConvertCurrency = function(session) {
/*
Create a new instance of the ConvertCurrency Choreo. A TembooSession object, containing a valid
set of Temboo credentials, must be supplied.
*/
var location = "/Library/PayPal/AdaptivePayments/ConvertCurrency"
ConvertCurrency.super_.call(this, session, location);
/*
Define a callback that will be used to appropriately format the results of this Choreo.
*/
var newResultSet = function(resultStream) {
return new ConvertCurrencyResultSet(resultStream);
}
/*
Obtain a new InputSet object, used to specify the input values for an execution of this Choreo.
*/
this.newInputSet = function() {
return new ConvertCurrencyInputSet();
}
/*
Execute this Choreo with the specified inputs, calling the specified callback upon success,
and the specified errorCallback upon error.
*/
this.execute = function(inputs, callback, errorCallback) {
this._execute(inputs, newResultSet, callback, errorCallback);
}
}
/*
An InputSet with methods appropriate for specifying the inputs to the ConvertCurrency
Choreo. The InputSet object is used to specify input parameters when executing this Choreo.
*/
var ConvertCurrencyInputSet = function() {
ConvertCurrencyInputSet.super_.call(this);
/*
Set the value of the Amount input for this Choreo. ((required, decimal) The amount that should be converted to a new currency.)
*/
this.set_Amount = function(value) {
this.setInput("Amount", value);
}
/*
Set the value of the AppID input for this Choreo. ((required, string) Your PayPal AppID (or the default AppID for the PayPal sandbox).)
*/
this.set_AppID = function(value) {
this.setInput("AppID", value);
}
/*
Set the value of the ConvertToCurrency input for this Choreo. ((required, string) The currency code that you want to convert to (i.e. GBP).)
*/
this.set_ConvertToCurrency = function(value) {
this.setInput("ConvertToCurrency", value);
}
/*
Set the value of the CurrencyCode input for this Choreo. ((required, string) The currency code that you want to convert. (i.e. USD).)
*/
this.set_CurrencyCode = function(value) {
this.setInput("CurrencyCode", value);
}
/*
Set the value of the Password input for this Choreo. ((required, password) The API Password provided by PayPal.)
*/
this.set_Password = function(value) {
this.setInput("Password", value);
}
/*
Set the value of the Signature input for this Choreo. ((required, string) The API Signature provided by PayPal.)
*/
this.set_Signature = function(value) {
this.setInput("Signature", value);
}
/*
Set the value of the UseSandbox input for this Choreo. ((optional, boolean) Set to 1 to indicate that you're testing against the PayPal sandbox instead of production. Set to 0 (the default) when moving to production.)
*/
this.set_UseSandbox = function(value) {
this.setInput("UseSandbox", value);
}
/*
Set the value of the Username input for this Choreo. ((required, string) The API Username provided by PayPal.)
*/
this.set_Username = function(value) {
this.setInput("Username", value);
}
}
/*
A ResultSet with methods tailored to the values returned by the ConvertCurrency Choreo.
The ResultSet object is used to retrieve the results of a Choreo execution.
*/
var ConvertCurrencyResultSet = function(resultStream) {
ConvertCurrencyResultSet.super_.call(this, resultStream);
/*
Retrieve the value for the "Response" output from this Choreo execution. ((json) The response from PayPal.)
*/
this.get_Response = function() {
return this.getResult("Response");
}
}
util.inherits(ConvertCurrency, choreography.Choreography);
util.inherits(ConvertCurrencyInputSet, choreography.InputSet);
util.inherits(ConvertCurrencyResultSet, choreography.ResultSet);
exports.ConvertCurrency = ConvertCurrency;
/*
PaymentDetails
Retrieves information about a specific payment.
*/
var PaymentDetails = function(session) {
/*
Create a new instance of the PaymentDetails Choreo. A TembooSession object, containing a valid
set of Temboo credentials, must be supplied.
*/
var location = "/Library/PayPal/AdaptivePayments/PaymentDetails"
PaymentDetails.super_.call(this, session, location);
/*
Define a callback that will be used to appropriately format the results of this Choreo.
*/
var newResultSet = function(resultStream) {
return new PaymentDetailsResultSet(resultStream);
}
/*
Obtain a new InputSet object, used to specify the input values for an execution of this Choreo.
*/
this.newInputSet = function() {
return new PaymentDetailsInputSet();
}
/*
Execute this Choreo with the specified inputs, calling the specified callback upon success,
and the specified errorCallback upon error.
*/
this.execute = function(inputs, callback, errorCallback) {
this._execute(inputs, newResultSet, callback, errorCallback);
}
}
/*
An InputSet with methods appropriate for specifying the inputs to the PaymentDetails
Choreo. The InputSet object is used to specify input parameters when executing this Choreo.
*/
var PaymentDetailsInputSet = function() {
PaymentDetailsInputSet.super_.call(this);
/*
Set the value of the AppID input for this Choreo. ((required, string) Your PayPal AppID (or the default AppID for the PayPal sandbox).)
*/
this.set_AppID = function(value) {
this.setInput("AppID", value);
}
/*
Set the value of the Password input for this Choreo. ((required, password) The API Password provided by PayPal.)
*/
this.set_Password = function(value) {
this.setInput("Password", value);
}
/*
Set the value of the PayKey input for this Choreo. ((conditional, string) The pay key that identifies the payment for which you want to retrieve details. This is the pay key returned in the response of the Pay method.)
*/
this.set_PayKey = function(value) {
this.setInput("PayKey", value);
}
/*
Set the value of the Signature input for this Choreo. ((required, string) The API Signature provided by PayPal.)
*/
this.set_Signature = function(value) {
this.setInput("Signature", value);
}
/*
Set the value of the TrackingID input for this Choreo. ((optional, string) The tracking ID that was specified for this payment in the PayRequest message.)
*/
this.set_TrackingID = function(value) {
this.setInput("TrackingID", value);
}
/*
Set the value of the TransactionID input for this Choreo. ((optional, string) The PayPal transaction ID associated with the payment. The Instant Payment Notification message associated with the payment contains the transaction ID.)
*/
this.set_TransactionID = function(value) {
this.setInput("TransactionID", value);
}
/*
Set the value of the UseSandbox input for this Choreo. ((optional, boolean) Set to 1 to indicate that you're testing against the PayPal sandbox instead of production. Set to 0 (the default) when moving to production.)
*/
this.set_UseSandbox = function(value) {
this.setInput("UseSandbox", value);
}
/*
Set the value of the Username input for this Choreo. ((required, string) The API Username provided by PayPal.)
*/
this.set_Username = function(value) {
this.setInput("Username", value);
}
}
/*
A ResultSet with methods tailored to the values returned by the PaymentDetails Choreo.
The ResultSet object is used to retrieve the results of a Choreo execution.
*/
var PaymentDetailsResultSet = function(resultStream) {
PaymentDetailsResultSet.super_.call(this, resultStream);
/*
Retrieve the value for the "Status" output from this Choreo execution. ((string) The status of the payment.)
*/
this.get_Status = function() {
return this.getResult("Status");
}
/*
Retrieve the value for the "CurrencyCode" output from this Choreo execution. ((string) The currency code for the payment.)
*/
this.get_CurrencyCode = function() {
return this.getResult("CurrencyCode");
}
/*
Retrieve the value for the "Email" output from this Choreo execution. ((string) The receiver email address.)
*/
this.get_Email = function() {
return this.getResult("Email");
}
/*
Retrieve the value for the "AccountID" output from this Choreo execution. ((string) The account id of the payment reciever.)
*/
this.get_AccountID = function() {
return this.getResult("AccountID");
}
/*
Retrieve the value for the "Response" output from this Choreo execution. ((json) The response from PayPal.)
*/
this.get_Response = function() {
return this.getResult("Response");
}
/*
Retrieve the value for the "TransactionStatus" output from this Choreo execution. ((string) The transaction status of the payment.)
*/
this.get_TransactionStatus = function() {
return this.getResult("TransactionStatus");
}
/*
Retrieve the value for the "Amount" output from this Choreo execution. ((decimal) The payment amount.)
*/
this.get_Amount = function() {
return this.getResult("Amount");
}
}
util.inherits(PaymentDetails, choreography.Choreography);
util.inherits(PaymentDetailsInputSet, choreography.InputSet);
util.inherits(PaymentDetailsResultSet, choreography.ResultSet);
exports.PaymentDetails = PaymentDetails;
|
define(['gen', 'bat', 'shared'], function(gen, bat, shared){
bat(gen);
return {
'module': "TakeWhile Tests",
'tests': [
["Simple TakeWhile",
function(){
var g = gen(shared.count())
.takeWhile(function(v){ return v < 2; })
.sync(undefined, shared.b);
assert.equal(g(), 0);
assert.equal(g(), 1);
assert.throws(g);
}],
["Zero TakeWhile",
function(){
var g = gen(shared.count())
.takeWhile(function(v){ return false; })
.sync(undefined, shared.b);
assert.throws(g);
}],
["Length TakeWhile",
function(){
var g = gen(shared.count(2))
.takeWhile(function(v){ return v < 4; })
.sync(undefined, shared.b);
assert.equal(g(), 0);
assert.equal(g(), 1);
assert.throws(g);
}],
["Custom Yield",
function(){
var b;
var g = gen(shared.count())
.takeWhile(function(v){ return v < 2; })
.sync(function(v){ b = v; return function(){}}, shared.b);
g();
assert.equal(b, 0);
g();
assert.equal(b, 1);
assert.throws(g);
}],
["Custom Break",
function(){
var b;
var g = gen(shared.count())
.takeWhile(function(v){ return v < 2; })
.sync(undefined, function(){ b = 10; return function(){}});
assert.equal(g(), 0);
assert.equal(g(), 1);
g();
assert.equal(b, 10);
}],
],
};
});
|
/* ************************************************************************
coretest
Copyright:
2010 Deutsche Telekom AG, Germany, http://telekom.com
************************************************************************ */
/* ************************************************************************
#asset(coretest/*)
************************************************************************ */
/**
* Unify application class
*/
core.Class("coretest.Application",
{
include : [unify.Application],
members :
{
// overridden
main : function()
{
// Call super class
unify.Application.prototype.main.call(this);
// Configure application
document.title = "coretest";
// Create view managers
var MasterViewManager = new unify.view.ViewManager("master");
// Register your view classes...
MasterViewManager.register(coretest.view.Start, true);
MasterViewManager.register(coretest.view.Test);
MasterViewManager.register(coretest.view.OtherTest);
// Add TabViews or SplitViews...
var TabView = new unify.view.TabViewManager(MasterViewManager);
TabView.register(coretest.view.Start);
TabView.register(coretest.view.Test);
// Add view manager (or SplitView or TabView) to the root
this.add(TabView);
//this.add(MasterViewManager);
// Add at least one view manager to the navigation managment
var Navigation = unify.view.Navigation.getInstance();
Navigation.register(MasterViewManager);
Navigation.init();
},
_getTheme : function() {
return new unify.theme.Dark();
}
}
});
|
import {isAffineMatrix} from '../src/isAffineMatrix';
import {assert} from 'chai'
describe('isAffineMatrix', () => {
it('should return true', () => {
let o1 = {a: 0, b: 0, c: 0, d: 0, e: 0, f: 0};
let o2 = {a: 0, b: 0, c: 0, d: 0, e: 0, f: 0, x: 100};
let o3 = {y: 200, a: 0, b: 0, c: 0, d: 0, e: 0, f: 0, x: 100};
assert.isTrue(isAffineMatrix(o1));
assert.isTrue(isAffineMatrix(o2));
assert.isTrue(isAffineMatrix(o3));
});
it('should return false', () => {
let o1 = {a: 0, b: 0, c: 0, d: 0, e: 0};
let o2 = {a: 0, b: 0, c: 0, d: 0, e: 0, f: Number.NaN};
let o3 = {a: 0, b: 0, c: 0, d: 0, e: Number.POSITIVE_INFINITY, f: 0};
let o4 = {a: "0", b: 0, c: 0, d: 0, e: 0, f: 0};
let o5 = "{a: 0, b: 0, c: 0, d: 0, e: 0, f: 0}";
let o6 = {};
let o7 = 42;
assert.isFalse(isAffineMatrix(o1));
assert.isFalse(isAffineMatrix(o2));
assert.isFalse(isAffineMatrix(o3));
assert.isFalse(isAffineMatrix(o4));
assert.isFalse(isAffineMatrix(o5));
assert.isFalse(isAffineMatrix(o6));
assert.isFalse(isAffineMatrix(o7));
assert.isFalse(isAffineMatrix(null))
})
});
|
/**
* Copyright: (c) 2015 Max Klein
* License: MIT
*/
var InputManager = (function (window, document) {
"use strict";
function InputManager(game, target) {
this.game = game;
this.target = target;
this.mouseDown = false;
this.lastMouseDown = false;
this.mousePressed = false;
this.mouseReleased = false;
this.keyDown = {};
this.register();
}
InputManager.prototype.register = function () {
var self = this;
function onMouseDown(evt) {
evt.preventDefault();
self.mouseDown = true;
}
function onMouseUp(evt) {
evt.preventDefault();
self.mouseDown = false;
}
var target = this.target;
target.addEventListener("touchstart", onMouseDown);
target.addEventListener("mousedown", onMouseDown);
target.addEventListener("touchend", onMouseUp);
target.addEventListener("touchcancel", onMouseUp);
target.addEventListener("mouseup", onMouseUp);
target.addEventListener("mouseleave", onMouseUp);
target.addEventListener("mouseout", onMouseUp);
window.addEventListener("keydown", function (evt) {
self.keyDown[evt.which] = true;
});
window.addEventListener("keyup", function (evt) {
self.keyDown[evt.which] = false;
});
};
InputManager.prototype.tick = function () {
this.mousePressed = !this.lastMouseDown && this.mouseDown;
this.mouseReleased = this.lastMouseDown && !this.mouseDown;
this.lastMouseDown = this.mouseDown;
};
return InputManager;
})(window, document);
|
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var Panel = {
defaults: {
fullscreen: false,
background: '#333'
},
// class variable for reference to all panels
panels: [],
create: function create() {
var props = arguments.length <= 0 || arguments[0] === undefined ? null : arguments[0];
var panel = Object.create(this);
// default: full window interface
if (props === null) {
Object.assign(panel, Panel.defaults, {
x: 0,
y: 0,
width: 1,
height: 1,
__x: 0,
__y: 0,
__width: null,
__height: null,
fullscreen: true,
children: []
});
panel.div = panel.__createHTMLElement();
panel.layout();
var body = document.querySelector('body');
body.appendChild(panel.div);
}
Panel.panels.push(panel);
return panel;
},
__createHTMLElement: function __createHTMLElement() {
var div = document.createElement('div');
div.style.position = 'absolute';
div.style.display = 'block';
div.style.backgroundColor = this.background;
return div;
},
layout: function layout() {
if (this.fullscreen) {
this.__width = window.innerWidth;
this.__height = window.innerHeight;
this.__x = this.x * this.__width;
this.__y = this.y * this.__height;
this.div.style.width = this.__width + 'px';
this.div.style.height = this.__height + 'px';
this.div.style.left = this.__x + 'px';
this.div.style.top = this.__y + 'px';
}
},
getWidth: function getWidth() {
return this.__width;
},
getHeight: function getHeight() {
return this.__height;
},
add: function add() {
for (var _len = arguments.length, widgets = Array(_len), _key = 0; _key < _len; _key++) {
widgets[_key] = arguments[_key];
}
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = widgets[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var widget = _step.value;
// check to make sure widget has not been already added
if (this.children.indexOf(widget) === -1) {
if (typeof widget.__addToPanel === 'function') {
this.div.appendChild(widget.element);
this.children.push(widget);
widget.__addToPanel(this);
} else {
throw Error('Widget cannot be added to panel; it does not contain the method .__addToPanel');
}
} else {
throw Error('Widget is already added to panel.');
}
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
}
};
exports.default = Panel; |
"use strict";
define(['model/DomoticItemModel'],
function(DomoticItem) {
return DomoticItem.extend({
defaults: {
"@type": "LightSwitch",
"status": "OFF"
}
});
}
);
|
/*
* jQuery Click with Children
* Version 1.1.9
* http://picturelife.com
*
* A jQuery plugin that overwrites the click event to work when the mousedown
* occurs on the element and the mouseup event occurs on a child element
*
* Copyright (c) 2013 Picturelife Inc (picturelife.com)
* Licensed under the MIT license
* https://raw.github.com/Picturelife/Click-with-Children/master/LICENSE.txt
*
*/
(function ($) {
"use strict";
// A private property.
var EVENT = 'click',
EVENT_CLASS = '.click_with_children';
// Special event definition.
$.event.special[EVENT] = {
setup: function (data, namespaces) {
$(this).bind('mousedown' + EVENT_CLASS, $.event.special[EVENT].down);
},
teardown: function (namespaces) {
$(this).unbind(EVENT_CLASS)
.children().unbind(EVENT_CLASS);
},
down: function (e) {
var elem = this;
$(elem).bind('mouseup' + EVENT_CLASS, $.event.special[EVENT].up);
$(elem).children().bind('mouseup' + EVENT_CLASS, function (e) {
$.event.special[EVENT].up.apply(elem, arguments);
});
},
up: function (e) {
e.type = EVENT;
$.event.dispatch.apply(this, arguments);
$(this).unbind('mouseup' + EVENT_CLASS)
.children().unbind('mouseup' + EVENT_CLASS);
}
};
}(jQuery)); |
export default {
// 小写
initmusicmes({ commit }, value) {
console.log(value)
commit('INITMUSICMES', value)
},
// 语言切换保存到状态管理
update_current_lang({ commit }, payload) {
commit('UPDATE_CURRENT_LANG', payload)
}
}
|
'use strict';
class AppConfig {
constructor(appConstant, appAnotherConstant) {
appConstant.value = appAnotherConstant;
}
}
module.exports = AppConfig; |
'use strict';
angular.module('kkNavigation', [])
.controller('NavigationCtrl', function ($scope, $http) {
$http.get('/api/is_admin').success(function(data, status, headers, config) {
$scope.is_admin = data.is_admin;
});
$http.get('/api/user_id').success(function(data, status, headers, config) {
$scope.user_id = data.user_id;
});
$http.get('/api/hide_matches').success(function(data, status, headers, config) {
$scope.hide_matches = data.hide_matches;
});
}); |
const {
Bookmark,
Song,
User
} = require('../models')
const _ = require('lodash');
module.exports = {
async index (req, res) {
try {
const userId = req.user.id
const { songId } = req.query
const where = {
UserId: userId
}
if (songId) {
where.SongId = songId
}
const bookmarks = await Bookmark.findAll({
where,
include: [
{
model: Song
}
]
}).map(bookmark => bookmark.toJSON())
.map(bookmark => _.extend(
{},
bookmark.Song,
bookmark
))
res.send(bookmarks)
} catch (e) {
res.status(500).send({
error: 'An error has occured trying to fetch the bookmark'
})
}
},
async post (req, res) {
try {
const userId = req.user.id
const { songId } = req.body
const bookmark = await Bookmark.findOne({
where: {
SongId: songId,
UserId: userId
}
})
console.log(bookmark)
if (bookmark) {
return res.status(400).send({
error: 'You already have this set as a bookmark'
})
}
const newBookmark = await Bookmark.create({
SongId: songId,
UserId: userId
})
res.send(newBookmark)
} catch (e) {
res.status(500).send({
error: 'An error has occured trying to create the bookmark'
})
}
},
async delete (req, res) {
try {
const userId = req.user.id
const { bookmarkId } = req.params
const bookmark = await Bookmark.findOne({
where: {
id: bookmarkId,
UserId: userId
}
})
if (!bookmark) {
return res.status(403).send({
error: 'You do not have access to this bookmark'
})
}
await bookmark.destroy()
res.send(bookmark)
} catch (e) {
res.status(500).send({
error: 'An error has occured trying to delete the bookmark'
})
}
}
}
|
'use strict';
angular.module('licenseManager.shared')
.service('messageService', ['$window', function ($window) {
this.confirm = function (message) {
return $window.confirm(message);
};
this.message = function (message) {
Materialize.toast(message, 4000);
};
this.error = function (message) {
Materialize.toast(message, 6000, 'red');
};
}]); |
'use strict';
/**
* Module dependencies.
*/
var
_ = require('lodash'),
mongoose = require('mongoose'),
Schema = mongoose.Schema;
var SmsMessageSchema = new Schema({
phoneNumber: {
type: String,
match: [/[0-9]{10}/, 'phonenumber must be 10 digits no spaces']
},
message: {
type:String,
required: 'message cannot be blank'
},
created: {
type: Date,
default: Date.now
}
});
mongoose.model('SmsMessage', SmsMessageSchema);
|
var Array = require('../array')
var Value = require('../value')
var value = Value('human')
var array = Array(['cat'])
array(x => console.log(x))
array.push('dog')
array.push('cow')
array.push(value)
array.push('chicken')
console.log('shift =>', array.shift())
array.push('wolf')
array.insert('sheep', 0)
console.log('pop =>', array.pop())
value.set('monkey')
|
/**
* Created by cpc on 6/12/16.
*/
export const LANGUAGE_NAMES = {
f: ['Fortran'],
c: ['C', 'GCC'],
cs: ['C#'],
cpp: ['C++', 'G++'],
java: ['Java'],
pas: ['Pascal'],
py: ['Python'],
};
export const LANGUAGES = {
local: ['C', 'C++', 'Java', 'Python'],
POJ: ['G++', 'GCC', 'Java', 'Pascal', 'C++', 'C', 'Fortran'],
HDOJ: ['G++', 'GCC', 'C++', 'C', 'Pascal', 'Java', 'C#'],
};
export const LANGUAGE_MODES = {
f: 'text/x-fortran',
c: 'text/x-csrc',
cpp: 'text/x-c++src',
cs: 'text/x-csharp',
java: 'text/x-java',
pas: 'text/x-pascal',
py: 'python',
};
export const getModeByName = (name) => {
let mode = '';
Object.keys(LANGUAGE_NAMES).forEach((lang) => {
const names = LANGUAGE_NAMES[lang];
if (names.indexOf(name) !== -1) {
mode = LANGUAGE_MODES[lang];
}
});
return mode;
};
export const getModeByValue = (oj, value) =>
getModeByName(LANGUAGES[oj][value]);
|
/**
* Framework7 1.0.6
* Full Featured Mobile HTML Framework For Building iOS Apps
*
* http://www.idangero.us/framework7
*
* Copyright 2015, Vladimir Kharlampidi
* The iDangero.us
* http://www.idangero.us/
*
* Licensed under MIT
*
* Released on: April 29, 2015
*/
(function () {
'use strict';
/*===========================
Framework 7
===========================*/
window.Framework7 = function (params) {
// App
var app = this;
// Version
app.version = '1.0.6';
// Default Parameters
app.params = {
cache: true,
cacheIgnore: [],
cacheIgnoreGetParameters: false,
cacheDuration: 1000 * 60 * 10, // Ten minutes
preloadPreviousPage: true,
uniqueHistory: false,
uniqueHistoryIgnoreGetParameters: false,
dynamicPageUrl: 'content-{{index}}',
allowDuplicateUrls: false,
router: true,
// Push State
pushState: false,
pushStateRoot: undefined,
pushStateNoAnimation: false,
pushStateSeparator: '#!/',
pushStatePreventOnLoad: true,
// Fast clicks
fastClicks: true,
fastClicksDistanceThreshold: 0,
fastClicksDelayBetweenClicks: 50,
// Tap Hold
tapHold: false,
tapHoldDelay: 750,
tapHoldPreventClicks: true,
// Active State
activeState: true,
activeStateElements: 'a, button, label, span',
// Animate Nav Back Icon
animateNavBackIcon: false,
// Swipe Back
swipeBackPage: true,
swipeBackPageThreshold: 0,
swipeBackPageActiveArea: 30,
swipeBackPageAnimateShadow: true,
swipeBackPageAnimateOpacity: true,
// Ajax
ajaxLinks: undefined, // or CSS selector
// External Links
externalLinks: '.external', // CSS selector
// Sortable
sortable: true,
// Scroll toolbars
hideNavbarOnPageScroll: false,
hideToolbarOnPageScroll: false,
hideTabbarOnPageScroll: false,
showBarsOnPageScrollEnd: true,
showBarsOnPageScrollTop: true,
// Swipeout
swipeout: true,
swipeoutActionsNoFold: false,
swipeoutNoFollow: false,
// Smart Select Back link template
smartSelectBackTemplate: '<div class="left sliding"><a href="#" class="back link"><i class="icon icon-back"></i><span>{{backText}}</span></a></div>',
smartSelectBackText: 'Back',
smartSelectInPopup: false,
smartSelectPopupCloseTemplate: '<div class="left"><a href="#" class="link close-popup"><i class="icon icon-back"></i><span>{{closeText}}</span></a></div>',
smartSelectPopupCloseText: 'Close',
smartSelectSearchbar: false,
smartSelectBackOnSelect: false,
// Searchbar
searchbarHideDividers: true,
searchbarHideGroups: true,
// Tap Navbar or Statusbar to scroll to top
scrollTopOnNavbarClick: false,
scrollTopOnStatusbarClick: false,
// Panels
swipePanel: false, // or 'left' or 'right'
swipePanelActiveArea: 0,
swipePanelCloseOpposite: true,
swipePanelOnlyClose: false,
swipePanelNoFollow: false,
swipePanelThreshold: 0,
panelsCloseByOutside: true,
// Modals
modalButtonOk: 'OK',
modalButtonCancel: 'Cancel',
modalUsernamePlaceholder: 'Username',
modalPasswordPlaceholder: 'Password',
modalTitle: 'Framework7',
modalCloseByOutside: false,
actionsCloseByOutside: true,
popupCloseByOutside: true,
modalPreloaderTitle: 'Loading... ',
modalStack: true,
// Lazy Load
imagesLazyLoadThreshold: 0,
imagesLazyLoadSequential: true,
// Name space
viewClass: 'view',
viewMainClass: 'view-main',
viewsClass: 'views',
// Notifications defaults
notificationCloseOnClick: false,
notificationCloseIcon: true,
// Animate Pages
animatePages: true,
// Template7
templates: {},
template7Data: {},
template7Pages: false,
precompileTemplates: false,
// Auto init
init: true,
};
// Extend defaults with parameters
for (var param in params) {
app.params[param] = params[param];
}
// DOM lib
var $ = Dom7;
// Template7 lib
var t7 = Template7;
app._compiledTemplates = {};
// Touch events
app.touchEvents = {
start: app.support.touch ? 'touchstart' : 'mousedown',
move: app.support.touch ? 'touchmove' : 'mousemove',
end: app.support.touch ? 'touchend' : 'mouseup'
};
// Link to local storage
app.ls = window.localStorage;
// RTL
app.rtl = $('body').css('direction') === 'rtl';
if (app.rtl) $('html').attr('dir', 'rtl');
// Overwrite statusbar overlay
if (typeof app.params.statusbarOverlay !== 'undefined') {
if (app.params.statusbarOverlay) $('html').addClass('with-statusbar-overlay');
else $('html').removeClass('with-statusbar-overlay');
}
/*======================================================
************ Views ************
======================================================*/
app.views = [];
var View = function (selector, params) {
var defaults = {
dynamicNavbar: false,
domCache: false,
linksView: undefined,
reloadPages: false,
uniqueHistory: app.params.uniqueHistory,
uniqueHistoryIgnoreGetParameters: app.params.uniqueHistoryIgnoreGetParameters,
allowDuplicateUrls: app.params.allowDuplicateUrls,
swipeBackPage: app.params.swipeBackPage,
swipeBackPageAnimateShadow: app.params.swipeBackPageAnimateShadow,
swipeBackPageAnimateOpacity: app.params.swipeBackPageAnimateOpacity,
swipeBackPageActiveArea: app.params.swipeBackPageActiveArea,
swipeBackPageThreshold: app.params.swipeBackPageThreshold,
animatePages: app.params.animatePages,
preloadPreviousPage: app.params.preloadPreviousPage
};
var i;
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined') {
params[def] = defaults[def];
}
}
// View
var view = this;
view.params = params;
// Selector
view.selector = selector;
// Container
var container = $(selector);
view.container = container[0];
// Is main
view.main = container.hasClass(app.params.viewMainClass);
// Content cache
view.contentCache = {};
// Pages cache
view.pagesCache = {};
// Store View in element for easy access
container[0].f7View = view;
// Pages
view.pagesContainer = container.find('.pages')[0];
view.initialPages = [];
view.initialNavbars = [];
if (view.params.domCache) {
var initialPages = container.find('.page');
for (i = 0; i < initialPages.length; i++) {
view.initialPages.push(initialPages[i]);
}
if (view.params.dynamicNavbar) {
var initialNavbars = container.find('.navbar-inner');
for (i = 0; i < initialNavbars.length; i++) {
view.initialNavbars.push(initialNavbars[i]);
}
}
}
view.allowPageChange = true;
// Location
var docLocation = document.location.href;
// History
view.history = [];
var viewURL = docLocation;
var pushStateSeparator = app.params.pushStateSeparator;
var pushStateRoot = app.params.pushStateRoot;
if (app.params.pushState && view.main) {
if (pushStateRoot) {
viewURL = pushStateRoot;
}
else {
if (viewURL.indexOf(pushStateSeparator) >= 0 && viewURL.indexOf(pushStateSeparator + '#') < 0) viewURL = viewURL.split(pushStateSeparator)[0];
}
}
// Active Page
var currentPage, currentPageData;
if (!view.activePage) {
currentPage = $(view.pagesContainer).find('.page-on-center');
if (currentPage.length === 0) {
currentPage = $(view.pagesContainer).find('.page:not(.cached)');
currentPage = currentPage.eq(currentPage.length - 1);
}
if (currentPage.length > 0) {
currentPageData = currentPage[0].f7PageData;
}
}
// View startup URL
if (view.params.domCache && currentPage) {
view.url = container.attr('data-url') || view.params.url || '#' + currentPage.attr('data-page');
view.pagesCache[view.url] = currentPage.attr('data-page');
}
else view.url = container.attr('data-url') || view.params.url || viewURL;
// Update current page Data
if (currentPageData) {
currentPageData.view = view;
currentPageData.url = view.url;
view.activePage = currentPageData;
currentPage[0].f7PageData = currentPageData;
}
// Store to history main view's url
if (view.url) {
view.history.push(view.url);
}
// Touch events
var isTouched = false,
isMoved = false,
touchesStart = {},
isScrolling,
activePage = [],
previousPage = [],
viewContainerWidth,
touchesDiff,
allowViewTouchMove = true,
touchStartTime,
activeNavbar = [],
previousNavbar = [],
activeNavElements,
previousNavElements,
activeNavBackIcon,
previousNavBackIcon,
dynamicNavbar,
pageShadow,
el;
view.handleTouchStart = function (e) {
if (!allowViewTouchMove || !view.params.swipeBackPage || isTouched || app.swipeoutOpenedEl || !view.allowPageChange) return;
isMoved = false;
isTouched = true;
isScrolling = undefined;
touchesStart.x = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
touchesStart.y = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
touchStartTime = (new Date()).getTime();
dynamicNavbar = view.params.dynamicNavbar && container.find('.navbar-inner').length > 1;
};
view.handleTouchMove = function (e) {
if (!isTouched) return;
var pageX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
var pageY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (typeof isScrolling === 'undefined') {
isScrolling = !!(isScrolling || Math.abs(pageY - touchesStart.y) > Math.abs(pageX - touchesStart.x));
}
if (isScrolling || e.f7PreventSwipeBack || app.preventSwipeBack) {
isTouched = false;
return;
}
if (!isMoved) {
var cancel = false;
// Calc values during first move fired
viewContainerWidth = container.width();
var target = $(e.target);
var swipeout = target.hasClass('swipeout') ? target : target.parents('.swipeout');
if (swipeout.length > 0) {
if (!app.rtl && swipeout.find('.swipeout-actions-left').length > 0) cancel = true;
if (app.rtl && swipeout.find('.swipeout-actions-right').length > 0) cancel = true;
}
activePage = target.is('.page') ? target : target.parents('.page');
if (activePage.hasClass('no-swipeback')) cancel = true;
previousPage = container.find('.page-on-left:not(.cached)');
var notFromBorder = touchesStart.x - container.offset().left > view.params.swipeBackPageActiveArea;
if (app.rtl) {
notFromBorder = touchesStart.x < container.offset().left - container[0].scrollLeft + viewContainerWidth - view.params.swipeBackPageActiveArea;
}
else {
notFromBorder = touchesStart.x - container.offset().left > view.params.swipeBackPageActiveArea;
}
if (notFromBorder) cancel = true;
if (previousPage.length === 0 || activePage.length === 0) cancel = true;
if (cancel) {
isTouched = false;
return;
}
if (view.params.swipeBackPageAnimateShadow && !app.device.android) {
pageShadow = activePage.find('.swipeback-page-shadow');
if (pageShadow.length === 0) {
pageShadow = $('<div class="swipeback-page-shadow"></div>');
activePage.append(pageShadow);
}
}
if (dynamicNavbar) {
activeNavbar = container.find('.navbar-on-center:not(.cached)');
previousNavbar = container.find('.navbar-on-left:not(.cached)');
activeNavElements = activeNavbar.find('.left, .center, .right, .subnavbar, .fading');
previousNavElements = previousNavbar.find('.left, .center, .right, .subnavbar, .fading');
if (app.params.animateNavBackIcon) {
activeNavBackIcon = activeNavbar.find('.left.sliding .back .icon');
previousNavBackIcon = previousNavbar.find('.left.sliding .back .icon');
}
}
// Close/Hide Any Picker
if ($('.picker-modal.modal-in').length > 0) {
app.closeModal($('.picker-modal.modal-in'));
}
}
e.f7PreventPanelSwipe = true;
isMoved = true;
e.preventDefault();
// RTL inverter
var inverter = app.rtl ? -1 : 1;
// Touches diff
touchesDiff = (pageX - touchesStart.x - view.params.swipeBackPageThreshold) * inverter;
if (touchesDiff < 0) touchesDiff = 0;
var percentage = touchesDiff / viewContainerWidth;
// Swipe Back Callback
var callbackData = {
percentage: percentage,
activePage: activePage[0],
previousPage: previousPage[0],
activeNavbar: activeNavbar[0],
previousNavbar: previousNavbar[0]
};
if (view.params.onSwipeBackMove) {
view.params.onSwipeBackMove(callbackData);
}
container.trigger('swipeBackMove', callbackData);
// Transform pages
var activePageTranslate = touchesDiff * inverter;
var previousPageTranslate = (touchesDiff / 5 - viewContainerWidth / 5) * inverter;
if (app.device.pixelRatio === 1) {
activePageTranslate = Math.round(activePageTranslate);
previousPageTranslate = Math.round(previousPageTranslate);
}
activePage.transform('translate3d(' + activePageTranslate + 'px,0,0)');
if (view.params.swipeBackPageAnimateShadow && !app.device.android) pageShadow[0].style.opacity = 1 - 1 * percentage;
previousPage.transform('translate3d(' + previousPageTranslate + 'px,0,0)');
if (view.params.swipeBackPageAnimateOpacity) previousPage[0].style.opacity = 0.9 + 0.1 * percentage;
// Dynamic Navbars Animation
if (dynamicNavbar) {
var i;
for (i = 0; i < activeNavElements.length; i++) {
el = $(activeNavElements[i]);
if (!el.is('.subnavbar.sliding')) el[0].style.opacity = (1 - percentage * 1.3);
if (el[0].className.indexOf('sliding') >= 0) {
var activeNavTranslate = percentage * el[0].f7NavbarRightOffset;
if (app.device.pixelRatio === 1) activeNavTranslate = Math.round(activeNavTranslate);
el.transform('translate3d(' + activeNavTranslate + 'px,0,0)');
if (app.params.animateNavBackIcon) {
if (el[0].className.indexOf('left') >= 0 && activeNavBackIcon.length > 0) {
activeNavBackIcon.transform('translate3d(' + -activeNavTranslate + 'px,0,0)');
}
}
}
}
for (i = 0; i < previousNavElements.length; i++) {
el = $(previousNavElements[i]);
if (!el.is('.subnavbar.sliding')) el[0].style.opacity = percentage * 1.3 - 0.3;
if (el[0].className.indexOf('sliding') >= 0) {
var previousNavTranslate = el[0].f7NavbarLeftOffset * (1 - percentage);
if (app.device.pixelRatio === 1) previousNavTranslate = Math.round(previousNavTranslate);
el.transform('translate3d(' + previousNavTranslate + 'px,0,0)');
if (app.params.animateNavBackIcon) {
if (el[0].className.indexOf('left') >= 0 && previousNavBackIcon.length > 0) {
previousNavBackIcon.transform('translate3d(' + -previousNavTranslate + 'px,0,0)');
}
}
}
}
}
};
view.handleTouchEnd = function (e) {
if (!isTouched || !isMoved) {
isTouched = false;
isMoved = false;
return;
}
isTouched = false;
isMoved = false;
if (touchesDiff === 0) {
$([activePage[0], previousPage[0]]).transform('').css({opacity: '', boxShadow: ''});
if (dynamicNavbar) {
activeNavElements.transform('').css({opacity: ''});
previousNavElements.transform('').css({opacity: ''});
if (activeNavBackIcon && activeNavBackIcon.length > 0) activeNavBackIcon.transform('');
if (previousNavBackIcon && activeNavBackIcon.length > 0) previousNavBackIcon.transform('');
}
return;
}
var timeDiff = (new Date()).getTime() - touchStartTime;
var pageChanged = false;
// Swipe back to previous page
if (
timeDiff < 300 && touchesDiff > 10 ||
timeDiff >= 300 && touchesDiff > viewContainerWidth / 2
) {
activePage.removeClass('page-on-center').addClass('page-on-right');
previousPage.removeClass('page-on-left').addClass('page-on-center');
if (dynamicNavbar) {
activeNavbar.removeClass('navbar-on-center').addClass('navbar-on-right');
previousNavbar.removeClass('navbar-on-left').addClass('navbar-on-center');
}
pageChanged = true;
}
// Reset custom styles
// Add transitioning class for transition-duration
$([activePage[0], previousPage[0]]).transform('').css({opacity: '', boxShadow: ''}).addClass('page-transitioning');
if (dynamicNavbar) {
activeNavElements.css({opacity: ''})
.each(function () {
var translate = pageChanged ? this.f7NavbarRightOffset : 0;
var sliding = $(this);
sliding.transform('translate3d(' + translate + 'px,0,0)');
if (app.params.animateNavBackIcon) {
if (sliding.hasClass('left') && activeNavBackIcon.length > 0) {
activeNavBackIcon.addClass('page-transitioning').transform('translate3d(' + -translate + 'px,0,0)');
}
}
}).addClass('page-transitioning');
previousNavElements.transform('').css({opacity: ''}).each(function () {
var translate = pageChanged ? 0 : this.f7NavbarLeftOffset;
var sliding = $(this);
sliding.transform('translate3d(' + translate + 'px,0,0)');
if (app.params.animateNavBackIcon) {
if (sliding.hasClass('left') && previousNavBackIcon.length > 0) {
previousNavBackIcon.addClass('page-transitioning').transform('translate3d(' + -translate + 'px,0,0)');
}
}
}).addClass('page-transitioning');
}
allowViewTouchMove = false;
view.allowPageChange = false;
// Swipe Back Callback
var callbackData = {
activePage: activePage[0],
previousPage: previousPage[0],
activeNavbar: activeNavbar[0],
previousNavbar: previousNavbar[0]
};
if (pageChanged) {
// Update View's URL
var url = view.history[view.history.length - 2];
view.url = url;
// Page before animation callback
app.pageBackCallback('before', view, {pageContainer: activePage[0], url: url, position: 'center', newPage: previousPage, oldPage: activePage, swipeBack: true});
app.pageAnimCallback('before', view, {pageContainer: previousPage[0], url: url, position: 'left', newPage: previousPage, oldPage: activePage, swipeBack: true});
if (view.params.onSwipeBackBeforeChange) {
view.params.onSwipeBackBeforeChange(callbackData);
}
container.trigger('swipeBackBeforeChange', callbackData);
}
else {
if (view.params.onSwipeBackBeforeReset) {
view.params.onSwipeBackBeforeReset(callbackData);
}
container.trigger('swipeBackBeforeReset', callbackData);
}
activePage.transitionEnd(function () {
$([activePage[0], previousPage[0]]).removeClass('page-transitioning');
if (dynamicNavbar) {
activeNavElements.removeClass('page-transitioning').css({opacity: ''});
previousNavElements.removeClass('page-transitioning').css({opacity: ''});
if (activeNavBackIcon && activeNavBackIcon.length > 0) activeNavBackIcon.removeClass('page-transitioning');
if (previousNavBackIcon && previousNavBackIcon.length > 0) previousNavBackIcon.removeClass('page-transitioning');
}
allowViewTouchMove = true;
view.allowPageChange = true;
if (pageChanged) {
if (app.params.pushState && view.main) history.back();
// Page after animation callback
app.pageBackCallback('after', view, {pageContainer: activePage[0], url: url, position: 'center', newPage: previousPage, oldPage: activePage, swipeBack: true});
app.pageAnimCallback('after', view, {pageContainer: previousPage[0], url: url, position: 'left', newPage: previousPage, oldPage: activePage, swipeBack: true});
app.router.afterBack(view, activePage, previousPage);
if (view.params.onSwipeBackAfterChange) {
view.params.onSwipeBackAfterChange(callbackData);
}
container.trigger('swipeBackAfterChange', callbackData);
}
else {
if (view.params.onSwipeBackAfterReset) {
view.params.onSwipeBackAfterReset(callbackData);
}
container.trigger('swipeBackAfterReset', callbackData);
}
if (pageShadow && pageShadow.length > 0) pageShadow.remove();
});
};
view.attachEvents = function (detach) {
var action = detach ? 'off' : 'on';
container[action](app.touchEvents.start, view.handleTouchStart);
container[action](app.touchEvents.move, view.handleTouchMove);
container[action](app.touchEvents.end, view.handleTouchEnd);
};
view.detachEvents = function () {
view.attachEvents(true);
};
// Init
if (view.params.swipeBackPage && !app.params.material) {
view.attachEvents();
}
// Add view to app
app.views.push(view);
if (view.main) app.mainView = view;
// Router
view.router = {
load: function (options) {
return app.router.load(view, options);
},
back: function (options) {
return app.router.back(view, options);
},
// Shortcuts
loadPage: function (options) {
options = options || {};
if (typeof options === 'string') {
var url = options;
options = {};
if (url && url.indexOf('#') === 0 && view.params.domCache) {
options.pageName = url.split('#')[1];
}
else options.url = url;
}
return app.router.load(view, options);
},
loadContent: function (content) {
return app.router.load(view, {content: content});
},
reloadPage: function (url) {
return app.router.load(view, {url: url, reload: true});
},
reloadContent: function (content) {
return app.router.load(view, {content: content, reload: true});
},
reloadPreviousPage: function (url) {
return app.router.load(view, {url: url, reloadPrevious: true, reload: true});
},
reloadPreviousContent: function (content) {
return app.router.load(view, {content: content, reloadPrevious: true, reload: true});
},
refreshPage: function () {
var options = {
url: view.url,
reload: true,
ignoreCache: true
};
if (options.url && options.url.indexOf('#') === 0) {
if (view.params.domCache && view.pagesCache[options.url]) {
options.pageName = view.pagesCache[options.url];
options.url = undefined;
delete options.url;
}
else if (view.contentCache[options.url]) {
options.content = view.contentCache[options.url];
options.url = undefined;
delete options.url;
}
}
return app.router.load(view, options);
},
refreshPreviousPage: function () {
var options = {
url: view.history[view.history.length - 2],
reload: true,
reloadPrevious: true,
ignoreCache: true
};
if (options.url && options.url.indexOf('#') === 0 && view.params.domCache && view.pagesCache[options.url]) {
options.pageName = view.pagesCache[options.url];
options.url = undefined;
delete options.url;
}
return app.router.load(view, options);
}
};
// Aliases for temporary backward compatibility
view.loadPage = view.router.loadPage;
view.loadContent = view.router.loadContent;
view.reloadPage = view.router.reloadPage;
view.reloadContent = view.router.reloadContent;
view.reloadPreviousPage = view.router.reloadPreviousPage;
view.reloadPreviousContent = view.router.reloadPreviousContent;
view.refreshPage = view.router.refreshPage;
view.refreshPreviousPage = view.router.refreshPreviousPage;
view.back = view.router.back;
// Bars methods
view.hideNavbar = function () {
return app.hideNavbar(container.find('.navbar'));
};
view.showNavbar = function () {
return app.showNavbar(container.find('.navbar'));
};
view.hideToolbar = function () {
return app.hideToolbar(container.find('.toolbar'));
};
view.showToolbar = function () {
return app.showToolbar(container.find('.toolbar'));
};
// Push State on load
if (app.params.pushState && view.main) {
var pushStateUrl;
if (pushStateRoot) {
pushStateUrl = docLocation.split(app.params.pushStateRoot + pushStateSeparator)[1];
}
else if (docLocation.indexOf(pushStateSeparator) >= 0 && docLocation.indexOf(pushStateSeparator + '#') < 0) {
pushStateUrl = docLocation.split(pushStateSeparator)[1];
}
var pushStateAnimatePages = app.params.pushStateNoAnimation ? false : undefined;
if (pushStateUrl) {
app.router.load(view, {url: pushStateUrl, animatePages: pushStateAnimatePages, pushState: false});
}
else if (docLocation.indexOf(pushStateSeparator + '#') >= 0) {
var state = history.state;
if (state.pageName && 'viewIndex' in state) {
app.router.load(view, {pageName: state.pageName, pushState: false});
}
}
}
// Destroy
view.destroy = function () {
view.detachEvents();
view = undefined;
};
// Plugin hook
app.pluginHook('addView', view);
// Return view
return view;
};
app.addView = function (selector, params) {
return new View(selector, params);
};
app.getCurrentView = function (index) {
var popoverView = $('.popover.modal-in .view');
var popupView = $('.popup.modal-in .view');
var panelView = $('.panel.active .view');
var appViews = $('.views');
// Find active view as tab
var appView = appViews.children('.view');
// Propably in tabs or split view
if (appView.length > 1) {
if (appView.hasClass('tab')) {
// Tabs
appView = appViews.children('.view.active');
}
else {
// Split View, leave appView intact
}
}
if (popoverView.length > 0 && popoverView[0].f7View) return popoverView[0].f7View;
if (popupView.length > 0 && popupView[0].f7View) return popupView[0].f7View;
if (panelView.length > 0 && panelView[0].f7View) return panelView[0].f7View;
if (appView.length > 0) {
if (appView.length === 1 && appView[0].f7View) return appView[0].f7View;
if (appView.length > 1) {
var currentViews = [];
for (var i = 0; i < appView.length; i++) {
if (appView[i].f7View) currentViews.push(appView[i].f7View);
}
if (currentViews.length > 0 && typeof index !== 'undefined') return currentViews[index];
if (currentViews.length > 1) return currentViews;
if (currentViews.length === 1) return currentViews[0];
return undefined;
}
}
return undefined;
};
/*======================================================
************ Navbars && Toolbars ************
======================================================*/
// On Navbar Init Callback
app.navbarInitCallback = function (view, pageContainer, navbarContainer, navbarInnerContainer) {
if (!navbarContainer && navbarInnerContainer) navbarContainer = $(navbarInnerContainer).parent('.navbar')[0];
if (navbarInnerContainer.f7NavbarInitialized && !view.params.domCache) return;
var navbarData = {
container: navbarContainer,
innerContainer: navbarInnerContainer
};
var pageData = pageContainer && pageContainer.f7PageData;
var eventData = {
page: pageData,
navbar: navbarData
};
if (navbarInnerContainer.f7NavbarInitialized && view.params.domCache) {
// Reinit Navbar
app.reinitNavbar(navbarContainer, navbarInnerContainer);
// Plugin hook
app.pluginHook('navbarReinit', eventData);
// Event
$(navbarInnerContainer).trigger('navbarReinit', eventData);
return;
}
navbarInnerContainer.f7NavbarInitialized = true;
// Before Init
app.pluginHook('navbarBeforeInit', navbarData, pageData);
$(navbarInnerContainer).trigger('navbarBeforeInit', eventData);
// Initialize Navbar
app.initNavbar(navbarContainer, navbarInnerContainer);
// On init
app.pluginHook('navbarInit', navbarData, pageData);
$(navbarInnerContainer).trigger('navbarInit', eventData);
};
// Navbar Remove Callback
app.navbarRemoveCallback = function (view, pageContainer, navbarContainer, navbarInnerContainer) {
if (!navbarContainer && navbarInnerContainer) navbarContainer = $(navbarInnerContainer).parent('.navbar')[0];
var navbarData = {
container: navbarContainer,
innerContainer: navbarInnerContainer
};
var pageData = pageContainer.f7PageData;
var eventData = {
page: pageData,
navbar: navbarData
};
app.pluginHook('navbarBeforeRemove', navbarData, pageData);
$(navbarInnerContainer).trigger('navbarBeforeRemove', eventData);
};
app.initNavbar = function (navbarContainer, navbarInnerContainer) {
// Init Subnavbar Searchbar
if (app.initSearchbar) app.initSearchbar(navbarInnerContainer);
};
app.reinitNavbar = function (navbarContainer, navbarInnerContainer) {
// Re init navbar methods
};
app.initNavbarWithCallback = function (navbarContainer) {
navbarContainer = $(navbarContainer);
var viewContainer = navbarContainer.parents('.' + app.params.viewClass);
var view;
if (viewContainer.length === 0) return;
if (navbarContainer.parents('.navbar-through').length === 0 && viewContainer.find('.navbar-through').length === 0) return;
view = viewContainer[0].f7View || undefined;
navbarContainer.find('.navbar-inner').each(function () {
var navbarInnerContainer = this;
var pageContainer;
if ($(navbarInnerContainer).attr('data-page')) {
// For dom cache
pageContainer = viewContainer.find('.page[data-page="' + $(navbarInnerContainer).attr('data-page') + '"]')[0];
}
if (!pageContainer) {
var pages = viewContainer.find('.page');
if (pages.length === 1) {
pageContainer = pages[0];
}
else {
viewContainer.find('.page').each(function () {
if (this.f7PageData && this.f7PageData.navbarInnerContainer === navbarInnerContainer) {
pageContainer = this;
}
});
}
}
app.navbarInitCallback(view, pageContainer, navbarContainer[0], navbarInnerContainer);
});
};
// Size Navbars
app.sizeNavbars = function (viewContainer) {
if (app.params.material) return;
var navbarInner = viewContainer ? $(viewContainer).find('.navbar .navbar-inner:not(.cached)') : $('.navbar .navbar-inner:not(.cached)');
navbarInner.each(function () {
var n = $(this);
if (n.hasClass('cached')) return;
var left = app.rtl ? n.find('.right') : n.find('.left'),
right = app.rtl ? n.find('.left') : n.find('.right'),
center = n.find('.center'),
subnavbar = n.find('.subnavbar'),
noLeft = left.length === 0,
noRight = right.length === 0,
leftWidth = noLeft ? 0 : left.outerWidth(true),
rightWidth = noRight ? 0 : right.outerWidth(true),
centerWidth = center.outerWidth(true),
navbarStyles = n.styles(),
navbarWidth = n[0].offsetWidth - parseInt(navbarStyles.paddingLeft, 10) - parseInt(navbarStyles.paddingRight, 10),
onLeft = n.hasClass('navbar-on-left'),
currLeft, diff;
if (noRight) {
currLeft = navbarWidth - centerWidth;
}
if (noLeft) {
currLeft = 0;
}
if (!noLeft && !noRight) {
currLeft = (navbarWidth - rightWidth - centerWidth + leftWidth) / 2;
}
var requiredLeft = (navbarWidth - centerWidth) / 2;
if (navbarWidth - leftWidth - rightWidth > centerWidth) {
if (requiredLeft < leftWidth) {
requiredLeft = leftWidth;
}
if (requiredLeft + centerWidth > navbarWidth - rightWidth) {
requiredLeft = navbarWidth - rightWidth - centerWidth;
}
diff = requiredLeft - currLeft;
}
else {
diff = 0;
}
// RTL inverter
var inverter = app.rtl ? -1 : 1;
if (center.hasClass('sliding')) {
center[0].f7NavbarLeftOffset = -(currLeft + diff) * inverter;
center[0].f7NavbarRightOffset = (navbarWidth - currLeft - diff - centerWidth) * inverter;
if (onLeft) center.transform('translate3d(' + center[0].f7NavbarLeftOffset + 'px, 0, 0)');
}
if (!noLeft && left.hasClass('sliding')) {
if (app.rtl) {
left[0].f7NavbarLeftOffset = -(navbarWidth - left[0].offsetWidth) / 2 * inverter;
left[0].f7NavbarRightOffset = leftWidth * inverter;
}
else {
left[0].f7NavbarLeftOffset = -leftWidth;
left[0].f7NavbarRightOffset = (navbarWidth - left[0].offsetWidth) / 2;
}
if (onLeft) left.transform('translate3d(' + left[0].f7NavbarLeftOffset + 'px, 0, 0)');
}
if (!noRight && right.hasClass('sliding')) {
if (app.rtl) {
right[0].f7NavbarLeftOffset = -rightWidth * inverter;
right[0].f7NavbarRightOffset = (navbarWidth - right[0].offsetWidth) / 2 * inverter;
}
else {
right[0].f7NavbarLeftOffset = -(navbarWidth - right[0].offsetWidth) / 2;
right[0].f7NavbarRightOffset = rightWidth;
}
if (onLeft) right.transform('translate3d(' + right[0].f7NavbarLeftOffset + 'px, 0, 0)');
}
if (subnavbar.length && subnavbar.hasClass('sliding')) {
subnavbar[0].f7NavbarLeftOffset = app.rtl ? subnavbar[0].offsetWidth : -subnavbar[0].offsetWidth;
subnavbar[0].f7NavbarRightOffset = -subnavbar[0].f7NavbarLeftOffset;
}
// Center left
var centerLeft = diff;
if (app.rtl && noLeft && noRight && center.length > 0) centerLeft = -centerLeft;
center.css({left: centerLeft + 'px'});
});
};
// Hide/Show Navbars/Toolbars
app.hideNavbar = function (navbarContainer) {
$(navbarContainer).addClass('navbar-hidden');
return true;
};
app.showNavbar = function (navbarContainer) {
var navbar = $(navbarContainer);
navbar.addClass('navbar-hiding').removeClass('navbar-hidden').transitionEnd(function () {
navbar.removeClass('navbar-hiding');
});
return true;
};
app.hideToolbar = function (toolbarContainer) {
$(toolbarContainer).addClass('toolbar-hidden');
return true;
};
app.showToolbar = function (toolbarContainer) {
var toolbar = $(toolbarContainer);
toolbar.addClass('toolbar-hiding').removeClass('toolbar-hidden').transitionEnd(function () {
toolbar.removeClass('toolbar-hiding');
});
};
/*======================================================
************ Searchbar ************
======================================================*/
var Searchbar = function (container, params) {
var defaults = {
input: null,
clearButton: null,
cancelButton: null,
searchList: null,
searchIn: '.item-title',
searchBy: '',
found: null,
notFound: null,
overlay: null,
ignore: '.searchbar-ignore',
customSearch: false,
removeDiacritics: false
};
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined' || params[def] === null) {
params[def] = defaults[def];
}
}
// Instance
var s = this;
// Params
s.params = params;
// Container
container = $(container);
s.container = container;
// Active
s.active = false;
// Input
s.input = s.params.input ? $(s.params.input) : s.container.find('input[type="search"]');
s.clearButton = s.params.clearButton ? $(s.params.clearButton) : s.container.find('.searchbar-clear');
s.cancelButton = s.params.cancelButton ? $(s.params.cancelButton) : s.container.find('.searchbar-cancel');
// Search List
s.searchList = $(s.params.searchList);
// Is Virtual List
s.isVirtualList = s.searchList.hasClass('virtual-list');
// Is In Page
s.pageContainer = s.container.parents('.page').eq(0);
// Overlay
if (!s.params.overlay) {
s.overlay = s.pageContainer.length > 0 ? s.pageContainer.find('.searchbar-overlay') : $('.searchbar-overlay');
}
else {
s.overlay = $(s.params.overlay);
}
// Found and not found
if (!s.params.found) {
s.found = s.pageContainer.length > 0 ? s.pageContainer.find('.searchbar-found') : $('.searchbar-found');
}
else {
s.found = $(s.params.found);
}
if (!s.params.notFound) {
s.notFound = s.pageContainer.length > 0 ? s.pageContainer.find('.searchbar-not-found') : $('.searchbar-not-found');
}
else {
s.notFound = $(s.params.notFound);
}
// Cancel button
var cancelMarginProp = app.rtl ? 'margin-left' : 'margin-right';
if (s.cancelButton.length > 0) {
s.cancelButton.transition(0).show();
s.cancelButton.css(cancelMarginProp, -s.cancelButton[0].offsetWidth + 'px');
setTimeout(function () {
s.cancelButton.transition('');
}, 0);
}
// Diacritics
var defaultDiacriticsRemovalap = [
{base:'A', letters:'\u0041\u24B6\uFF21\u00C0\u00C1\u00C2\u1EA6\u1EA4\u1EAA\u1EA8\u00C3\u0100\u0102\u1EB0\u1EAE\u1EB4\u1EB2\u0226\u01E0\u00C4\u01DE\u1EA2\u00C5\u01FA\u01CD\u0200\u0202\u1EA0\u1EAC\u1EB6\u1E00\u0104\u023A\u2C6F'},
{base:'AA',letters:'\uA732'},
{base:'AE',letters:'\u00C6\u01FC\u01E2'},
{base:'AO',letters:'\uA734'},
{base:'AU',letters:'\uA736'},
{base:'AV',letters:'\uA738\uA73A'},
{base:'AY',letters:'\uA73C'},
{base:'B', letters:'\u0042\u24B7\uFF22\u1E02\u1E04\u1E06\u0243\u0182\u0181'},
{base:'C', letters:'\u0043\u24B8\uFF23\u0106\u0108\u010A\u010C\u00C7\u1E08\u0187\u023B\uA73E'},
{base:'D', letters:'\u0044\u24B9\uFF24\u1E0A\u010E\u1E0C\u1E10\u1E12\u1E0E\u0110\u018B\u018A\u0189\uA779'},
{base:'DZ',letters:'\u01F1\u01C4'},
{base:'Dz',letters:'\u01F2\u01C5'},
{base:'E', letters:'\u0045\u24BA\uFF25\u00C8\u00C9\u00CA\u1EC0\u1EBE\u1EC4\u1EC2\u1EBC\u0112\u1E14\u1E16\u0114\u0116\u00CB\u1EBA\u011A\u0204\u0206\u1EB8\u1EC6\u0228\u1E1C\u0118\u1E18\u1E1A\u0190\u018E'},
{base:'F', letters:'\u0046\u24BB\uFF26\u1E1E\u0191\uA77B'},
{base:'G', letters:'\u0047\u24BC\uFF27\u01F4\u011C\u1E20\u011E\u0120\u01E6\u0122\u01E4\u0193\uA7A0\uA77D\uA77E'},
{base:'H', letters:'\u0048\u24BD\uFF28\u0124\u1E22\u1E26\u021E\u1E24\u1E28\u1E2A\u0126\u2C67\u2C75\uA78D'},
{base:'I', letters:'\u0049\u24BE\uFF29\u00CC\u00CD\u00CE\u0128\u012A\u012C\u0130\u00CF\u1E2E\u1EC8\u01CF\u0208\u020A\u1ECA\u012E\u1E2C\u0197'},
{base:'J', letters:'\u004A\u24BF\uFF2A\u0134\u0248'},
{base:'K', letters:'\u004B\u24C0\uFF2B\u1E30\u01E8\u1E32\u0136\u1E34\u0198\u2C69\uA740\uA742\uA744\uA7A2'},
{base:'L', letters:'\u004C\u24C1\uFF2C\u013F\u0139\u013D\u1E36\u1E38\u013B\u1E3C\u1E3A\u0141\u023D\u2C62\u2C60\uA748\uA746\uA780'},
{base:'LJ',letters:'\u01C7'},
{base:'Lj',letters:'\u01C8'},
{base:'M', letters:'\u004D\u24C2\uFF2D\u1E3E\u1E40\u1E42\u2C6E\u019C'},
{base:'N', letters:'\u004E\u24C3\uFF2E\u01F8\u0143\u00D1\u1E44\u0147\u1E46\u0145\u1E4A\u1E48\u0220\u019D\uA790\uA7A4'},
{base:'NJ',letters:'\u01CA'},
{base:'Nj',letters:'\u01CB'},
{base:'O', letters:'\u004F\u24C4\uFF2F\u00D2\u00D3\u00D4\u1ED2\u1ED0\u1ED6\u1ED4\u00D5\u1E4C\u022C\u1E4E\u014C\u1E50\u1E52\u014E\u022E\u0230\u00D6\u022A\u1ECE\u0150\u01D1\u020C\u020E\u01A0\u1EDC\u1EDA\u1EE0\u1EDE\u1EE2\u1ECC\u1ED8\u01EA\u01EC\u00D8\u01FE\u0186\u019F\uA74A\uA74C'},
{base:'OI',letters:'\u01A2'},
{base:'OO',letters:'\uA74E'},
{base:'OU',letters:'\u0222'},
{base:'OE',letters:'\u008C\u0152'},
{base:'oe',letters:'\u009C\u0153'},
{base:'P', letters:'\u0050\u24C5\uFF30\u1E54\u1E56\u01A4\u2C63\uA750\uA752\uA754'},
{base:'Q', letters:'\u0051\u24C6\uFF31\uA756\uA758\u024A'},
{base:'R', letters:'\u0052\u24C7\uFF32\u0154\u1E58\u0158\u0210\u0212\u1E5A\u1E5C\u0156\u1E5E\u024C\u2C64\uA75A\uA7A6\uA782'},
{base:'S', letters:'\u0053\u24C8\uFF33\u1E9E\u015A\u1E64\u015C\u1E60\u0160\u1E66\u1E62\u1E68\u0218\u015E\u2C7E\uA7A8\uA784'},
{base:'T', letters:'\u0054\u24C9\uFF34\u1E6A\u0164\u1E6C\u021A\u0162\u1E70\u1E6E\u0166\u01AC\u01AE\u023E\uA786'},
{base:'TZ',letters:'\uA728'},
{base:'U', letters:'\u0055\u24CA\uFF35\u00D9\u00DA\u00DB\u0168\u1E78\u016A\u1E7A\u016C\u00DC\u01DB\u01D7\u01D5\u01D9\u1EE6\u016E\u0170\u01D3\u0214\u0216\u01AF\u1EEA\u1EE8\u1EEE\u1EEC\u1EF0\u1EE4\u1E72\u0172\u1E76\u1E74\u0244'},
{base:'V', letters:'\u0056\u24CB\uFF36\u1E7C\u1E7E\u01B2\uA75E\u0245'},
{base:'VY',letters:'\uA760'},
{base:'W', letters:'\u0057\u24CC\uFF37\u1E80\u1E82\u0174\u1E86\u1E84\u1E88\u2C72'},
{base:'X', letters:'\u0058\u24CD\uFF38\u1E8A\u1E8C'},
{base:'Y', letters:'\u0059\u24CE\uFF39\u1EF2\u00DD\u0176\u1EF8\u0232\u1E8E\u0178\u1EF6\u1EF4\u01B3\u024E\u1EFE'},
{base:'Z', letters:'\u005A\u24CF\uFF3A\u0179\u1E90\u017B\u017D\u1E92\u1E94\u01B5\u0224\u2C7F\u2C6B\uA762'},
{base:'a', letters:'\u0061\u24D0\uFF41\u1E9A\u00E0\u00E1\u00E2\u1EA7\u1EA5\u1EAB\u1EA9\u00E3\u0101\u0103\u1EB1\u1EAF\u1EB5\u1EB3\u0227\u01E1\u00E4\u01DF\u1EA3\u00E5\u01FB\u01CE\u0201\u0203\u1EA1\u1EAD\u1EB7\u1E01\u0105\u2C65\u0250'},
{base:'aa',letters:'\uA733'},
{base:'ae',letters:'\u00E6\u01FD\u01E3'},
{base:'ao',letters:'\uA735'},
{base:'au',letters:'\uA737'},
{base:'av',letters:'\uA739\uA73B'},
{base:'ay',letters:'\uA73D'},
{base:'b', letters:'\u0062\u24D1\uFF42\u1E03\u1E05\u1E07\u0180\u0183\u0253'},
{base:'c', letters:'\u0063\u24D2\uFF43\u0107\u0109\u010B\u010D\u00E7\u1E09\u0188\u023C\uA73F\u2184'},
{base:'d', letters:'\u0064\u24D3\uFF44\u1E0B\u010F\u1E0D\u1E11\u1E13\u1E0F\u0111\u018C\u0256\u0257\uA77A'},
{base:'dz',letters:'\u01F3\u01C6'},
{base:'e', letters:'\u0065\u24D4\uFF45\u00E8\u00E9\u00EA\u1EC1\u1EBF\u1EC5\u1EC3\u1EBD\u0113\u1E15\u1E17\u0115\u0117\u00EB\u1EBB\u011B\u0205\u0207\u1EB9\u1EC7\u0229\u1E1D\u0119\u1E19\u1E1B\u0247\u025B\u01DD'},
{base:'f', letters:'\u0066\u24D5\uFF46\u1E1F\u0192\uA77C'},
{base:'g', letters:'\u0067\u24D6\uFF47\u01F5\u011D\u1E21\u011F\u0121\u01E7\u0123\u01E5\u0260\uA7A1\u1D79\uA77F'},
{base:'h', letters:'\u0068\u24D7\uFF48\u0125\u1E23\u1E27\u021F\u1E25\u1E29\u1E2B\u1E96\u0127\u2C68\u2C76\u0265'},
{base:'hv',letters:'\u0195'},
{base:'i', letters:'\u0069\u24D8\uFF49\u00EC\u00ED\u00EE\u0129\u012B\u012D\u00EF\u1E2F\u1EC9\u01D0\u0209\u020B\u1ECB\u012F\u1E2D\u0268\u0131'},
{base:'j', letters:'\u006A\u24D9\uFF4A\u0135\u01F0\u0249'},
{base:'k', letters:'\u006B\u24DA\uFF4B\u1E31\u01E9\u1E33\u0137\u1E35\u0199\u2C6A\uA741\uA743\uA745\uA7A3'},
{base:'l', letters:'\u006C\u24DB\uFF4C\u0140\u013A\u013E\u1E37\u1E39\u013C\u1E3D\u1E3B\u017F\u0142\u019A\u026B\u2C61\uA749\uA781\uA747'},
{base:'lj',letters:'\u01C9'},
{base:'m', letters:'\u006D\u24DC\uFF4D\u1E3F\u1E41\u1E43\u0271\u026F'},
{base:'n', letters:'\u006E\u24DD\uFF4E\u01F9\u0144\u00F1\u1E45\u0148\u1E47\u0146\u1E4B\u1E49\u019E\u0272\u0149\uA791\uA7A5'},
{base:'nj',letters:'\u01CC'},
{base:'o', letters:'\u006F\u24DE\uFF4F\u00F2\u00F3\u00F4\u1ED3\u1ED1\u1ED7\u1ED5\u00F5\u1E4D\u022D\u1E4F\u014D\u1E51\u1E53\u014F\u022F\u0231\u00F6\u022B\u1ECF\u0151\u01D2\u020D\u020F\u01A1\u1EDD\u1EDB\u1EE1\u1EDF\u1EE3\u1ECD\u1ED9\u01EB\u01ED\u00F8\u01FF\u0254\uA74B\uA74D\u0275'},
{base:'oi',letters:'\u01A3'},
{base:'ou',letters:'\u0223'},
{base:'oo',letters:'\uA74F'},
{base:'p',letters:'\u0070\u24DF\uFF50\u1E55\u1E57\u01A5\u1D7D\uA751\uA753\uA755'},
{base:'q',letters:'\u0071\u24E0\uFF51\u024B\uA757\uA759'},
{base:'r',letters:'\u0072\u24E1\uFF52\u0155\u1E59\u0159\u0211\u0213\u1E5B\u1E5D\u0157\u1E5F\u024D\u027D\uA75B\uA7A7\uA783'},
{base:'s',letters:'\u0073\u24E2\uFF53\u00DF\u015B\u1E65\u015D\u1E61\u0161\u1E67\u1E63\u1E69\u0219\u015F\u023F\uA7A9\uA785\u1E9B'},
{base:'t',letters:'\u0074\u24E3\uFF54\u1E6B\u1E97\u0165\u1E6D\u021B\u0163\u1E71\u1E6F\u0167\u01AD\u0288\u2C66\uA787'},
{base:'tz',letters:'\uA729'},
{base:'u',letters: '\u0075\u24E4\uFF55\u00F9\u00FA\u00FB\u0169\u1E79\u016B\u1E7B\u016D\u00FC\u01DC\u01D8\u01D6\u01DA\u1EE7\u016F\u0171\u01D4\u0215\u0217\u01B0\u1EEB\u1EE9\u1EEF\u1EED\u1EF1\u1EE5\u1E73\u0173\u1E77\u1E75\u0289'},
{base:'v',letters:'\u0076\u24E5\uFF56\u1E7D\u1E7F\u028B\uA75F\u028C'},
{base:'vy',letters:'\uA761'},
{base:'w',letters:'\u0077\u24E6\uFF57\u1E81\u1E83\u0175\u1E87\u1E85\u1E98\u1E89\u2C73'},
{base:'x',letters:'\u0078\u24E7\uFF58\u1E8B\u1E8D'},
{base:'y',letters:'\u0079\u24E8\uFF59\u1EF3\u00FD\u0177\u1EF9\u0233\u1E8F\u00FF\u1EF7\u1E99\u1EF5\u01B4\u024F\u1EFF'},
{base:'z',letters:'\u007A\u24E9\uFF5A\u017A\u1E91\u017C\u017E\u1E93\u1E95\u01B6\u0225\u0240\u2C6C\uA763'}
];
var diacriticsMap = {};
for (var i=0; i < defaultDiacriticsRemovalap.length; i++){
var letters = defaultDiacriticsRemovalap[i].letters;
for (var j=0; j < letters.length ; j++){
diacriticsMap[letters[j]] = defaultDiacriticsRemovalap[i].base;
}
}
function removeDiacritics (str) {
return str.replace(/[^\u0000-\u007E]/g, function(a){
return diacriticsMap[a] || a;
});
}
// Trigger
s.triggerEvent = function (eventName, eventData) {
s.container.trigger(eventName, eventData);
if (s.searchList.length > 0) s.searchList.trigger(eventName, eventData);
};
// Enable/disalbe
s.enable = function () {
function _enable() {
if (s.searchList.length && !s.container.hasClass('searchbar-active')) s.overlay.addClass('searchbar-overlay-active');
s.container.addClass('searchbar-active');
if (s.cancelButton.length > 0) s.cancelButton.css(cancelMarginProp, '0px');
s.triggerEvent('enableSearch');
s.active = true;
}
if (app.device.ios) {
setTimeout(function () {
_enable();
}, 400);
}
else {
_enable();
}
};
s.disable = function () {
s.input.val('').trigger('change');
s.container.removeClass('searchbar-active searchbar-not-empty');
if (s.cancelButton.length > 0) s.cancelButton.css(cancelMarginProp, -s.cancelButton[0].offsetWidth + 'px');
if (s.searchList.length) s.overlay.removeClass('searchbar-overlay-active');
function _disable() {
s.input.blur();
s.triggerEvent('disableSearch');
s.active = false;
}
if (app.device.ios) {
setTimeout(function () {
_disable();
}, 400);
}
else {
_disable();
}
};
// Clear
s.clear = function () {
s.input.val('').trigger('change').focus();
s.triggerEvent('clearSearch');
};
// Search
s.handleInput = function () {
setTimeout(function () {
var value = s.input.val().trim();
if (s.searchList.length > 0 && (s.params.searchIn || s.isVirtualList)) s.search(value, true);
}, 0);
};
var previousQuery = '';
var virtualList;
s.search = function (query, internal) {
if (query.trim() === previousQuery) return;
previousQuery = query.trim();
if (!internal) {
if (!s.active) {
s.enable();
}
if (!internal) {
s.input.val(query);
}
}
// Add active/inactive classes on overlay
if (query.length === 0) {
s.container.removeClass('searchbar-not-empty');
if (s.searchList.length && s.container.hasClass('searchbar-active')) s.overlay.addClass('searchbar-overlay-active');
}
else {
s.container.addClass('searchbar-not-empty');
if (s.searchList.length && s.container.hasClass('searchbar-active')) s.overlay.removeClass('searchbar-overlay-active');
}
if (s.params.customSearch) {
s.triggerEvent('search', {query: query});
return;
}
var foundItems = [];
if (s.isVirtualList) {
virtualList = s.searchList[0].f7VirtualList;
if (query.trim() === '') {
virtualList.resetFilter();
s.notFound.hide();
s.found.show();
return;
}
if (virtualList.params.searchAll) {
foundItems = virtualList.params.searchAll(query, virtualList.items) || [];
}
else if (virtualList.params.searchByItem) {
for (var i = 0; i < virtualList.items.length; i++) {
if(virtualList.params.searchByItem(query, i, virtualList.params.items[i])) {
foundItems.push(i);
}
}
}
}
else {
var values;
if (s.params.removeDiacritics) values = removeDiacritics(query.trim().toLowerCase()).split(' ');
else {
values = query.trim().toLowerCase().split(' ');
}
s.searchList.find('li').removeClass('hidden-by-searchbar').each(function (index, el) {
el = $(el);
var compareWithText = [];
el.find(s.params.searchIn).each(function () {
var itemText = $(this).text().trim().toLowerCase();
if (s.params.removeDiacritics) itemText = removeDiacritics(itemText);
compareWithText.push(itemText);
});
compareWithText = compareWithText.join(' ');
var wordsMatch = 0;
for (var i = 0; i < values.length; i++) {
if (compareWithText.indexOf(values[i]) >= 0) wordsMatch++;
}
if (wordsMatch !== values.length && !(s.params.ignore && el.is(s.params.ignore))) {
el.addClass('hidden-by-searchbar');
}
else {
foundItems.push(el[0]);
}
});
if (app.params.searchbarHideDividers) {
s.searchList.find('.item-divider, .list-group-title').each(function () {
var title = $(this);
var nextElements = title.nextAll('li');
var hide = true;
for (var i = 0; i < nextElements.length; i++) {
var nextEl = $(nextElements[i]);
if (nextEl.hasClass('list-group-title') || nextEl.hasClass('item-divider')) break;
if (!nextEl.hasClass('hidden-by-searchbar')) {
hide = false;
}
}
var ignore = s.params.ignore && title.is(s.params.ignore);
if (hide && !ignore) title.addClass('hidden-by-searchbar');
else title.removeClass('hidden-by-searchbar');
});
}
if (app.params.searchbarHideGroups) {
s.searchList.find('.list-group').each(function () {
var group = $(this);
var ignore = s.params.ignore && group.is(s.params.ignore);
var notHidden = group.find('li:not(.hidden-by-searchbar)');
if (notHidden.length === 0 && !ignore) {
group.addClass('hidden-by-searchbar');
}
else {
group.removeClass('hidden-by-searchbar');
}
});
}
}
s.triggerEvent('search', {query: query, foundItems: foundItems});
if (foundItems.length === 0) {
s.notFound.show();
s.found.hide();
}
else {
s.notFound.hide();
s.found.show();
}
if (s.isVirtualList) {
virtualList.filterItems(foundItems);
}
};
// Events
function preventSubmit(e) {
e.preventDefault();
}
s.attachEvents = function (destroy) {
var method = destroy ? 'off' : 'on';
s.container[method]('submit', preventSubmit);
s.cancelButton[method]('click', s.disable);
s.overlay[method]('click', s.disable);
s.input[method]('focus', s.enable);
s.input[method]('change keydown keypress keyup', s.handleInput);
s.clearButton[method]('click', s.clear);
};
s.detachEvents = function() {
s.attachEvents(true);
};
// Init Destroy
s.init = function () {
s.attachEvents();
};
s.destroy = function () {
if (!s) return;
s.detachEvents();
s = null;
};
// Init
s.init();
s.container[0].f7Searchbar = s;
return s;
};
app.searchbar = function (container, params) {
return new Searchbar(container, params);
};
app.initSearchbar = function (container) {
container = $(container);
var searchbar = container.hasClass('searchbar') ? container : container.find('.searchbar');
if (searchbar.length === 0) return;
if (!searchbar.hasClass('searchbar-init')) return;
var sb = app.searchbar(searchbar, searchbar.dataset());
function onBeforeRemove() {
if (sb) sb.destroy();
}
if (container.hasClass('page')) {
container.once('pageBeforeRemove', onBeforeRemove);
}
else if (container.hasClass('navbar-inner')) {
container.once('navbarBeforeRemove', onBeforeRemove);
}
};
/*======================================================
************ Messagebar ************
======================================================*/
var Messagebar = function (container, params) {
var defaults = {
textarea: null,
maxHeight: null,
};
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined' || params[def] === null) {
params[def] = defaults[def];
}
}
// Instance
var m = this;
// Params
m.params = params;
// Container
m.container = $(container);
if (m.container.length === 0) return;
// Textarea
m.textarea = m.params.textarea ? $(m.params.textarea) : m.container.find('textarea');
// Is In Page
m.pageContainer = m.container.parents('.page').eq(0);
m.pageContent = m.pageContainer.find('.page-content');
// Initial Sizes
m.pageContentPadding = parseInt(m.pageContent.css('padding-bottom'));
m.initialBarHeight = m.container[0].offsetHeight;
m.initialAreaHeight = m.textarea[0].offsetHeight;
// Resize textarea
m.sizeTextarea = function () {
// Reset
m.textarea.css({'height': ''});
var height = m.textarea[0].offsetHeight;
var diff = height - m.textarea[0].clientHeight;
var scrollHeight = m.textarea[0].scrollHeight;
// Update
if (scrollHeight + diff > height) {
var newAreaHeight = scrollHeight + diff;
var newBarHeight = m.initialBarHeight + (newAreaHeight - m.initialAreaHeight);
var maxBarHeight = m.params.maxHeight || m.container.parents('.view')[0].offsetHeight - 88;
if (newBarHeight > maxBarHeight) {
newBarHeight = parseInt(maxBarHeight, 10);
newAreaHeight = newBarHeight - m.initialBarHeight + m.initialAreaHeight;
}
m.textarea.css('height', newAreaHeight + 'px');
m.container.css('height', newBarHeight + 'px');
if (m.pageContent.length > 0) {
m.pageContent.css('padding-bottom', newBarHeight + 'px');
m.pageContent.scrollTop(m.pageContent[0].scrollHeight - m.pageContent[0].offsetHeight);
}
}
else {
if (m.pageContent.length > 0) {
m.container.css({'height': '', 'bottom': ''});
m.pageContent.css({'padding-bottom': ''});
}
}
};
// Clear
m.clear = function () {
m.textarea.val('').trigger('change');
};
m.value = function (value) {
if (typeof value === 'undefined') return m.textarea.val();
else m.textarea.val(value).trigger('change');
};
// Handle textarea
m.textareaTimeout = undefined;
m.handleTextarea = function (e) {
clearTimeout(m.textareaTimeout);
m.textareaTimeout = setTimeout(function () {
m.sizeTextarea();
}, 0);
};
//Events
function preventSubmit(e) {
e.preventDefault();
}
m.attachEvents = function (destroy) {
var method = destroy ? 'off' : 'on';
m.container[method]('submit', preventSubmit);
m.textarea[method]('change keydown keypress keyup paste cut', m.handleTextarea);
};
m.detachEvents = function () {
m.attachEvents(true);
};
// Init Destroy
m.init = function () {
m.attachEvents();
};
m.destroy = function () {
m.detachEvents();
m = null;
};
// Init
m.init();
m.container[0].f7Messagebar = m;
return m;
};
app.messagebar = function (container, params) {
return new Messagebar(container, params);
};
app.initPageMessagebar = function (pageContainer) {
pageContainer = $(pageContainer);
var messagebar = pageContainer.hasClass('messagebar') ? pageContainer : pageContainer.find('.messagebar');
if (messagebar.length === 0) return;
if (!messagebar.hasClass('messagebar-init')) return;
var mb = app.messagebar(messagebar, messagebar.dataset());
// Destroy on page remove
function pageBeforeRemove() {
mb.destroy();
pageContainer.off('pageBeforeRemove', pageBeforeRemove);
}
if (pageContainer.hasClass('page')) {
pageContainer.on('pageBeforeRemove', pageBeforeRemove);
}
};
/*======================================================
************ XHR ************
======================================================*/
// XHR Caching
app.cache = [];
app.removeFromCache = function (url) {
var index = false;
for (var i = 0; i < app.cache.length; i++) {
if (app.cache[i].url === url) index = i;
}
if (index !== false) app.cache.splice(index, 1);
};
// XHR
app.xhr = false;
app.get = function (url, view, ignoreCache, callback) {
// should we ignore get params or not
var _url = url;
if (app.params.cacheIgnoreGetParameters && url.indexOf('?') >= 0) {
_url = url.split('?')[0];
}
if (app.params.cache && !ignoreCache && url.indexOf('nocache') < 0 && app.params.cacheIgnore.indexOf(_url) < 0) {
// Check is the url cached
for (var i = 0; i < app.cache.length; i++) {
if (app.cache[i].url === _url) {
// Check expiration
if ((new Date()).getTime() - app.cache[i].time < app.params.cacheDuration) {
// Load from cache
callback(app.cache[i].content);
return false;
}
}
}
}
app.xhr = $.ajax({
url: url,
method: 'GET',
beforeSend: app.params.onAjaxStart,
complete: function (xhr) {
if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 0) {
if (app.params.cache && !ignoreCache) {
app.removeFromCache(_url);
app.cache.push({
url: _url,
time: (new Date()).getTime(),
content: xhr.responseText
});
}
callback(xhr.responseText, false);
}
else {
callback(xhr.responseText, true);
}
if (app.params.onAjaxComplete) app.params.onAjaxComplete(xhr);
},
error: function (xhr) {
callback(xhr.responseText, true);
if (app.params.onAjaxError) app.params.onAjaxError(xhr);
}
});
if (view) view.xhr = app.xhr;
return app.xhr;
};
/*======================================================
************ Pages ************
======================================================*/
// Page Callbacks API
app.pageCallbacks = {};
app.onPage = function (callbackName, pageName, callback) {
if (pageName && pageName.split(' ').length > 1) {
var pageNames = pageName.split(' ');
var returnCallbacks = [];
for (var i = 0; i < pageNames.length; i++) {
returnCallbacks.push(app.onPage(callbackName, pageNames[i], callback));
}
returnCallbacks.remove = function () {
for (var i = 0; i < returnCallbacks.length; i++) {
returnCallbacks[i].remove();
}
};
returnCallbacks.trigger = function () {
for (var i = 0; i < returnCallbacks.length; i++) {
returnCallbacks[i].trigger();
}
};
return returnCallbacks;
}
var callbacks = app.pageCallbacks[callbackName][pageName];
if (!callbacks) {
callbacks = app.pageCallbacks[callbackName][pageName] = [];
}
app.pageCallbacks[callbackName][pageName].push(callback);
return {
remove: function () {
var removeIndex;
for (var i = 0; i < callbacks.length; i++) {
if (callbacks[i].toString() === callback.toString()) {
removeIndex = i;
}
}
if (typeof removeIndex !== 'undefined') callbacks.splice(removeIndex, 1);
},
trigger: callback
};
};
//Create callbacks methods dynamically
function createPageCallback(callbackName) {
var capitalized = callbackName.replace(/^./, function (match) {
return match.toUpperCase();
});
app['onPage' + capitalized] = function (pageName, callback) {
return app.onPage(callbackName, pageName, callback);
};
}
var pageCallbacksNames = ('beforeInit init reinit beforeAnimation afterAnimation back afterBack beforeRemove').split(' ');
for (var i = 0; i < pageCallbacksNames.length; i++) {
app.pageCallbacks[pageCallbacksNames[i]] = {};
createPageCallback(pageCallbacksNames[i]);
}
app.triggerPageCallbacks = function (callbackName, pageName, pageData) {
var allPagesCallbacks = app.pageCallbacks[callbackName]['*'];
if (allPagesCallbacks) {
for (var j = 0; j < allPagesCallbacks.length; j++) {
allPagesCallbacks[j](pageData);
}
}
var callbacks = app.pageCallbacks[callbackName][pageName];
if (!callbacks || callbacks.length === 0) return;
for (var i = 0; i < callbacks.length; i++) {
callbacks[i](pageData);
}
};
// On Page Init Callback
app.pageInitCallback = function (view, params) {
var pageContainer = params.pageContainer;
if (pageContainer.f7PageInitialized && !view.params.domCache) return;
// Page Data
var pageData = {
container: pageContainer,
url: params.url,
query: params.query || $.parseUrlQuery(params.url || ''),
name: $(pageContainer).attr('data-page'),
view: view,
from: params.position,
context: params.context,
navbarInnerContainer: params.navbarInnerContainer,
fromPage: params.fromPage
};
if (params.fromPage && !params.fromPage.navbarInnerContainer && params.oldNavbarInnerContainer) {
params.fromPage.navbarInnerContainer = params.oldNavbarInnerContainer;
}
if (pageContainer.f7PageInitialized && view.params.domCache) {
// Reinit Page
app.reinitPage(pageContainer);
// Callbacks
app.pluginHook('pageReinit', pageData);
if (app.params.onPageReinit) app.params.onPageBeforeInit(app, pageData);
app.triggerPageCallbacks('reinit', pageData.name, pageData);
$(pageData.container).trigger('pageReinit', {page: pageData});
return;
}
pageContainer.f7PageInitialized = true;
// Store pagedata in page
pageContainer.f7PageData = pageData;
// Update View's activePage
if (view && !params.preloadOnly && !params.reloadPrevious) {
// Add data-page on view
$(view.container).attr('data-page', pageData.name);
// Update View active page data
view.activePage = pageData;
}
// Before Init Callbacks
app.pluginHook('pageBeforeInit', pageData);
if (app.params.onPageBeforeInit) app.params.onPageBeforeInit(app, pageData);
app.triggerPageCallbacks('beforeInit', pageData.name, pageData);
$(pageData.container).trigger('pageBeforeInit', {page: pageData});
// Init page
app.initPage(pageContainer);
// Init Callback
app.pluginHook('pageInit', pageData);
if (app.params.onPageInit) app.params.onPageInit(app, pageData);
app.triggerPageCallbacks('init', pageData.name, pageData);
$(pageData.container).trigger('pageInit', {page: pageData});
};
app.pageRemoveCallback = function (view, pageContainer, position) {
var pageContext;
if (pageContainer.f7PageData) pageContext = pageContainer.f7PageData.context;
// Page Data
var pageData = {
container: pageContainer,
name: $(pageContainer).attr('data-page'),
view: view,
url: pageContainer.f7PageData && pageContainer.f7PageData.url,
query: pageContainer.f7PageData && pageContainer.f7PageData.query,
navbarInnerContainer: pageContainer.f7PageData && pageContainer.f7PageData.navbarInnerContainer,
from: position,
context: pageContext
};
// Before Init Callback
app.pluginHook('pageBeforeRemove', pageData);
if (app.params.onPageBeforeRemove) app.params.onPageBeforeRemove(app, pageData);
app.triggerPageCallbacks('beforeRemove', pageData.name, pageData);
$(pageData.container).trigger('pageBeforeRemove', {page: pageData});
};
app.pageBackCallback = function (callback, view, params) {
// Page Data
var pageContainer = params.pageContainer;
var pageContext;
if (pageContainer.f7PageData) pageContext = pageContainer.f7PageData.context;
var pageData = {
container: pageContainer,
name: $(pageContainer).attr('data-page'),
url: pageContainer.f7PageData && pageContainer.f7PageData.url,
query: pageContainer.f7PageData && pageContainer.f7PageData.query,
view: view,
from: params.position,
context: pageContext,
navbarInnerContainer: pageContainer.f7PageData && pageContainer.f7PageData.navbarInnerContainer,
swipeBack: params.swipeBack
};
if (callback === 'after') {
app.pluginHook('pageAfterBack', pageData);
if (app.params.onPageAfterBack) app.params.onPageAfterBack(app, pageData);
app.triggerPageCallbacks('afterBack', pageData.name, pageData);
$(pageContainer).trigger('pageAfterBack', {page: pageData});
}
if (callback === 'before') {
app.pluginHook('pageBack', pageData);
if (app.params.onPageBack) app.params.onPageBack(app, pageData);
app.triggerPageCallbacks('back', pageData.name, pageData);
$(pageData.container).trigger('pageBack', {page: pageData});
}
};
app.pageAnimCallback = function (callback, view, params) {
var pageContainer = params.pageContainer;
var pageContext;
if (pageContainer.f7PageData) pageContext = pageContainer.f7PageData.context;
// Page Data
var pageData = {
container: pageContainer,
url: params.url,
query: params.query || $.parseUrlQuery(params.url || ''),
name: $(pageContainer).attr('data-page'),
view: view,
from: params.position,
context: pageContext,
swipeBack: params.swipeBack,
navbarInnerContainer: pageContainer.f7PageData && pageContainer.f7PageData.navbarInnerContainer,
fromPage: params.fromPage
};
var oldPage = params.oldPage,
newPage = params.newPage;
// Update page date
pageContainer.f7PageData = pageData;
if (callback === 'after') {
app.pluginHook('pageAfterAnimation', pageData);
if (app.params.onPageAfterAnimation) app.params.onPageAfterAnimation(app, pageData);
app.triggerPageCallbacks('afterAnimation', pageData.name, pageData);
$(pageData.container).trigger('pageAfterAnimation', {page: pageData});
}
if (callback === 'before') {
// Add data-page on view
$(view.container).attr('data-page', pageData.name);
// Update View's activePage
if (view) view.activePage = pageData;
// Hide/show navbar dynamically
if (newPage.hasClass('no-navbar') && !oldPage.hasClass('no-navbar')) {
view.hideNavbar();
}
if (!newPage.hasClass('no-navbar') && (oldPage.hasClass('no-navbar') || oldPage.hasClass('no-navbar-by-scroll'))) {
view.showNavbar();
}
// Hide/show navbar toolbar
if (newPage.hasClass('no-toolbar') && !oldPage.hasClass('no-toolbar')) {
view.hideToolbar();
}
if (!newPage.hasClass('no-toolbar') && (oldPage.hasClass('no-toolbar') || oldPage.hasClass('no-toolbar-by-scroll'))) {
view.showToolbar();
}
// Hide/show tabbar
var tabBar;
if (newPage.hasClass('no-tabbar') && !oldPage.hasClass('no-tabbar')) {
tabBar = $(view.container).find('.tabbar');
if (tabBar.length === 0) tabBar = $(view.container).parents('.' + app.params.viewsClass).find('.tabbar');
app.hideToolbar(tabBar);
}
if (!newPage.hasClass('no-tabbar') && (oldPage.hasClass('no-tabbar') || oldPage.hasClass('no-tabbar-by-scroll'))) {
tabBar = $(view.container).find('.tabbar');
if (tabBar.length === 0) tabBar = $(view.container).parents('.' + app.params.viewsClass).find('.tabbar');
app.showToolbar(tabBar);
}
oldPage.removeClass('no-navbar-by-scroll no-toolbar-by-scroll');
// Callbacks
app.pluginHook('pageBeforeAnimation', pageData);
if (app.params.onPageBeforeAnimation) app.params.onPageBeforeAnimation(app, pageData);
app.triggerPageCallbacks('beforeAnimation', pageData.name, pageData);
$(pageData.container).trigger('pageBeforeAnimation', {page: pageData});
}
};
// Init Page Events and Manipulations
app.initPage = function (pageContainer) {
pageContainer = $(pageContainer);
// Size navbars on page load
if (app.sizeNavbars) app.sizeNavbars(pageContainer.parents('.' + app.params.viewClass)[0]);
// Init messages
if (app.initPageMessages) app.initPageMessages(pageContainer);
// Init forms storage
if (app.initFormsStorage) app.initFormsStorage(pageContainer);
// Init smart select
if (app.initSmartSelects) app.initSmartSelects(pageContainer);
// Init slider
if (app.initPageSwiper) app.initPageSwiper(pageContainer);
// Init pull to refres
if (app.initPullToRefresh) app.initPullToRefresh(pageContainer);
// Init infinite scroll
if (app.initInfiniteScroll) app.initInfiniteScroll(pageContainer);
// Init searchbar
if (app.initSearchbar) app.initSearchbar(pageContainer);
// Init message bar
if (app.initPageMessagebar) app.initPageMessagebar(pageContainer);
// Init scroll toolbars
if (app.initScrollToolbars) app.initScrollToolbars(pageContainer);
// Init scroll toolbars
if (app.initImagesLazyLoad) app.initImagesLazyLoad(pageContainer);
};
app.reinitPage = function (pageContainer) {
pageContainer = $(pageContainer);
// Size navbars on page reinit
if (app.sizeNavbars) app.sizeNavbars(pageContainer.parents('.' + app.params.viewClass)[0]);
// Reinit slider
if (app.reinitPageSwiper) app.reinitPageSwiper(pageContainer);
// Reinit lazy load
if (app.reinitLazyLoad) app.reinitLazyLoad(pageContainer);
};
app.initPageWithCallback = function (pageContainer) {
pageContainer = $(pageContainer);
var viewContainer = pageContainer.parents('.' + app.params.viewClass);
if (viewContainer.length === 0) return;
var view = viewContainer[0].f7View || undefined;
var url = view && view.url ? view.url : undefined;
if (viewContainer && pageContainer.attr('data-page')) {
viewContainer.attr('data-page', pageContainer.attr('data-page'));
}
app.pageInitCallback(view, {pageContainer: pageContainer[0], url: url, position: 'center'});
};
/*======================================================
************ Navigation / Router ************
======================================================*/
app.router = {
// Temporary DOM Element
temporaryDom: document.createElement('div'),
// Find page or navbar in passed container which are related to View
findElement: function (selector, container, view, notCached) {
container = $(container);
if (notCached) selector = selector + ':not(.cached)';
var found = container.find(selector);
if (found.length > 1) {
if (typeof view.selector === 'string') {
// Search in related view
found = container.find(view.selector + ' ' + selector);
}
if (found.length > 1) {
// Search in main view
found = container.find('.' + app.params.viewMainClass + ' ' + selector);
}
}
if (found.length === 1) return found;
else {
// Try to find non cached
if (!notCached) found = app.router.findElement(selector, container, view, true);
if (found && found.length === 1) return found;
else return undefined;
}
},
// Set pages classess for animationEnd
animatePages: function (leftPage, rightPage, direction, view) {
// Loading new page
var removeClasses = 'page-on-center page-on-right page-on-left';
if (direction === 'to-left') {
leftPage.removeClass(removeClasses).addClass('page-from-center-to-left');
rightPage.removeClass(removeClasses).addClass('page-from-right-to-center');
}
// Go back
if (direction === 'to-right') {
leftPage.removeClass(removeClasses).addClass('page-from-left-to-center');
rightPage.removeClass(removeClasses).addClass('page-from-center-to-right');
}
},
// Prepare navbar before animarion
prepareNavbar: function (newNavbarInner, oldNavbarInner, newNavbarPosition) {
$(newNavbarInner).find('.sliding').each(function () {
var sliding = $(this);
var slidingOffset = newNavbarPosition === 'right' ? this.f7NavbarRightOffset : this.f7NavbarLeftOffset;
if (app.params.animateNavBackIcon) {
if (sliding.hasClass('left') && sliding.find('.back .icon').length > 0) {
sliding.find('.back .icon').transform('translate3d(' + (-slidingOffset) + 'px,0,0)');
}
if (newNavbarPosition === 'left' && sliding.hasClass('center') && $(oldNavbarInner).find('.left .back .icon ~ span').length > 0) {
slidingOffset += $(oldNavbarInner).find('.left .back span')[0].offsetLeft;
}
}
sliding.transform('translate3d(' + slidingOffset + 'px,0,0)');
});
},
// Set navbars classess for animation
animateNavbars: function (leftNavbarInner, rightNavbarInner, direction, view) {
// Loading new page
var removeClasses = 'navbar-on-right navbar-on-center navbar-on-left';
if (direction === 'to-left') {
rightNavbarInner.removeClass(removeClasses).addClass('navbar-from-right-to-center');
rightNavbarInner.find('.sliding').each(function () {
var sliding = $(this);
sliding.transform('translate3d(0px,0,0)');
if (app.params.animateNavBackIcon) {
if (sliding.hasClass('left') && sliding.find('.back .icon').length > 0) {
sliding.find('.back .icon').transform('translate3d(0px,0,0)');
}
}
});
leftNavbarInner.removeClass(removeClasses).addClass('navbar-from-center-to-left');
leftNavbarInner.find('.sliding').each(function () {
var sliding = $(this);
if (app.params.animateNavBackIcon) {
if (sliding.hasClass('center') && rightNavbarInner.find('.sliding.left .back .icon').length > 0) {
this.f7NavbarLeftOffset += rightNavbarInner.find('.sliding.left .back span')[0].offsetLeft;
}
if (sliding.hasClass('left') && sliding.find('.back .icon').length > 0) {
sliding.find('.back .icon').transform('translate3d(' + (-this.f7NavbarLeftOffset) + 'px,0,0)');
}
}
sliding.transform('translate3d(' + (this.f7NavbarLeftOffset) + 'px,0,0)');
});
}
// Go back
if (direction === 'to-right') {
leftNavbarInner.removeClass(removeClasses).addClass('navbar-from-left-to-center');
leftNavbarInner.find('.sliding').each(function () {
var sliding = $(this);
sliding.transform('translate3d(0px,0,0)');
if (app.params.animateNavBackIcon) {
if (sliding.hasClass('left') && sliding.find('.back .icon').length > 0) {
sliding.find('.back .icon').transform('translate3d(0px,0,0)');
}
}
});
rightNavbarInner.removeClass(removeClasses).addClass('navbar-from-center-to-right');
rightNavbarInner.find('.sliding').each(function () {
var sliding = $(this);
if (app.params.animateNavBackIcon) {
if (sliding.hasClass('left') && sliding.find('.back .icon').length > 0) {
sliding.find('.back .icon').transform('translate3d(' + (-this.f7NavbarRightOffset) + 'px,0,0)');
}
}
sliding.transform('translate3d(' + (this.f7NavbarRightOffset) + 'px,0,0)');
});
}
},
preprocess: function(view, content, url, next) {
// Plugin hook
app.pluginHook('routerPreprocess', view, content, url, next);
// Preprocess by plugin
content = app.pluginProcess('preprocess', content);
if (view && view.params && view.params.preprocess) {
content = view.params.preprocess(content, url, next);
if (typeof content !== 'undefined') {
next(content);
}
}
else if (app.params.preprocess) {
content = app.params.preprocess(content, url, next);
if (typeof content !== 'undefined') {
next(content);
}
}
else {
next(content);
}
},
preroute: function(view, options) {
app.pluginHook('routerPreroute', view, options);
if ((app.params.preroute && app.params.preroute(view, options) === false) || (view && view.params.preroute && view.params.preroute(view, options) === false)) {
return true;
}
else {
return false;
}
},
template7Render: function (view, options) {
var url = options.url,
content = options.content, //initial content
t7_rendered_content = options.content, // will be rendered using Template7
context = options.context, // Context data for Template7
contextName = options.contextName,
template = options.template, // Template 7 compiled template
pageName = options.pageName;
var t7_ctx, t7_template;
if (typeof content === 'string') {
if (url) {
if (app.template7Cache[url]) t7_template = t7.cache[url];
else {
t7_template = t7.compile(content);
t7.cache[url] = t7_template;
}
}
else t7_template = t7.compile(content);
}
else if (template) {
t7_template = template;
}
if (context) t7_ctx = context;
else {
if (contextName) {
if (contextName.indexOf('.') >= 0) {
var _ctx_path = contextName.split('.');
var _ctx = t7.data[_ctx_path[0]];
for (var i = 1; i < _ctx_path.length; i++) {
if (_ctx_path[i]) _ctx = _ctx[_ctx_path[i]];
}
t7_ctx = _ctx;
}
else t7_ctx = t7.data[contextName];
}
if (!t7_ctx && url) {
t7_ctx = t7.data['url:' + url];
}
if (!t7_ctx && typeof content === 'string' && !template) {
//try to find by page name in content
var pageNameMatch = content.match(/(data-page=["'][^"^']*["'])/);
if (pageNameMatch) {
var page = pageNameMatch[0].split('data-page=')[1].replace(/['"]/g, '');
if (page) t7_ctx = t7.data['page:' + page];
}
}
if (!t7_ctx && template && t7.templates) {
// Try to find matched template name in t7.templates
for (var templateName in t7.templates) {
if (t7.templates[templateName] === template) t7_ctx = t7.data[templateName];
}
}
if (!t7_ctx) t7_ctx = {};
}
if (t7_template && t7_ctx) {
if (typeof t7_ctx === 'function') t7_ctx = t7_ctx();
if (url) {
// Extend data with URL query
var query = $.parseUrlQuery(url);
t7_ctx.url_query = {};
for (var key in query) {
t7_ctx.url_query[key] = query[key];
}
}
t7_rendered_content = t7_template(t7_ctx);
}
return {content: t7_rendered_content, context: t7_ctx};
}
};
app.router._load = function (view, options) {
options = options || {};
var url = options.url,
content = options.content, //initial content
t7_rendered = {content: options.content},
template = options.template, // Template 7 compiled template
pageName = options.pageName,
viewContainer = $(view.container),
pagesContainer = $(view.pagesContainer),
animatePages = options.animatePages,
newPage, oldPage, pagesInView, i, oldNavbarInner, newNavbarInner, navbar, dynamicNavbar, reloadPosition,
isDynamicPage = typeof url === 'undefined' && content || template,
pushState = options.pushState;
if (typeof animatePages === 'undefined') animatePages = view.params.animatePages;
// Plugin hook
app.pluginHook('routerLoad', view, options);
// Render with Template7
if (app.params.template7Pages && typeof content === 'string' || template) {
t7_rendered = app.router.template7Render(view, options);
if (t7_rendered.content && !content) {
content = t7_rendered.content;
}
}
app.router.temporaryDom.innerHTML = '';
// Parse DOM
if (!pageName) {
if (url || (typeof content === 'string')) {
app.router.temporaryDom.innerHTML = t7_rendered.content;
} else {
if ('length' in content && content.length > 1) {
for (var ci = 0; ci < content.length; ci++) {
$(app.router.temporaryDom).append(content[ci]);
}
} else {
$(app.router.temporaryDom).append(content);
}
}
}
// Reload position
reloadPosition = options.reload && (options.reloadPrevious ? 'left' : 'center');
// Find new page
if (pageName) newPage = pagesContainer.find('.page[data-page="' + pageName + '"]');
else {
newPage = app.router.findElement('.page', app.router.temporaryDom, view);
}
// If page not found exit
if (!newPage || newPage.length === 0 || (pageName && view.activePage && view.activePage.name === pageName)) {
view.allowPageChange = true;
return;
}
newPage.addClass(options.reload ? 'page-on-' + reloadPosition : 'page-on-right');
// Find old page (should be the last one) and remove older pages
pagesInView = pagesContainer.children('.page:not(.cached)');
if (options.reload && options.reloadPrevious && pagesInView.length === 1) {
view.allowPageChange = true;
return;
}
if (options.reload) {
oldPage = pagesInView.eq(pagesInView.length - 1);
}
else {
if (pagesInView.length > 1) {
for (i = 0; i < pagesInView.length - 2; i++) {
if (!view.params.domCache) {
app.pageRemoveCallback(view, pagesInView[i], 'left');
$(pagesInView[i]).remove();
}
else {
$(pagesInView[i]).addClass('cached');
}
}
if (!view.params.domCache) {
app.pageRemoveCallback(view, pagesInView[i], 'left');
$(pagesInView[i]).remove();
}
else {
$(pagesInView[i]).addClass('cached');
}
}
oldPage = pagesContainer.children('.page:not(.cached)');
}
if(view.params.domCache) newPage.removeClass('cached');
// Dynamic navbar
if (view.params.dynamicNavbar) {
dynamicNavbar = true;
// Find navbar
if (pageName) {
newNavbarInner = viewContainer.find('.navbar-inner[data-page="' + pageName + '"]');
}
else {
newNavbarInner = app.router.findElement('.navbar-inner', app.router.temporaryDom, view);
}
if (!newNavbarInner || newNavbarInner.length === 0) {
dynamicNavbar = false;
}
navbar = viewContainer.find('.navbar');
if (options.reload) {
oldNavbarInner = navbar.find('.navbar-inner:not(.cached):last-child');
}
else {
oldNavbarInner = navbar.find('.navbar-inner:not(.cached)');
if (oldNavbarInner.length > 0) {
for (i = 0; i < oldNavbarInner.length - 1; i++) {
if (!view.params.domCache) {
app.navbarRemoveCallback(view, pagesInView[i], navbar[0], oldNavbarInner[i]);
$(oldNavbarInner[i]).remove();
}
else
$(oldNavbarInner[i]).addClass('cached');
}
if (!newNavbarInner && oldNavbarInner.length === 1) {
if (!view.params.domCache) {
app.navbarRemoveCallback(view, pagesInView[0], navbar[0], oldNavbarInner[0]);
$(oldNavbarInner[0]).remove();
}
else
$(oldNavbarInner[0]).addClass('cached');
}
oldNavbarInner = navbar.find('.navbar-inner:not(.cached)');
}
}
}
if (dynamicNavbar) {
newNavbarInner.addClass(options.reload ? 'navbar-on-' + reloadPosition : 'navbar-on-right');
if(view.params.domCache) newNavbarInner.removeClass('cached');
newPage[0].f7RelatedNavbar = newNavbarInner[0];
newNavbarInner[0].f7RelatedPage = newPage[0];
}
// save content areas into view's cache
if (!url) {
var newPageName = pageName || newPage.attr('data-page');
if (isDynamicPage) url = '#' + app.params.dynamicPageUrl.replace(/{{name}}/g, newPageName).replace(/{{index}}/g, view.history.length - (options.reload ? 1 : 0));
else url = '#' + newPageName;
if (!view.params.domCache) {
view.contentCache[url] = content;
}
if (view.params.domCache && pageName) {
view.pagesCache[url] = pageName;
}
}
// Push State
if (app.params.pushState && !options.reloadPrevious && view.main) {
if (typeof pushState === 'undefined') pushState = true;
var pushStateRoot = app.params.pushStateRoot || '';
var method = options.reload ? 'replaceState' : 'pushState';
if (pushState) {
if (!isDynamicPage && !pageName) {
history[method]({url: url, viewIndex: app.views.indexOf(view)}, '', pushStateRoot + app.params.pushStateSeparator + url);
}
else if (isDynamicPage && content) {
history[method]({content: content, url: url, viewIndex: app.views.indexOf(view)}, '', pushStateRoot + app.params.pushStateSeparator + url);
}
else if (pageName) {
history[method]({pageName: pageName, url: url, viewIndex: app.views.indexOf(view)}, '', pushStateRoot + app.params.pushStateSeparator + url);
}
}
}
// Update View history
view.url = url;
if (options.reload) {
var lastUrl = view.history[view.history.length - (options.reloadPrevious ? 2 : 1)];
if (lastUrl && lastUrl.indexOf('#') === 0 && lastUrl in view.contentCache && lastUrl !== url) {
view.contentCache[lastUrl] = null;
delete view.contentCache[lastUrl];
}
view.history[view.history.length - (options.reloadPrevious ? 2 : 1)] = url;
}
else {
view.history.push(url);
}
// Unique history
var historyBecameUnique = false;
if (view.params.uniqueHistory) {
var _history = view.history;
var _url = url;
if (view.params.uniqueHistoryIgnoreGetParameters) {
_history = [];
_url = url.split('?')[0];
for (i = 0; i < view.history.length; i++) {
_history.push(view.history[i].split('?')[0]);
}
}
if (_history.indexOf(_url) !== _history.lastIndexOf(_url)) {
view.history = view.history.slice(0, _history.indexOf(_url));
view.history.push(url);
historyBecameUnique = true;
}
}
// Dom manipulations
if (options.reloadPrevious) {
oldPage = oldPage.prev('.page');
newPage.insertBefore(oldPage);
if (dynamicNavbar) {
oldNavbarInner = oldNavbarInner.prev('.navbar-inner');
newNavbarInner.insertAfter(oldNavbarInner);
}
}
else {
pagesContainer.append(newPage[0]);
if (dynamicNavbar) navbar.append(newNavbarInner[0]);
}
// Remove Old Page And Navbar
if (options.reload) {
if (view.params.domCache && view.initialPages.indexOf(oldPage[0]) >= 0) {
oldPage.addClass('cached');
if (dynamicNavbar) oldNavbarInner.addClass('cached');
}
else {
app.pageRemoveCallback(view, oldPage[0], reloadPosition);
if (dynamicNavbar) app.navbarRemoveCallback(view, oldPage[0], navbar[0], oldNavbarInner[0]);
oldPage.remove();
if (dynamicNavbar) oldNavbarInner.remove();
}
}
// Page Init Events
app.pageInitCallback(view, {
pageContainer: newPage[0],
url: url,
position: options.reload ? reloadPosition : 'right',
navbarInnerContainer: dynamicNavbar ? newNavbarInner && newNavbarInner[0] : undefined,
oldNavbarInnerContainer: dynamicNavbar ? oldNavbarInner && oldNavbarInner[0] : undefined,
context: t7_rendered.context,
query: options.query,
fromPage: oldPage && oldPage.length && oldPage[0].f7PageData,
reload: options.reload,
reloadPrevious: options.reloadPrevious
});
// Navbar init event
if (dynamicNavbar) {
app.navbarInitCallback(view, newPage[0], navbar[0], newNavbarInner[0], url, options.reload ? reloadPosition : 'right');
}
if (options.reload) {
view.allowPageChange = true;
if (historyBecameUnique) view.refreshPreviousPage();
return;
}
if (dynamicNavbar && animatePages) {
app.router.prepareNavbar(newNavbarInner, oldNavbarInner, 'right');
}
// Force reLayout
var clientLeft = newPage[0].clientLeft;
// Before Anim Callback
app.pageAnimCallback('before', view, {
pageContainer: newPage[0],
url: url,
position: 'right',
oldPage: oldPage,
newPage: newPage,
query: options.query,
fromPage: oldPage && oldPage.length && oldPage[0].f7PageData
});
function afterAnimation() {
view.allowPageChange = true;
newPage.removeClass('page-from-right-to-center page-on-right page-on-left').addClass('page-on-center');
oldPage.removeClass('page-from-center-to-left page-on-center page-on-right').addClass('page-on-left');
if (dynamicNavbar) {
newNavbarInner.removeClass('navbar-from-right-to-center navbar-on-left navbar-on-right').addClass('navbar-on-center');
oldNavbarInner.removeClass('navbar-from-center-to-left navbar-on-center navbar-on-right').addClass('navbar-on-left');
}
app.pageAnimCallback('after', view, {
pageContainer: newPage[0],
url: url,
position: 'right',
oldPage: oldPage,
newPage: newPage,
query: options.query,
fromPage: oldPage && oldPage.length && oldPage[0].f7PageData
});
if (app.params.pushState && view.main) app.pushStateClearQueue();
if (!(view.params.swipeBackPage || view.params.preloadPreviousPage)) {
if (view.params.domCache) {
oldPage.addClass('cached');
oldNavbarInner.addClass('cached');
}
else {
if (!(url.indexOf('#') === 0 && newPage.attr('data-page').indexOf('smart-select-') === 0)) {
app.pageRemoveCallback(view, oldPage[0], 'left');
if (dynamicNavbar) app.navbarRemoveCallback(view, oldPage[0], navbar[0], oldNavbarInner[0]);
oldPage.remove();
if (dynamicNavbar) oldNavbarInner.remove();
}
}
}
if (view.params.uniqueHistory && historyBecameUnique) {
view.refreshPreviousPage();
}
}
if (animatePages) {
// Set pages before animation
app.router.animatePages(oldPage, newPage, 'to-left', view);
// Dynamic navbar animation
if (dynamicNavbar) {
setTimeout(function() {
app.router.animateNavbars(oldNavbarInner, newNavbarInner, 'to-left', view);
}, 0);
}
newPage.animationEnd(function (e) {
afterAnimation();
});
}
else {
if (dynamicNavbar) newNavbarInner.find('.sliding, .sliding .back .icon').transform('');
afterAnimation();
}
};
app.router.load = function (view, options) {
if (app.router.preroute(view, options)) {
return false;
}
options = options || {};
var url = options.url;
var content = options.content;
var pageName = options.pageName;
if (pageName) {
if (pageName.indexOf('?') > 0) {
options.query = $.parseUrlQuery(pageName);
options.pageName = pageName = pageName.split('?')[0];
}
}
var template = options.template;
if (view.params.reloadPages === true) options.reload = true;
if (!view.allowPageChange) return false;
if (url && view.url === url && !options.reload && !view.params.allowDuplicateUrls) return false;
view.allowPageChange = false;
if (app.xhr && view.xhr && view.xhr === app.xhr) {
app.xhr.abort();
app.xhr = false;
}
function proceed(content) {
app.router.preprocess(view, content, url, function (content) {
options.content = content;
app.router._load(view, options);
});
}
if (content || pageName) {
proceed(content);
return;
}
else if (template) {
app.router._load(view, options);
return;
}
if (!options.url || options.url === '#') {
view.allowPageChange = true;
return;
}
app.get(options.url, view, options.ignoreCache, function (content, error) {
if (error) {
view.allowPageChange = true;
return;
}
proceed(content);
});
};
app.router._back = function (view, options) {
options = options || {};
var url = options.url,
content = options.content,
t7_rendered = {content: options.content}, // will be rendered using Template7
template = options.template, // Template 7 compiled template
animatePages = options.animatePages,
preloadOnly = options.preloadOnly,
pushState = options.pushState,
ignoreCache = options.ignoreCache,
force = options.force,
pageName = options.pageName;
var viewContainer = $(view.container),
pagesContainer = $(view.pagesContainer),
pagesInView = pagesContainer.children('.page:not(.cached)'),
oldPage, newPage, oldNavbarInner, newNavbarInner, navbar, navbarInners, dynamicNavbar, manipulateDom = true;
if (typeof animatePages === 'undefined') animatePages = view.params.animatePages;
app.pluginHook('routerBack', view, options);
// Render with Template7
if (app.params.template7Pages && typeof content === 'string' || template) {
t7_rendered = app.router.template7Render(view, options);
if (t7_rendered.content && !content) {
content = t7_rendered.content;
}
}
// Push state
if (app.params.pushState && view.main) {
if (typeof pushState === 'undefined') pushState = true;
if (!preloadOnly && history.state && pushState) {
history.back();
}
}
// Animation
function afterAnimation() {
app.pageBackCallback('after', view, {
pageContainer: oldPage[0],
url: url,
position: 'center',
oldPage: oldPage,
newPage: newPage,
});
app.pageAnimCallback('after', view, {
pageContainer: newPage[0],
url: url,
position: 'left',
oldPage: oldPage,
newPage: newPage,
query: options.query,
fromPage: oldPage && oldPage.length && oldPage[0].f7PageData
});
app.router.afterBack(view, oldPage[0], newPage[0]);
}
function animateBack() {
// Page before animation callback
app.pageBackCallback('before', view, {
pageContainer: oldPage[0],
url: url,
position: 'center',
oldPage: oldPage,
newPage: newPage,
});
app.pageAnimCallback('before', view, {
pageContainer: newPage[0],
url: url,
position: 'left',
oldPage: oldPage,
newPage: newPage,
query: options.query,
fromPage: oldPage && oldPage.length && oldPage[0].f7PageData
});
if (animatePages) {
// Set pages before animation
app.router.animatePages(newPage, oldPage, 'to-right', view);
// Dynamic navbar animation
if (dynamicNavbar) {
setTimeout(function () {
app.router.animateNavbars(newNavbarInner, oldNavbarInner, 'to-right', view);
}, 0);
}
newPage.animationEnd(function () {
afterAnimation();
});
}
else {
if (dynamicNavbar) newNavbarInner.find('.sliding, .sliding .back .icon').transform('');
afterAnimation();
}
}
function parseNewPage() {
app.router.temporaryDom.innerHTML = '';
// Parse DOM
if (url || (typeof content === 'string')) {
app.router.temporaryDom.innerHTML = t7_rendered.content;
} else {
if ('length' in content && content.length > 1) {
for (var ci = 0; ci < content.length; ci++) {
$(app.router.temporaryDom).append(content[ci]);
}
} else {
$(app.router.temporaryDom).append(content);
}
}
newPage = app.router.findElement('.page', app.router.temporaryDom, view);
if (view.params.dynamicNavbar) {
// Find navbar
newNavbarInner = app.router.findElement('.navbar-inner', app.router.temporaryDom, view);
}
}
function setPages() {
// If pages not found or there are still more than one, exit
if (!newPage || newPage.length === 0) {
view.allowPageChange = true;
return;
}
if (view.params.dynamicNavbar && typeof dynamicNavbar === 'undefined') {
if (!newNavbarInner || newNavbarInner.length === 0) {
dynamicNavbar = false;
}
else {
dynamicNavbar = true;
}
}
newPage.addClass('page-on-left').removeClass('cached');
if (dynamicNavbar) {
navbar = viewContainer.find('.navbar');
navbarInners = viewContainer.find('.navbar-inner:not(.cached)');
newNavbarInner.addClass('navbar-on-left').removeClass('cached');
}
// Remove/hide previous page in force mode
if (force) {
var pageToRemove, navbarToRemove;
pageToRemove = $(pagesInView[pagesInView.length - 2]);
if (dynamicNavbar) navbarToRemove = $(pageToRemove[0] && pageToRemove[0].f7RelatedNavbar || navbarInners[navbarInners.length - 2]);
if (view.params.domCache && view.initialPages.indexOf(pageToRemove[0]) >= 0) {
if (pageToRemove.length && pageToRemove[0] !== newPage[0]) pageToRemove.addClass('cached');
if (dynamicNavbar && navbarToRemove.length && navbarToRemove[0] !== newNavbarInner[0]) {
navbarToRemove.addClass('cached');
}
}
else {
if (pageToRemove.length) pageToRemove.remove();
if (dynamicNavbar && navbarToRemove.length) {
navbarToRemove.remove();
}
}
pagesInView = pagesContainer.children('.page:not(.cached)');
if (dynamicNavbar) {
navbarInners = viewContainer.find('.navbar-inner:not(.cached)');
}
if (view.history.indexOf(url) >= 0) {
view.history = view.history.slice(0, view.history.indexOf(url) + 2);
}
else {
if (view.history[[view.history.length - 2]]) {
view.history[view.history.length - 2] = url;
}
else {
view.history.unshift(url);
}
}
}
oldPage = $(pagesInView[pagesInView.length - 1]);
if (view.params.domCache) {
if (oldPage[0] === newPage[0]) {
oldPage = pagesContainer.children('.page.page-on-center');
if (oldPage.length === 0 && view.activePage) oldPage = $(view.activePage.container);
}
}
if (dynamicNavbar && !oldNavbarInner) {
oldNavbarInner = $(navbarInners[navbarInners.length - 1]);
if (view.params.domCache) {
if (oldNavbarInner[0] === newNavbarInner[0]) {
oldNavbarInner = navbar.children('.navbar-inner.navbar-on-center:not(.cached)');
}
if (oldNavbarInner.length === 0) {
oldNavbarInner = navbar.children('.navbar-inner[data-page="'+oldPage.attr('data-page')+'"]');
}
}
if (oldNavbarInner.length === 0 || newNavbarInner[0] === oldNavbarInner[0]) dynamicNavbar = false;
}
if (dynamicNavbar) {
if (manipulateDom) newNavbarInner.insertBefore(oldNavbarInner);
newNavbarInner[0].f7RelatedPage = newPage[0];
newPage[0].f7RelatedNavbar = newNavbarInner[0];
}
if (manipulateDom) newPage.insertBefore(oldPage);
// Page Init Events
app.pageInitCallback(view, {
pageContainer: newPage[0],
url: url,
position: 'left',
navbarInnerContainer: dynamicNavbar ? newNavbarInner[0] : undefined,
oldNavbarInnerContainer: dynamicNavbar ? oldNavbarInner && oldNavbarInner[0] : undefined,
context: t7_rendered.context,
query: options.query,
fromPage: oldPage && oldPage.length && oldPage[0].f7PageData,
preloadOnly: preloadOnly
});
if (dynamicNavbar) {
app.navbarInitCallback(view, newPage[0], navbar[0], newNavbarInner[0], url, 'right');
}
if (dynamicNavbar && newNavbarInner.hasClass('navbar-on-left') && animatePages) {
app.router.prepareNavbar(newNavbarInner, oldNavbarInner, 'left');
}
if (preloadOnly) {
view.allowPageChange = true;
return;
}
// Update View's URL
view.url = url;
// Force reLayout
var clientLeft = newPage[0].clientLeft;
animateBack();
return;
}
// Simple go back when we have pages on left
if (pagesInView.length > 1 && !force) {
// Exit if only preloadOnly
if (preloadOnly) {
view.allowPageChange = true;
return;
}
// Update View's URL
view.url = view.history[view.history.length - 2];
url = view.url;
// Define old and new pages
newPage = $(pagesInView[pagesInView.length - 2]);
oldPage = $(pagesInView[pagesInView.length - 1]);
// Dynamic navbar
if (view.params.dynamicNavbar) {
dynamicNavbar = true;
// Find navbar
navbarInners = viewContainer.find('.navbar-inner:not(.cached)');
newNavbarInner = $(navbarInners[0]);
oldNavbarInner = $(navbarInners[1]);
if (newNavbarInner.length === 0 || oldNavbarInner.length === 0 || oldNavbarInner[0] === newNavbarInner[0]) {
dynamicNavbar = false;
}
}
manipulateDom = false;
setPages();
return;
}
if (!force) {
// Go back when there is no pages on left
if (!preloadOnly) {
view.url = view.history[view.history.length - 2];
url = view.url;
}
if (content) {
parseNewPage();
setPages();
return;
}
else if (pageName) {
// Get dom cached pages
newPage = $(viewContainer).find('.page[data-page="' + pageName + '"]');
if (view.params.dynamicNavbar) {
newNavbarInner = $(viewContainer).find('.navbar-inner[data-page="' + pageName + '"]');
}
setPages();
return;
}
else {
view.allowPageChange = true;
return;
}
}
else {
if (url && url === view.url || pageName && view.activePage && view.activePage.name === pageName) {
view.allowPageChange = true;
return;
}
// Go back with force url
if (content) {
parseNewPage();
setPages();
return;
}
else if (pageName && view.params.domCache) {
if (pageName) url = '#' + pageName;
newPage = $(viewContainer).find('.page[data-page="' + pageName + '"]');
if (newPage[0].f7PageData && newPage[0].f7PageData.url) {
url = newPage[0].f7PageData.url;
}
if (view.params.dynamicNavbar) {
newNavbarInner = $(viewContainer).find('.navbar-inner[data-page="' + pageName + '"]');
if (newNavbarInner.length === 0) {
newNavbarInner = $(newPage[0].f7RelatedNavbar);
}
}
setPages();
return;
}
else {
view.allowPageChange = true;
return;
}
}
};
app.router.back = function (view, options) {
if (app.router.preroute(view, options)) {
return false;
}
options = options || {};
var url = options.url;
var content = options.content;
var pageName = options.pageName;
if (pageName) {
if (pageName.indexOf('?') > 0) {
options.query = $.parseUrlQuery(pageName);
options.pageName = pageName = pageName.split('?')[0];
}
}
var force = options.force;
if (!view.allowPageChange) return false;
view.allowPageChange = false;
if (app.xhr && view.xhr && view.xhr === app.xhr) {
app.xhr.abort();
app.xhr = false;
}
var pagesInView = $(view.pagesContainer).find('.page:not(.cached)');
function proceed(content) {
app.router.preprocess(view, content, url, function (content) {
options.content = content;
app.router._back(view, options);
});
}
if (pagesInView.length > 1 && !force) {
// Simple go back to previos page in view
app.router._back(view, options);
return;
}
if (!force) {
url = options.url = view.history[view.history.length - 2];
if (!url) {
view.allowPageChange = true;
return;
}
if (url.indexOf('#') === 0 && view.contentCache[url]) {
proceed(view.contentCache[url]);
return;
}
else if (url.indexOf('#') === 0 && view.params.domCache) {
if (!pageName) options.pageName = url.split('#')[1];
proceed();
return;
}
else if (url.indexOf('#') !== 0) {
// Load ajax page
app.get(options.url, view, options.ignoreCache, function (content, error) {
if (error) {
view.allowPageChange = true;
return;
}
proceed(content);
});
return;
}
}
else {
// Go back with force url
if (!url && content) {
proceed(content);
return;
}
else if (!url && pageName) {
if (pageName) url = '#' + pageName;
proceed();
return;
}
else if (url) {
app.get(options.url, view, options.ignoreCache, function (content, error) {
if (error) {
view.allowPageChange = true;
return;
}
proceed(content);
});
return;
}
}
view.allowPageChange = true;
return;
};
app.router.afterBack = function (view, oldPage, newPage) {
// Remove old page and set classes on new one
oldPage = $(oldPage);
newPage = $(newPage);
if (view.params.domCache && view.initialPages.indexOf(oldPage[0]) >= 0) {
oldPage.removeClass('page-from-center-to-right').addClass('cached');
}
else {
oldPage.remove();
app.pageRemoveCallback(view, oldPage[0], 'right');
}
newPage.removeClass('page-from-left-to-center page-on-left').addClass('page-on-center');
view.allowPageChange = true;
// Update View's History
var previousURL = view.history.pop();
var newNavbar;
// Updated dynamic navbar
if (view.params.dynamicNavbar) {
var inners = $(view.container).find('.navbar-inner:not(.cached)');
var oldNavbar = $(oldPage[0].f7RelatedNavbar || inners[1]);
if (view.params.domCache && view.initialNavbars.indexOf(oldNavbar[0]) >= 0) {
oldNavbar.removeClass('navbar-from-center-to-right').addClass('cached');
}
else {
app.navbarRemoveCallback(view, oldPage[0], undefined, oldNavbar[0]);
oldNavbar.remove();
}
newNavbar = $(inners[0]).removeClass('navbar-on-left navbar-from-left-to-center').addClass('navbar-on-center');
}
// Remove pages in dom cache
if (view.params.domCache) {
$(view.container).find('.page.cached').each(function () {
var page = $(this);
var index = page.index();
var pageUrl = page[0].f7PageData && page[0].f7PageData.url;
if (pageUrl && view.history.indexOf(pageUrl) < 0 && view.initialPages.indexOf(this) < 0) {
if (page[0].f7RelatedNavbar) $(page[0].f7RelatedNavbar).remove();
page.remove();
}
});
}
// Check previous page is content based only and remove it from content cache
if (!view.params.domCache && previousURL && previousURL.indexOf('#') > -1 && (previousURL in view.contentCache)) {
view.contentCache[previousURL] = null;
delete view.contentCache[previousURL];
}
if (app.params.pushState && view.main) app.pushStateClearQueue();
// Preload previous page
if (view.params.preloadPreviousPage) {
if (view.params.domCache && view.history.length > 1) {
var preloadUrl = view.history[view.history.length - 2];
var previousPage;
var previousNavbar;
if (preloadUrl && view.pagesCache[preloadUrl]) {
// Load by page name
previousPage = $(view.container).find('.page[data-page="' + view.pagesCache[preloadUrl] + '"]');
previousPage.insertBefore(newPage);
if (newNavbar) {
previousNavbar = $(view.container).find('.navbar-inner[data-page="' + view.pagesCache[preloadUrl] + '"]');
previousNavbar.insertBefore(newNavbar);
if(!previousNavbar || previousNavbar.length === 0) previousNavbar = newNavbar.prev('.navbar-inner.cached');
}
}
else {
// Just load previous page
previousPage = newPage.prev('.page.cached');
if (newNavbar) previousNavbar = newNavbar.prev('.navbar-inner.cached');
}
if (previousPage && previousPage.length > 0) previousPage.removeClass('cached page-on-right page-on-center').addClass('page-on-left');
if (previousNavbar && previousNavbar.length > 0) previousNavbar.removeClass('cached navbar-on-right navbar-on-center').addClass('navbar-on-left');
}
else {
app.router.back(view, {preloadOnly: true});
}
}
};
/*======================================================
************ Modals ************
======================================================*/
var _modalTemplateTempDiv = document.createElement('div');
app.modalStack = [];
app.modalStackClearQueue = function () {
if (app.modalStack.length) {
(app.modalStack.shift())();
}
};
app.modal = function (params) {
params = params || {};
var modalHTML = '';
if (app.params.modalTemplate) {
if (!app._compiledTemplates.modal) app._compiledTemplates.modal = t7.compile(app.params.modalTemplate);
modalHTML = app._compiledTemplates.modal(params);
}
else {
var buttonsHTML = '';
if (params.buttons && params.buttons.length > 0) {
for (var i = 0; i < params.buttons.length; i++) {
buttonsHTML += '<span class="modal-button' + (params.buttons[i].bold ? ' modal-button-bold' : '') + '">' + params.buttons[i].text + '</span>';
}
}
var titleHTML = params.title ? '<div class="modal-title">' + params.title + '</div>' : '';
var textHTML = params.text ? '<div class="modal-text">' + params.text + '</div>' : '';
var afterTextHTML = params.afterText ? params.afterText : '';
var noButtons = !params.buttons || params.buttons.length === 0 ? 'modal-no-buttons' : '';
var verticalButtons = params.verticalButtons ? 'modal-buttons-vertical' : '';
modalHTML = '<div class="modal ' + noButtons + ' ' + (params.cssClass || '') + '"><div class="modal-inner">' + (titleHTML + textHTML + afterTextHTML) + '</div><div class="modal-buttons ' + verticalButtons + '">' + buttonsHTML + '</div></div>';
}
_modalTemplateTempDiv.innerHTML = modalHTML;
var modal = $(_modalTemplateTempDiv).children();
$('body').append(modal[0]);
// Add events on buttons
modal.find('.modal-button').each(function (index, el) {
$(el).on('click', function (e) {
if (params.buttons[index].close !== false) app.closeModal(modal);
if (params.buttons[index].onClick) params.buttons[index].onClick(modal, e);
if (params.onClick) params.onClick(modal, index);
});
});
app.openModal(modal);
return modal[0];
};
app.alert = function (text, title, callbackOk) {
if (typeof title === 'function') {
callbackOk = arguments[1];
title = undefined;
}
return app.modal({
text: text || '',
title: typeof title === 'undefined' ? app.params.modalTitle : title,
buttons: [ {text: app.params.modalButtonOk, bold: true, onClick: callbackOk} ]
});
};
app.confirm = function (text, title, callbackOk, callbackCancel) {
if (typeof title === 'function') {
callbackCancel = arguments[2];
callbackOk = arguments[1];
title = undefined;
}
return app.modal({
text: text || '',
title: typeof title === 'undefined' ? app.params.modalTitle : title,
buttons: [
{text: app.params.modalButtonCancel, onClick: callbackCancel},
{text: app.params.modalButtonOk, bold: true, onClick: callbackOk}
]
});
};
app.prompt = function (text, title, callbackOk, callbackCancel) {
if (typeof title === 'function') {
callbackCancel = arguments[2];
callbackOk = arguments[1];
title = undefined;
}
return app.modal({
text: text || '',
title: typeof title === 'undefined' ? app.params.modalTitle : title,
afterText: '<input type="text" class="modal-text-input">',
buttons: [
{
text: app.params.modalButtonCancel
},
{
text: app.params.modalButtonOk,
bold: true
}
],
onClick: function (modal, index) {
if (index === 0 && callbackCancel) callbackCancel($(modal).find('.modal-text-input').val());
if (index === 1 && callbackOk) callbackOk($(modal).find('.modal-text-input').val());
}
});
};
app.modalLogin = function (text, title, callbackOk, callbackCancel) {
if (typeof title === 'function') {
callbackCancel = arguments[2];
callbackOk = arguments[1];
title = undefined;
}
return app.modal({
text: text || '',
title: typeof title === 'undefined' ? app.params.modalTitle : title,
afterText: '<input type="text" name="modal-username" placeholder="' + app.params.modalUsernamePlaceholder + '" class="modal-text-input modal-text-input-double"><input type="password" name="modal-password" placeholder="' + app.params.modalPasswordPlaceholder + '" class="modal-text-input modal-text-input-double">',
buttons: [
{
text: app.params.modalButtonCancel
},
{
text: app.params.modalButtonOk,
bold: true
}
],
onClick: function (modal, index) {
var username = $(modal).find('.modal-text-input[name="modal-username"]').val();
var password = $(modal).find('.modal-text-input[name="modal-password"]').val();
if (index === 0 && callbackCancel) callbackCancel(username, password);
if (index === 1 && callbackOk) callbackOk(username, password);
}
});
};
app.modalPassword = function (text, title, callbackOk, callbackCancel) {
if (typeof title === 'function') {
callbackCancel = arguments[2];
callbackOk = arguments[1];
title = undefined;
}
return app.modal({
text: text || '',
title: typeof title === 'undefined' ? app.params.modalTitle : title,
afterText: '<input type="password" name="modal-password" placeholder="' + app.params.modalPasswordPlaceholder + '" class="modal-text-input">',
buttons: [
{
text: app.params.modalButtonCancel
},
{
text: app.params.modalButtonOk,
bold: true
}
],
onClick: function (modal, index) {
var password = $(modal).find('.modal-text-input[name="modal-password"]').val();
if (index === 0 && callbackCancel) callbackCancel(password);
if (index === 1 && callbackOk) callbackOk(password);
}
});
};
app.showPreloader = function (title) {
return app.modal({
title: title || app.params.modalPreloaderTitle,
text: '<div class="preloader"></div>',
cssClass: 'modal-preloader'
});
};
app.hidePreloader = function () {
app.closeModal('.modal.modal-in');
};
app.showIndicator = function () {
$('body').append('<div class="preloader-indicator-overlay"></div><div class="preloader-indicator-modal"><span class="preloader preloader-white"></span></div>');
};
app.hideIndicator = function () {
$('.preloader-indicator-overlay, .preloader-indicator-modal').remove();
};
// Action Sheet
app.actions = function (target, params) {
var toPopover = false, modal, groupSelector, buttonSelector;
if (arguments.length === 1) {
// Actions
params = target;
}
else {
// Popover
if (app.device.ios) {
if (app.device.ipad) toPopover = true;
}
else {
if ($(window).width() >= 768) toPopover = true;
}
}
params = params || [];
if (params.length > 0 && !$.isArray(params[0])) {
params = [params];
}
var modalHTML;
if (toPopover) {
var actionsToPopoverTemplate = app.params.modalActionsToPopoverTemplate ||
'<div class="popover actions-popover">' +
'<div class="popover-inner">' +
'{{#each this}}' +
'<div class="list-block">' +
'<ul>' +
'{{#each this}}' +
'{{#if label}}' +
'<li class="actions-popover-label {{#if color}}color-{{color}}{{/if}} {{#if bold}}actions-popover-bold{{/if}}">{{text}}</li>' +
'{{else}}' +
'<li><a href="#" class="item-link list-button {{#if color}}color-{{color}}{{/if}} {{#if bg}}bg-{{bg}}{{/if}} {{#if bold}}actions-popover-bold{{/if}} {{#if disabled}}disabled{{/if}}">{{text}}</a></li>' +
'{{/if}}' +
'{{/each}}' +
'</ul>' +
'</div>' +
'{{/each}}' +
'</div>' +
'</div>';
if (!app._compiledTemplates.actionsToPopover) {
app._compiledTemplates.actionsToPopover = t7.compile(actionsToPopoverTemplate);
}
var popoverHTML = app._compiledTemplates.actionsToPopover(params);
modal = $(app.popover(popoverHTML, target, true));
groupSelector = '.list-block ul';
buttonSelector = '.list-button';
}
else {
if (app.params.modalActionsTemplate) {
if (!app._compiledTemplates.actions) app._compiledTemplates.actions = t7.compile(app.params.modalActionsTemplate);
modalHTML = app._compiledTemplates.actions(params);
}
else {
var buttonsHTML = '';
for (var i = 0; i < params.length; i++) {
for (var j = 0; j < params[i].length; j++) {
if (j === 0) buttonsHTML += '<div class="actions-modal-group">';
var button = params[i][j];
var buttonClass = button.label ? 'actions-modal-label' : 'actions-modal-button';
if (button.bold) buttonClass += ' actions-modal-button-bold';
if (button.color) buttonClass += ' color-' + button.color;
if (button.bg) buttonClass += ' bg-' + button.bg;
if (button.disabled) buttonClass += ' disabled';
buttonsHTML += '<span class="' + buttonClass + '">' + button.text + '</span>';
if (j === params[i].length - 1) buttonsHTML += '</div>';
}
}
modalHTML = '<div class="actions-modal">' + buttonsHTML + '</div>';
}
_modalTemplateTempDiv.innerHTML = modalHTML;
modal = $(_modalTemplateTempDiv).children();
$('body').append(modal[0]);
groupSelector = '.actions-modal-group';
buttonSelector = '.actions-modal-button';
}
var groups = modal.find(groupSelector);
groups.each(function (index, el) {
var groupIndex = index;
$(el).children().each(function (index, el) {
var buttonIndex = index;
var buttonParams = params[groupIndex][buttonIndex];
var clickTarget;
if (!toPopover && $(el).is(buttonSelector)) clickTarget = $(el);
if (toPopover && $(el).find(buttonSelector).length > 0) clickTarget = $(el).find(buttonSelector);
if (clickTarget) {
clickTarget.on('click', function (e) {
if (buttonParams.close !== false) app.closeModal(modal);
if (buttonParams.onClick) buttonParams.onClick(modal, e);
});
}
});
});
if (!toPopover) app.openModal(modal);
return modal[0];
};
app.popover = function (modal, target, removeOnClose) {
if (typeof removeOnClose === 'undefined') removeOnClose = true;
if (typeof modal === 'string' && modal.indexOf('<') >= 0) {
var _modal = document.createElement('div');
_modal.innerHTML = modal.trim();
if (_modal.childNodes.length > 0) {
modal = _modal.childNodes[0];
if (removeOnClose) modal.classList.add('remove-on-close');
$('body').append(modal);
}
else return false; //nothing found
}
modal = $(modal);
target = $(target);
if (modal.length === 0 || target.length === 0) return false;
if (modal.find('.popover-angle').length === 0 && !app.params.material) {
modal.append('<div class="popover-angle"></div>');
}
modal.show();
var material = app.params.material;
function sizePopover() {
modal.css({left: '', top: ''});
var modalWidth = modal.width();
var modalHeight = modal.height(); // 13 - height of angle
var modalAngle, modalAngleSize = 0, modalAngleLeft, modalAngleTop;
if (!material) {
modalAngle = modal.find('.popover-angle');
modalAngleSize = modalAngle.width() / 2;
modalAngle.removeClass('on-left on-right on-top on-bottom').css({left: '', top: ''});
}
else {
modal.removeClass('popover-on-left popover-on-right popover-on-top popover-on-bottom').css({left: '', top: ''});
}
var targetWidth = target.outerWidth();
var targetHeight = target.outerHeight();
var targetOffset = target.offset();
var targetParentPage = target.parents('.page');
if (targetParentPage.length > 0) {
targetOffset.top = targetOffset.top - targetParentPage[0].scrollTop;
}
var windowHeight = $(window).height();
var windowWidth = $(window).width();
var modalTop = 0;
var modalLeft = 0;
var diff = 0;
// Top Position
var modalPosition = 'top';
if (material) {
if (modalHeight < targetOffset.top) {
// On top
modalTop = targetOffset.top - modalHeight + targetHeight;
}
else if (modalHeight < windowHeight - targetOffset.top - targetHeight) {
// On bottom
modalPosition = 'bottom';
modalTop = targetOffset.top;
}
else {
// On middle
modalPosition = 'bottom';
modalTop = targetOffset.top;
}
if (modalTop <= 0) {
modalTop = 5;
}
else if (modalTop + modalHeight >= windowHeight) {
modalTop = windowHeight - modalHeight - 5;
}
// Horizontal Position
modalLeft = targetOffset.left;
if (modalLeft < 5) modalLeft = 5;
if (modalLeft + modalWidth > windowWidth) {
modalLeft = targetOffset.left + targetWidth - modalWidth;
}
if (modalPosition === 'top') {
modal.addClass('popover-on-top');
}
if (modalPosition === 'bottom') {
modal.addClass('popover-on-bottom');
}
}
else {
if ((modalHeight + modalAngleSize) < targetOffset.top) {
// On top
modalTop = targetOffset.top - modalHeight - modalAngleSize;
}
else if ((modalHeight + modalAngleSize) < windowHeight - targetOffset.top - targetHeight) {
// On bottom
modalPosition = 'bottom';
modalTop = targetOffset.top + targetHeight + modalAngleSize;
}
else {
// On middle
modalPosition = 'middle';
modalTop = targetHeight / 2 + targetOffset.top - modalHeight / 2;
diff = modalTop;
if (modalTop <= 0) {
modalTop = 5;
}
else if (modalTop + modalHeight >= windowHeight) {
modalTop = windowHeight - modalHeight - 5;
}
diff = diff - modalTop;
}
// Horizontal Position
if (modalPosition === 'top' || modalPosition === 'bottom') {
modalLeft = targetWidth / 2 + targetOffset.left - modalWidth / 2;
diff = modalLeft;
if (modalLeft < 5) modalLeft = 5;
if (modalLeft + modalWidth > windowWidth) modalLeft = windowWidth - modalWidth - 5;
if (modalPosition === 'top') {
modalAngle.addClass('on-bottom');
}
if (modalPosition === 'bottom') {
modalAngle.addClass('on-top');
}
diff = diff - modalLeft;
modalAngleLeft = (modalWidth / 2 - modalAngleSize + diff);
modalAngleLeft = Math.max(Math.min(modalAngleLeft, modalWidth - modalAngleSize * 2 - 6), 6);
modalAngle.css({left: modalAngleLeft + 'px'});
}
else if (modalPosition === 'middle') {
modalLeft = targetOffset.left - modalWidth - modalAngleSize;
modalAngle.addClass('on-right');
if (modalLeft < 5 || (modalLeft + modalWidth > windowWidth)) {
if (modalLeft < 5) modalLeft = targetOffset.left + targetWidth + modalAngleSize;
if (modalLeft + modalWidth > windowWidth) modalLeft = windowWidth - modalWidth - 5;
modalAngle.removeClass('on-right').addClass('on-left');
}
modalAngleTop = (modalHeight / 2 - modalAngleSize + diff);
modalAngleTop = Math.max(Math.min(modalAngleTop, modalHeight - modalAngleSize * 2 - 6), 6);
modalAngle.css({top: modalAngleTop + 'px'});
}
}
// Apply Styles
modal.css({top: modalTop + 'px', left: modalLeft + 'px'});
}
sizePopover();
$(window).on('resize', sizePopover);
modal.on('close', function () {
$(window).off('resize', sizePopover);
});
if (modal.find('.' + app.params.viewClass).length > 0) {
app.sizeNavbars(modal.find('.' + app.params.viewClass)[0]);
}
app.openModal(modal);
return modal[0];
};
app.popup = function (modal, removeOnClose) {
if (typeof removeOnClose === 'undefined') removeOnClose = true;
if (typeof modal === 'string' && modal.indexOf('<') >= 0) {
var _modal = document.createElement('div');
_modal.innerHTML = modal.trim();
if (_modal.childNodes.length > 0) {
modal = _modal.childNodes[0];
if (removeOnClose) modal.classList.add('remove-on-close');
$('body').append(modal);
}
else return false; //nothing found
}
modal = $(modal);
if (modal.length === 0) return false;
modal.show();
if (modal.find('.' + app.params.viewClass).length > 0) {
app.sizeNavbars(modal.find('.' + app.params.viewClass)[0]);
}
app.openModal(modal);
return modal[0];
};
app.pickerModal = function (pickerModal, removeOnClose) {
if (typeof removeOnClose === 'undefined') removeOnClose = true;
if (typeof pickerModal === 'string' && pickerModal.indexOf('<') >= 0) {
pickerModal = $(pickerModal);
if (pickerModal.length > 0) {
if (removeOnClose) pickerModal.addClass('remove-on-close');
$('body').append(pickerModal[0]);
}
else return false; //nothing found
}
pickerModal = $(pickerModal);
if (pickerModal.length === 0) return false;
pickerModal.show();
app.openModal(pickerModal);
return pickerModal[0];
};
app.loginScreen = function (modal) {
if (!modal) modal = '.login-screen';
modal = $(modal);
if (modal.length === 0) return false;
modal.show();
if (modal.find('.' + app.params.viewClass).length > 0) {
app.sizeNavbars(modal.find('.' + app.params.viewClass)[0]);
}
app.openModal(modal);
return modal[0];
};
app.openModal = function (modal) {
modal = $(modal);
var isModal = modal.hasClass('modal');
if ($('.modal.modal-in:not(.modal-out)').length && app.params.modalStack && isModal) {
app.modalStack.push(function () {
app.openModal(modal);
});
return;
}
var isPopover = modal.hasClass('popover');
var isPopup = modal.hasClass('popup');
var isLoginScreen = modal.hasClass('login-screen');
var isPickerModal = modal.hasClass('picker-modal');
if (isModal) {
modal.show();
modal.css({
marginTop: - Math.round(modal.outerHeight() / 2) + 'px'
});
}
var overlay;
if (!isLoginScreen && !isPickerModal) {
if ($('.modal-overlay').length === 0 && !isPopup) {
$('body').append('<div class="modal-overlay"></div>');
}
if ($('.popup-overlay').length === 0 && isPopup) {
$('body').append('<div class="popup-overlay"></div>');
}
overlay = isPopup ? $('.popup-overlay') : $('.modal-overlay');
}
//Make sure that styles are applied, trigger relayout;
var clientLeft = modal[0].clientLeft;
// Trugger open event
modal.trigger('open');
// Picker modal body class
if (isPickerModal) {
$('body').addClass('with-picker-modal');
}
// Classes for transition in
if (!isLoginScreen && !isPickerModal) overlay.addClass('modal-overlay-visible');
modal.removeClass('modal-out').addClass('modal-in').transitionEnd(function (e) {
if (modal.hasClass('modal-out')) modal.trigger('closed');
else modal.trigger('opened');
});
return true;
};
app.closeModal = function (modal) {
modal = $(modal || '.modal-in');
if (typeof modal !== 'undefined' && modal.length === 0) {
return;
}
var isModal = modal.hasClass('modal');
var isPopover = modal.hasClass('popover');
var isPopup = modal.hasClass('popup');
var isLoginScreen = modal.hasClass('login-screen');
var isPickerModal = modal.hasClass('picker-modal');
var removeOnClose = modal.hasClass('remove-on-close');
var overlay = isPopup ? $('.popup-overlay') : $('.modal-overlay');
if (isPopup){
if (modal.length === $('.popup.modal-in').length) {
overlay.removeClass('modal-overlay-visible');
}
}
else if (!isPickerModal) {
overlay.removeClass('modal-overlay-visible');
}
modal.trigger('close');
// Picker modal body class
if (isPickerModal) {
$('body').removeClass('with-picker-modal');
$('body').addClass('picker-modal-closing');
}
if (!isPopover) {
modal.removeClass('modal-in').addClass('modal-out').transitionEnd(function (e) {
if (modal.hasClass('modal-out')) modal.trigger('closed');
else modal.trigger('opened');
if (isPickerModal) {
$('body').removeClass('picker-modal-closing');
}
if (isPopup || isLoginScreen || isPickerModal) {
modal.removeClass('modal-out').hide();
if (removeOnClose && modal.length > 0) {
modal.remove();
}
}
else {
modal.remove();
}
});
if (isModal && app.params.modalStack) {
app.modalStackClearQueue();
}
}
else {
modal.removeClass('modal-in modal-out').trigger('closed').hide();
if (removeOnClose) {
modal.remove();
}
}
return true;
};
/*======================================================
************ Panels ************
======================================================*/
app.allowPanelOpen = true;
app.openPanel = function (panelPosition) {
if (!app.allowPanelOpen) return false;
var panel = $('.panel-' + panelPosition);
if (panel.length === 0 || panel.hasClass('active')) return false;
app.closePanel(); // Close if some panel is opened
app.allowPanelOpen = false;
var effect = panel.hasClass('panel-reveal') ? 'reveal' : 'cover';
panel.css({display: 'block'}).addClass('active');
panel.trigger('open');
if (panel.find('.' + app.params.viewClass).length > 0) {
if (app.sizeNavbars) app.sizeNavbars(panel.find('.' + app.params.viewClass)[0]);
}
// Trigger reLayout
var clientLeft = panel[0].clientLeft;
// Transition End;
var transitionEndTarget = effect === 'reveal' ? $('.' + app.params.viewsClass) : panel;
var openedTriggered = false;
function panelTransitionEnd() {
transitionEndTarget.transitionEnd(function (e) {
if ($(e.target).is(transitionEndTarget)) {
if (panel.hasClass('active')) {
panel.trigger('opened');
}
else {
panel.trigger('closed');
}
app.allowPanelOpen = true;
}
else panelTransitionEnd();
});
}
panelTransitionEnd();
$('body').addClass('with-panel-' + panelPosition + '-' + effect);
return true;
};
app.closePanel = function () {
var activePanel = $('.panel.active');
if (activePanel.length === 0) return false;
var effect = activePanel.hasClass('panel-reveal') ? 'reveal' : 'cover';
var panelPosition = activePanel.hasClass('panel-left') ? 'left' : 'right';
activePanel.removeClass('active');
var transitionEndTarget = effect === 'reveal' ? $('.' + app.params.viewsClass) : activePanel;
activePanel.trigger('close');
app.allowPanelOpen = false;
transitionEndTarget.transitionEnd(function () {
if (activePanel.hasClass('active')) return;
activePanel.css({display: ''});
activePanel.trigger('closed');
$('body').removeClass('panel-closing');
app.allowPanelOpen = true;
});
$('body').addClass('panel-closing').removeClass('with-panel-' + panelPosition + '-' + effect);
};
/*======================================================
************ Swipe panels ************
======================================================*/
app.initSwipePanels = function () {
var panel, side;
if (app.params.swipePanel) {
panel = $('.panel.panel-' + app.params.swipePanel);
side = app.params.swipePanel;
if (panel.length === 0) return;
}
else {
if (app.params.swipePanelOnlyClose) {
if ($('.panel').length === 0) return;
}
else return;
}
var panelOverlay = $('.panel-overlay');
var isTouched, isMoved, isScrolling, touchesStart = {}, touchStartTime, touchesDiff, translate, opened, panelWidth, effect, direction;
var views = $('.' + app.params.viewsClass);
function handleTouchStart(e) {
if (!app.allowPanelOpen || (!app.params.swipePanel && !app.params.swipePanelOnlyClose) || isTouched) return;
if ($('.modal-in, .photo-browser-in').length > 0) return;
if (!(app.params.swipePanelCloseOpposite || app.params.swipePanelOnlyClose)) {
if ($('.panel.active').length > 0 && !panel.hasClass('active')) return;
}
touchesStart.x = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
touchesStart.y = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
if (app.params.swipePanelCloseOpposite || app.params.swipePanelOnlyClose) {
if ($('.panel.active').length > 0) {
side = $('.panel.active').hasClass('panel-left') ? 'left' : 'right';
}
else {
if (app.params.swipePanelOnlyClose) return;
side = app.params.swipePanel;
}
if (!side) return;
}
panel = $('.panel.panel-' + side);
opened = panel.hasClass('active');
if (app.params.swipePanelActiveArea && !opened) {
if (side === 'left') {
if (touchesStart.x > app.params.swipePanelActiveArea) return;
}
if (side === 'right') {
if (touchesStart.x < window.innerWidth - app.params.swipePanelActiveArea) return;
}
}
isMoved = false;
isTouched = true;
isScrolling = undefined;
touchStartTime = (new Date()).getTime();
direction = undefined;
}
function handleTouchMove(e) {
if (!isTouched) return;
if (e.f7PreventPanelSwipe) return;
var pageX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
var pageY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (typeof isScrolling === 'undefined') {
isScrolling = !!(isScrolling || Math.abs(pageY - touchesStart.y) > Math.abs(pageX - touchesStart.x));
}
if (isScrolling) {
isTouched = false;
return;
}
if (!direction) {
if (pageX > touchesStart.x) {
direction = 'to-right';
}
else {
direction = 'to-left';
}
if (
side === 'left' &&
(
direction === 'to-left' && !panel.hasClass('active')
) ||
side === 'right' &&
(
direction === 'to-right' && !panel.hasClass('active')
)
)
{
isTouched = false;
return;
}
}
if (app.params.swipePanelNoFollow) {
var timeDiff = (new Date()).getTime() - touchStartTime;
if (timeDiff < 300) {
if (direction === 'to-left') {
if (side === 'right') app.openPanel(side);
if (side === 'left' && panel.hasClass('active')) app.closePanel();
}
if (direction === 'to-right') {
if (side === 'left') app.openPanel(side);
if (side === 'right' && panel.hasClass('active')) app.closePanel();
}
}
isTouched = false;
isMoved = false;
return;
}
if (!isMoved) {
effect = panel.hasClass('panel-cover') ? 'cover' : 'reveal';
if (!opened) {
panel.show();
panelOverlay.show();
}
panelWidth = panel[0].offsetWidth;
panel.transition(0);
if (panel.find('.' + app.params.viewClass).length > 0) {
if (app.sizeNavbars) app.sizeNavbars(panel.find('.' + app.params.viewClass)[0]);
}
}
isMoved = true;
e.preventDefault();
var threshold = opened ? 0 : -app.params.swipePanelThreshold;
if (side === 'right') threshold = -threshold;
touchesDiff = pageX - touchesStart.x + threshold;
if (side === 'right') {
translate = touchesDiff - (opened ? panelWidth : 0);
if (translate > 0) translate = 0;
if (translate < -panelWidth) {
translate = -panelWidth;
}
}
else {
translate = touchesDiff + (opened ? panelWidth : 0);
if (translate < 0) translate = 0;
if (translate > panelWidth) {
translate = panelWidth;
}
}
if (effect === 'reveal') {
views.transform('translate3d(' + translate + 'px,0,0)').transition(0);
panelOverlay.transform('translate3d(' + translate + 'px,0,0)');
app.pluginHook('swipePanelSetTransform', views[0], panel[0], Math.abs(translate / panelWidth));
}
else {
panel.transform('translate3d(' + translate + 'px,0,0)').transition(0);
app.pluginHook('swipePanelSetTransform', views[0], panel[0], Math.abs(translate / panelWidth));
}
}
function handleTouchEnd(e) {
if (!isTouched || !isMoved) {
isTouched = false;
isMoved = false;
return;
}
isTouched = false;
isMoved = false;
var timeDiff = (new Date()).getTime() - touchStartTime;
var action;
var edge = (translate === 0 || Math.abs(translate) === panelWidth);
if (!opened) {
if (translate === 0) {
action = 'reset';
}
else if (
timeDiff < 300 && Math.abs(translate) > 0 ||
timeDiff >= 300 && (Math.abs(translate) >= panelWidth / 2)
) {
action = 'swap';
}
else {
action = 'reset';
}
}
else {
if (translate === -panelWidth) {
action = 'reset';
}
else if (
timeDiff < 300 && Math.abs(translate) >= 0 ||
timeDiff >= 300 && (Math.abs(translate) <= panelWidth / 2)
) {
if (side === 'left' && translate === panelWidth) action = 'reset';
else action = 'swap';
}
else {
action = 'reset';
}
}
if (action === 'swap') {
app.allowPanelOpen = true;
if (opened) {
app.closePanel();
if (edge) {
panel.css({display: ''});
$('body').removeClass('panel-closing');
}
}
else {
app.openPanel(side);
}
if (edge) app.allowPanelOpen = true;
}
if (action === 'reset') {
if (opened) {
app.allowPanelOpen = true;
app.openPanel(side);
}
else {
app.closePanel();
if (edge) {
app.allowPanelOpen = true;
panel.css({display: ''});
}
else {
var target = effect === 'reveal' ? views : panel;
$('body').addClass('panel-closing');
target.transitionEnd(function () {
app.allowPanelOpen = true;
panel.css({display: ''});
$('body').removeClass('panel-closing');
});
}
}
}
if (effect === 'reveal') {
views.transition('');
views.transform('');
}
panel.transition('').transform('');
panelOverlay.css({display: ''}).transform('');
}
$(document).on(app.touchEvents.start, handleTouchStart);
$(document).on(app.touchEvents.move, handleTouchMove);
$(document).on(app.touchEvents.end, handleTouchEnd);
};
/*======================================================
************ Image Lazy Loading ************
************ Based on solution by Marc Godard, https://github.com/MarcGodard ************
======================================================*/
app.initImagesLazyLoad = function (pageContainer) {
pageContainer = $(pageContainer);
// Lazy images
var lazyLoadImages;
if (pageContainer.hasClass('lazy')) {
lazyLoadImages = pageContainer;
pageContainer = lazyLoadImages.parents('.page');
}
else {
lazyLoadImages = pageContainer.find('.lazy');
}
if (lazyLoadImages.length === 0) return;
// Scrollable page content
var pageContent;
if (pageContainer.hasClass('page-content')) {
pageContent = pageContainer;
pageContainer = pageContainer.parents('.page');
}
else {
pageContent = pageContainer.find('.page-content');
}
if (pageContent.length === 0) return;
// Placeholder
var placeholderSrc = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABAQMAAAAl21bKAAAAA1BMVEXCwsK592mkAAAACklEQVQI12NgAAAAAgAB4iG8MwAAAABJRU5ErkJggg==';
if (typeof app.params.imagesLazyLoadPlaceholder === 'string') {
placeholderSrc = app.params.imagesLazyLoadPlaceholder;
}
if (app.params.imagesLazyLoadPlaceholder !== false) lazyLoadImages.each(function(){
if ($(this).attr('data-src')) $(this).attr('src', placeholderSrc);
});
// load image
var imagesSequence = [];
var imageIsLoading = false;
function loadImage(el) {
el = $(el);
var bg = el.attr('data-background');
var src = bg ? bg : el.attr('data-src');
if (!src) return;
function onLoad() {
el.removeClass('lazy').addClass('lazy-loaded');
if (bg) {
el.css('background-image', 'url(' + src + ')');
}
else {
el.attr('src', src);
}
if (app.params.imagesLazyLoadSequential) {
imageIsLoading = false;
if (imagesSequence.length > 0) {
loadImage(imagesSequence.shift());
}
}
}
if (app.params.imagesLazyLoadSequential) {
if (imageIsLoading) {
if (imagesSequence.indexOf(el[0]) < 0) imagesSequence.push(el[0]);
return;
}
}
// Loading flag
imageIsLoading = true;
var image = new Image();
image.onload = onLoad;
image.onerror = onLoad;
image.src =src;
}
function lazyHandler() {
lazyLoadImages = pageContainer.find('.lazy');
lazyLoadImages.each(function(index, el) {
el = $(el);
if (isElementInViewport(el[0])) {
loadImage(el);
}
});
}
function isElementInViewport (el) {
var rect = el.getBoundingClientRect();
var threshold = app.params.imagesLazyLoadThreshold || 0;
return (
rect.top >= (0 - threshold) &&
rect.left >= (0 - threshold) &&
rect.top <= (window.innerHeight + threshold) &&
rect.left <= (window.innerWidth + threshold)
);
}
function attachEvents(destroy) {
var method = destroy ? 'off' : 'on';
lazyLoadImages[method]('lazy', lazyHandler);
pageContainer[method]('lazy', lazyHandler);
pageContent[method]('lazy', lazyHandler);
pageContent[method]('scroll', lazyHandler);
$(window)[method]('resize', lazyHandler);
}
function detachEvents() {
attachEvents(true);
}
// Store detach function
pageContainer[0].f7DestroyImagesLazyLoad = detachEvents;
// Attach events
attachEvents();
// Destroy on page remove
if (pageContainer.hasClass('page')) {
pageContainer.once('pageBeforeRemove', detachEvents);
}
// Run loader on page load/init
lazyHandler();
// Run after page animation
pageContainer.once('pageAfterAnimation', lazyHandler);
};
app.destroyImagesLazyLoad = function (pageContainer) {
pageContainer = $(pageContainer);
if (pageContainer.length > 0 && pageContainer[0].f7DestroyImagesLazyLoad) {
pageContainer[0].f7DestroyLazyLoad();
}
};
app.reinitImagesLazyLoad = function (pageContainer) {
pageContainer = $(pageContainer);
if (pageContainer.length > 0) {
pageContainer.trigger('lazy');
}
};
/*======================================================
************ Messages ************
======================================================*/
var Messages = function (container, params) {
var defaults = {
autoLayout: true,
newMessagesFirst: false,
messageTemplate:
'{{#if day}}' +
'<div class="messages-date">{{day}} {{#if time}}, <span>{{time}}</span>{{/if}}</div>' +
'{{/if}}' +
'<div class="message message-{{type}} {{#if hasImage}}message-pic{{/if}} {{#if avatar}}message-with-avatar{{/if}} {{#if position}}message-appear-from-{{position}}{{/if}}">' +
'{{#if name}}<div class="message-name">{{name}}</div>{{/if}}' +
'<div class="message-text">{{text}}</div>' +
'{{#if avatar}}<div class="message-avatar" style="background-image:url({{avatar}})"></div>{{/if}}' +
'{{#if label}}<div class="message-label">{{label}}</div>{{/if}}' +
'</div>'
};
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined' || params[def] === null) {
params[def] = defaults[def];
}
}
// Instance
var m = this;
// Params
m.params = params;
// Container
m.container = $(container);
if (m.container.length === 0) return;
// Autolayout
if (m.params.autoLayout) m.container.addClass('messages-auto-layout');
// Is In Page
m.pageContainer = m.container.parents('.page').eq(0);
m.pageContent = m.pageContainer.find('.page-content');
// Compiled template
m.template = Template7.compile(m.params.messageTemplate);
// Auto Layout
m.layout = function () {
if (!m.container.hasClass('messages-auto-layout')) m.container.addClass('messages-auto-layout');
m.container.find('.message').each(function () {
var message = $(this);
if (message.find('.message-text img').length > 0) message.addClass('message-pic');
if (message.find('.message-avatar').length > 0) message.addClass('message-with-avatar');
});
m.container.find('.message').each(function () {
var message = $(this);
var isSent = message.hasClass('message-sent');
var next = message.next('.message-' + (isSent ? 'sent' : 'received'));
var prev = message.prev('.message-' + (isSent ? 'sent' : 'received'));
if (next.length === 0) {
message.addClass('message-last message-with-tail');
}
else message.removeClass('message-last message-with-tail');
if (prev.length === 0) {
message.addClass('message-first');
}
else message.removeClass('message-first');
if (prev.length > 0 && prev.find('.message-name').length > 0 && message.find('.message-name').length > 0) {
if (prev.find('.message-name').text() !== message.find('.message-name').text()) {
prev.addClass('message-last message-with-tail');
message.addClass('message-first');
}
}
});
};
// Add Message
m.appendMessage = function (props, animate) {
return m.addMessage(props, 'append', animate);
};
m.prependMessage = function (props, animate) {
return m.addMessage(props, 'prepend', animate);
};
m.addMessage = function (props, method, animate) {
return m.addMessages([props], method, animate);
};
m.addMessages = function (newMessages, method, animate) {
if (typeof animate === 'undefined') {
animate = true;
}
if (typeof method === 'undefined') {
method = m.params.newMessagesFirst ? 'prepend' : 'append';
}
var newMessagesHTML = '', i;
for (i = 0; i < newMessages.length; i++) {
var props = newMessages[i] || {};
props.type = props.type || 'sent';
if (!props.text) continue;
props.hasImage = props.text.indexOf('<img') >= 0;
if (animate) props.position = method === 'append' ? 'bottom' : 'top';
newMessagesHTML += m.template(props);
}
m.container[method](newMessagesHTML);
if (m.params.autoLayout) m.layout();
if ((method === 'append' && !m.params.newMessagesFirst) || (method === 'prepend' && m.params.newMessagesFirst)) {
m.scrollMessages(animate ? undefined : 0);
}
var messages = m.container.find('.message');
if (newMessages.length === 1) {
return method === 'append' ? messages[messages.length - 1] : messages[0];
}
else {
var messagesToReturn = [];
if (method === 'append') {
for (i = messages.length - newMessages.length; i < messages.length; i++) {
messagesToReturn.push(messages[i]);
}
}
else {
for (i = 0; i < newMessages.length; i++) {
messagesToReturn.push(messages[i]);
}
}
return messagesToReturn;
}
};
m.removeMessage = function (message) {
message = $(message);
if (message.length === 0) {
return false;
}
else {
message.remove();
if (m.params.autoLayout) m.layout();
return true;
}
};
m.removeMessages = function (messages) {
m.removeMessage(messages);
};
m.clean = function () {
m.container.html('');
};
// Scroll
m.scrollMessages = function (duration) {
if (typeof duration === 'undefined') duration = 400;
var currentScroll = m.pageContent[0].scrollTop;
var newScroll = m.params.newMessagesFirst ? 0 : m.pageContent[0].scrollHeight - m.pageContent[0].offsetHeight;
if (newScroll === currentScroll) return;
m.pageContent.scrollTop(newScroll, duration);
};
// Init Destroy
m.init = function () {
if (m.params.messages) {
m.addMessages(m.params.messages, undefined, false);
}
else {
if (m.params.autoLayout) m.layout();
m.scrollMessages(0);
}
};
m.destroy = function () {
m = null;
};
// Init
m.init();
m.container[0].f7Messages = m;
return m;
};
app.messages = function (container, params) {
return new Messages (container, params);
};
app.initPageMessages = function (pageContainer) {
pageContainer = $(pageContainer);
var messages = pageContainer.find('.messages');
if (messages.length === 0) return;
if (!messages.hasClass('messages-init')) {
return;
}
var m = app.messages(messages, messages.dataset());
// Destroy on page remove
function pageBeforeRemove() {
m.destroy();
pageContainer.off('pageBeforeRemove', pageBeforeRemove);
}
if (pageContainer.hasClass('page')) {
pageContainer.on('pageBeforeRemove', pageBeforeRemove);
}
};
/*===============================================================================
************ Swipeout Actions (Swipe to delete) ************
===============================================================================*/
app.swipeoutOpenedEl = undefined;
app.allowSwipeout = true;
app.initSwipeout = function (swipeoutEl) {
var isTouched, isMoved, isScrolling, touchesStart = {}, touchStartTime, touchesDiff, swipeOutEl, swipeOutContent, actionsRight, actionsLeft, actionsLeftWidth, actionsRightWidth, translate, opened, openedActions, buttonsLeft, buttonsRight, direction, overswipeLeftButton, overswipeRightButton, overswipeLeft, overswipeRight, noFoldLeft, noFoldRight;
$(document).on(app.touchEvents.start, function (e) {
if (app.swipeoutOpenedEl) {
var target = $(e.target);
if (!(
app.swipeoutOpenedEl.is(target[0]) ||
target.parents('.swipeout').is(app.swipeoutOpenedEl) ||
target.hasClass('modal-in') ||
target.hasClass('modal-overlay') ||
target.hasClass('actions-modal') ||
target.parents('.actions-modal.modal-in, .modal.modal-in').length > 0
)) {
app.swipeoutClose(app.swipeoutOpenedEl);
}
}
});
function handleTouchStart(e) {
if (!app.allowSwipeout) return;
isMoved = false;
isTouched = true;
isScrolling = undefined;
touchesStart.x = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
touchesStart.y = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
touchStartTime = (new Date()).getTime();
}
function handleTouchMove(e) {
if (!isTouched) return;
var pageX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
var pageY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (typeof isScrolling === 'undefined') {
isScrolling = !!(isScrolling || Math.abs(pageY - touchesStart.y) > Math.abs(pageX - touchesStart.x));
}
if (isScrolling) {
isTouched = false;
return;
}
if (!isMoved) {
if ($('.list-block.sortable-opened').length > 0) return;
/*jshint validthis:true */
swipeOutEl = $(this);
swipeOutContent = swipeOutEl.find('.swipeout-content');
actionsRight = swipeOutEl.find('.swipeout-actions-right');
actionsLeft = swipeOutEl.find('.swipeout-actions-left');
actionsLeftWidth = actionsRightWidth = buttonsLeft = buttonsRight = overswipeRightButton = overswipeLeftButton = null;
noFoldLeft = actionsLeft.hasClass('swipeout-actions-no-fold') || app.params.swipeoutActionsNoFold;
noFoldRight = actionsRight.hasClass('swipeout-actions-no-fold') || app.params.swipeoutActionsNoFold;
if (actionsLeft.length > 0) {
actionsLeftWidth = actionsLeft.outerWidth();
buttonsLeft = actionsLeft.children('a');
overswipeLeftButton = actionsLeft.find('.swipeout-overswipe');
}
if (actionsRight.length > 0) {
actionsRightWidth = actionsRight.outerWidth();
buttonsRight = actionsRight.children('a');
overswipeRightButton = actionsRight.find('.swipeout-overswipe');
}
opened = swipeOutEl.hasClass('swipeout-opened');
if (opened) {
openedActions = swipeOutEl.find('.swipeout-actions-left.swipeout-actions-opened').length > 0 ? 'left' : 'right';
}
swipeOutEl.removeClass('transitioning');
if (!app.params.swipeoutNoFollow) {
swipeOutEl.find('.swipeout-actions-opened').removeClass('swipeout-actions-opened');
swipeOutEl.removeClass('swipeout-opened');
}
}
isMoved = true;
e.preventDefault();
touchesDiff = pageX - touchesStart.x;
translate = touchesDiff;
if (opened) {
if (openedActions === 'right') translate = translate - actionsRightWidth;
else translate = translate + actionsLeftWidth;
}
if (translate > 0 && actionsLeft.length === 0 || translate < 0 && actionsRight.length === 0) {
if (!opened) {
isTouched = isMoved = false;
return;
}
translate = 0;
}
if (translate < 0) direction = 'to-left';
else if (translate > 0) direction = 'to-right';
else {
if (direction) direction = direction;
else direction = 'to-left';
}
var i, buttonOffset, progress;
e.f7PreventPanelSwipe = true;
if (app.params.swipeoutNoFollow) {
if (opened) {
if (openedActions === 'right' && touchesDiff > 0) {
app.swipeoutClose(swipeOutEl);
}
if (openedActions === 'left' && touchesDiff < 0) {
app.swipeoutClose(swipeOutEl);
}
}
else {
if (touchesDiff < 0 && actionsRight.length > 0) {
app.swipeoutOpen(swipeOutEl, 'right');
}
if (touchesDiff > 0 && actionsLeft.length > 0) {
app.swipeoutOpen(swipeOutEl, 'left');
}
}
isTouched = false;
isMoved = false;
return;
}
overswipeLeft = false;
overswipeRight = false;
var $button;
if (actionsRight.length > 0) {
// Show right actions
progress = translate / actionsRightWidth;
if (translate < -actionsRightWidth) {
translate = -actionsRightWidth - Math.pow(-translate - actionsRightWidth, 0.8);
if (overswipeRightButton.length > 0) {
overswipeRight = true;
}
}
for (i = 0; i < buttonsRight.length; i++) {
if (typeof buttonsRight[i]._buttonOffset === 'undefined') {
buttonsRight[i]._buttonOffset = buttonsRight[i].offsetLeft;
}
buttonOffset = buttonsRight[i]._buttonOffset;
$button = $(buttonsRight[i]);
if (overswipeRightButton.length > 0 && $button.hasClass('swipeout-overswipe')) {
$button.css({left: (overswipeRight ? -buttonOffset : 0) + 'px'});
}
$button.transform('translate3d(' + (translate - buttonOffset * (1 + Math.max(progress, -1))) + 'px,0,0)');
}
}
if (actionsLeft.length > 0) {
// Show left actions
progress = translate / actionsLeftWidth;
if (translate > actionsLeftWidth) {
translate = actionsLeftWidth + Math.pow(translate - actionsLeftWidth, 0.8);
if (overswipeLeftButton.length > 0) {
overswipeLeft = true;
}
}
for (i = 0; i < buttonsLeft.length; i++) {
if (typeof buttonsLeft[i]._buttonOffset === 'undefined') {
buttonsLeft[i]._buttonOffset = actionsLeftWidth - buttonsLeft[i].offsetLeft - buttonsLeft[i].offsetWidth;
}
buttonOffset = buttonsLeft[i]._buttonOffset;
$button = $(buttonsLeft[i]);
if (overswipeLeftButton.length > 0 && $button.hasClass('swipeout-overswipe')) {
$button.css({left: (overswipeLeft ? buttonOffset : 0) + 'px'});
}
if (buttonsLeft.length > 1) {
$button.css('z-index', buttonsLeft.length - i);
}
$button.transform('translate3d(' + (translate + buttonOffset * (1 - Math.min(progress, 1))) + 'px,0,0)');
}
}
swipeOutContent.transform('translate3d(' + translate + 'px,0,0)');
}
function handleTouchEnd(e) {
if (!isTouched || !isMoved) {
isTouched = false;
isMoved = false;
return;
}
isTouched = false;
isMoved = false;
var timeDiff = (new Date()).getTime() - touchStartTime;
var action, actionsWidth, actions, buttons, i, noFold;
noFold = direction === 'to-left' ? noFoldRight : noFoldLeft;
actions = direction === 'to-left' ? actionsRight : actionsLeft;
actionsWidth = direction === 'to-left' ? actionsRightWidth : actionsLeftWidth;
if (
timeDiff < 300 && (touchesDiff < -10 && direction === 'to-left' || touchesDiff > 10 && direction === 'to-right') ||
timeDiff >= 300 && Math.abs(translate) > actionsWidth / 2
) {
action = 'open';
}
else {
action = 'close';
}
if (timeDiff < 300) {
if (Math.abs(translate) === 0) action = 'close';
if (Math.abs(translate) === actionsWidth) action = 'open';
}
if (action === 'open') {
app.swipeoutOpenedEl = swipeOutEl;
swipeOutEl.trigger('open');
swipeOutEl.addClass('swipeout-opened transitioning');
var newTranslate = direction === 'to-left' ? -actionsWidth : actionsWidth;
swipeOutContent.transform('translate3d(' + newTranslate + 'px,0,0)');
actions.addClass('swipeout-actions-opened');
buttons = direction === 'to-left' ? buttonsRight : buttonsLeft;
if (buttons) {
for (i = 0; i < buttons.length; i++) {
$(buttons[i]).transform('translate3d(' + newTranslate + 'px,0,0)');
}
}
if (overswipeRight) {
actionsRight.find('.swipeout-overswipe')[0].click();
}
if (overswipeLeft) {
actionsLeft.find('.swipeout-overswipe')[0].click();
}
}
else {
swipeOutEl.trigger('close');
app.swipeoutOpenedEl = undefined;
swipeOutEl.addClass('transitioning').removeClass('swipeout-opened');
swipeOutContent.transform('');
actions.removeClass('swipeout-actions-opened');
}
var buttonOffset;
if (buttonsLeft && buttonsLeft.length > 0 && buttonsLeft !== buttons) {
for (i = 0; i < buttonsLeft.length; i++) {
buttonOffset = buttonsLeft[i]._buttonOffset;
if (typeof buttonOffset === 'undefined') {
buttonsLeft[i]._buttonOffset = actionsLeftWidth - buttonsLeft[i].offsetLeft - buttonsLeft[i].offsetWidth;
}
$(buttonsLeft[i]).transform('translate3d(' + (buttonOffset) + 'px,0,0)');
}
}
if (buttonsRight && buttonsRight.length > 0 && buttonsRight !== buttons) {
for (i = 0; i < buttonsRight.length; i++) {
buttonOffset = buttonsRight[i]._buttonOffset;
if (typeof buttonOffset === 'undefined') {
buttonsRight[i]._buttonOffset = buttonsRight[i].offsetLeft;
}
$(buttonsRight[i]).transform('translate3d(' + (-buttonOffset) + 'px,0,0)');
}
}
swipeOutContent.transitionEnd(function (e) {
if (opened && action === 'open' || closed && action === 'close') return;
swipeOutEl.trigger(action === 'open' ? 'opened' : 'closed');
if (opened && action === 'close') {
if (actionsRight.length > 0) {
buttonsRight.transform('');
}
if (actionsLeft.length > 0) {
buttonsLeft.transform('');
}
}
});
}
if (swipeoutEl) {
$(swipeoutEl).on(app.touchEvents.start, handleTouchStart);
$(swipeoutEl).on(app.touchEvents.move, handleTouchMove);
$(swipeoutEl).on(app.touchEvents.end, handleTouchEnd);
}
else {
$(document).on(app.touchEvents.start, '.list-block li.swipeout', handleTouchStart);
$(document).on(app.touchEvents.move, '.list-block li.swipeout', handleTouchMove);
$(document).on(app.touchEvents.end, '.list-block li.swipeout', handleTouchEnd);
}
};
app.swipeoutOpen = function (el, dir, callback) {
el = $(el);
if (arguments.length === 2) {
if (typeof arguments[1] === 'function') {
callback = dir;
}
}
if (el.length === 0) return;
if (el.length > 1) el = $(el[0]);
if (!el.hasClass('swipeout') || el.hasClass('swipeout-opened')) return;
if (!dir) {
if (el.find('.swipeout-actions-right').length > 0) dir = 'right';
else dir = 'left';
}
var swipeOutActions = el.find('.swipeout-actions-' + dir);
if (swipeOutActions.length === 0) return;
var noFold = swipeOutActions.hasClass('swipeout-actions-no-fold') || app.params.swipeoutActionsNoFold;
el.trigger('open').addClass('swipeout-opened').removeClass('transitioning');
swipeOutActions.addClass('swipeout-actions-opened');
var buttons = swipeOutActions.children('a');
var swipeOutActionsWidth = swipeOutActions.outerWidth();
var translate = dir === 'right' ? -swipeOutActionsWidth : swipeOutActionsWidth;
var i;
if (buttons.length > 1) {
for (i = 0; i < buttons.length; i++) {
if (dir === 'right') {
$(buttons[i]).transform('translate3d(' + (- buttons[i].offsetLeft) + 'px,0,0)');
}
else {
$(buttons[i]).css('z-index', buttons.length - i).transform('translate3d(' + (swipeOutActionsWidth - buttons[i].offsetWidth - buttons[i].offsetLeft) + 'px,0,0)');
}
}
var clientLeft = buttons[1].clientLeft;
}
el.addClass('transitioning');
for (i = 0; i < buttons.length; i++) {
$(buttons[i]).transform('translate3d(' + (translate) + 'px,0,0)');
}
el.find('.swipeout-content').transform('translate3d(' + translate + 'px,0,0)').transitionEnd(function () {
el.trigger('opened');
if (callback) callback.call(el[0]);
});
app.swipeoutOpenedEl = el;
};
app.swipeoutClose = function (el, callback) {
el = $(el);
if (el.length === 0) return;
if (!el.hasClass('swipeout-opened')) return;
var dir = el.find('.swipeout-actions-opened').hasClass('swipeout-actions-right') ? 'right' : 'left';
var swipeOutActions = el.find('.swipeout-actions-opened').removeClass('swipeout-actions-opened');
var noFold = swipeOutActions.hasClass('swipeout-actions-no-fold') || app.params.swipeoutActionsNoFold;
var buttons = swipeOutActions.children('a');
var swipeOutActionsWidth = swipeOutActions.outerWidth();
app.allowSwipeout = false;
el.trigger('close');
el.removeClass('swipeout-opened').addClass('transitioning');
var closeTO;
function onSwipeoutClose() {
app.allowSwipeout = true;
buttons.transform('');
el.trigger('closed');
if (callback) callback.call(el[0]);
if (closeTO) clearTimeout(closeTO);
}
el.find('.swipeout-content').transform('translate3d(' + 0 + 'px,0,0)').transitionEnd(onSwipeoutClose);
closeTO = setTimeout(onSwipeoutClose, 500);
for (var i = 0; i < buttons.length; i++) {
if (dir === 'right') {
$(buttons[i]).transform('translate3d(' + (-buttons[i].offsetLeft) + 'px,0,0)');
}
else {
$(buttons[i]).transform('translate3d(' + (swipeOutActionsWidth - buttons[i].offsetWidth - buttons[i].offsetLeft) + 'px,0,0)');
}
$(buttons[i]).css({left:0 + 'px'});
}
if (app.swipeoutOpenedEl && app.swipeoutOpenedEl[0] === el[0]) app.swipeoutOpenedEl = undefined;
};
app.swipeoutDelete = function (el, callback) {
el = $(el);
if (el.length === 0) return;
if (el.length > 1) el = $(el[0]);
app.swipeoutOpenedEl = undefined;
el.trigger('delete');
el.css({height: el.outerHeight() + 'px'});
var clientLeft = el[0].clientLeft;
el.css({height: 0 + 'px'}).addClass('deleting transitioning').transitionEnd(function () {
el.trigger('deleted');
if (callback) callback.call(el[0]);
if (el.parents('.virtual-list').length > 0) {
var virtualList = el.parents('.virtual-list')[0].f7VirtualList;
var virtualIndex = el[0].f7VirtualListIndex;
if (virtualList && typeof virtualIndex !== 'undefined') virtualList.deleteItem(virtualIndex);
}
else {
el.remove();
}
});
var translate = '-100%';
el.find('.swipeout-content').transform('translate3d(' + translate + ',0,0)');
};
/*===============================================================================
************ Sortable ************
===============================================================================*/
app.sortableToggle = function (sortableContainer) {
sortableContainer = $(sortableContainer);
if (sortableContainer.length === 0) sortableContainer = $('.list-block.sortable');
sortableContainer.toggleClass('sortable-opened');
if (sortableContainer.hasClass('sortable-opened')) {
sortableContainer.trigger('open');
}
else {
sortableContainer.trigger('close');
}
return sortableContainer;
};
app.sortableOpen = function (sortableContainer) {
sortableContainer = $(sortableContainer);
if (sortableContainer.length === 0) sortableContainer = $('.list-block.sortable');
sortableContainer.addClass('sortable-opened');
sortableContainer.trigger('open');
return sortableContainer;
};
app.sortableClose = function (sortableContainer) {
sortableContainer = $(sortableContainer);
if (sortableContainer.length === 0) sortableContainer = $('.list-block.sortable');
sortableContainer.removeClass('sortable-opened');
sortableContainer.trigger('close');
return sortableContainer;
};
app.initSortable = function () {
var isTouched, isMoved, touchStartY, touchesDiff, sortingEl, sortingElHeight, sortingItems, minTop, maxTop, insertAfter, insertBefore, sortableContainer;
function handleTouchStart(e) {
isMoved = false;
isTouched = true;
touchStartY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
/*jshint validthis:true */
sortingEl = $(this).parent();
sortingItems = sortingEl.parent().find('li');
sortableContainer = sortingEl.parents('.sortable');
e.preventDefault();
app.allowPanelOpen = app.allowSwipeout = false;
}
function handleTouchMove(e) {
if (!isTouched || !sortingEl) return;
var pageX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
var pageY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (!isMoved) {
sortingEl.addClass('sorting');
sortableContainer.addClass('sortable-sorting');
minTop = sortingEl[0].offsetTop;
maxTop = sortingEl.parent().height() - sortingEl[0].offsetTop - sortingEl.height();
sortingElHeight = sortingEl[0].offsetHeight;
}
isMoved = true;
e.preventDefault();
e.f7PreventPanelSwipe = true;
touchesDiff = pageY - touchStartY;
var translate = touchesDiff;
if (translate < -minTop) translate = -minTop;
if (translate > maxTop) translate = maxTop;
sortingEl.transform('translate3d(0,' + translate + 'px,0)');
insertBefore = insertAfter = undefined;
sortingItems.each(function () {
var currentEl = $(this);
if (currentEl[0] === sortingEl[0]) return;
var currentElOffset = currentEl[0].offsetTop;
var currentElHeight = currentEl.height();
var sortingElOffset = sortingEl[0].offsetTop + translate;
if ((sortingElOffset >= currentElOffset - currentElHeight / 2) && sortingEl.index() < currentEl.index()) {
currentEl.transform('translate3d(0, '+(-sortingElHeight)+'px,0)');
insertAfter = currentEl;
insertBefore = undefined;
}
else if ((sortingElOffset <= currentElOffset + currentElHeight / 2) && sortingEl.index() > currentEl.index()) {
currentEl.transform('translate3d(0, '+(sortingElHeight)+'px,0)');
insertAfter = undefined;
if (!insertBefore) insertBefore = currentEl;
}
else {
$(this).transform('translate3d(0, 0%,0)');
}
});
}
function handleTouchEnd(e) {
app.allowPanelOpen = app.allowSwipeout = true;
if (!isTouched || !isMoved) {
isTouched = false;
isMoved = false;
return;
}
e.preventDefault();
sortingItems.transform('');
sortingEl.removeClass('sorting');
sortableContainer.removeClass('sortable-sorting');
var virtualList, oldIndex, newIndex;
if (insertAfter) {
sortingEl.insertAfter(insertAfter);
sortingEl.trigger('sort');
}
if (insertBefore) {
sortingEl.insertBefore(insertBefore);
sortingEl.trigger('sort');
}
if ((insertAfter || insertBefore) && sortableContainer.hasClass('virtual-list')) {
virtualList = sortableContainer[0].f7VirtualList;
oldIndex = sortingEl[0].f7VirtualListIndex;
newIndex = insertBefore ? insertBefore[0].f7VirtualListIndex : insertAfter[0].f7VirtualListIndex;
if (virtualList) virtualList.moveItem(oldIndex, newIndex);
}
insertAfter = insertBefore = undefined;
isTouched = false;
isMoved = false;
}
$(document).on(app.touchEvents.start, '.list-block.sortable .sortable-handler', handleTouchStart);
if (app.support.touch) {
$(document).on(app.touchEvents.move, '.list-block.sortable .sortable-handler', handleTouchMove);
$(document).on(app.touchEvents.end, '.list-block.sortable .sortable-handler', handleTouchEnd);
}
else {
$(document).on(app.touchEvents.move, handleTouchMove);
$(document).on(app.touchEvents.end, handleTouchEnd);
}
};
/*===============================================================================
************ Smart Select ************
===============================================================================*/
app.initSmartSelects = function (pageContainer) {
var page = $(pageContainer);
if (page.length === 0) return;
var selects;
if (page.is('.smart-select')) {
selects = page;
}
else {
selects = page.find('.smart-select');
}
if (selects.length === 0) return;
selects.each(function () {
var smartSelect = $(this);
var $select = smartSelect.find('select');
if ($select.length === 0) return;
var select = $select[0];
if (select.length === 0) return;
var valueText = [];
for (var i = 0; i < select.length; i++) {
if (select[i].selected) valueText.push(select[i].textContent.trim());
}
var itemAfter = smartSelect.find('.item-after');
if (itemAfter.length === 0) {
smartSelect.find('.item-inner').append('<div class="item-after">' + valueText.join(', ') + '</div>');
}
else {
var selectedText = itemAfter.text();
if (itemAfter.hasClass('smart-select-value')) {
for (i = 0; i < select.length; i++) {
select[i].selected = select[i].textContent.trim() === selectedText.trim();
}
} else {
itemAfter.text(valueText.join(', '));
}
}
});
};
app.smartSelectAddOption = function (select, option, index) {
select = $(select);
var smartSelect = select.parents('.smart-select');
if (typeof index === 'undefined') {
select.append(option);
}
else {
$(option).insertBefore(select.find('option').eq(index));
}
app.initSmartSelects(smartSelect);
var selectName = smartSelect.find('select').attr('name');
var opened = $('.page.smart-select-page[data-select-name="' + selectName + '"]').length > 0;
if (opened) {
app.smartSelectOpen(smartSelect, true);
}
};
app.smartSelectOpen = function (smartSelect, reLayout) {
smartSelect = $(smartSelect);
if (smartSelect.length === 0) return;
// Find related view
var view = smartSelect.parents('.' + app.params.viewClass);
if (view.length === 0) return;
view = view[0].f7View;
if (!view) return;
// Parameters
var openIn = smartSelect.attr('data-open-in');
if (!openIn) openIn = app.params.smartSelectInPopup ? 'popup' : 'page';
var smartSelectData = smartSelect.dataset();
var pageTitle = smartSelectData.pageTitle || smartSelect.find('.item-title').text();
var backText = smartSelectData.backText || app.params.smartSelectBackText;
var closeText = smartSelectData.popupCloseText || smartSelectData.backText || app.params.smartSelectPopupCloseText ;
var backOnSelect = smartSelectData.backOnSelect !== undefined ? smartSelectData.backOnSelect : app.params.smartSelectBackOnSelect;
var formTheme = smartSelectData.formTheme || app.params.smartSelectFormTheme;
var navbarTheme = smartSelectData.navbarTheme || app.params.smartSelectNavbarTheme;
var virtualList = smartSelectData.virtualList;
var virtualListHeight = smartSelectData.virtualListHeight;
// Collect all options/values
var select = smartSelect.find('select')[0];
var $select = $(select);
var $selectData = $select.dataset();
if (select.disabled || smartSelect.hasClass('disabled') || $select.hasClass('disabled')) {
return;
}
var values = [];
var id = (new Date()).getTime();
var inputType = select.multiple ? 'checkbox' : 'radio';
var inputName = inputType + '-' + id;
var selectName = select.name;
var option, optionHasMedia, optionImage, optionIcon, optionGroup, optionGroupLabel, optionPreviousGroup, optionShowGroupLabel, previousGroup, optionColor, optionClassName, optionData;
for (var i = 0; i < select.length; i++) {
option = $(select[i]);
if (option[0].disabled) continue;
optionData = option.dataset();
optionImage = optionData.optionImage || $selectData.optionImage;
optionIcon = optionData.optionIcon || $selectData.optionIcon;
optionHasMedia = optionImage || optionIcon || inputType === 'checkbox';
if (app.params.material) optionHasMedia = optionImage || optionIcon;
optionColor = optionData.optionColor;
optionClassName = optionData.optionClass;
optionGroup = option.parent('optgroup')[0];
optionGroupLabel = optionGroup && optionGroup.label;
optionShowGroupLabel = false;
if (optionGroup) {
if (optionGroup !== previousGroup) {
optionShowGroupLabel = true;
previousGroup = optionGroup;
}
}
values.push({
value: option[0].value,
text: option[0].textContent.trim(),
selected: option[0].selected,
group: optionGroup,
groupLabel: optionGroupLabel,
showGroupLabel: optionShowGroupLabel,
image: optionImage,
icon: optionIcon,
color: optionColor,
className: optionClassName,
disabled: option[0].disabled,
inputType: inputType,
id: id,
hasMedia: optionHasMedia,
checkbox: inputType === 'checkbox',
inputName: inputName,
test: this,
material: app.params.material
});
}
// Item template/HTML
if (!app._compiledTemplates.smartSelectItem) {
app._compiledTemplates.smartSelectItem = t7.compile(app.params.smartSelectItemTemplate ||
'{{#if showGroupLabel}}' +
'<li class="item-divider">{{groupLabel}}</li>' +
'{{/if}}' +
'<li{{#if className}} class="{{className}}"{{/if}}>' +
'<label class="label-{{inputType}} item-content">' +
'<input type="{{inputType}}" name="{{inputName}}" value="{{value}}" {{#if selected}}checked{{/if}}>' +
'{{#if hasMedia}}' +
'<div class="item-media">' +
'{{#if checkbox}}<i class="icon icon-form-checkbox"></i>{{/if}}' +
'{{#if icon}}<i class="icon {{icon}}"></i>{{/if}}' +
'{{#if image}}<img src="{{image}}">{{/if}}' +
'</div>' +
'{{/if}}' +
'<div class="item-inner">' +
'<div class="item-title{{#if color}} color-{{color}}{{/if}}">{{text}}</div>' +
'</div>' +
'</label>' +
'</li>'
);
}
var smartSelectItemTemplate = app._compiledTemplates.smartSelectItem;
var inputsHTML = '';
if (!virtualList) {
for (var j = 0; j < values.length; j++) {
inputsHTML += smartSelectItemTemplate(values[j]);
}
}
// Navbar HTML
if (!app._compiledTemplates.smartSelectNavbar) {
app._compiledTemplates.smartSelectNavbar = t7.compile(app.params.smartSelectNavbarTemplate ||
'<div class="navbar {{#if navbarTheme}}theme-{{navbarTheme}}{{/if}}">' +
'<div class="navbar-inner">' +
'{{leftTemplate}}' +
'<div class="center sliding">{{pageTitle}}</div>' +
'</div>' +
'</div>'
);
}
var navbarHTML = app._compiledTemplates.smartSelectNavbar({
pageTitle: pageTitle,
backText: backText,
closeText: closeText,
openIn: openIn,
navbarTheme: navbarTheme,
inPopup: openIn === 'popup',
inPage: openIn === 'page',
leftTemplate: openIn === 'popup' ? app.params.smartSelectPopupCloseTemplate.replace(/{{closeText}}/g, closeText) : app.params.smartSelectBackTemplate.replace(/{{backText}}/g, backText)
});
// Determine navbar layout type - static/fixed/through
var noNavbar = '', noToolbar = '', navbarLayout;
if (openIn === 'page') {
navbarLayout = 'static';
if (smartSelect.parents('.navbar-through').length > 0) navbarLayout = 'through';
if (smartSelect.parents('.navbar-fixed').length > 0) navbarLayout = 'fixed';
noToolbar = smartSelect.parents('.page').hasClass('no-toolbar') ? 'no-toolbar' : '';
noNavbar = smartSelect.parents('.page').hasClass('no-navbar') ? 'no-navbar' : 'navbar-' + navbarLayout;
}
else {
navbarLayout = 'fixed';
}
// Page Layout
var pageName = 'smart-select-' + inputName;
var useSearchbar = typeof smartSelect.data('searchbar') === 'undefined' ? app.params.smartSelectSearchbar : (smartSelect.data('searchbar') === 'true' ? true : false);
var searchbarPlaceholder, searchbarCancel;
if (useSearchbar) {
searchbarPlaceholder = smartSelect.data('searchbar-placeholder') || 'Search';
searchbarCancel = smartSelect.data('searchbar-cancel') || 'Cancel';
}
var searchbarHTML = '<form class="searchbar searchbar-init" data-search-list=".smart-select-list-' + id + '" data-search-in=".item-title">' +
'<div class="searchbar-input">' +
'<input type="search" placeholder="' + searchbarPlaceholder + '">' +
'<a href="#" class="searchbar-clear"></a>' +
'</div>' +
'<a href="#" class="searchbar-cancel">' + searchbarCancel + '</a>' +
'</form>' +
'<div class="searchbar-overlay"></div>';
var pageHTML =
(navbarLayout === 'through' ? navbarHTML : '') +
'<div class="pages">' +
' <div data-page="' + pageName + '" data-select-name="' + selectName + '" class="page smart-select-page ' + noNavbar + ' ' + noToolbar + '">' +
(navbarLayout === 'fixed' ? navbarHTML : '') +
(useSearchbar ? searchbarHTML : '') +
' <div class="page-content">' +
(navbarLayout === 'static' ? navbarHTML : '') +
' <div class="list-block ' + (virtualList ? 'virtual-list' : '') + ' smart-select-list-' + id + ' ' + (formTheme ? 'theme-' + formTheme : '') + '">' +
' <ul>' +
(virtualList ? '' : inputsHTML) +
' </ul>' +
' </div>' +
' </div>' +
' </div>' +
'</div>';
// Define popup
var popup;
// Event Listeners on new page
function handleInputs(container) {
if (virtualList) {
var virtualListInstance = app.virtualList($(container).find('.virtual-list'), {
items: values,
template: smartSelectItemTemplate,
height: virtualListHeight || undefined,
searchByItem: function (query, index, item) {
if (item.text.toLowerCase().indexOf(query.trim().toLowerCase()) >=0 ) return true;
return false;
}
});
$(container).once(openIn === 'popup' ? 'closed': 'pageBeforeRemove', function () {
if (virtualListInstance && virtualListInstance.destroy) virtualListInstance.destroy();
});
}
$(container).on('change', 'input[name="' + inputName + '"]', function () {
var input = this;
var value = input.value;
var optionText = [];
if (input.type === 'checkbox') {
var values = [];
for (var i = 0; i < select.options.length; i++) {
var option = select.options[i];
if (option.value === value) {
option.selected = input.checked;
}
if (option.selected) {
optionText.push(option.textContent.trim());
}
}
}
else {
optionText = [smartSelect.find('option[value="' + value + '"]').text()];
select.value = value;
}
$select.trigger('change');
smartSelect.find('.item-after').text(optionText.join(', '));
if (backOnSelect && inputType === 'radio') {
if (openIn === 'popup') app.closeModal(popup);
else view.router.back();
}
});
}
function pageInit(e) {
var page = e.detail.page;
if (page.name === pageName) {
handleInputs(page.container);
}
}
if (openIn === 'popup') {
if (reLayout) {
popup = $('.popup.smart-select-popup .view');
popup.html(pageHTML);
}
else {
popup = app.popup(
'<div class="popup smart-select-popup smart-select-popup-' + inputName + '">' +
'<div class="view navbar-fixed">' +
pageHTML +
'</div>' +
'</div>'
);
popup = $(popup);
}
app.initPage(popup.find('.page'));
handleInputs(popup);
}
else {
$(document).once('pageInit', '.smart-select-page', pageInit);
view.router.load({
content: pageHTML,
reload: reLayout ? true : undefined
});
}
};
/*===============================================================================
************ Virtual List ************
===============================================================================*/
var VirtualList = function (listBlock, params) {
var defaults = {
cols: 1,
height: 44,
cache: true,
dynamicHeightBufferSize: 1
};
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined') {
params[def] = defaults[def];
}
}
// Preparation
var vl = this;
vl.listBlock = $(listBlock);
vl.params = params;
vl.items = params.items;
if (params.template) {
if (typeof params.template === 'string') vl.template = t7.compile(params.template);
else if (typeof params.template === 'function') vl.template = params.template;
}
vl.pageContent = vl.listBlock.parents('.page-content');
// Bad scroll
var updatableScroll;
if (typeof vl.params.updatableScroll !== 'undefined') {
updatableScroll = vl.params.updatableScroll;
}
else {
updatableScroll = true;
if (app.device.ios && app.device.osVersion.split('.')[0] < 8) {
updatableScroll = false;
}
}
// Append <ul>
vl.ul = vl.params.ul ? $(vl.params.ul) : vl.listBlock.children('ul');
if (vl.ul.length === 0) {
vl.listBlock.append('<ul></ul>');
vl.ul = vl.listBlock.children('ul');
}
// DOM cached items
vl.domCache = {};
vl.displayDomCache = {};
// Temporary DOM Element
vl.tempDomElement = document.createElement('ul');
// Last repain position
vl.lastRepaintY = null;
// Fragment
vl.fragment = document.createDocumentFragment();
// Filter
vl.filterItems = function (indexes, resetScrollTop) {
vl.filteredItems = [];
var firstIndex = indexes[0];
var lastIndex = indexes[indexes.length - 1];
for (var i = 0; i < indexes.length; i++) {
vl.filteredItems.push(vl.items[indexes[i]]);
}
if (typeof resetScrollTop === 'undefined') resetScrollTop = true;
if (resetScrollTop) {
vl.pageContent[0].scrollTop = 0;
}
vl.update();
};
vl.resetFilter = function () {
vl.filteredItems = null;
delete vl.filteredItems;
vl.update();
};
var pageHeight, rowsPerScreen, rowsBefore, rowsAfter, rowsToRender, maxBufferHeight = 0, listHeight;
var dynamicHeight = typeof vl.params.height === 'function';
// Set list size
vl.setListSize = function () {
var items = vl.filteredItems || vl.items;
pageHeight = vl.pageContent[0].offsetHeight;
if (dynamicHeight) {
listHeight = 0;
vl.heights = [];
for (var i = 0; i < items.length; i++) {
var itemHeight = vl.params.height(items[i]);
listHeight += itemHeight;
vl.heights.push(itemHeight);
}
}
else {
listHeight = items.length * vl.params.height / vl.params.cols;
rowsPerScreen = Math.ceil(pageHeight / vl.params.height);
rowsBefore = vl.params.rowsBefore || rowsPerScreen * 2;
rowsAfter = vl.params.rowsAfter || rowsPerScreen;
rowsToRender = (rowsPerScreen + rowsBefore + rowsAfter);
maxBufferHeight = rowsBefore / 2 * vl.params.height;
}
if (updatableScroll) {
vl.ul.css({height: listHeight + 'px'});
}
};
// Render items
vl.render = function (force, forceScrollTop) {
if (force) vl.lastRepaintY = null;
var scrollTop = -(vl.listBlock[0].getBoundingClientRect().top + vl.pageContent[0].getBoundingClientRect().top);
if (typeof forceScrollTop !== 'undefined') scrollTop = forceScrollTop;
if (vl.lastRepaintY === null || Math.abs(scrollTop - vl.lastRepaintY) > maxBufferHeight || (!updatableScroll && (vl.pageContent[0].scrollTop + pageHeight >= vl.pageContent[0].scrollHeight))) {
vl.lastRepaintY = scrollTop;
}
else {
return;
}
var items = vl.filteredItems || vl.items,
fromIndex, toIndex, heightBeforeFirstItem = 0, heightBeforeLastItem = 0;
if (dynamicHeight) {
var itemTop = 0, j, itemHeight;
maxBufferHeight = pageHeight;
for (j = 0; j < vl.heights.length; j++) {
itemHeight = vl.heights[j];
if (typeof fromIndex === 'undefined') {
if (itemTop + itemHeight >= scrollTop - pageHeight * 2 * vl.params.dynamicHeightBufferSize) fromIndex = j;
else heightBeforeFirstItem += itemHeight;
}
if (typeof toIndex === 'undefined') {
if (itemTop + itemHeight >= scrollTop + pageHeight * 2 * vl.params.dynamicHeightBufferSize || j === vl.heights.length - 1) toIndex = j + 1;
heightBeforeLastItem += itemHeight;
}
itemTop += itemHeight;
}
toIndex = Math.min(toIndex, items.length);
}
else {
fromIndex = (parseInt(scrollTop / vl.params.height) - rowsBefore) * vl.params.cols;
if (fromIndex < 0) {
fromIndex = 0;
}
toIndex = Math.min(fromIndex + rowsToRender * vl.params.cols, items.length);
}
var topPosition;
vl.reachEnd = false;
for (var i = fromIndex; i < toIndex; i++) {
var item, index;
// Define real item index
index = vl.items.indexOf(items[i]);
if (i === fromIndex) vl.currentFromIndex = index;
if (i === toIndex - 1) vl.currentToIndex = index;
if (index === vl.items.length - 1) vl.reachEnd = true;
// Find items
if (vl.domCache[index]) {
item = vl.domCache[index];
}
else {
if (vl.template) {
vl.tempDomElement.innerHTML = vl.template(items[i], {index: index});
}
else if (vl.params.renderItem) {
vl.tempDomElement.innerHTML = vl.params.renderItem(index, items[i]);
}
else {
vl.tempDomElement.innerHTML = items[i];
}
item = vl.tempDomElement.childNodes[0];
if (vl.params.cache) vl.domCache[index] = item;
}
item.f7VirtualListIndex = index;
// Set item top position
if (i === fromIndex) {
if (dynamicHeight) {
topPosition = heightBeforeFirstItem;
}
else {
topPosition = (i * vl.params.height / vl.params.cols);
}
}
item.style.top = topPosition + 'px';
// Before item insert
if (vl.params.onItemBeforeInsert) vl.params.onItemBeforeInsert(vl, item);
// Append item to fragment
vl.fragment.appendChild(item);
}
// Update list height with not updatable scroll
if (!updatableScroll) {
if (dynamicHeight) {
vl.ul[0].style.height = heightBeforeLastItem + 'px';
}
else {
vl.ul[0].style.height = i * vl.params.height / vl.params.cols + 'px';
}
}
// Update list html
if (vl.params.onBeforeClear) vl.params.onBeforeClear(vl, vl.fragment);
vl.ul[0].innerHTML = '';
if (vl.params.onItemsBeforeInsert) vl.params.onItemsBeforeInsert(vl, vl.fragment);
vl.ul[0].appendChild(vl.fragment);
if (vl.params.onItemsAfterInsert) vl.params.onItemsAfterInsert(vl, vl.fragment);
if (typeof forceScrollTop !== 'undefined' && force) {
vl.pageContent.scrollTop(forceScrollTop, 0);
}
};
vl.scrollToItem = function (index) {
if (index > vl.items.length) return false;
var itemTop = 0, listTop;
if (dynamicHeight) {
for (var i = 0; i < index; i++) {
itemTop += vl.heights[i];
}
}
else {
itemTop = index * vl.params.height;
}
listTop = vl.listBlock[0].offsetTop;
vl.render(true, listTop + itemTop - parseInt(vl.pageContent.css('padding-top'), 10));
return true;
};
// Handle scroll event
vl.handleScroll = function (e) {
vl.render();
};
// Handle resize event
vl.handleResize = function (e) {
vl.setListSize();
vl.render(true);
};
vl.attachEvents = function (detach) {
var action = detach ? 'off' : 'on';
vl.pageContent[action]('scroll', vl.handleScroll);
$(window)[action]('resize', vl.handleResize);
};
// Init Virtual List
vl.init = function () {
vl.attachEvents();
vl.setListSize();
vl.render();
};
// Append
vl.appendItems = function (items) {
for (var i = 0; i < items.length; i++) {
vl.items.push(items[i]);
}
vl.update();
};
vl.appendItem = function (item) {
vl.appendItems([item]);
};
// Replace
vl.replaceAllItems = function (items) {
vl.items = items;
delete vl.filteredItems;
vl.domCache = {};
vl.update();
};
vl.replaceItem = function (index, item) {
vl.items[index] = item;
if (vl.params.cache) delete vl.domCache[index];
vl.update();
};
// Prepend
vl.prependItems = function (items) {
for (var i = items.length - 1; i >= 0; i--) {
vl.items.unshift(items[i]);
}
if (vl.params.cache) {
var newCache = {};
for (var cached in vl.domCache) {
newCache[parseInt(cached, 10) + items.length] = vl.domCache[cached];
}
vl.domCache = newCache;
}
vl.update();
};
vl.prependItem = function (item) {
vl.prependItems([item]);
};
// Move
vl.moveItem = function (oldIndex, newIndex) {
if (oldIndex === newIndex) return;
// remove item from array
var item = vl.items.splice(oldIndex, 1)[0];
if (newIndex >= vl.items.length) {
// Add item to the end
vl.items.push(item);
newIndex = vl.items.length - 1;
}
else {
// Add item to new index
vl.items.splice(newIndex, 0, item);
}
// Update cache
if (vl.params.cache) {
var newCache = {};
for (var cached in vl.domCache) {
var cachedIndex = parseInt(cached, 10);
var leftIndex = oldIndex < newIndex ? oldIndex : newIndex;
var rightIndex = oldIndex < newIndex ? newIndex : oldIndex;
var indexShift = oldIndex < newIndex ? -1 : 1;
if (cachedIndex < leftIndex || cachedIndex > rightIndex) newCache[cachedIndex] = vl.domCache[cachedIndex];
if (cachedIndex === leftIndex) newCache[rightIndex] = vl.domCache[cachedIndex];
if (cachedIndex > leftIndex && cachedIndex <= rightIndex) newCache[cachedIndex + indexShift] = vl.domCache[cachedIndex];
}
vl.domCache = newCache;
}
vl.update();
};
// Insert before
vl.insertItemBefore = function (index, item) {
if (index === 0) {
vl.prependItem(item);
return;
}
if (index >= vl.items.length) {
vl.appendItem(item);
return;
}
vl.items.splice(index, 0, item);
// Update cache
if (vl.params.cache) {
var newCache = {};
for (var cached in vl.domCache) {
var cachedIndex = parseInt(cached, 10);
if (cachedIndex >= index) {
newCache[cachedIndex + 1] = vl.domCache[cachedIndex];
}
}
vl.domCache = newCache;
}
vl.update();
};
// Delete
vl.deleteItems = function (indexes) {
var prevIndex, indexShift = 0;
for (var i = 0; i < indexes.length; i++) {
var index = indexes[i];
if (typeof prevIndex !== 'undefined') {
if (index > prevIndex) {
indexShift = -i;
}
}
index = index + indexShift;
prevIndex = indexes[i];
// Delete item
var deletedItem = vl.items.splice(index, 1)[0];
// Delete from filtered
if (vl.filteredItems && vl.filteredItems.indexOf(deletedItem) >= 0) {
vl.filteredItems.splice(vl.filteredItems.indexOf(deletedItem), 1);
}
// Update cache
if (vl.params.cache) {
var newCache = {};
for (var cached in vl.domCache) {
var cachedIndex = parseInt(cached, 10);
if (cachedIndex === index) {
delete vl.domCache[index];
}
else if (parseInt(cached, 10) > index) {
newCache[cachedIndex - 1] = vl.domCache[cached];
}
else {
newCache[cachedIndex] = vl.domCache[cached];
}
}
vl.domCache = newCache;
}
}
vl.update();
};
vl.deleteAllItems = function () {
vl.items = [];
delete vl.filteredItems;
if (vl.params.cache) vl.domCache = {};
vl.update();
};
vl.deleteItem = function (index) {
vl.deleteItems([index]);
};
// Clear cache
vl.clearCache = function () {
vl.domCache = {};
};
// Update Virtual List
vl.update = function () {
vl.setListSize();
vl.render(true);
};
// Destroy
vl.destroy = function () {
vl.attachEvents(true);
delete vl.items;
delete vl.domCache;
};
// Init Virtual List
vl.init();
// Store vl in container
vl.listBlock[0].f7VirtualList = vl;
return vl;
};
// App Method
app.virtualList = function (listBlock, params) {
return new VirtualList(listBlock, params);
};
app.reinitVirtualList = function (pageContainer) {
var page = $(pageContainer);
var vlists = page.find('.virtual-list');
if (vlists.length === 0) return;
for (var i = 0; i < vlists.length; i++) {
var vlistInstance = vlists[i].f7VirtualList;
if (vlistInstance) {
vlistInstance.update();
}
}
};
/*======================================================
************ Pull To Refresh ************
======================================================*/
app.initPullToRefresh = function (pageContainer) {
var eventsTarget = $(pageContainer);
if (!eventsTarget.hasClass('pull-to-refresh-content')) {
eventsTarget = eventsTarget.find('.pull-to-refresh-content');
}
if (!eventsTarget || eventsTarget.length === 0) return;
var isTouched, isMoved, touchesStart = {}, isScrolling, touchesDiff, touchStartTime, container, refresh = false, useTranslate = false, startTranslate = 0, translate, scrollTop, wasScrolled, layer, triggerDistance, dynamicTriggerDistance;
var page = eventsTarget.hasClass('page') ? eventsTarget : eventsTarget.parents('.page');
var hasNavbar = false;
if (page.find('.navbar').length > 0 || page.parents('.navbar-fixed, .navbar-through').length > 0 || page.hasClass('navbar-fixed') || page.hasClass('navbar-through')) hasNavbar = true;
if (page.hasClass('no-navbar')) hasNavbar = false;
if (!hasNavbar) eventsTarget.addClass('pull-to-refresh-no-navbar');
container = eventsTarget;
// Define trigger distance
if (container.attr('data-ptr-distance')) {
dynamicTriggerDistance = true;
}
else {
triggerDistance = 44;
}
function handleTouchStart(e) {
if (isTouched) {
if (app.device.os === 'android') {
if ('targetTouches' in e && e.targetTouches.length > 1) return;
}
else return;
}
isMoved = false;
isTouched = true;
isScrolling = undefined;
wasScrolled = undefined;
touchesStart.x = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
touchesStart.y = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
touchStartTime = (new Date()).getTime();
/*jshint validthis:true */
container = $(this);
}
function handleTouchMove(e) {
if (!isTouched) return;
var pageX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
var pageY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (typeof isScrolling === 'undefined') {
isScrolling = !!(isScrolling || Math.abs(pageY - touchesStart.y) > Math.abs(pageX - touchesStart.x));
}
if (!isScrolling) {
isTouched = false;
return;
}
scrollTop = container[0].scrollTop;
if (typeof wasScrolled === 'undefined' && scrollTop !== 0) wasScrolled = true;
if (!isMoved) {
/*jshint validthis:true */
container.removeClass('transitioning');
if (scrollTop > container[0].offsetHeight) {
isTouched = false;
return;
}
if (dynamicTriggerDistance) {
triggerDistance = container.attr('data-ptr-distance');
if (triggerDistance.indexOf('%') >= 0) triggerDistance = container[0].offsetHeight * parseInt(triggerDistance, 10) / 100;
}
startTranslate = container.hasClass('refreshing') ? triggerDistance : 0;
if (container[0].scrollHeight === container[0].offsetHeight || app.device.os !== 'ios') {
useTranslate = true;
}
else {
useTranslate = false;
}
}
isMoved = true;
touchesDiff = pageY - touchesStart.y;
if (touchesDiff > 0 && scrollTop <= 0 || scrollTop < 0) {
// iOS 8 fix
if (app.device.os === 'ios' && parseInt(app.device.osVersion.split('.')[0], 10) > 7 && scrollTop === 0 && !wasScrolled) useTranslate = true;
if (useTranslate) {
e.preventDefault();
translate = (Math.pow(touchesDiff, 0.85) + startTranslate);
container.transform('translate3d(0,' + translate + 'px,0)');
}
else {
}
if ((useTranslate && Math.pow(touchesDiff, 0.85) > triggerDistance) || (!useTranslate && touchesDiff >= triggerDistance * 2)) {
refresh = true;
container.addClass('pull-up').removeClass('pull-down');
}
else {
refresh = false;
container.removeClass('pull-up').addClass('pull-down');
}
}
else {
container.removeClass('pull-up pull-down');
refresh = false;
return;
}
}
function handleTouchEnd(e) {
if (!isTouched || !isMoved) {
isTouched = false;
isMoved = false;
return;
}
if (translate) {
container.addClass('transitioning');
translate = 0;
}
container.transform('');
if (refresh) {
container.addClass('refreshing');
container.trigger('refresh', {
done: function () {
app.pullToRefreshDone(container);
}
});
}
else {
container.removeClass('pull-down');
}
isTouched = false;
isMoved = false;
}
// Attach Events
eventsTarget.on(app.touchEvents.start, handleTouchStart);
eventsTarget.on(app.touchEvents.move, handleTouchMove);
eventsTarget.on(app.touchEvents.end, handleTouchEnd);
// Detach Events on page remove
if (page.length === 0) return;
function destroyPullToRefresh() {
eventsTarget.off(app.touchEvents.start, handleTouchStart);
eventsTarget.off(app.touchEvents.move, handleTouchMove);
eventsTarget.off(app.touchEvents.end, handleTouchEnd);
}
eventsTarget[0].f7DestroyPullToRefresh = destroyPullToRefresh;
function detachEvents() {
destroyPullToRefresh();
page.off('pageBeforeRemove', detachEvents);
}
page.on('pageBeforeRemove', detachEvents);
};
app.pullToRefreshDone = function (container) {
container = $(container);
if (container.length === 0) container = $('.pull-to-refresh-content.refreshing');
container.removeClass('refreshing').addClass('transitioning');
container.transitionEnd(function () {
container.removeClass('transitioning pull-up pull-down');
});
};
app.pullToRefreshTrigger = function (container) {
container = $(container);
if (container.length === 0) container = $('.pull-to-refresh-content');
if (container.hasClass('refreshing')) return;
container.addClass('transitioning refreshing');
container.trigger('refresh', {
done: function () {
app.pullToRefreshDone(container);
}
});
};
app.destroyPullToRefresh = function (pageContainer) {
pageContainer = $(pageContainer);
var pullToRefreshContent = pageContainer.hasClass('pull-to-refresh-content') ? pageContainer : pageContainer.find('.pull-to-refresh-content');
if (pullToRefreshContent.length === 0) return;
if (pullToRefreshContent[0].f7DestroyPullToRefresh) pullToRefreshContent[0].f7DestroyPullToRefresh();
};
/* ===============================================================================
************ Infinite Scroll ************
=============================================================================== */
function handleInfiniteScroll() {
/*jshint validthis:true */
var inf = $(this);
var scrollTop = inf[0].scrollTop;
var scrollHeight = inf[0].scrollHeight;
var height = inf[0].offsetHeight;
var distance = inf[0].getAttribute('data-distance');
var virtualListContainer = inf.find('.virtual-list');
var virtualList;
var onTop = inf.hasClass('infinite-scroll-top');
if (!distance) distance = 50;
if (typeof distance === 'string' && distance.indexOf('%') >= 0) {
distance = parseInt(distance, 10) / 100 * height;
}
if (distance > height) distance = height;
if (onTop) {
if (scrollTop < distance) {
inf.trigger('infinite');
}
}
else {
if (scrollTop + height >= scrollHeight - distance) {
if (virtualListContainer.length > 0) {
virtualList = virtualListContainer[0].f7VirtualList;
if (virtualList && !virtualList.reachEnd) return;
}
inf.trigger('infinite');
}
}
}
app.attachInfiniteScroll = function (infiniteContent) {
$(infiniteContent).on('scroll', handleInfiniteScroll);
};
app.detachInfiniteScroll = function (infiniteContent) {
$(infiniteContent).off('scroll', handleInfiniteScroll);
};
app.initInfiniteScroll = function (pageContainer) {
pageContainer = $(pageContainer);
var infiniteContent = pageContainer.find('.infinite-scroll');
if (infiniteContent.length === 0) return;
app.attachInfiniteScroll(infiniteContent);
function detachEvents() {
app.detachInfiniteScroll(infiniteContent);
pageContainer.off('pageBeforeRemove', detachEvents);
}
pageContainer.on('pageBeforeRemove', detachEvents);
};
/*=============================================================
************ Hide/show Toolbar/Navbar on scroll ************
=============================================================*/
app.initScrollToolbars = function (pageContainer) {
pageContainer = $(pageContainer);
var scrollContent = pageContainer.find('.page-content');
if (scrollContent.length === 0) return;
var hideNavbar = (app.params.hideNavbarOnPageScroll || scrollContent.hasClass('hide-navbar-on-scroll') || scrollContent.hasClass('hide-bars-on-scroll')) && !(scrollContent.hasClass('keep-navbar-on-scroll') || scrollContent.hasClass('keep-bars-on-scroll'));
var hideToolbar = (app.params.hideToolbarOnPageScroll || scrollContent.hasClass('hide-toolbar-on-scroll') || scrollContent.hasClass('hide-bars-on-scroll')) && !(scrollContent.hasClass('keep-toolbar-on-scroll') || scrollContent.hasClass('keep-bars-on-scroll'));
var hideTabbar = (app.params.hideTabbarOnPageScroll || scrollContent.hasClass('hide-tabbar-on-scroll')) && !(scrollContent.hasClass('keep-tabbar-on-scroll'));
if (!(hideNavbar || hideToolbar || hideTabbar)) return;
var viewContainer = scrollContent.parents('.' + app.params.viewClass);
if (viewContainer.length === 0) return;
var navbar = viewContainer.find('.navbar'),
toolbar = viewContainer.find('.toolbar'),
tabbar;
if (hideTabbar) {
tabbar = viewContainer.find('.tabbar');
if (tabbar.length === 0) tabbar = viewContainer.parents('.' + app.params.viewsClass).find('.tabbar');
}
var hasNavbar = navbar.length > 0,
hasToolbar = toolbar.length > 0,
hasTabbar = tabbar && tabbar.length > 0;
var previousScroll, currentScroll;
previousScroll = currentScroll = scrollContent[0].scrollTop;
var scrollHeight, offsetHeight, reachEnd, action, navbarHidden, toolbarHidden, tabbarHidden;
var toolbarHeight = (hasToolbar && hideToolbar) ? toolbar[0].offsetHeight : 0;
var tabbarHeight = (hasTabbar && hideTabbar) ? tabbar[0].offsetHeight : 0;
var bottomBarHeight = tabbarHeight || toolbarHeight;
function handleScroll(e) {
if (pageContainer.hasClass('page-on-left')) return;
currentScroll = scrollContent[0].scrollTop;
scrollHeight = scrollContent[0].scrollHeight;
offsetHeight = scrollContent[0].offsetHeight;
reachEnd = app.params.showBarsOnPageScrollEnd && (currentScroll + offsetHeight >= scrollHeight - bottomBarHeight);
navbarHidden = navbar.hasClass('navbar-hidden');
toolbarHidden = toolbar.hasClass('toolbar-hidden');
tabbarHidden = tabbar && tabbar.hasClass('toolbar-hidden');
if (reachEnd) {
action = 'show';
}
else if (previousScroll > currentScroll) {
if (app.params.showBarsOnPageScrollTop || currentScroll <= 44) {
action = 'show';
}
else {
action = 'hide';
}
}
else {
if (currentScroll > 44) {
action = 'hide';
}
else {
action = 'show';
}
}
if (action === 'show') {
if (hasNavbar && hideNavbar && navbarHidden) {
app.showNavbar(navbar);
pageContainer.removeClass('no-navbar-by-scroll');
navbarHidden = false;
}
if (hasToolbar && hideToolbar && toolbarHidden) {
app.showToolbar(toolbar);
pageContainer.removeClass('no-toolbar-by-scroll');
toolbarHidden = false;
}
if (hasTabbar && hideTabbar && tabbarHidden) {
app.showToolbar(tabbar);
pageContainer.removeClass('no-tabbar-by-scroll');
tabbarHidden = false;
}
}
else {
if (hasNavbar && hideNavbar && !navbarHidden) {
app.hideNavbar(navbar);
pageContainer.addClass('no-navbar-by-scroll');
navbarHidden = true;
}
if (hasToolbar && hideToolbar && !toolbarHidden) {
app.hideToolbar(toolbar);
pageContainer.addClass('no-toolbar-by-scroll');
toolbarHidden = true;
}
if (hasTabbar && hideTabbar && !tabbarHidden) {
app.hideToolbar(tabbar);
pageContainer.addClass('no-tabbar-by-scroll');
tabbarHidden = true;
}
}
previousScroll = currentScroll;
}
scrollContent.on('scroll', handleScroll);
scrollContent[0].f7ScrollToolbarsHandler = handleScroll;
};
app.destroyScrollToolbars = function (pageContainer) {
pageContainer = $(pageContainer);
var scrollContent = pageContainer.find('.page-content');
if (scrollContent.length === 0) return;
var handler = scrollContent[0].f7ScrollToolbarsHandler;
if (!handler) return;
scrollContent.off('scroll', scrollContent[0].f7ScrollToolbarsHandler);
};
/* ===============================================================================
************ Tabs ************
=============================================================================== */
app.showTab = function (tab, tabLink, force) {
var newTab = $(tab);
if (arguments.length === 2) {
if (typeof tabLink === 'boolean') {
force = tabLink;
}
}
if (newTab.length === 0) return false;
if (newTab.hasClass('active')) {
if (force) newTab.trigger('show');
return false;
}
var tabs = newTab.parent('.tabs');
if (tabs.length === 0) return false;
// Return swipeouts in hidden tabs
app.allowSwipeout = true;
// Animated tabs
var isAnimatedTabs = tabs.parent().hasClass('tabs-animated-wrap');
if (isAnimatedTabs) {
tabs.transform('translate3d(' + -newTab.index() * 100 + '%,0,0)');
}
// Remove active class from old tabs
var oldTab = tabs.children('.tab.active').removeClass('active');
// Add active class to new tab
newTab.addClass('active');
// Trigger 'show' event on new tab
newTab.trigger('show');
// Update navbars in new tab
if (!isAnimatedTabs && newTab.find('.navbar').length > 0) {
// Find tab's view
var viewContainer;
if (newTab.hasClass(app.params.viewClass)) viewContainer = newTab[0];
else viewContainer = newTab.parents('.' + app.params.viewClass)[0];
app.sizeNavbars(viewContainer);
}
// Find related link for new tab
if (tabLink) tabLink = $(tabLink);
else {
// Search by id
if (typeof tab === 'string') tabLink = $('.tab-link[href="' + tab + '"]');
else tabLink = $('.tab-link[href="#' + newTab.attr('id') + '"]');
// Search by data-tab
if (!tabLink || tabLink && tabLink.length === 0) {
$('[data-tab]').each(function () {
if (newTab.is($(this).attr('data-tab'))) tabLink = $(this);
});
}
}
if (tabLink.length === 0) return;
// Find related link for old tab
var oldTabLink;
if (oldTab && oldTab.length > 0) {
// Search by id
var oldTabId = oldTab.attr('id');
if (oldTabId) oldTabLink = $('.tab-link[href="#' + oldTabId + '"]');
// Search by data-tab
if (!oldTabLink || oldTabLink && oldTabLink.length === 0) {
$('[data-tab]').each(function () {
if (oldTab.is($(this).attr('data-tab'))) oldTabLink = $(this);
});
}
}
// Update links' classes
if (tabLink && tabLink.length > 0) tabLink.addClass('active');
if (oldTabLink && oldTabLink.length > 0) oldTabLink.removeClass('active');
return true;
};
/*===============================================================================
************ Accordion ************
===============================================================================*/
app.accordionToggle = function (item) {
item = $(item);
if (item.length === 0) return;
if (item.hasClass('accordion-item-expanded')) app.accordionClose(item);
else app.accordionOpen(item);
};
app.accordionOpen = function (item) {
item = $(item);
var list = item.parents('.accordion-list').eq(0);
var content = item.children('.accordion-item-content');
if (content.length === 0) content = item.find('.accordion-item-content');
var expandedItem = list.length > 0 && item.parent().children('.accordion-item-expanded');
if (expandedItem.length > 0) {
app.accordionClose(expandedItem);
}
content.css('height', content[0].scrollHeight + 'px').transitionEnd(function () {
if (item.hasClass('accordion-item-expanded')) {
content.transition(0);
content.css('height', 'auto');
var clientLeft = content[0].clientLeft;
content.transition('');
item.trigger('opened');
}
else {
content.css('height', '');
item.trigger('closed');
}
});
item.trigger('open');
item.addClass('accordion-item-expanded');
};
app.accordionClose = function (item) {
item = $(item);
var content = item.children('.accordion-item-content');
if (content.length === 0) content = item.find('.accordion-item-content');
item.removeClass('accordion-item-expanded');
content.transition(0);
content.css('height', content[0].scrollHeight + 'px');
// Relayout
var clientLeft = content[0].clientLeft;
// Close
content.transition('');
content.css('height', '').transitionEnd(function () {
if (item.hasClass('accordion-item-expanded')) {
content.transition(0);
content.css('height', 'auto');
var clientLeft = content[0].clientLeft;
content.transition('');
item.trigger('opened');
}
else {
content.css('height', '');
item.trigger('closed');
}
});
item.trigger('close');
};
/*===============================================================================
************ Fast Clicks ************
************ Inspired by https://github.com/ftlabs/fastclick ************
===============================================================================*/
app.initFastClicks = function () {
if (app.params.activeState) {
$('html').addClass('watch-active-state');
}
if (app.device.ios && app.device.webView) {
// Strange hack required for iOS 8 webview to work on inputs
window.addEventListener('touchstart', function () {});
}
var touchStartX, touchStartY, touchStartTime, targetElement, trackClick, activeSelection, scrollParent, lastClickTime, isMoved, tapHoldFired, tapHoldTimeout;
var activableElement, activeTimeout, needsFastClick, needsFastClickTimeOut;
function findActivableElement(e) {
var target = $(e.target);
var parents = target.parents(app.params.activeStateElements);
var activable;
if (target.is(app.params.activeStateElements)) {
activable = target;
}
if (parents.length > 0) {
activable = activable ? activable.add(parents) : parents;
}
return activable ? activable : target;
}
function isInsideScrollableView() {
var pageContent = activableElement.parents('.page-content, .panel');
if (pageContent.length === 0) {
return false;
}
// This event handler covers the "tap to stop scrolling".
if (pageContent.prop('scrollHandlerSet') !== 'yes') {
pageContent.on('scroll', function() {
clearTimeout(activeTimeout);
});
pageContent.prop('scrollHandlerSet', 'yes');
}
return true;
}
function addActive() {
activableElement.addClass('active-state');
}
function removeActive(el) {
activableElement.removeClass('active-state');
}
function isFormElement(el) {
var nodes = ('input select textarea label').split(' ');
if (el.nodeName && nodes.indexOf(el.nodeName.toLowerCase()) >= 0) return true;
return false;
}
function androidNeedsBlur(el) {
var noBlur = ('button input textarea select').split(' ');
if (document.activeElement && el !== document.activeElement && document.activeElement !== document.body) {
if (noBlur.indexOf(el.nodeName.toLowerCase()) >= 0) {
return false;
}
else {
return true;
}
}
else {
return false;
}
}
function targetNeedsFastClick(el) {
var $el = $(el);
if (el.nodeName.toLowerCase() === 'input' && el.type === 'file') return false;
if ($el.hasClass('no-fastclick') || $el.parents('.no-fastclick').length > 0) return false;
return true;
}
function targetNeedsFocus(el) {
if (document.activeElement === el) {
return false;
}
var tag = el.nodeName.toLowerCase();
var skipInputs = ('button checkbox file image radio submit').split(' ');
if (el.disabled || el.readOnly) return false;
if (tag === 'textarea') return true;
if (tag === 'select') {
if (app.device.android) return false;
else return true;
}
if (tag === 'input' && skipInputs.indexOf(el.type) < 0) return true;
}
function targetNeedsPrevent(el) {
el = $(el);
var prevent = true;
if (el.is('label') || el.parents('label').length > 0) {
if (app.device.android) {
prevent = false;
}
else if (app.device.ios && el.is('input')) {
prevent = true;
}
else prevent = false;
}
return prevent;
}
// Mouse Handlers
function handleMouseDown (e) {
findActivableElement(e).addClass('active-state');
if ('which' in e && e.which === 3) {
setTimeout(function () {
$('.active-state').removeClass('active-state');
}, 0);
}
}
function handleMouseMove (e) {
$('.active-state').removeClass('active-state');
}
function handleMouseUp (e) {
$('.active-state').removeClass('active-state');
}
// Touch Handlers
function handleTouchStart(e) {
isMoved = false;
tapHoldFired = false;
if (e.targetTouches.length > 1) {
return true;
}
if (app.params.tapHold) {
if (tapHoldTimeout) clearTimeout(tapHoldTimeout);
tapHoldTimeout = setTimeout(function () {
tapHoldFired = true;
e.preventDefault();
$(e.target).trigger('taphold');
}, app.params.tapHoldDelay);
}
if (needsFastClickTimeOut) clearTimeout(needsFastClickTimeOut);
needsFastClick = targetNeedsFastClick(e.target);
if (!needsFastClick) {
trackClick = false;
return true;
}
if (app.device.ios) {
var selection = window.getSelection();
if (selection.rangeCount && selection.focusNode !== document.body && (!selection.isCollapsed || document.activeElement === selection.focusNode)) {
activeSelection = true;
return true;
}
else {
activeSelection = false;
}
}
if (app.device.android) {
if (androidNeedsBlur(e.target)) {
document.activeElement.blur();
}
}
trackClick = true;
targetElement = e.target;
touchStartTime = (new Date()).getTime();
touchStartX = e.targetTouches[0].pageX;
touchStartY = e.targetTouches[0].pageY;
// Detect scroll parent
if (app.device.ios) {
scrollParent = undefined;
$(targetElement).parents().each(function () {
var parent = this;
if (parent.scrollHeight > parent.offsetHeight && !scrollParent) {
scrollParent = parent;
scrollParent.f7ScrollTop = scrollParent.scrollTop;
}
});
}
if ((e.timeStamp - lastClickTime) < app.params.fastClicksDelayBetweenClicks) {
e.preventDefault();
}
if (app.params.activeState) {
activableElement = findActivableElement(e);
// If it's inside a scrollable view, we don't trigger active-state yet,
// because it can be a scroll instead. Based on the link:
// http://labnote.beedesk.com/click-scroll-and-pseudo-active-on-mobile-webk
if (!isInsideScrollableView(e)) {
addActive();
} else {
activeTimeout = setTimeout(addActive, 80);
}
}
}
function handleTouchMove(e) {
if (!trackClick) return;
var _isMoved = false;
var distance = app.params.fastClicksDistanceThreshold;
if (distance) {
var pageX = e.targetTouches[0].pageX;
var pageY = e.targetTouches[0].pageY;
if (Math.abs(pageX - touchStartX) > distance || Math.abs(pageY - touchStartY) > distance) {
_isMoved = true;
}
}
else {
_isMoved = true;
}
if (_isMoved) {
trackClick = false;
targetElement = null;
isMoved = true;
if (app.params.tapHold) {
clearTimeout(tapHoldTimeout);
}
if (app.params.activeState) {
clearTimeout(activeTimeout);
removeActive();
}
}
}
function handleTouchEnd(e) {
clearTimeout(activeTimeout);
clearTimeout(tapHoldTimeout);
if (!trackClick) {
if (!activeSelection && needsFastClick) {
if (!(app.device.android && !e.cancelable)) {
e.preventDefault();
}
}
return true;
}
if (document.activeElement === e.target) {
return true;
}
if (!activeSelection) {
e.preventDefault();
}
if ((e.timeStamp - lastClickTime) < app.params.fastClicksDelayBetweenClicks) {
setTimeout(removeActive, 0);
return true;
}
lastClickTime = e.timeStamp;
trackClick = false;
if (app.device.ios && scrollParent) {
if (scrollParent.scrollTop !== scrollParent.f7ScrollTop) {
return false;
}
}
// Add active-state here because, in a very fast tap, the timeout didn't
// have the chance to execute. Removing active-state in a timeout gives
// the chance to the animation execute.
if (app.params.activeState) {
addActive();
setTimeout(removeActive, 0);
}
// Trigger focus when required
if (targetNeedsFocus(targetElement)) {
targetElement.focus();
}
// Blur active elements
if (document.activeElement && targetElement !== document.activeElement && document.activeElement !== document.body && targetElement.nodeName.toLowerCase() !== 'label') {
document.activeElement.blur();
}
// Send click
e.preventDefault();
var touch = e.changedTouches[0];
var evt = document.createEvent('MouseEvents');
var eventType = 'click';
if (app.device.android && targetElement.nodeName.toLowerCase() === 'select') {
eventType = 'mousedown';
}
evt.initMouseEvent(eventType, true, true, window, 1, touch.screenX, touch.screenY, touch.clientX, touch.clientY, false, false, false, false, 0, null);
evt.forwardedTouchEvent = true;
targetElement.dispatchEvent(evt);
return false;
}
function handleTouchCancel(e) {
trackClick = false;
targetElement = null;
}
function handleClick(e) {
var allowClick = false;
if (trackClick) {
targetElement = null;
trackClick = false;
return true;
}
if (e.target.type === 'submit' && e.detail === 0) {
return true;
}
if (!targetElement) {
if (!isFormElement(e.target)) {
allowClick = true;
}
}
if (!needsFastClick) {
allowClick = true;
}
if (document.activeElement === targetElement) {
allowClick = true;
}
if (e.forwardedTouchEvent) {
allowClick = true;
}
if (!e.cancelable) {
allowClick = true;
}
if (app.params.tapHold && app.params.tapHoldPreventClicks && tapHoldFired) {
allowClick = false;
}
if (!allowClick) {
e.stopImmediatePropagation();
e.stopPropagation();
if (targetElement) {
if (targetNeedsPrevent(targetElement) || isMoved) {
e.preventDefault();
}
}
else {
e.preventDefault();
}
targetElement = null;
}
needsFastClickTimeOut = setTimeout(function () {
needsFastClick = false;
}, (app.device.ios || app.device.androidChrome ? 100 : 400));
if (app.params.tapHold) {
tapHoldTimeout = setTimeout(function () {
tapHoldFired = false;
}, (app.device.ios || app.device.androidChrome ? 100 : 400));
}
return allowClick;
}
if (app.support.touch) {
document.addEventListener('click', handleClick, true);
document.addEventListener('touchstart', handleTouchStart);
document.addEventListener('touchmove', handleTouchMove);
document.addEventListener('touchend', handleTouchEnd);
document.addEventListener('touchcancel', handleTouchCancel);
}
else {
if (app.params.activeState) {
document.addEventListener('mousedown', handleMouseDown);
document.addEventListener('mousemove', handleMouseMove);
document.addEventListener('mouseup', handleMouseUp);
}
}
};
/*===============================================================================
************ Handle clicks and make them fast (on tap); ************
===============================================================================*/
app.initClickEvents = function () {
function handleScrollTop(e) {
/*jshint validthis:true */
var clicked = $(this);
var target = $(e.target);
var isLink = clicked[0].nodeName.toLowerCase() === 'a' ||
clicked.parents('a').length > 0 ||
target[0].nodeName.toLowerCase() === 'a' ||
target.parents('a').length > 0;
if (isLink) return;
var pageContent, page;
if (app.params.scrollTopOnNavbarClick && clicked.is('.navbar .center')) {
// Find active page
var navbar = clicked.parents('.navbar');
// Static Layout
pageContent = navbar.parents('.page-content');
if (pageContent.length === 0) {
// Fixed Layout
if (navbar.parents('.page').length > 0) {
pageContent = navbar.parents('.page').find('.page-content');
}
// Through Layout
if (pageContent.length === 0) {
if (navbar.nextAll('.pages').length > 0) {
pageContent = navbar.nextAll('.pages').find('.page:not(.page-on-left):not(.page-on-right):not(.cached)').find('.page-content');
}
}
}
}
if (app.params.scrollTopOnStatusbarClick && clicked.is('.statusbar-overlay')) {
if ($('.popup.modal-in').length > 0) {
// Check for opened popup
pageContent = $('.popup.modal-in').find('.page:not(.page-on-left):not(.page-on-right):not(.cached)').find('.page-content');
}
else if ($('.panel.active').length > 0) {
// Check for opened panel
pageContent = $('.panel.active').find('.page:not(.page-on-left):not(.page-on-right):not(.cached)').find('.page-content');
}
else if ($('.views > .view.active').length > 0) {
// View in tab bar app layout
pageContent = $('.views > .view.active').find('.page:not(.page-on-left):not(.page-on-right):not(.cached)').find('.page-content');
}
else {
// Usual case
pageContent = $('.views').find('.page:not(.page-on-left):not(.page-on-right):not(.cached)').find('.page-content');
}
}
if (pageContent && pageContent.length > 0) {
// Check for tab
if (pageContent.hasClass('tab')) {
pageContent = pageContent.parent('.tabs').children('.page-content.active');
}
if (pageContent.length > 0) pageContent.scrollTop(0, 300);
}
}
function handleClicks(e) {
/*jshint validthis:true */
var clicked = $(this);
var url = clicked.attr('href');
var isLink = clicked[0].nodeName.toLowerCase() === 'a';
// Check if link is external
if (isLink) {
if (clicked.is(app.params.externalLinks)) {
if(clicked.attr('target') === '_system') {
e.preventDefault();
window.open(url, '_system');
}
return;
}
}
// Collect Clicked data- attributes
var clickedData = clicked.dataset();
// Smart Select
if (clicked.hasClass('smart-select')) {
if (app.smartSelectOpen) app.smartSelectOpen(clicked);
}
// Open Panel
if (clicked.hasClass('open-panel')) {
if ($('.panel').length === 1) {
if ($('.panel').hasClass('panel-left')) app.openPanel('left');
else app.openPanel('right');
}
else {
if (clickedData.panel === 'right') app.openPanel('right');
else app.openPanel('left');
}
}
// Close Panel
if (clicked.hasClass('close-panel')) {
app.closePanel();
}
if (clicked.hasClass('panel-overlay') && app.params.panelsCloseByOutside) {
app.closePanel();
}
// Popover
if (clicked.hasClass('open-popover')) {
var popover;
if (clickedData.popover) {
popover = clickedData.popover;
}
else popover = '.popover';
app.popover(popover, clicked);
}
if (clicked.hasClass('close-popover')) {
app.closeModal('.popover.modal-in');
}
// Popup
var popup;
if (clicked.hasClass('open-popup')) {
if (clickedData.popup) {
popup = clickedData.popup;
}
else popup = '.popup';
app.popup(popup);
}
if (clicked.hasClass('close-popup')) {
if (clickedData.popup) {
popup = clickedData.popup;
}
else popup = '.popup.modal-in';
app.closeModal(popup);
}
// Login Screen
var loginScreen;
if (clicked.hasClass('open-login-screen')) {
if (clickedData.loginScreen) {
loginScreen = clickedData.loginScreen;
}
else loginScreen = '.login-screen';
app.loginScreen(loginScreen);
}
if (clicked.hasClass('close-login-screen')) {
app.closeModal('.login-screen.modal-in');
}
// Close Modal
if (clicked.hasClass('modal-overlay')) {
if ($('.modal.modal-in').length > 0 && app.params.modalCloseByOutside)
app.closeModal('.modal.modal-in');
if ($('.actions-modal.modal-in').length > 0 && app.params.actionsCloseByOutside)
app.closeModal('.actions-modal.modal-in');
if ($('.popover.modal-in').length > 0) app.closeModal('.popover.modal-in');
}
if (clicked.hasClass('popup-overlay')) {
if ($('.popup.modal-in').length > 0 && app.params.popupCloseByOutside)
app.closeModal('.popup.modal-in');
}
// Picker
if (clicked.hasClass('close-picker')) {
var pickerToClose = $('.picker-modal.modal-in');
if (pickerToClose.length > 0) {
app.closeModal(pickerToClose);
}
else {
pickerToClose = $('.popover.modal-in .picker-modal');
if (pickerToClose.length > 0) {
app.closeModal(pickerToClose.parents('.popover'));
}
}
}
if (clicked.hasClass('open-picker')) {
var pickerToOpen;
if (clickedData.picker) {
pickerToOpen = clickedData.picker;
}
else pickerToOpen = '.picker-modal';
app.pickerModal(pickerToOpen, clicked);
}
// Tabs
var isTabLink;
if (clicked.hasClass('tab-link')) {
isTabLink = true;
app.showTab(clickedData.tab || clicked.attr('href'), clicked);
}
// Swipeout Close
if (clicked.hasClass('swipeout-close')) {
app.swipeoutClose(clicked.parents('.swipeout-opened'));
}
// Swipeout Delete
if (clicked.hasClass('swipeout-delete')) {
if (clickedData.confirm) {
var text = clickedData.confirm;
var title = clickedData.confirmTitle;
if (title) {
app.confirm(text, title, function () {
app.swipeoutDelete(clicked.parents('.swipeout'));
});
}
else {
app.confirm(text, function () {
app.swipeoutDelete(clicked.parents('.swipeout'));
});
}
}
else {
app.swipeoutDelete(clicked.parents('.swipeout'));
}
}
// Sortable
if (clicked.hasClass('toggle-sortable')) {
app.sortableToggle(clickedData.sortable);
}
if (clicked.hasClass('open-sortable')) {
app.sortableOpen(clickedData.sortable);
}
if (clicked.hasClass('close-sortable')) {
app.sortableClose(clickedData.sortable);
}
// Accordion
if (clicked.hasClass('accordion-item-toggle') || (clicked.hasClass('item-link') && clicked.parent().hasClass('accordion-item'))) {
var accordionItem = clicked.parent('.accordion-item');
if (accordionItem.length === 0) accordionItem = clicked.parents('.accordion-item');
if (accordionItem.length === 0) accordionItem = clicked.parents('li');
app.accordionToggle(accordionItem);
}
// Load Page
if (app.params.ajaxLinks && !clicked.is(app.params.ajaxLinks) || !isLink || !app.params.router) {
return;
}
if (isLink) {
e.preventDefault();
}
var validUrl = url && url.length > 0 && url !== '#' && !isTabLink;
var template = clickedData.template;
if (validUrl || clicked.hasClass('back') || template) {
var view;
if (clickedData.view) {
view = $(clickedData.view)[0].f7View;
}
else {
view = clicked.parents('.' + app.params.viewClass)[0] && clicked.parents('.' + app.params.viewClass)[0].f7View;
if (view && view.params.linksView) {
if (typeof view.params.linksView === 'string') view = $(view.params.linksView)[0].f7View;
else if (view.params.linksView instanceof View) view = view.params.linksView;
}
}
if (!view) {
if (app.mainView) view = app.mainView;
}
if (!view) return;
var pageName;
if (!template) {
if (url.indexOf('#') === 0 && url !== '#') {
if (view.params.domCache) {
pageName = url.split('#')[1];
url = undefined;
}
else return;
}
if (url === '#' && !clicked.hasClass('back')) return;
}
else {
url = undefined;
}
var animatePages;
if (typeof clickedData.animatePages !== 'undefined') {
animatePages = clickedData.animatePages;
}
else {
if (clicked.hasClass('with-animation')) animatePages = true;
if (clicked.hasClass('no-animation')) animatePages = false;
}
var options = {
animatePages: animatePages,
ignoreCache: clickedData.ignoreCache,
force: clickedData.force,
reload: clickedData.reload,
reloadPrevious: clickedData.reloadPrevious,
pageName: pageName,
url: url
};
if (app.params.template7Pages) {
options.contextName = clickedData.contextName;
var context = clickedData.context;
if (context) {
options.context = JSON.parse(context);
}
}
if (template && template in t7.templates) {
options.template = t7.templates[template];
}
if (clicked.hasClass('back')) view.router.back(options);
else view.router.load(options);
}
}
$(document).on('click', 'a, .open-panel, .close-panel, .panel-overlay, .modal-overlay, .popup-overlay, .swipeout-delete, .swipeout-close, .close-popup, .open-popup, .open-popover, .open-login-screen, .close-login-screen .smart-select, .toggle-sortable, .open-sortable, .close-sortable, .accordion-item-toggle, .close-picker', handleClicks);
if (app.params.scrollTopOnNavbarClick || app.params.scrollTopOnStatusbarClick) {
$(document).on('click', '.statusbar-overlay, .navbar .center', handleScrollTop);
}
// Prevent scrolling on overlays
function preventScrolling(e) {
e.preventDefault();
}
if (app.support.touch) {
$(document).on((app.params.fastClicks ? 'touchstart' : 'touchmove'), '.panel-overlay, .modal-overlay, .preloader-indicator-overlay, .popup-overlay, .searchbar-overlay', preventScrolling);
}
};
/*======================================================
************ App Resize Actions ************
======================================================*/
// Prevent iPad horizontal body scrolling when soft keyboard is opened
function _fixIpadBodyScrolLeft() {
if (app.device.ipad) {
document.body.scrollLeft = 0;
setTimeout(function () {
document.body.scrollLeft = 0;
}, 0);
}
}
app.initResize = function () {
$(window).on('resize', app.resize);
$(window).on('orientationchange', app.orientationchange);
};
app.resize = function () {
if (app.sizeNavbars) app.sizeNavbars();
_fixIpadBodyScrolLeft();
};
app.orientationchange = function () {
if (app.device && app.device.minimalUi) {
if (window.orientation === 90 || window.orientation === -90) document.body.scrollTop = 0;
}
_fixIpadBodyScrolLeft();
};
/*===============================================================================
************ Store and parse forms data ************
===============================================================================*/
app.formsData = {};
app.formStoreData = function (formId, formJSON) {
// Store form data in app.formsData
app.formsData[formId] = formJSON;
// Store form data in local storage also
app.ls['f7form-' + formId] = JSON.stringify(formJSON);
};
app.formDeleteData = function (formId) {
// Delete form data from app.formsData
if (app.formsData[formId]) {
app.formsData[formId] = '';
delete app.formsData[formId];
}
// Delete form data from local storage also
if (app.ls['f7form-' + formId]) {
app.ls['f7form-' + formId] = '';
app.ls.removeItem('f7form-' + formId);
}
};
app.formGetData = function (formId) {
// First of all check in local storage
if (app.ls['f7form-' + formId]) {
return JSON.parse(app.ls['f7form-' + formId]);
}
// Try to get it from formsData obj
else if (app.formsData[formId]) return app.formsData[formId];
};
app.formToJSON = function (form) {
form = $(form);
if (form.length !== 1) return false;
// Form data
var formData = {};
// Skip input types
var skipTypes = ['submit', 'image', 'button', 'file'];
var skipNames = [];
form.find('input, select, textarea').each(function () {
var input = $(this);
var name = input.attr('name');
var type = input.attr('type');
var tag = this.nodeName.toLowerCase();
if (skipTypes.indexOf(type) >= 0) return;
if (skipNames.indexOf(name) >= 0 || !name) return;
if (tag === 'select' && input.attr('multiple')) {
skipNames.push(name);
formData[name] = [];
form.find('select[name="' + name + '"] option').each(function () {
if (this.selected) formData[name].push(this.value);
});
}
else {
switch (type) {
case 'checkbox' :
skipNames.push(name);
formData[name] = [];
form.find('input[name="' + name + '"]').each(function () {
if (this.checked) formData[name].push(this.value);
});
break;
case 'radio' :
skipNames.push(name);
form.find('input[name="' + name + '"]').each(function () {
if (this.checked) formData[name] = this.value;
});
break;
default :
formData[name] = input.val();
break;
}
}
});
form.trigger('formToJSON', {formData: formData});
return formData;
};
app.formFromJSON = function (form, formData) {
form = $(form);
if (form.length !== 1) return false;
// Skip input types
var skipTypes = ['submit', 'image', 'button', 'file'];
var skipNames = [];
form.find('input, select, textarea').each(function () {
var input = $(this);
var name = input.attr('name');
var type = input.attr('type');
var tag = this.nodeName.toLowerCase();
if (!formData[name]) return;
if (skipTypes.indexOf(type) >= 0) return;
if (skipNames.indexOf(name) >= 0 || !name) return;
if (tag === 'select' && input.attr('multiple')) {
skipNames.push(name);
form.find('select[name="' + name + '"] option').each(function () {
if (formData[name].indexOf(this.value) >= 0) this.selected = true;
else this.selected = false;
});
}
else {
switch (type) {
case 'checkbox' :
skipNames.push(name);
form.find('input[name="' + name + '"]').each(function () {
if (formData[name].indexOf(this.value) >= 0) this.checked = true;
else this.checked = false;
});
break;
case 'radio' :
skipNames.push(name);
form.find('input[name="' + name + '"]').each(function () {
if (formData[name] === this.value) this.checked = true;
else this.checked = false;
});
break;
default :
input.val(formData[name]);
break;
}
}
});
form.trigger('formFromJSON', {formData: formData});
};
app.initFormsStorage = function (pageContainer) {
pageContainer = $(pageContainer);
if (pageContainer.length === 0) return;
var forms = pageContainer.find('form.store-data');
if (forms.length === 0) return;
// Parse forms data and fill form if there is such data
forms.each(function () {
var id = this.getAttribute('id');
if (!id) return;
var formData = app.formGetData(id);
if (formData) app.formFromJSON(this, formData);
});
// Update forms data on inputs change
function storeForm() {
/*jshint validthis:true */
var form = $(this);
var formId = form[0].id;
if (!formId) return;
var formJSON = app.formToJSON(form);
if (!formJSON) return;
app.formStoreData(formId, formJSON);
form.trigger('store', {data: formJSON});
}
forms.on('change submit', storeForm);
// Detach Listeners
function pageBeforeRemove() {
forms.off('change submit', storeForm);
pageContainer.off('pageBeforeRemove', pageBeforeRemove);
}
pageContainer.on('pageBeforeRemove', pageBeforeRemove);
};
// Ajax submit on forms
$(document).on('submit change', 'form.ajax-submit, form.ajax-submit-onchange', function (e) {
var form = $(this);
if (e.type === 'change' && !form.hasClass('ajax-submit-onchange')) return;
if (e.type === 'submit') e.preventDefault();
var method = form.attr('method') || 'GET';
var contentType = form.prop('enctype') || form.attr('enctype');
var url = form.attr('action');
if (!url) return;
var data;
if (method === 'POST') data = new FormData(form[0]);
else data = $.serializeObject(app.formToJSON(form[0]));
var xhr = $.ajax({
method: method,
url: url,
contentType: contentType,
data: data,
beforeSend: function (xhr) {
form.trigger('beforeSubmit', {data:data, xhr: xhr});
},
error: function (xhr) {
form.trigger('submitError', {data:data, xhr: xhr});
},
success: function (data) {
form.trigger('submitted', {data: data, xhr: xhr});
}
});
});
/*======================================================
************ Handle Browser's History ************
======================================================*/
app.pushStateQueue = [];
app.pushStateClearQueue = function () {
if (app.pushStateQueue.length === 0) return;
var queue = app.pushStateQueue.pop();
var animatePages;
if (app.params.pushStateNoAnimation === true) animatePages = false;
if (queue.action === 'back') {
app.router.back(queue.view, {animatePages: animatePages});
}
if (queue.action === 'loadPage') {
app.router.load(queue.view, {url: queue.stateUrl, animatePages: animatePages, pushState: false});
}
if (queue.action === 'loadContent') {
app.router.load(queue.view, {content: queue.stateContent, animatePages: animatePages, pushState: false});
}
if (queue.action === 'loadPageName') {
app.router.load(queue.view, {pageName: queue.statePageName, animatePages: animatePages, pushState: false});
}
};
app.initPushState = function () {
var blockPopstate;
if (app.params.pushStatePreventOnLoad) {
blockPopstate = true;
$(window).on('load', function () {
setTimeout(function () {
blockPopstate = false;
}, 0);
});
}
function handlePopState(e) {
if (blockPopstate) return;
var mainView = app.mainView;
if (!mainView) return;
var state = e.state;
if (!state) {
state = {
viewIndex: app.views.indexOf(mainView),
url : mainView.history[0]
};
}
if (state.viewIndex < 0) return;
var view = app.views[state.viewIndex];
var stateUrl = state && state.url || undefined;
var stateContent = state && state.content || undefined;
var statePageName = state && state.pageName || undefined;
var animatePages;
if (app.params.pushStateNoAnimation === true) animatePages = false;
if (stateUrl !== view.url) {
if (view.history.indexOf(stateUrl) >= 0) {
// Go Back
if (view.allowPageChange) {
app.router.back(view, {url:undefined, animatePages: animatePages, pushState: false, preloadOnly:false});
}
else {
app.pushStateQueue.push({
action: 'back',
view: view
});
}
}
else if (stateContent) {
// Load Page
if (view.allowPageChange) {
app.router.load(view, {content:stateContent, animatePages: animatePages, pushState: false});
}
else {
app.pushStateQueue.unshift({
action: 'loadContent',
stateContent: stateContent,
view: view
});
}
}
else if (statePageName) {
// Load Page by page name with Dom Cache
if (view.allowPageChange) {
app.router.load(view, {pageName:statePageName, animatePages: animatePages, pushState: false});
}
else {
app.pushStateQueue.unshift({
action: 'loadPageName',
statePageName: statePageName,
view: view
});
}
}
else {
// Load Page
if (view.allowPageChange) {
app.router.load(view, {url:stateUrl, animatePages: animatePages, pushState: false});
}
else {
app.pushStateQueue.unshift({
action: 'loadPage',
stateUrl: stateUrl,
view: view
});
}
}
}
}
$(window).on('popstate', handlePopState);
};
/*===========================
Framework7 Swiper Additions
===========================*/
app.swiper = function (container, params) {
return new Swiper(container, params);
};
app.initPageSwiper = function (pageContainer) {
var page = $(pageContainer);
var swipers = page.find('.swiper-init');
if (swipers.length === 0) return;
function destroySwiperOnRemove(slider) {
function destroySwiper() {
slider.destroy();
page.off('pageBeforeRemove', destroySwiper);
}
page.on('pageBeforeRemove', destroySwiper);
}
for (var i = 0; i < swipers.length; i++) {
var swiper = swipers.eq(i);
var params;
if (swiper.data('swiper')) {
params = JSON.parse(swiper.data('swiper'));
}
else {
params = swiper.dataset();
}
var _slider = app.swiper(swiper[0], params);
destroySwiperOnRemove(_slider);
}
};
app.reinitPageSwiper = function (pageContainer) {
var page = $(pageContainer);
var sliders = page.find('.swiper-init');
if (sliders.length === 0) return;
for (var i = 0; i < sliders.length; i++) {
var sliderInstance = sliders[0].swiper;
if (sliderInstance) {
sliderInstance.update(true);
}
}
};
/*======================================================
************ Photo Browser ************
======================================================*/
var PhotoBrowser = function (params) {
var pb = this, i;
var defaults = {
photos : [],
initialSlide: 0,
spaceBetween: 20,
speed: 300,
zoom: true,
maxZoom: 3,
minZoom: 1,
exposition: true,
expositionHideCaptions: false,
type: 'standalone',
navbar: true,
toolbar: true,
theme: 'light',
swipeToClose: true,
backLinkText: 'Close',
ofText: 'of',
loop: false,
lazyLoading: false,
lazyLoadingInPrevNext: false,
lazyLoadingOnTransitionStart: false,
/*
Callbacks:
onLazyImageLoad(pb, slide, img)
onLazyImageReady(pb, slide, img)
onOpen(pb)
onClose(pb)
onSlideChangeStart(swiper)
onSlideChangeEnd(swiper)
onTap(swiper, e)
onClick(swiper, e)
onDoubleTap(swiper, e)
onSwipeToClose(pb)
*/
};
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined') {
params[def] = defaults[def];
}
}
pb.params = params;
var iconColor = pb.params.theme === 'dark' ? 'color-white' : '';
var navbarTemplate = pb.params.navbarTemplate ||
'<div class="navbar">' +
'<div class="navbar-inner">' +
'<div class="left sliding"><a href="#" class="link ' + (pb.params.type === 'page' && 'back') + ' close-popup photo-browser-close-link" data-popup=".photo-browser-popup"><i class="icon icon-back ' + iconColor + '"></i><span>' + pb.params.backLinkText + '</span></a></div>' +
'<div class="center sliding"><span class="photo-browser-current"></span> <span class="photo-browser-of">' + pb.params.ofText + '</span> <span class="photo-browser-total"></span></div>' +
'<div class="right"></div>' +
'</div>' +
'</div>';
var toolbarTemplate = pb.params.toolbarTemplate ||
'<div class="toolbar tabbar">' +
'<div class="toolbar-inner">' +
'<a href="#" class="link photo-browser-prev"><i class="icon icon-prev ' + iconColor + '"></i></a>' +
'<a href="#" class="link photo-browser-next"><i class="icon icon-next ' + iconColor + '"></i></a>' +
'</div>' +
'</div>';
var template = pb.params.template ||
'<div class="photo-browser photo-browser-' + pb.params.theme + '">' +
'<div class="view navbar-fixed toolbar-fixed">' +
'{{navbar}}' +
'<div data-page="photo-browser-slides" class="page no-toolbar {{noNavbar}} toolbar-fixed navbar-fixed">' +
'{{toolbar}}' +
'{{captions}}' +
'<div class="photo-browser-swiper-container swiper-container">' +
'<div class="photo-browser-swiper-wrapper swiper-wrapper">' +
'{{photos}}' +
'</div>' +
'</div>' +
'</div>' +
'</div>' +
'</div>';
var photoTemplate = !pb.params.lazyLoading ?
(pb.params.photoTemplate || '<div class="photo-browser-slide swiper-slide"><span class="photo-browser-zoom-container"><img src="{{url}}"></span></div>') :
(pb.params.photoLazyTemplate || '<div class="photo-browser-slide photo-browser-slide-lazy swiper-slide"><div class="preloader' + (pb.params.theme === 'dark' ? ' preloader-white' : '') + '"></div><span class="photo-browser-zoom-container"><img data-src="{{url}}" class="swiper-lazy"></span></div>');
var captionsTheme = pb.params.captionsTheme || pb.params.theme;
var captionsTemplate = pb.params.captionsTemplate || '<div class="photo-browser-captions photo-browser-captions-' + captionsTheme + '">{{captions}}</div>';
var captionTemplate = pb.params.captionTemplate || '<div class="photo-browser-caption" data-caption-index="{{captionIndex}}">{{caption}}</div>';
var objectTemplate = pb.params.objectTemplate || '<div class="photo-browser-slide photo-browser-object-slide swiper-slide">{{html}}</div>';
var photosHtml = '';
var captionsHtml = '';
for (i = 0; i < pb.params.photos.length; i ++) {
var photo = pb.params.photos[i];
var thisTemplate = '';
//check if photo is a string or string-like object, for backwards compatibility
if (typeof(photo) === 'string' || photo instanceof String) {
//check if "photo" is html object
if (photo.indexOf('<') >= 0 || photo.indexOf('>') >= 0) {
thisTemplate = objectTemplate.replace(/{{html}}/g, photo);
} else {
thisTemplate = photoTemplate.replace(/{{url}}/g, photo);
}
//photo is a string, thus has no caption, so remove the caption template placeholder
//otherwise check if photo is an object with a url property
} else if (typeof(photo) === 'object') {
//check if "photo" is html object
if (photo.hasOwnProperty('html') && photo.html.length > 0) {
thisTemplate = objectTemplate.replace(/{{html}}/g, photo.html);
} else if (photo.hasOwnProperty('url') && photo.url.length > 0) {
thisTemplate = photoTemplate.replace(/{{url}}/g, photo.url);
}
//check if photo has a caption
if (photo.hasOwnProperty('caption') && photo.caption.length > 0) {
captionsHtml += captionTemplate.replace(/{{caption}}/g, photo.caption).replace(/{{captionIndex}}/g, i);
} else {
thisTemplate = thisTemplate.replace(/{{caption}}/g, '');
}
}
photosHtml += thisTemplate;
}
var htmlTemplate = template
.replace('{{navbar}}', (pb.params.navbar ? navbarTemplate : ''))
.replace('{{noNavbar}}', (pb.params.navbar ? '' : 'no-navbar'))
.replace('{{photos}}', photosHtml)
.replace('{{captions}}', captionsTemplate.replace(/{{captions}}/g, captionsHtml))
.replace('{{toolbar}}', (pb.params.toolbar ? toolbarTemplate : ''));
pb.activeIndex = pb.params.initialSlide;
pb.openIndex = pb.activeIndex;
pb.opened = false;
pb.open = function (index) {
if (typeof index === 'undefined') index = pb.activeIndex;
index = parseInt(index, 10);
if (pb.opened && pb.swiper) {
pb.swiper.slideTo(index);
return;
}
pb.opened = true;
pb.openIndex = index;
// pb.initialLazyLoaded = false;
if (pb.params.type === 'standalone') {
$('body').append(htmlTemplate);
}
if (pb.params.type === 'popup') {
pb.popup = app.popup('<div class="popup photo-browser-popup">' + htmlTemplate + '</div>');
$(pb.popup).on('closed', pb.onPopupClose);
}
if (pb.params.type === 'page') {
$(document).on('pageBeforeInit', pb.onPageBeforeInit);
$(document).on('pageBeforeRemove', pb.onPageBeforeRemove);
if (!pb.params.view) pb.params.view = app.mainView;
pb.params.view.loadContent(htmlTemplate);
return;
}
pb.layout(pb.openIndex);
if (pb.params.onOpen) {
pb.params.onOpen(pb);
}
};
pb.close = function () {
pb.opened = false;
if (!pb.swiperContainer || pb.swiperContainer.length === 0) {
return;
}
if (pb.params.onClose) {
pb.params.onClose(pb);
}
// Detach events
pb.attachEvents(true);
// Delete from DOM
if (pb.params.type === 'standalone') {
pb.container.removeClass('photo-browser-in').addClass('photo-browser-out').animationEnd(function () {
pb.container.remove();
});
}
// Destroy slider
pb.swiper.destroy();
// Delete references
pb.swiper = pb.swiperContainer = pb.swiperWrapper = pb.slides = gestureSlide = gestureImg = gestureImgWrap = undefined;
};
pb.onPopupClose = function (e) {
pb.close();
$(pb.popup).off('pageBeforeInit', pb.onPopupClose);
};
pb.onPageBeforeInit = function (e) {
if (e.detail.page.name === 'photo-browser-slides') {
pb.layout(pb.openIndex);
}
$(document).off('pageBeforeInit', pb.onPageBeforeInit);
};
pb.onPageBeforeRemove = function (e) {
if (e.detail.page.name === 'photo-browser-slides') {
pb.close();
}
$(document).off('pageBeforeRemove', pb.onPageBeforeRemove);
};
pb.onSliderTransitionStart = function (swiper) {
pb.activeIndex = swiper.activeIndex;
var current = swiper.activeIndex + 1;
var total = swiper.slides.length;
if (pb.params.loop) {
total = total - 2;
current = current - swiper.loopedSlides;
if (current < 1) current = total + current;
if (current > total) current = current - total;
}
pb.container.find('.photo-browser-current').text(current);
pb.container.find('.photo-browser-total').text(total);
$('.photo-browser-prev, .photo-browser-next').removeClass('photo-browser-link-inactive');
if (swiper.isBeginning && !pb.params.loop) {
$('.photo-browser-prev').addClass('photo-browser-link-inactive');
}
if (swiper.isEnd && !pb.params.loop) {
$('.photo-browser-next').addClass('photo-browser-link-inactive');
}
// Update captions
if (pb.captions.length > 0) {
pb.captionsContainer.find('.photo-browser-caption-active').removeClass('photo-browser-caption-active');
var captionIndex = pb.params.loop ? swiper.slides.eq(swiper.activeIndex).attr('data-swiper-slide-index') : pb.activeIndex;
pb.captionsContainer.find('[data-caption-index="' + captionIndex + '"]').addClass('photo-browser-caption-active');
}
// Stop Video
var previousSlideVideo = swiper.slides.eq(swiper.previousIndex).find('video');
if (previousSlideVideo.length > 0) {
if ('pause' in previousSlideVideo[0]) previousSlideVideo[0].pause();
}
// Callback
if (pb.params.onSlideChangeStart) pb.params.onSlideChangeStart(swiper);
};
pb.onSliderTransitionEnd = function (swiper) {
// Reset zoom
if (pb.params.zoom && gestureSlide && swiper.previousIndex !== swiper.activeIndex) {
gestureImg.transform('translate3d(0,0,0) scale(1)');
gestureImgWrap.transform('translate3d(0,0,0)');
gestureSlide = gestureImg = gestureImgWrap = undefined;
scale = currentScale = 1;
}
if (pb.params.onSlideChangeEnd) pb.params.onSlideChangeEnd(swiper);
};
pb.layout = function (index) {
if (pb.params.type === 'page') {
pb.container = $('.photo-browser-swiper-container').parents('.view');
}
else {
pb.container = $('.photo-browser');
}
if (pb.params.type === 'standalone') {
pb.container.addClass('photo-browser-in');
app.sizeNavbars(pb.container);
}
pb.swiperContainer = pb.container.find('.photo-browser-swiper-container');
pb.swiperWrapper = pb.container.find('.photo-browser-swiper-wrapper');
pb.slides = pb.container.find('.photo-browser-slide');
pb.captionsContainer = pb.container.find('.photo-browser-captions');
pb.captions = pb.container.find('.photo-browser-caption');
var sliderSettings = {
nextButton: pb.params.nextButton || '.photo-browser-next',
prevButton: pb.params.prevButton || '.photo-browser-prev',
indexButton: pb.params.indexButton,
initialSlide: index,
spaceBetween: pb.params.spaceBetween,
speed: pb.params.speed,
loop: pb.params.loop,
lazyLoading: pb.params.lazyLoading,
lazyLoadingInPrevNext: pb.params.lazyLoadingInPrevNext,
lazyLoadingOnTransitionStart: pb.params.lazyLoadingOnTransitionStart,
preloadImages: pb.params.lazyLoading ? false : true,
onTap: function (swiper, e) {
if (pb.params.onTap) pb.params.onTap(swiper, e);
},
onClick: function (swiper, e) {
if (pb.params.exposition) pb.toggleExposition();
if (pb.params.onClick) pb.params.onClick(swiper, e);
},
onDoubleTap: function (swiper, e) {
pb.toggleZoom($(e.target).parents('.photo-browser-slide'));
if (pb.params.onDoubleTap) pb.params.onDoubleTap(swiper, e);
},
onTransitionStart: function (swiper) {
pb.onSliderTransitionStart(swiper);
},
onTransitionEnd: function (swiper) {
pb.onSliderTransitionEnd(swiper);
},
onLazyImageLoad: function (swiper, slide, img) {
if (pb.params.onLazyImageLoad) pb.params.onLazyImageLoad(pb, slide, img);
},
onLazyImageReady: function (swiper, slide, img) {
$(slide).removeClass('photo-browser-slide-lazy');
if (pb.params.onLazyImageReady) pb.params.onLazyImageReady(pb, slide, img);
}
};
if (pb.params.swipeToClose && pb.params.type !== 'page') {
sliderSettings.onTouchStart = pb.swipeCloseTouchStart;
sliderSettings.onTouchMoveOpposite = pb.swipeCloseTouchMove;
sliderSettings.onTouchEnd = pb.swipeCloseTouchEnd;
}
pb.swiper = app.swiper(pb.swiperContainer, sliderSettings);
if (index === 0) {
pb.onSliderTransitionStart(pb.swiper);
}
pb.attachEvents();
};
pb.attachEvents = function (detach) {
var action = detach ? 'off' : 'on';
// Slide between photos
if (pb.params.zoom) {
var target = pb.params.loop ? pb.swiper.slides : pb.slides;
// Scale image
target[action]('gesturestart', pb.onSlideGestureStart);
target[action]('gesturechange', pb.onSlideGestureChange);
target[action]('gestureend', pb.onSlideGestureEnd);
// Move image
target[action](app.touchEvents.start, pb.onSlideTouchStart);
target[action](app.touchEvents.move, pb.onSlideTouchMove);
target[action](app.touchEvents.end, pb.onSlideTouchEnd);
}
pb.container.find('.photo-browser-close-link')[action]('click', pb.close);
};
var isTouched, isMoved, touchesStart = {}, touchesCurrent = {}, touchStartTime, isScrolling, animating = false, currentTranslate;
var allowClick = true;
// Expose
pb.exposed = false;
pb.toggleExposition = function () {
if (pb.container) pb.container.toggleClass('photo-browser-exposed');
if (pb.params.expositionHideCaptions) pb.captionsContainer.toggleClass('photo-browser-captions-exposed');
pb.exposed = !pb.exposed;
};
pb.enableExposition = function () {
if (pb.container) pb.container.addClass('photo-browser-exposed');
if (pb.params.expositionHideCaptions) pb.captionsContainer.addClass('photo-browser-captions-exposed');
pb.exposed = true;
};
pb.disableExposition = function () {
if (pb.container) pb.container.removeClass('photo-browser-exposed');
if (pb.params.expositionHideCaptions) pb.captionsContainer.removeClass('photo-browser-captions-exposed');
pb.exposed = false;
};
// Gestures
var gestureSlide, gestureImg, gestureImgWrap, scale = 1, currentScale = 1, isScaling = false;
pb.onSlideGestureStart = function (e) {
if (!gestureSlide || !gestureSlide.length) {
gestureSlide = $(this);
if (gestureSlide.length === 0) gestureSlide = pb.swiper.slides.eq(pb.swiper.activeIndex);
gestureImg = gestureSlide.find('img, svg, canvas');
gestureImgWrap = gestureImg.parent('.photo-browser-zoom-container');
if (gestureImgWrap.length === 0) {
gestureImg = undefined;
return;
}
}
gestureImg.transition(0);
isScaling = true;
};
pb.onSlideGestureChange = function (e) {
if (!gestureImg || gestureImg.length === 0) return;
scale = e.scale * currentScale;
if (scale > pb.params.maxZoom) {
scale = pb.params.maxZoom - 1 + Math.pow((scale - pb.params.maxZoom + 1), 0.5);
}
if (scale < pb.params.minZoom) {
scale = pb.params.minZoom + 1 - Math.pow((pb.params.minZoom - scale + 1), 0.5);
}
gestureImg.transform('translate3d(0,0,0) scale(' + scale + ')');
};
pb.onSlideGestureEnd = function (e) {
if (!gestureImg || gestureImg.length === 0) return;
scale = Math.max(Math.min(scale, pb.params.maxZoom), pb.params.minZoom);
gestureImg.transition(pb.params.speed).transform('translate3d(0,0,0) scale(' + scale + ')');
currentScale = scale;
isScaling = false;
if (scale === 1) gestureSlide = undefined;
};
pb.toggleZoom = function () {
if (!gestureSlide) {
gestureSlide = pb.swiper.slides.eq(pb.swiper.activeIndex);
gestureImg = gestureSlide.find('img, svg, canvas');
gestureImgWrap = gestureImg.parent('.photo-browser-zoom-container');
}
if (!gestureImg || gestureImg.length === 0) return;
gestureImgWrap.transition(300).transform('translate3d(0,0,0)');
if (scale && scale !== 1) {
scale = currentScale = 1;
gestureImg.transition(300).transform('translate3d(0,0,0) scale(1)');
gestureSlide = undefined;
}
else {
scale = currentScale = pb.params.maxZoom;
gestureImg.transition(300).transform('translate3d(0,0,0) scale(' + scale + ')');
}
};
var imageIsTouched, imageIsMoved, imageCurrentX, imageCurrentY, imageMinX, imageMinY, imageMaxX, imageMaxY, imageWidth, imageHeight, imageTouchesStart = {}, imageTouchesCurrent = {}, imageStartX, imageStartY, velocityPrevPositionX, velocityPrevTime, velocityX, velocityPrevPositionY, velocityY;
pb.onSlideTouchStart = function (e) {
if (!gestureImg || gestureImg.length === 0) return;
if (imageIsTouched) return;
if (app.device.os === 'android') e.preventDefault();
imageIsTouched = true;
imageTouchesStart.x = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
imageTouchesStart.y = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
};
pb.onSlideTouchMove = function (e) {
if (!gestureImg || gestureImg.length === 0) return;
pb.swiper.allowClick = false;
if (!imageIsTouched || !gestureSlide) return;
if (!imageIsMoved) {
imageWidth = gestureImg[0].offsetWidth;
imageHeight = gestureImg[0].offsetHeight;
imageStartX = $.getTranslate(gestureImgWrap[0], 'x') || 0;
imageStartY = $.getTranslate(gestureImgWrap[0], 'y') || 0;
gestureImgWrap.transition(0);
}
// Define if we need image drag
var scaledWidth = imageWidth * scale;
var scaledHeight = imageHeight * scale;
if (scaledWidth < pb.swiper.width && scaledHeight < pb.swiper.height) return;
imageMinX = Math.min((pb.swiper.width / 2 - scaledWidth / 2), 0);
imageMaxX = -imageMinX;
imageMinY = Math.min((pb.swiper.height / 2 - scaledHeight / 2), 0);
imageMaxY = -imageMinY;
imageTouchesCurrent.x = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
imageTouchesCurrent.y = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (!imageIsMoved && !isScaling) {
if (
(Math.floor(imageMinX) === Math.floor(imageStartX) && imageTouchesCurrent.x < imageTouchesStart.x) ||
(Math.floor(imageMaxX) === Math.floor(imageStartX) && imageTouchesCurrent.x > imageTouchesStart.x)
) {
imageIsTouched = false;
return;
}
}
e.preventDefault();
e.stopPropagation();
imageIsMoved = true;
imageCurrentX = imageTouchesCurrent.x - imageTouchesStart.x + imageStartX;
imageCurrentY = imageTouchesCurrent.y - imageTouchesStart.y + imageStartY;
if (imageCurrentX < imageMinX) {
imageCurrentX = imageMinX + 1 - Math.pow((imageMinX - imageCurrentX + 1), 0.8);
}
if (imageCurrentX > imageMaxX) {
imageCurrentX = imageMaxX - 1 + Math.pow((imageCurrentX - imageMaxX + 1), 0.8);
}
if (imageCurrentY < imageMinY) {
imageCurrentY = imageMinY + 1 - Math.pow((imageMinY - imageCurrentY + 1), 0.8);
}
if (imageCurrentY > imageMaxY) {
imageCurrentY = imageMaxY - 1 + Math.pow((imageCurrentY - imageMaxY + 1), 0.8);
}
//Velocity
if (!velocityPrevPositionX) velocityPrevPositionX = imageTouchesCurrent.x;
if (!velocityPrevPositionY) velocityPrevPositionY = imageTouchesCurrent.y;
if (!velocityPrevTime) velocityPrevTime = Date.now();
velocityX = (imageTouchesCurrent.x - velocityPrevPositionX) / (Date.now() - velocityPrevTime) / 2;
velocityY = (imageTouchesCurrent.y - velocityPrevPositionY) / (Date.now() - velocityPrevTime) / 2;
if (Math.abs(imageTouchesCurrent.x - velocityPrevPositionX) < 2) velocityX = 0;
if (Math.abs(imageTouchesCurrent.y - velocityPrevPositionY) < 2) velocityY = 0;
velocityPrevPositionX = imageTouchesCurrent.x;
velocityPrevPositionY = imageTouchesCurrent.y;
velocityPrevTime = Date.now();
gestureImgWrap.transform('translate3d(' + imageCurrentX + 'px, ' + imageCurrentY + 'px,0)');
};
pb.onSlideTouchEnd = function (e) {
if (!gestureImg || gestureImg.length === 0) return;
if (!imageIsTouched || !imageIsMoved) {
imageIsTouched = false;
imageIsMoved = false;
return;
}
imageIsTouched = false;
imageIsMoved = false;
var momentumDurationX = 300;
var momentumDurationY = 300;
var momentumDistanceX = velocityX * momentumDurationX;
var newPositionX = imageCurrentX + momentumDistanceX;
var momentumDistanceY = velocityY * momentumDurationY;
var newPositionY = imageCurrentY + momentumDistanceY;
//Fix duration
if (velocityX !== 0) momentumDurationX = Math.abs((newPositionX - imageCurrentX) / velocityX);
if (velocityY !== 0) momentumDurationY = Math.abs((newPositionY - imageCurrentY) / velocityY);
var momentumDuration = Math.max(momentumDurationX, momentumDurationY);
imageCurrentX = newPositionX;
imageCurrentY = newPositionY;
// Define if we need image drag
var scaledWidth = imageWidth * scale;
var scaledHeight = imageHeight * scale;
imageMinX = Math.min((pb.swiper.width / 2 - scaledWidth / 2), 0);
imageMaxX = -imageMinX;
imageMinY = Math.min((pb.swiper.height / 2 - scaledHeight / 2), 0);
imageMaxY = -imageMinY;
imageCurrentX = Math.max(Math.min(imageCurrentX, imageMaxX), imageMinX);
imageCurrentY = Math.max(Math.min(imageCurrentY, imageMaxY), imageMinY);
gestureImgWrap.transition(momentumDuration).transform('translate3d(' + imageCurrentX + 'px, ' + imageCurrentY + 'px,0)');
};
// Swipe Up To Close
var swipeToCloseIsTouched = false;
var allowSwipeToClose = true;
var swipeToCloseDiff, swipeToCloseStart, swipeToCloseCurrent, swipeToCloseStarted = false, swipeToCloseActiveSlide, swipeToCloseTimeStart;
pb.swipeCloseTouchStart = function (swiper, e) {
if (!allowSwipeToClose) return;
swipeToCloseIsTouched = true;
};
pb.swipeCloseTouchMove = function (swiper, e) {
if (!swipeToCloseIsTouched) return;
if (!swipeToCloseStarted) {
swipeToCloseStarted = true;
swipeToCloseStart = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
swipeToCloseActiveSlide = pb.swiper.slides.eq(pb.swiper.activeIndex);
swipeToCloseTimeStart = (new Date()).getTime();
}
e.preventDefault();
swipeToCloseCurrent = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
swipeToCloseDiff = swipeToCloseStart - swipeToCloseCurrent;
var opacity = 1 - Math.abs(swipeToCloseDiff) / 300;
swipeToCloseActiveSlide.transform('translate3d(0,' + (-swipeToCloseDiff) + 'px,0)');
pb.swiper.container.css('opacity', opacity).transition(0);
};
pb.swipeCloseTouchEnd = function (swiper, e) {
swipeToCloseIsTouched = false;
if (!swipeToCloseStarted) {
swipeToCloseStarted = false;
return;
}
swipeToCloseStarted = false;
allowSwipeToClose = false;
var diff = Math.abs(swipeToCloseDiff);
var timeDiff = (new Date()).getTime() - swipeToCloseTimeStart;
if ((timeDiff < 300 && diff > 20) || (timeDiff >= 300 && diff > 100)) {
setTimeout(function () {
if (pb.params.type === 'standalone') {
pb.close();
}
if (pb.params.type === 'popup') {
app.closeModal(pb.popup);
}
if (pb.params.onSwipeToClose) {
pb.params.onSwipeToClose(pb);
}
allowSwipeToClose = true;
}, 0);
return;
}
if (diff !== 0) {
swipeToCloseActiveSlide.addClass('transitioning').transitionEnd(function () {
allowSwipeToClose = true;
swipeToCloseActiveSlide.removeClass('transitioning');
});
}
else {
allowSwipeToClose = true;
}
pb.swiper.container.css('opacity', '').transition('');
swipeToCloseActiveSlide.transform('');
};
return pb;
};
app.photoBrowser = function (params) {
return new PhotoBrowser(params);
};
/*======================================================
************ Picker ************
======================================================*/
var Picker = function (params) {
var p = this;
var defaults = {
updateValuesOnMomentum: false,
updateValuesOnTouchmove: true,
rotateEffect: false,
momentumRatio: 7,
freeMode: false,
// Common settings
scrollToInput: true,
inputReadOnly: true,
convertToPopover: true,
onlyInPopover: false,
toolbar: true,
toolbarCloseText: 'Done',
toolbarTemplate:
'<div class="toolbar">' +
'<div class="toolbar-inner">' +
'<div class="left"></div>' +
'<div class="right">' +
'<a href="#" class="link close-picker">{{closeText}}</a>' +
'</div>' +
'</div>' +
'</div>'
};
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined') {
params[def] = defaults[def];
}
}
p.params = params;
p.cols = [];
p.initialized = false;
// Inline flag
p.inline = p.params.container ? true : false;
// 3D Transforms origin bug, only on safari
var originBug = app.device.ios || (navigator.userAgent.toLowerCase().indexOf('safari') >= 0 && navigator.userAgent.toLowerCase().indexOf('chrome') < 0) && !app.device.android;
// Should be converted to popover
function isPopover() {
var toPopover = false;
if (!p.params.convertToPopover && !p.params.onlyInPopover) return toPopover;
if (!p.inline && p.params.input) {
if (p.params.onlyInPopover) toPopover = true;
else {
if (app.device.ios) {
toPopover = app.device.ipad ? true : false;
}
else {
if ($(window).width() >= 768) toPopover = true;
}
}
}
return toPopover;
}
function inPopover() {
if (p.opened && p.container && p.container.length > 0 && p.container.parents('.popover').length > 0) return true;
else return false;
}
// Value
p.setValue = function (arrValues, transition) {
var valueIndex = 0;
for (var i = 0; i < p.cols.length; i++) {
if (p.cols[i] && !p.cols[i].divider) {
p.cols[i].setValue(arrValues[valueIndex], transition);
valueIndex++;
}
}
};
p.updateValue = function () {
var newValue = [];
var newDisplayValue = [];
for (var i = 0; i < p.cols.length; i++) {
if (!p.cols[i].divider) {
newValue.push(p.cols[i].value);
newDisplayValue.push(p.cols[i].displayValue);
}
}
if (newValue.indexOf(undefined) >= 0) {
return;
}
p.value = newValue;
p.displayValue = newDisplayValue;
if (p.params.onChange) {
p.params.onChange(p, p.value, p.displayValue);
}
if (p.input && p.input.length > 0) {
$(p.input).val(p.params.formatValue ? p.params.formatValue(p, p.value, p.displayValue) : p.value.join(' '));
$(p.input).trigger('change');
}
};
// Columns Handlers
p.initPickerCol = function (colElement, updateItems) {
var colContainer = $(colElement);
var colIndex = colContainer.index();
var col = p.cols[colIndex];
if (col.divider) return;
col.container = colContainer;
col.wrapper = col.container.find('.picker-items-col-wrapper');
col.items = col.wrapper.find('.picker-item');
var i, j;
var wrapperHeight, itemHeight, itemsHeight, minTranslate, maxTranslate;
col.replaceValues = function (values, displayValues) {
col.destroyEvents();
col.values = values;
col.displayValues = displayValues;
var newItemsHTML = p.columnHTML(col, true);
col.wrapper.html(newItemsHTML);
col.items = col.wrapper.find('.picker-item');
col.calcSize();
col.setValue(col.values[0], 0, true);
col.initEvents();
};
col.calcSize = function () {
if (p.params.rotateEffect) {
col.container.removeClass('picker-items-col-absolute');
if (!col.width) col.container.css({width:''});
}
var colWidth, colHeight;
colWidth = 0;
colHeight = col.container[0].offsetHeight;
wrapperHeight = col.wrapper[0].offsetHeight;
itemHeight = col.items[0].offsetHeight;
itemsHeight = itemHeight * col.items.length;
minTranslate = colHeight / 2 - itemsHeight + itemHeight / 2;
maxTranslate = colHeight / 2 - itemHeight / 2;
if (col.width) {
colWidth = col.width;
if (parseInt(colWidth, 10) === colWidth) colWidth = colWidth + 'px';
col.container.css({width: colWidth});
}
if (p.params.rotateEffect) {
if (!col.width) {
col.items.each(function () {
var item = $(this);
item.css({width:'auto'});
colWidth = Math.max(colWidth, item[0].offsetWidth);
item.css({width:''});
});
col.container.css({width: (colWidth + 2) + 'px'});
}
col.container.addClass('picker-items-col-absolute');
}
};
col.calcSize();
col.wrapper.transform('translate3d(0,' + maxTranslate + 'px,0)').transition(0);
var activeIndex = 0;
var animationFrameId;
// Set Value Function
col.setValue = function (newValue, transition, valueCallbacks) {
if (typeof transition === 'undefined') transition = '';
var newActiveIndex = col.wrapper.find('.picker-item[data-picker-value="' + newValue + '"]').index();
if(typeof newActiveIndex === 'undefined' || newActiveIndex === -1) {
return;
}
var newTranslate = -newActiveIndex * itemHeight + maxTranslate;
// Update wrapper
col.wrapper.transition(transition);
col.wrapper.transform('translate3d(0,' + (newTranslate) + 'px,0)');
// Watch items
if (p.params.updateValuesOnMomentum && col.activeIndex && col.activeIndex !== newActiveIndex ) {
$.cancelAnimationFrame(animationFrameId);
col.wrapper.transitionEnd(function(){
$.cancelAnimationFrame(animationFrameId);
});
updateDuringScroll();
}
// Update items
col.updateItems(newActiveIndex, newTranslate, transition, valueCallbacks);
};
col.updateItems = function (activeIndex, translate, transition, valueCallbacks) {
if (typeof translate === 'undefined') {
translate = $.getTranslate(col.wrapper[0], 'y');
}
if(typeof activeIndex === 'undefined') activeIndex = -Math.round((translate - maxTranslate)/itemHeight);
if (activeIndex < 0) activeIndex = 0;
if (activeIndex >= col.items.length) activeIndex = col.items.length - 1;
var previousActiveIndex = col.activeIndex;
col.activeIndex = activeIndex;
col.wrapper.find('.picker-selected, .picker-after-selected, .picker-before-selected').removeClass('picker-selected picker-after-selected picker-before-selected');
col.items.transition(transition);
var selectedItem = col.items.eq(activeIndex).addClass('picker-selected').transform('');
var prevItems = selectedItem.prevAll().addClass('picker-before-selected');
var nextItems = selectedItem.nextAll().addClass('picker-after-selected');
if (valueCallbacks || typeof valueCallbacks === 'undefined') {
// Update values
col.value = selectedItem.attr('data-picker-value');
col.displayValue = col.displayValues ? col.displayValues[activeIndex] : col.value;
// On change callback
if (previousActiveIndex !== activeIndex) {
if (col.onChange) {
col.onChange(p, col.value, col.displayValue);
}
p.updateValue();
}
}
// Set 3D rotate effect
if (!p.params.rotateEffect) {
return;
}
var percentage = (translate - (Math.floor((translate - maxTranslate)/itemHeight) * itemHeight + maxTranslate)) / itemHeight;
col.items.each(function () {
var item = $(this);
var itemOffsetTop = item.index() * itemHeight;
var translateOffset = maxTranslate - translate;
var itemOffset = itemOffsetTop - translateOffset;
var percentage = itemOffset / itemHeight;
var itemsFit = Math.ceil(col.height / itemHeight / 2) + 1;
var angle = (-18*percentage);
if (angle > 180) angle = 180;
if (angle < -180) angle = -180;
// Far class
if (Math.abs(percentage) > itemsFit) item.addClass('picker-item-far');
else item.removeClass('picker-item-far');
// Set transform
item.transform('translate3d(0, ' + (-translate + maxTranslate) + 'px, ' + (originBug ? -110 : 0) + 'px) rotateX(' + angle + 'deg)');
});
};
function updateDuringScroll() {
animationFrameId = $.requestAnimationFrame(function () {
col.updateItems(undefined, undefined, 0);
updateDuringScroll();
});
}
// Update items on init
if (updateItems) col.updateItems(0, maxTranslate, 0);
var allowItemClick = true;
var isTouched, isMoved, touchStartY, touchCurrentY, touchStartTime, touchEndTime, startTranslate, returnTo, currentTranslate, prevTranslate, velocityTranslate, velocityTime;
function handleTouchStart (e) {
if (isMoved || isTouched) return;
e.preventDefault();
isTouched = true;
touchStartY = touchCurrentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
touchStartTime = (new Date()).getTime();
allowItemClick = true;
startTranslate = currentTranslate = $.getTranslate(col.wrapper[0], 'y');
}
function handleTouchMove (e) {
if (!isTouched) return;
e.preventDefault();
allowItemClick = false;
touchCurrentY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (!isMoved) {
// First move
$.cancelAnimationFrame(animationFrameId);
isMoved = true;
startTranslate = currentTranslate = $.getTranslate(col.wrapper[0], 'y');
col.wrapper.transition(0);
}
e.preventDefault();
var diff = touchCurrentY - touchStartY;
currentTranslate = startTranslate + diff;
returnTo = undefined;
// Normalize translate
if (currentTranslate < minTranslate) {
currentTranslate = minTranslate - Math.pow(minTranslate - currentTranslate, 0.8);
returnTo = 'min';
}
if (currentTranslate > maxTranslate) {
currentTranslate = maxTranslate + Math.pow(currentTranslate - maxTranslate, 0.8);
returnTo = 'max';
}
// Transform wrapper
col.wrapper.transform('translate3d(0,' + currentTranslate + 'px,0)');
// Update items
col.updateItems(undefined, currentTranslate, 0, p.params.updateValuesOnTouchmove);
// Calc velocity
velocityTranslate = currentTranslate - prevTranslate || currentTranslate;
velocityTime = (new Date()).getTime();
prevTranslate = currentTranslate;
}
function handleTouchEnd (e) {
if (!isTouched || !isMoved) {
isTouched = isMoved = false;
return;
}
isTouched = isMoved = false;
col.wrapper.transition('');
if (returnTo) {
if (returnTo === 'min') {
col.wrapper.transform('translate3d(0,' + minTranslate + 'px,0)');
}
else col.wrapper.transform('translate3d(0,' + maxTranslate + 'px,0)');
}
touchEndTime = new Date().getTime();
var velocity, newTranslate;
if (touchEndTime - touchStartTime > 300) {
newTranslate = currentTranslate;
}
else {
velocity = Math.abs(velocityTranslate / (touchEndTime - velocityTime));
newTranslate = currentTranslate + velocityTranslate * p.params.momentumRatio;
}
newTranslate = Math.max(Math.min(newTranslate, maxTranslate), minTranslate);
// Active Index
var activeIndex = -Math.floor((newTranslate - maxTranslate)/itemHeight);
// Normalize translate
if (!p.params.freeMode) newTranslate = -activeIndex * itemHeight + maxTranslate;
// Transform wrapper
col.wrapper.transform('translate3d(0,' + (parseInt(newTranslate,10)) + 'px,0)');
// Update items
col.updateItems(activeIndex, newTranslate, '', true);
// Watch items
if (p.params.updateValuesOnMomentum) {
updateDuringScroll();
col.wrapper.transitionEnd(function(){
$.cancelAnimationFrame(animationFrameId);
});
}
// Allow click
setTimeout(function () {
allowItemClick = true;
}, 100);
}
function handleClick(e) {
if (!allowItemClick) return;
$.cancelAnimationFrame(animationFrameId);
/*jshint validthis:true */
var value = $(this).attr('data-picker-value');
col.setValue(value);
}
col.initEvents = function (detach) {
var method = detach ? 'off' : 'on';
col.container[method](app.touchEvents.start, handleTouchStart);
col.container[method](app.touchEvents.move, handleTouchMove);
col.container[method](app.touchEvents.end, handleTouchEnd);
col.items[method]('click', handleClick);
};
col.destroyEvents = function () {
col.initEvents(true);
};
col.container[0].f7DestroyPickerCol = function () {
col.destroyEvents();
};
col.initEvents();
};
p.destroyPickerCol = function (colContainer) {
colContainer = $(colContainer);
if ('f7DestroyPickerCol' in colContainer[0]) colContainer[0].f7DestroyPickerCol();
};
// Resize cols
function resizeCols() {
if (!p.opened) return;
for (var i = 0; i < p.cols.length; i++) {
if (!p.cols[i].divider) {
p.cols[i].calcSize();
p.cols[i].setValue(p.cols[i].value, 0, false);
}
}
}
$(window).on('resize', resizeCols);
// HTML Layout
p.columnHTML = function (col, onlyItems) {
var columnItemsHTML = '';
var columnHTML = '';
if (col.divider) {
columnHTML += '<div class="picker-items-col picker-items-col-divider ' + (col.textAlign ? 'picker-items-col-' + col.textAlign : '') + ' ' + (col.cssClass || '') + '">' + col.content + '</div>';
}
else {
for (var j = 0; j < col.values.length; j++) {
columnItemsHTML += '<div class="picker-item" data-picker-value="' + col.values[j] + '">' + (col.displayValues ? col.displayValues[j] : col.values[j]) + '</div>';
}
columnHTML += '<div class="picker-items-col ' + (col.textAlign ? 'picker-items-col-' + col.textAlign : '') + ' ' + (col.cssClass || '') + '"><div class="picker-items-col-wrapper">' + columnItemsHTML + '</div></div>';
}
return onlyItems ? columnItemsHTML : columnHTML;
};
p.layout = function () {
var pickerHTML = '';
var pickerClass = '';
var i;
p.cols = [];
var colsHTML = '';
for (i = 0; i < p.params.cols.length; i++) {
var col = p.params.cols[i];
colsHTML += p.columnHTML(p.params.cols[i]);
p.cols.push(col);
}
pickerClass = 'picker-modal picker-columns ' + (p.params.cssClass || '') + (p.params.rotateEffect ? ' picker-3d' : '');
pickerHTML =
'<div class="' + (pickerClass) + '">' +
(p.params.toolbar ? p.params.toolbarTemplate.replace(/{{closeText}}/g, p.params.toolbarCloseText) : '') +
'<div class="picker-modal-inner picker-items">' +
colsHTML +
'<div class="picker-center-highlight"></div>' +
'</div>' +
'</div>';
p.pickerHTML = pickerHTML;
};
// Input Events
function openOnInput(e) {
e.preventDefault();
if (p.opened) return;
p.open();
if (p.params.scrollToInput && !isPopover()) {
var pageContent = p.input.parents('.page-content');
if (pageContent.length === 0) return;
var paddingTop = parseInt(pageContent.css('padding-top'), 10),
paddingBottom = parseInt(pageContent.css('padding-bottom'), 10),
pageHeight = pageContent[0].offsetHeight - paddingTop - p.container.height(),
pageScrollHeight = pageContent[0].scrollHeight - paddingTop - p.container.height(),
newPaddingBottom;
var inputTop = p.input.offset().top - paddingTop + p.input[0].offsetHeight;
if (inputTop > pageHeight) {
var scrollTop = pageContent.scrollTop() + inputTop - pageHeight;
if (scrollTop + pageHeight > pageScrollHeight) {
newPaddingBottom = scrollTop + pageHeight - pageScrollHeight + paddingBottom;
if (pageHeight === pageScrollHeight) {
newPaddingBottom = p.container.height();
}
pageContent.css({'padding-bottom': (newPaddingBottom) + 'px'});
}
pageContent.scrollTop(scrollTop, 300);
}
}
}
function closeOnHTMLClick(e) {
if (inPopover()) return;
if (p.input && p.input.length > 0) {
if (e.target !== p.input[0] && $(e.target).parents('.picker-modal').length === 0) p.close();
}
else {
if ($(e.target).parents('.picker-modal').length === 0) p.close();
}
}
if (p.params.input) {
p.input = $(p.params.input);
if (p.input.length > 0) {
if (p.params.inputReadOnly) p.input.prop('readOnly', true);
if (!p.inline) {
p.input.on('click', openOnInput);
}
if (p.params.inputReadOnly) {
p.input.on('focus mousedown', function (e) {
e.preventDefault();
});
}
}
}
if (!p.inline) $('html').on('click', closeOnHTMLClick);
// Open
function onPickerClose() {
p.opened = false;
if (p.input && p.input.length > 0) p.input.parents('.page-content').css({'padding-bottom': ''});
if (p.params.onClose) p.params.onClose(p);
// Destroy events
p.container.find('.picker-items-col').each(function () {
p.destroyPickerCol(this);
});
}
p.opened = false;
p.open = function () {
var toPopover = isPopover();
if (!p.opened) {
// Layout
p.layout();
// Append
if (toPopover) {
p.pickerHTML = '<div class="popover popover-picker-columns"><div class="popover-inner">' + p.pickerHTML + '</div></div>';
p.popover = app.popover(p.pickerHTML, p.params.input, true);
p.container = $(p.popover).find('.picker-modal');
$(p.popover).on('close', function () {
onPickerClose();
});
}
else if (p.inline) {
p.container = $(p.pickerHTML);
p.container.addClass('picker-modal-inline');
$(p.params.container).append(p.container);
}
else {
p.container = $(app.pickerModal(p.pickerHTML));
$(p.container)
.on('close', function () {
onPickerClose();
});
}
// Store picker instance
p.container[0].f7Picker = p;
// Init Events
p.container.find('.picker-items-col').each(function () {
var updateItems = true;
if ((!p.initialized && p.params.value) || (p.initialized && p.value)) updateItems = false;
p.initPickerCol(this, updateItems);
});
// Set value
if (!p.initialized) {
if (p.params.value) {
p.setValue(p.params.value, 0);
}
}
else {
if (p.value) p.setValue(p.value, 0);
}
}
// Set flag
p.opened = true;
p.initialized = true;
if (p.params.onOpen) p.params.onOpen(p);
};
// Close
p.close = function () {
if (!p.opened || p.inline) return;
if (inPopover()) {
app.closeModal(p.popover);
return;
}
else {
app.closeModal(p.container);
return;
}
};
// Destroy
p.destroy = function () {
p.close();
if (p.params.input && p.input.length > 0) {
p.input.off('click focus', openOnInput);
}
$('html').off('click', closeOnHTMLClick);
$(window).off('resize', resizeCols);
};
if (p.inline) {
p.open();
}
return p;
};
app.picker = function (params) {
return new Picker(params);
};
/*======================================================
************ Calendar ************
======================================================*/
var Calendar = function (params) {
var p = this;
var defaults = {
monthNames: ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August' , 'September' , 'October', 'November', 'December'],
monthNamesShort: ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'],
dayNames: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
dayNamesShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
firstDay: 1, // First day of the week, Monday
weekendDays: [0, 6], // Sunday and Saturday
multiple: false,
dateFormat: 'yyyy-mm-dd',
direction: 'horizontal', // or 'vertical'
minDate: null,
maxDate: null,
touchMove: true,
animate: true,
closeOnSelect: false,
monthPicker: true,
monthPickerTemplate:
'<div class="picker-calendar-month-picker">' +
'<a href="#" class="link icon-only picker-calendar-prev-month"><i class="icon icon-prev"></i></a>' +
'<span class="current-month-value"></span>' +
'<a href="#" class="link icon-only picker-calendar-next-month"><i class="icon icon-next"></i></a>' +
'</div>',
yearPicker: true,
yearPickerTemplate:
'<div class="picker-calendar-year-picker">' +
'<a href="#" class="link icon-only picker-calendar-prev-year"><i class="icon icon-prev"></i></a>' +
'<span class="current-year-value"></span>' +
'<a href="#" class="link icon-only picker-calendar-next-year"><i class="icon icon-next"></i></a>' +
'</div>',
weekHeader: true,
// Common settings
scrollToInput: true,
inputReadOnly: true,
convertToPopover: true,
onlyInPopover: false,
toolbar: true,
toolbarCloseText: 'Done',
toolbarTemplate:
'<div class="toolbar">' +
'<div class="toolbar-inner">' +
'{{monthPicker}}' +
'{{yearPicker}}' +
// '<a href="#" class="link close-picker">{{closeText}}</a>' +
'</div>' +
'</div>',
/* Callbacks
onMonthAdd
onChange
onOpen
onClose
onDayClick
onMonthYearChangeStart
onMonthYearChangeEnd
*/
};
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined') {
params[def] = defaults[def];
}
}
p.params = params;
p.initialized = false;
// Inline flag
p.inline = p.params.container ? true : false;
// Is horizontal
p.isH = p.params.direction === 'horizontal';
// RTL inverter
var inverter = p.isH ? (app.rtl ? -1 : 1) : 1;
// Animating flag
p.animating = false;
// Should be converted to popover
function isPopover() {
var toPopover = false;
if (!p.params.convertToPopover && !p.params.onlyInPopover) return toPopover;
if (!p.inline && p.params.input) {
if (p.params.onlyInPopover) toPopover = true;
else {
if (app.device.ios) {
toPopover = app.device.ipad ? true : false;
}
else {
if ($(window).width() >= 768) toPopover = true;
}
}
}
return toPopover;
}
function inPopover() {
if (p.opened && p.container && p.container.length > 0 && p.container.parents('.popover').length > 0) return true;
else return false;
}
// Format date
function formatDate(date) {
date = new Date(date);
var year = date.getFullYear();
var month = date.getMonth();
var month1 = month + 1;
var day = date.getDate();
var weekDay = date.getDay();
return p.params.dateFormat
.replace(/yyyy/g, year)
.replace(/yy/g, (year + '').substring(2))
.replace(/mm/g, month1 < 10 ? '0' + month1 : month1)
.replace(/m/g, month1)
.replace(/MM/g, p.params.monthNames[month])
.replace(/M/g, p.params.monthNamesShort[month])
.replace(/dd/g, day < 10 ? '0' + day : day)
.replace(/d/g, day)
.replace(/DD/g, p.params.dayNames[weekDay])
.replace(/D/g, p.params.dayNamesShort[weekDay]);
}
// Value
p.addValue = function (value) {
if (p.params.multiple) {
if (!p.value) p.value = [];
var inValuesIndex;
for (var i = 0; i < p.value.length; i++) {
if (new Date(value).getTime() === new Date(p.value[i]).getTime()) {
inValuesIndex = i;
}
}
if (typeof inValuesIndex === 'undefined') {
p.value.push(value);
}
else {
p.value.splice(inValuesIndex, 1);
}
p.updateValue();
}
else {
p.value = [value];
p.updateValue();
}
};
p.setValue = function (arrValues) {
p.value = arrValues;
p.updateValue();
};
p.updateValue = function () {
p.wrapper.find('.picker-calendar-day-selected').removeClass('picker-calendar-day-selected');
var i, inputValue;
for (i = 0; i < p.value.length; i++) {
var valueDate = new Date(p.value[i]);
p.wrapper.find('.picker-calendar-day[data-date="' + valueDate.getFullYear() + '-' + valueDate.getMonth() + '-' + valueDate.getDate() + '"]').addClass('picker-calendar-day-selected');
}
if (p.params.onChange) {
p.params.onChange(p, p.value);
}
if (p.input && p.input.length > 0) {
if (p.params.formatValue) inputValue = p.params.formatValue(p, p.value);
else {
inputValue = [];
for (i = 0; i < p.value.length; i++) {
inputValue.push(formatDate(p.value[i]));
}
inputValue = inputValue.join(', ');
}
$(p.input).val(inputValue);
$(p.input).trigger('change');
}
};
// Columns Handlers
p.initCalendarEvents = function () {
var col;
var allowItemClick = true;
var isTouched, isMoved, touchStartX, touchStartY, touchCurrentX, touchCurrentY, touchStartTime, touchEndTime, startTranslate, currentTranslate, wrapperWidth, wrapperHeight, percentage, touchesDiff, isScrolling;
function handleTouchStart (e) {
if (isMoved || isTouched) return;
// e.preventDefault();
isTouched = true;
touchStartX = touchCurrentY = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
touchStartY = touchCurrentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
touchStartTime = (new Date()).getTime();
percentage = 0;
allowItemClick = true;
isScrolling = undefined;
startTranslate = currentTranslate = p.monthsTranslate;
}
function handleTouchMove (e) {
if (!isTouched) return;
touchCurrentX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
touchCurrentY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (typeof isScrolling === 'undefined') {
isScrolling = !!(isScrolling || Math.abs(touchCurrentY - touchStartY) > Math.abs(touchCurrentX - touchStartX));
}
if (p.isH && isScrolling) {
isTouched = false;
return;
}
e.preventDefault();
if (p.animating) {
isTouched = false;
return;
}
allowItemClick = false;
if (!isMoved) {
// First move
isMoved = true;
wrapperWidth = p.wrapper[0].offsetWidth;
wrapperHeight = p.wrapper[0].offsetHeight;
p.wrapper.transition(0);
}
e.preventDefault();
touchesDiff = p.isH ? touchCurrentX - touchStartX : touchCurrentY - touchStartY;
percentage = touchesDiff/(p.isH ? wrapperWidth : wrapperHeight);
currentTranslate = (p.monthsTranslate * inverter + percentage) * 100;
// Transform wrapper
p.wrapper.transform('translate3d(' + (p.isH ? currentTranslate : 0) + '%, ' + (p.isH ? 0 : currentTranslate) + '%, 0)');
}
function handleTouchEnd (e) {
if (!isTouched || !isMoved) {
isTouched = isMoved = false;
return;
}
isTouched = isMoved = false;
touchEndTime = new Date().getTime();
if (touchEndTime - touchStartTime < 300) {
if (Math.abs(touchesDiff) < 10) {
p.resetMonth();
}
else if (touchesDiff >= 10) {
if (app.rtl) p.nextMonth();
else p.prevMonth();
}
else {
if (app.rtl) p.prevMonth();
else p.nextMonth();
}
}
else {
if (percentage <= -0.5) {
if (app.rtl) p.prevMonth();
else p.nextMonth();
}
else if (percentage >= 0.5) {
if (app.rtl) p.nextMonth();
else p.prevMonth();
}
else {
p.resetMonth();
}
}
// Allow click
setTimeout(function () {
allowItemClick = true;
}, 100);
}
function handleDayClick(e) {
if (!allowItemClick) return;
var day = $(e.target).parents('.picker-calendar-day');
if (day.length === 0 && $(e.target).hasClass('picker-calendar-day')) {
day = $(e.target);
}
if (day.length === 0) return;
if (day.hasClass('picker-calendar-day-selected') && !p.params.multiple) return;
if (day.hasClass('picker-calendar-day-disabled')) return;
if (day.hasClass('picker-calendar-day-next')) p.nextMonth();
if (day.hasClass('picker-calendar-day-prev')) p.prevMonth();
var dateYear = day.attr('data-year');
var dateMonth = day.attr('data-month');
var dateDay = day.attr('data-day');
if (p.params.onDayClick) {
p.params.onDayClick(p, day[0], dateYear, dateMonth, dateDay);
}
p.addValue(new Date(dateYear, dateMonth, dateDay).getTime());
if (p.params.closeOnSelect) p.close();
}
p.container.find('.picker-calendar-prev-month').on('click', p.prevMonth);
p.container.find('.picker-calendar-next-month').on('click', p.nextMonth);
p.container.find('.picker-calendar-prev-year').on('click', p.prevYear);
p.container.find('.picker-calendar-next-year').on('click', p.nextYear);
p.wrapper.on('click', handleDayClick);
if (p.params.touchMove) {
p.wrapper.on(app.touchEvents.start, handleTouchStart);
p.wrapper.on(app.touchEvents.move, handleTouchMove);
p.wrapper.on(app.touchEvents.end, handleTouchEnd);
}
p.container[0].f7DestroyCalendarEvents = function () {
p.container.find('.picker-calendar-prev-month').off('click', p.prevMonth);
p.container.find('.picker-calendar-next-month').off('click', p.nextMonth);
p.container.find('.picker-calendar-prev-year').off('click', p.prevYear);
p.container.find('.picker-calendar-next-year').off('click', p.nextYear);
p.wrapper.off('click', handleDayClick);
if (p.params.touchMove) {
p.wrapper.off(app.touchEvents.start, handleTouchStart);
p.wrapper.off(app.touchEvents.move, handleTouchMove);
p.wrapper.off(app.touchEvents.end, handleTouchEnd);
}
};
};
p.destroyCalendarEvents = function (colContainer) {
if ('f7DestroyCalendarEvents' in p.container[0]) p.container[0].f7DestroyCalendarEvents();
};
// Calendar Methods
p.daysInMonth = function (date) {
var d = new Date(date);
return new Date(d.getFullYear(), d.getMonth() + 1, 0).getDate();
};
p.monthHTML = function (date, offset) {
date = new Date(date);
var year = date.getFullYear(),
month = date.getMonth(),
day = date.getDate();
if (offset === 'next') {
if (month === 11) date = new Date(year + 1, 0);
else date = new Date(year, month + 1, 1);
}
if (offset === 'prev') {
if (month === 0) date = new Date(year - 1, 11);
else date = new Date(year, month - 1, 1);
}
if (offset === 'next' || offset === 'prev') {
month = date.getMonth();
year = date.getFullYear();
}
var daysInPrevMonth = p.daysInMonth(new Date(date.getFullYear(), date.getMonth()).getTime() - 10 * 24 * 60 * 60 * 1000),
daysInMonth = p.daysInMonth(date),
firstDayOfMonthIndex = new Date(date.getFullYear(), date.getMonth()).getDay();
if (firstDayOfMonthIndex === 0) firstDayOfMonthIndex = 7;
var dayDate, currentValues = [], i, j,
rows = 6, cols = 7,
monthHTML = '',
dayIndex = 0 + (p.params.firstDay - 1),
today = new Date().setHours(0,0,0,0),
minDate = p.params.minDate ? new Date(p.params.minDate).getTime() : null,
maxDate = p.params.maxDate ? new Date(p.params.maxDate).getTime() : null;
if (p.value && p.value.length) {
for (i = 0; i < p.value.length; i++) {
currentValues.push(new Date(p.value[i]).setHours(0,0,0,0));
}
}
for (i = 1; i <= rows; i++) {
var rowHTML = '';
var row = i;
for (j = 1; j <= cols; j++) {
var col = j;
dayIndex ++;
var dayNumber = dayIndex - firstDayOfMonthIndex;
var addClass = '';
if (dayNumber < 0) {
dayNumber = daysInPrevMonth + dayNumber + 1;
addClass += ' picker-calendar-day-prev';
dayDate = new Date(month - 1 < 0 ? year - 1 : year, month - 1 < 0 ? 11 : month - 1, dayNumber).getTime();
}
else {
dayNumber = dayNumber + 1;
if (dayNumber > daysInMonth) {
dayNumber = dayNumber - daysInMonth;
addClass += ' picker-calendar-day-next';
dayDate = new Date(month + 1 > 11 ? year + 1 : year, month + 1 > 11 ? 0 : month + 1, dayNumber).getTime();
}
else {
dayDate = new Date(year, month, dayNumber).getTime();
}
}
// Today
if (dayDate === today) addClass += ' picker-calendar-day-today';
// Selected
if (currentValues.indexOf(dayDate) >= 0) addClass += ' picker-calendar-day-selected';
// Weekend
if (p.params.weekendDays.indexOf(col - 1) >= 0) {
addClass += ' picker-calendar-day-weekend';
}
// Disabled
if ((minDate && dayDate < minDate) || (maxDate && dayDate > maxDate)) {
addClass += ' picker-calendar-day-disabled';
}
dayDate = new Date(dayDate);
var dayYear = dayDate.getFullYear();
var dayMonth = dayDate.getMonth();
rowHTML += '<div data-year="' + dayYear + '" data-month="' + dayMonth + '" data-day="' + dayNumber + '" class="picker-calendar-day' + (addClass) + '" data-date="' + (dayYear + '-' + dayMonth + '-' + dayNumber) + '"><span>'+dayNumber+'</span></div>';
}
monthHTML += '<div class="picker-calendar-row">' + rowHTML + '</div>';
}
monthHTML = '<div class="picker-calendar-month" data-year="' + year + '" data-month="' + month + '">' + monthHTML + '</div>';
return monthHTML;
};
p.animating = false;
p.updateCurrentMonthYear = function (dir) {
if (typeof dir === 'undefined') {
p.currentMonth = parseInt(p.months.eq(1).attr('data-month'), 10);
p.currentYear = parseInt(p.months.eq(1).attr('data-year'), 10);
}
else {
p.currentMonth = parseInt(p.months.eq(dir === 'next' ? (p.months.length - 1) : 0).attr('data-month'), 10);
p.currentYear = parseInt(p.months.eq(dir === 'next' ? (p.months.length - 1) : 0).attr('data-year'), 10);
}
p.container.find('.current-month-value').text(p.params.monthNames[p.currentMonth]);
p.container.find('.current-year-value').text(p.currentYear);
};
p.onMonthChangeStart = function (dir) {
p.updateCurrentMonthYear(dir);
p.months.removeClass('picker-calendar-month-current picker-calendar-month-prev picker-calendar-month-next');
var currentIndex = dir === 'next' ? p.months.length - 1 : 0;
p.months.eq(currentIndex).addClass('picker-calendar-month-current');
p.months.eq(dir === 'next' ? currentIndex - 1 : currentIndex + 1).addClass(dir === 'next' ? 'picker-calendar-month-prev' : 'picker-calendar-month-next');
if (p.params.onMonthYearChangeStart) {
p.params.onMonthYearChangeStart(p, p.currentYear, p.currentMonth);
}
};
p.onMonthChangeEnd = function (dir, rebuildBoth) {
p.animating = false;
var nextMonthHTML, prevMonthHTML, newMonthHTML;
p.wrapper.find('.picker-calendar-month:not(.picker-calendar-month-prev):not(.picker-calendar-month-current):not(.picker-calendar-month-next)').remove();
if (typeof dir === 'undefined') {
dir = 'next';
rebuildBoth = true;
}
if (!rebuildBoth) {
newMonthHTML = p.monthHTML(new Date(p.currentYear, p.currentMonth), dir);
}
else {
p.wrapper.find('.picker-calendar-month-next, .picker-calendar-month-prev').remove();
prevMonthHTML = p.monthHTML(new Date(p.currentYear, p.currentMonth), 'prev');
nextMonthHTML = p.monthHTML(new Date(p.currentYear, p.currentMonth), 'next');
}
if (dir === 'next' || rebuildBoth) {
p.wrapper.append(newMonthHTML || nextMonthHTML);
}
if (dir === 'prev' || rebuildBoth) {
p.wrapper.prepend(newMonthHTML || prevMonthHTML);
}
p.months = p.wrapper.find('.picker-calendar-month');
p.setMonthsTranslate(p.monthsTranslate);
if (p.params.onMonthAdd) {
p.params.onMonthAdd(p, dir === 'next' ? p.months.eq(p.months.length - 1)[0] : p.months.eq(0)[0]);
}
if (p.params.onMonthYearChangeEnd) {
p.params.onMonthYearChangeEnd(p, p.currentYear, p.currentMonth);
}
};
p.setMonthsTranslate = function (translate) {
translate = translate || p.monthsTranslate || 0;
if (typeof p.monthsTranslate === 'undefined') p.monthsTranslate = translate;
p.months.removeClass('picker-calendar-month-current picker-calendar-month-prev picker-calendar-month-next');
var prevMonthTranslate = -(translate + 1) * 100 * inverter;
var currentMonthTranslate = -translate * 100 * inverter;
var nextMonthTranslate = -(translate - 1) * 100 * inverter;
p.months.eq(0).transform('translate3d(' + (p.isH ? prevMonthTranslate : 0) + '%, ' + (p.isH ? 0 : prevMonthTranslate) + '%, 0)').addClass('picker-calendar-month-prev');
p.months.eq(1).transform('translate3d(' + (p.isH ? currentMonthTranslate : 0) + '%, ' + (p.isH ? 0 : currentMonthTranslate) + '%, 0)').addClass('picker-calendar-month-current');
p.months.eq(2).transform('translate3d(' + (p.isH ? nextMonthTranslate : 0) + '%, ' + (p.isH ? 0 : nextMonthTranslate) + '%, 0)').addClass('picker-calendar-month-next');
};
p.nextMonth = function (transition) {
if (typeof transition === 'undefined' || typeof transition === 'object') {
transition = '';
if (!p.params.animate) transition = 0;
}
var nextMonth = parseInt(p.months.eq(p.months.length - 1).attr('data-month'), 10);
var nextYear = parseInt(p.months.eq(p.months.length - 1).attr('data-year'), 10);
var nextDate = new Date(nextYear, nextMonth);
var nextDateTime = nextDate.getTime();
var transitionEndCallback = p.animating ? false : true;
if (p.params.maxDate) {
if (nextDateTime > new Date(p.params.maxDate).getTime()) {
return p.resetMonth();
}
}
p.monthsTranslate --;
if (nextMonth === p.currentMonth) {
var nextMonthTranslate = -(p.monthsTranslate) * 100 * inverter;
var nextMonthHTML = $(p.monthHTML(nextDateTime, 'next')).transform('translate3d(' + (p.isH ? nextMonthTranslate : 0) + '%, ' + (p.isH ? 0 : nextMonthTranslate) + '%, 0)').addClass('picker-calendar-month-next');
p.wrapper.append(nextMonthHTML[0]);
p.months = p.wrapper.find('.picker-calendar-month');
if (p.params.onMonthAdd) {
p.params.onMonthAdd(p, p.months.eq(p.months.length - 1)[0]);
}
}
p.animating = true;
p.onMonthChangeStart('next');
var translate = (p.monthsTranslate * 100) * inverter;
p.wrapper.transition(transition).transform('translate3d(' + (p.isH ? translate : 0) + '%, ' + (p.isH ? 0 : translate) + '%, 0)');
if (transitionEndCallback) {
p.wrapper.transitionEnd(function () {
p.onMonthChangeEnd('next');
});
}
if (!p.params.animate) {
p.onMonthChangeEnd('next');
}
};
p.prevMonth = function (transition) {
if (typeof transition === 'undefined' || typeof transition === 'object') {
transition = '';
if (!p.params.animate) transition = 0;
}
var prevMonth = parseInt(p.months.eq(0).attr('data-month'), 10);
var prevYear = parseInt(p.months.eq(0).attr('data-year'), 10);
var prevDate = new Date(prevYear, prevMonth + 1, -1);
var prevDateTime = prevDate.getTime();
var transitionEndCallback = p.animating ? false : true;
if (p.params.minDate) {
if (prevDateTime < new Date(p.params.minDate).getTime()) {
return p.resetMonth();
}
}
p.monthsTranslate ++;
if (prevMonth === p.currentMonth) {
var prevMonthTranslate = -(p.monthsTranslate) * 100 * inverter;
var prevMonthHTML = $(p.monthHTML(prevDateTime, 'prev')).transform('translate3d(' + (p.isH ? prevMonthTranslate : 0) + '%, ' + (p.isH ? 0 : prevMonthTranslate) + '%, 0)').addClass('picker-calendar-month-prev');
p.wrapper.prepend(prevMonthHTML[0]);
p.months = p.wrapper.find('.picker-calendar-month');
if (p.params.onMonthAdd) {
p.params.onMonthAdd(p, p.months.eq(0)[0]);
}
}
p.animating = true;
p.onMonthChangeStart('prev');
var translate = (p.monthsTranslate * 100) * inverter;
p.wrapper.transition(transition).transform('translate3d(' + (p.isH ? translate : 0) + '%, ' + (p.isH ? 0 : translate) + '%, 0)');
if (transitionEndCallback) {
p.wrapper.transitionEnd(function () {
p.onMonthChangeEnd('prev');
});
}
if (!p.params.animate) {
p.onMonthChangeEnd('prev');
}
};
p.resetMonth = function (transition) {
if (typeof transition === 'undefined') transition = '';
var translate = (p.monthsTranslate * 100) * inverter;
p.wrapper.transition(transition).transform('translate3d(' + (p.isH ? translate : 0) + '%, ' + (p.isH ? 0 : translate) + '%, 0)');
};
p.setYearMonth = function (year, month, transition) {
if (typeof year === 'undefined') year = p.currentYear;
if (typeof month === 'undefined') month = p.currentMonth;
if (typeof transition === 'undefined' || typeof transition === 'object') {
transition = '';
if (!p.params.animate) transition = 0;
}
var targetDate;
if (year < p.currentYear) {
targetDate = new Date(year, month + 1, -1).getTime();
}
else {
targetDate = new Date(year, month).getTime();
}
if (p.params.maxDate && targetDate > new Date(p.params.maxDate).getTime()) {
return false;
}
if (p.params.minDate && targetDate < new Date(p.params.minDate).getTime()) {
return false;
}
var currentDate = new Date(p.currentYear, p.currentMonth).getTime();
var dir = targetDate > currentDate ? 'next' : 'prev';
var newMonthHTML = p.monthHTML(new Date(year, month));
p.monthsTranslate = p.monthsTranslate || 0;
var prevTranslate = p.monthsTranslate;
var monthTranslate, wrapperTranslate;
var transitionEndCallback = p.animating ? false : true;
if (targetDate > currentDate) {
// To next
p.monthsTranslate --;
if (!p.animating) p.months.eq(p.months.length - 1).remove();
p.wrapper.append(newMonthHTML);
p.months = p.wrapper.find('.picker-calendar-month');
monthTranslate = -(prevTranslate - 1) * 100 * inverter;
p.months.eq(p.months.length - 1).transform('translate3d(' + (p.isH ? monthTranslate : 0) + '%, ' + (p.isH ? 0 : monthTranslate) + '%, 0)').addClass('picker-calendar-month-next');
}
else {
// To prev
p.monthsTranslate ++;
if (!p.animating) p.months.eq(0).remove();
p.wrapper.prepend(newMonthHTML);
p.months = p.wrapper.find('.picker-calendar-month');
monthTranslate = -(prevTranslate + 1) * 100 * inverter;
p.months.eq(0).transform('translate3d(' + (p.isH ? monthTranslate : 0) + '%, ' + (p.isH ? 0 : monthTranslate) + '%, 0)').addClass('picker-calendar-month-prev');
}
if (p.params.onMonthAdd) {
p.params.onMonthAdd(p, dir === 'next' ? p.months.eq(p.months.length - 1)[0] : p.months.eq(0)[0]);
}
p.animating = true;
p.onMonthChangeStart(dir);
wrapperTranslate = (p.monthsTranslate * 100) * inverter;
p.wrapper.transition(transition).transform('translate3d(' + (p.isH ? wrapperTranslate : 0) + '%, ' + (p.isH ? 0 : wrapperTranslate) + '%, 0)');
if (transitionEndCallback) {
p.wrapper.transitionEnd(function () {
p.onMonthChangeEnd(dir, true);
});
}
if (!p.params.animate) {
p.onMonthChangeEnd(dir);
}
};
p.nextYear = function () {
p.setYearMonth(p.currentYear + 1);
};
p.prevYear = function () {
p.setYearMonth(p.currentYear - 1);
};
// HTML Layout
p.layout = function () {
var pickerHTML = '';
var pickerClass = '';
var i;
var layoutDate = p.value && p.value.length ? p.value[0] : new Date().setHours(0,0,0,0);
var prevMonthHTML = p.monthHTML(layoutDate, 'prev');
var currentMonthHTML = p.monthHTML(layoutDate);
var nextMonthHTML = p.monthHTML(layoutDate, 'next');
var monthsHTML = '<div class="picker-calendar-months"><div class="picker-calendar-months-wrapper">' + (prevMonthHTML + currentMonthHTML + nextMonthHTML) + '</div></div>';
// Week days header
var weekHeaderHTML = '';
if (p.params.weekHeader) {
for (i = 0; i < 7; i++) {
var weekDayIndex = (i + p.params.firstDay > 6) ? (i - 7 + p.params.firstDay) : (i + p.params.firstDay);
var dayName = p.params.dayNamesShort[weekDayIndex];
weekHeaderHTML += '<div class="picker-calendar-week-day ' + ((p.params.weekendDays.indexOf(weekDayIndex) >= 0) ? 'picker-calendar-week-day-weekend' : '') + '"> ' + dayName + '</div>';
}
weekHeaderHTML = '<div class="picker-calendar-week-days">' + weekHeaderHTML + '</div>';
}
pickerClass = 'picker-modal picker-calendar ' + (p.params.cssClass || '');
var toolbarHTML = p.params.toolbar ? p.params.toolbarTemplate.replace(/{{closeText}}/g, p.params.toolbarCloseText) : '';
if (p.params.toolbar) {
toolbarHTML = p.params.toolbarTemplate
.replace(/{{closeText}}/g, p.params.toolbarCloseText)
.replace(/{{monthPicker}}/g, (p.params.monthPicker ? p.params.monthPickerTemplate : ''))
.replace(/{{yearPicker}}/g, (p.params.yearPicker ? p.params.yearPickerTemplate : ''));
}
pickerHTML =
'<div class="' + (pickerClass) + '">' +
toolbarHTML +
'<div class="picker-modal-inner">' +
weekHeaderHTML +
monthsHTML +
'</div>' +
'</div>';
p.pickerHTML = pickerHTML;
};
// Input Events
function openOnInput(e) {
e.preventDefault();
if (p.opened) return;
p.open();
if (p.params.scrollToInput && !isPopover()) {
var pageContent = p.input.parents('.page-content');
if (pageContent.length === 0) return;
var paddingTop = parseInt(pageContent.css('padding-top'), 10),
paddingBottom = parseInt(pageContent.css('padding-bottom'), 10),
pageHeight = pageContent[0].offsetHeight - paddingTop - p.container.height(),
pageScrollHeight = pageContent[0].scrollHeight - paddingTop - p.container.height(),
newPaddingBottom;
var inputTop = p.input.offset().top - paddingTop + p.input[0].offsetHeight;
if (inputTop > pageHeight) {
var scrollTop = pageContent.scrollTop() + inputTop - pageHeight;
if (scrollTop + pageHeight > pageScrollHeight) {
newPaddingBottom = scrollTop + pageHeight - pageScrollHeight + paddingBottom;
if (pageHeight === pageScrollHeight) {
newPaddingBottom = p.container.height();
}
pageContent.css({'padding-bottom': (newPaddingBottom) + 'px'});
}
pageContent.scrollTop(scrollTop, 300);
}
}
}
function closeOnHTMLClick(e) {
if (inPopover()) return;
if (p.input && p.input.length > 0) {
if (e.target !== p.input[0] && $(e.target).parents('.picker-modal').length === 0) p.close();
}
else {
if ($(e.target).parents('.picker-modal').length === 0) p.close();
}
}
if (p.params.input) {
p.input = $(p.params.input);
if (p.input.length > 0) {
if (p.params.inputReadOnly) p.input.prop('readOnly', true);
if (!p.inline) {
p.input.on('click', openOnInput);
}
if (p.params.inputReadOnly) {
p.input.on('focus mousedown', function (e) {
e.preventDefault();
});
}
}
}
if (!p.inline) $('html').on('click', closeOnHTMLClick);
// Open
function onPickerClose() {
p.opened = false;
if (p.input && p.input.length > 0) p.input.parents('.page-content').css({'padding-bottom': ''});
if (p.params.onClose) p.params.onClose(p);
// Destroy events
p.destroyCalendarEvents();
}
p.opened = false;
p.open = function () {
var toPopover = isPopover();
var updateValue = false;
if (!p.opened) {
// Set date value
if (!p.value) {
if (p.params.value) {
p.value = p.params.value;
updateValue = true;
}
}
// Layout
p.layout();
// Append
if (toPopover) {
p.pickerHTML = '<div class="popover popover-picker-calendar"><div class="popover-inner">' + p.pickerHTML + '</div></div>';
p.popover = app.popover(p.pickerHTML, p.params.input, true);
p.container = $(p.popover).find('.picker-modal');
$(p.popover).on('close', function () {
onPickerClose();
});
}
else if (p.inline) {
p.container = $(p.pickerHTML);
p.container.addClass('picker-modal-inline');
$(p.params.container).append(p.container);
}
else {
p.container = $(app.pickerModal(p.pickerHTML));
$(p.container)
.on('close', function () {
onPickerClose();
});
}
// Store calendar instance
p.container[0].f7Calendar = p;
p.wrapper = p.container.find('.picker-calendar-months-wrapper');
// Months
p.months = p.wrapper.find('.picker-calendar-month');
// Update current month and year
p.updateCurrentMonthYear();
// Set initial translate
p.monthsTranslate = 0;
p.setMonthsTranslate();
// Init events
p.initCalendarEvents();
// Update input value
if (updateValue) p.updateValue();
}
// Set flag
p.opened = true;
p.initialized = true;
if (p.params.onMonthAdd) {
p.months.each(function () {
p.params.onMonthAdd(p, this);
});
}
if (p.params.onOpen) p.params.onOpen(p);
};
// Close
p.close = function () {
if (!p.opened || p.inline) return;
if (inPopover()) {
app.closeModal(p.popover);
return;
}
else {
app.closeModal(p.container);
return;
}
};
// Destroy
p.destroy = function () {
p.close();
if (p.params.input && p.input.length > 0) {
p.input.off('click focus', openOnInput);
}
$('html').off('click', closeOnHTMLClick);
};
if (p.inline) {
p.open();
}
return p;
};
app.calendar = function (params) {
return new Calendar(params);
};
/*======================================================
************ Notifications ************
======================================================*/
var _tempNotificationElement;
app.addNotification = function (params) {
if (!params) return;
if (typeof params.media === 'undefined') params.media = app.params.notificationMedia;
if (typeof params.title === 'undefined') params.title = app.params.notificationTitle;
if (typeof params.subtitle === 'undefined') params.subtitle = app.params.notificationSubtitle;
if (typeof params.closeIcon === 'undefined') params.closeIcon = app.params.notificationCloseIcon;
if (typeof params.hold === 'undefined') params.hold = app.params.notificationHold;
if (typeof params.closeOnClick === 'undefined') params.closeOnClick = app.params.notificationCloseOnClick;
if (!_tempNotificationElement) _tempNotificationElement = document.createElement('div');
var container = $('.notifications');
if (container.length === 0) {
$('body').append('<div class="notifications list-block media-list"><ul></ul></div>');
container = $('.notifications');
}
var list = container.children('ul');
var itemHTML;
if (params.custom) {
itemHTML = '<li>' + params.custom + '</li>';
}
else {
itemHTML = '<li class="notification-item notification-hidden"><div class="item-content">' +
(params.media ?
'<div class="item-media">' +
params.media +
'</div>' : '') +
'<div class="item-inner">' +
'<div class="item-title-row">' +
(params.title ? '<div class="item-title">' + params.title + '</div>' : '') +
(params.closeIcon ? '<div class="item-after"><a href="#" class="close-notification"><span></span></a></div>' : '') +
'</div>' +
(params.subtitle ? '<div class="item-subtitle">' + params.subtitle + '</div>' : '') +
(params.message ? '<div class="item-text">' + params.message + '</div>' : '') +
'</div>' +
'</div></li>';
}
_tempNotificationElement.innerHTML = itemHTML;
var item = $(_tempNotificationElement).children();
item.on('click', function (e) {
var close = false;
if ($(e.target).is('.close-notification') || $(e.target).parents('.close-notification').length > 0) {
close = true;
}
else {
if (params.onClick) params.onClick(e, item[0]);
if (params.closeOnClick) close = true;
}
if (close) app.closeNotification(item[0]);
});
if (params.onClose) {
item.data('f7NotificationOnClose', function () {
params.onClose(item[0]);
});
}
if (params.additionalClass) {
item.addClass(params.additionalClass);
}
if (params.hold) {
setTimeout(function () {
if (item.length > 0) app.closeNotification(item[0]);
}, params.hold);
}
list.prepend(item[0]);
container.show();
var itemHeight = item.outerHeight();
item.css('marginTop', -itemHeight + 'px');
item.transition(0);
var clientLeft = item[0].clientLeft;
item.transition('');
item.css('marginTop', '0px');
container.transform('translate3d(0, 0,0)');
item.removeClass('notification-hidden');
return item[0];
};
app.closeNotification = function (item) {
item = $(item);
if (item.length === 0) return;
if (item.hasClass('notification-item-removing')) return;
var container = $('.notifications');
var itemHeight = item.outerHeight();
item.css('height', itemHeight + 'px').transition(0);
var clientLeft = item[0].clientLeft;
item.css('height', '0px').transition('').addClass('notification-item-removing');
if (item.data('f7NotificationOnClose')) item.data('f7NotificationOnClose')();
if (container.find('.notification-item:not(.notification-item-removing)').length === 0) {
container.transform('');
}
item.addClass('notification-hidden').transitionEnd(function () {
item.remove();
if (container.find('.notification-item').length === 0) {
container.hide();
}
});
};
/*===========================
Compile Template7 Templates On App Init
===========================*/
app.initTemplate7Templates = function () {
if (!window.Template7) return;
Template7.templates = Template7.templates || app.params.templates || {};
Template7.data = Template7.data || app.params.template7Data || {};
Template7.cache = Template7.cache || {};
app.templates = Template7.templates;
app.template7Data = Template7.data;
app.template7Cache = Template7.cache;
// Precompile templates on app init
if (!app.params.precompileTemplates) return;
$('script[type="text/template7"]').each(function () {
var id = $(this).attr('id');
if (!id) return;
Template7.templates[id] = Template7.compile($(this).html());
});
};
/*=======================================
************ Plugins API ************
=======================================*/
var _plugins = [];
app.initPlugins = function () {
// Initialize plugins
for (var plugin in app.plugins) {
var p = app.plugins[plugin](app, app.params[plugin]);
if (p) _plugins.push(p);
}
};
// Plugin Hooks
app.pluginHook = function (hook) {
for (var i = 0; i < _plugins.length; i++) {
if (_plugins[i].hooks && hook in _plugins[i].hooks) {
_plugins[i].hooks[hook](arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
}
}
};
// Prevented by plugin
app.pluginPrevent = function (action) {
var prevent = false;
for (var i = 0; i < _plugins.length; i++) {
if (_plugins[i].prevents && action in _plugins[i].prevents) {
if (_plugins[i].prevents[action](arguments[1], arguments[2], arguments[3], arguments[4], arguments[5])) prevent = true;
}
}
return prevent;
};
// Preprocess content by plugin
app.pluginProcess = function (action, data) {
var processed = data;
for (var i = 0; i < _plugins.length; i++) {
if (_plugins[i].preprocess && process in _plugins[i].preprocess) {
processed = _plugins[i].preprocess[process](data, arguments[2], arguments[3], arguments[4], arguments[5], arguments[6]);
}
}
return processed;
};
/*======================================================
************ App Init ************
======================================================*/
app.init = function () {
// Compile Template7 templates on app load
if (app.initTemplate7Templates) app.initTemplate7Templates();
// Init Plugins
if (app.initPlugins) app.initPlugins();
// Init Device
if (app.getDeviceInfo) app.getDeviceInfo();
// Init Click events
if (app.initFastClicks && app.params.fastClicks) app.initFastClicks();
if (app.initClickEvents) app.initClickEvents();
// Init each page callbacks
$('.page:not(.cached)').each(function () {
app.initPageWithCallback(this);
});
// Init each navbar callbacks
$('.navbar:not(.cached)').each(function () {
app.initNavbarWithCallback(this);
});
// Init resize events
if (app.initResize) app.initResize();
// Init push state
if (app.initPushState && app.params.pushState) app.initPushState();
// Init Live Swipeouts events
if (app.initSwipeout && app.params.swipeout) app.initSwipeout();
// Init Live Sortable events
if (app.initSortable && app.params.sortable) app.initSortable();
// Init Live Swipe Panels
if (app.initSwipePanels && (app.params.swipePanel || app.params.swipePanelOnlyClose)) app.initSwipePanels();
// App Init callback
if (app.params.onAppInit) app.params.onAppInit();
// Plugin app init hook
app.pluginHook('appInit');
};
if (app.params.init) app.init();
//Return instance
return app;
};
/*===========================
Dom7 Library
===========================*/
var Dom7 = (function () {
var Dom7 = function (arr) {
var _this = this, i = 0;
// Create array-like object
for (i = 0; i < arr.length; i++) {
_this[i] = arr[i];
}
_this.length = arr.length;
// Return collection with methods
return this;
};
var $ = function (selector, context) {
var arr = [], i = 0;
if (selector && !context) {
if (selector instanceof Dom7) {
return selector;
}
}
if (selector) {
// String
if (typeof selector === 'string') {
var els, tempParent, html = selector.trim();
if (html.indexOf('<') >= 0 && html.indexOf('>') >= 0) {
var toCreate = 'div';
if (html.indexOf('<li') === 0) toCreate = 'ul';
if (html.indexOf('<tr') === 0) toCreate = 'tbody';
if (html.indexOf('<td') === 0 || html.indexOf('<th') === 0) toCreate = 'tr';
if (html.indexOf('<tbody') === 0) toCreate = 'table';
if (html.indexOf('<option') === 0) toCreate = 'select';
tempParent = document.createElement(toCreate);
tempParent.innerHTML = selector;
for (i = 0; i < tempParent.childNodes.length; i++) {
arr.push(tempParent.childNodes[i]);
}
}
else {
if (!context && selector[0] === '#' && !selector.match(/[ .<>:~]/)) {
// Pure ID selector
els = [document.getElementById(selector.split('#')[1])];
}
else {
// Other selectors
els = (context || document).querySelectorAll(selector);
}
for (i = 0; i < els.length; i++) {
if (els[i]) arr.push(els[i]);
}
}
}
// Node/element
else if (selector.nodeType || selector === window || selector === document) {
arr.push(selector);
}
//Array of elements or instance of Dom
else if (selector.length > 0 && selector[0].nodeType) {
for (i = 0; i < selector.length; i++) {
arr.push(selector[i]);
}
}
}
return new Dom7(arr);
};
Dom7.prototype = {
// Classes and attriutes
addClass: function (className) {
if (typeof className === 'undefined') {
return this;
}
var classes = className.split(' ');
for (var i = 0; i < classes.length; i++) {
for (var j = 0; j < this.length; j++) {
if (typeof this[j].classList !== 'undefined') this[j].classList.add(classes[i]);
}
}
return this;
},
removeClass: function (className) {
var classes = className.split(' ');
for (var i = 0; i < classes.length; i++) {
for (var j = 0; j < this.length; j++) {
if (typeof this[j].classList !== 'undefined') this[j].classList.remove(classes[i]);
}
}
return this;
},
hasClass: function (className) {
if (!this[0]) return false;
else return this[0].classList.contains(className);
},
toggleClass: function (className) {
var classes = className.split(' ');
for (var i = 0; i < classes.length; i++) {
for (var j = 0; j < this.length; j++) {
if (typeof this[j].classList !== 'undefined') this[j].classList.toggle(classes[i]);
}
}
return this;
},
attr: function (attrs, value) {
if (arguments.length === 1 && typeof attrs === 'string') {
// Get attr
if (this[0]) return this[0].getAttribute(attrs);
else return undefined;
}
else {
// Set attrs
for (var i = 0; i < this.length; i++) {
if (arguments.length === 2) {
// String
this[i].setAttribute(attrs, value);
}
else {
// Object
for (var attrName in attrs) {
this[i][attrName] = attrs[attrName];
this[i].setAttribute(attrName, attrs[attrName]);
}
}
}
return this;
}
},
removeAttr: function (attr) {
for (var i = 0; i < this.length; i++) {
this[i].removeAttribute(attr);
}
return this;
},
prop: function (props, value) {
if (arguments.length === 1 && typeof props === 'string') {
// Get prop
if (this[0]) return this[0][props];
else return undefined;
}
else {
// Set props
for (var i = 0; i < this.length; i++) {
if (arguments.length === 2) {
// String
this[i][props] = value;
}
else {
// Object
for (var propName in props) {
this[i][propName] = props[propName];
}
}
}
return this;
}
},
data: function (key, value) {
if (typeof value === 'undefined') {
// Get value
if (this[0]) {
var dataKey = this[0].getAttribute('data-' + key);
if (dataKey) return dataKey;
else if (this[0].dom7ElementDataStorage && (key in this[0].dom7ElementDataStorage)) return this[0].dom7ElementDataStorage[key];
else return undefined;
}
else return undefined;
}
else {
// Set value
for (var i = 0; i < this.length; i++) {
var el = this[i];
if (!el.dom7ElementDataStorage) el.dom7ElementDataStorage = {};
el.dom7ElementDataStorage[key] = value;
}
return this;
}
},
dataset: function () {
var el = this[0];
if (el) {
var dataset = {};
if (el.dataset) {
for (var dataKey in el.dataset) {
dataset[dataKey] = el.dataset[dataKey];
}
}
else {
for (var i = 0; i < el.attributes.length; i++) {
var attr = el.attributes[i];
if (attr.name.indexOf('data-') >= 0) {
dataset[$.toCamelCase(attr.name.split('data-')[1])] = attr.value;
}
}
}
for (var key in dataset) {
if (dataset[key] === 'false') dataset[key] = false;
else if (dataset[key] === 'true') dataset[key] = true;
else if (parseFloat(dataset[key]) === dataset[key] * 1) dataset[key] = dataset[key] * 1;
}
return dataset;
}
else return undefined;
},
val: function (value) {
if (typeof value === 'undefined') {
if (this[0]) return this[0].value;
else return undefined;
}
else {
for (var i = 0; i < this.length; i++) {
this[i].value = value;
}
return this;
}
},
// Transforms
transform : function (transform) {
for (var i = 0; i < this.length; i++) {
var elStyle = this[i].style;
elStyle.webkitTransform = elStyle.MsTransform = elStyle.msTransform = elStyle.MozTransform = elStyle.OTransform = elStyle.transform = transform;
}
return this;
},
transition: function (duration) {
if (typeof duration !== 'string') {
duration = duration + 'ms';
}
for (var i = 0; i < this.length; i++) {
var elStyle = this[i].style;
elStyle.webkitTransitionDuration = elStyle.MsTransitionDuration = elStyle.msTransitionDuration = elStyle.MozTransitionDuration = elStyle.OTransitionDuration = elStyle.transitionDuration = duration;
}
return this;
},
//Events
on: function (eventName, targetSelector, listener, capture) {
function handleLiveEvent(e) {
var target = e.target;
if ($(target).is(targetSelector)) listener.call(target, e);
else {
var parents = $(target).parents();
for (var k = 0; k < parents.length; k++) {
if ($(parents[k]).is(targetSelector)) listener.call(parents[k], e);
}
}
}
var events = eventName.split(' ');
var i, j;
for (i = 0; i < this.length; i++) {
if (typeof targetSelector === 'function' || targetSelector === false) {
// Usual events
if (typeof targetSelector === 'function') {
listener = arguments[1];
capture = arguments[2] || false;
}
for (j = 0; j < events.length; j++) {
this[i].addEventListener(events[j], listener, capture);
}
}
else {
//Live events
for (j = 0; j < events.length; j++) {
if (!this[i].dom7LiveListeners) this[i].dom7LiveListeners = [];
this[i].dom7LiveListeners.push({listener: listener, liveListener: handleLiveEvent});
this[i].addEventListener(events[j], handleLiveEvent, capture);
}
}
}
return this;
},
off: function (eventName, targetSelector, listener, capture) {
var events = eventName.split(' ');
for (var i = 0; i < events.length; i++) {
for (var j = 0; j < this.length; j++) {
if (typeof targetSelector === 'function' || targetSelector === false) {
// Usual events
if (typeof targetSelector === 'function') {
listener = arguments[1];
capture = arguments[2] || false;
}
this[j].removeEventListener(events[i], listener, capture);
}
else {
// Live event
if (this[j].dom7LiveListeners) {
for (var k = 0; k < this[j].dom7LiveListeners.length; k++) {
if (this[j].dom7LiveListeners[k].listener === listener) {
this[j].removeEventListener(events[i], this[j].dom7LiveListeners[k].liveListener, capture);
}
}
}
}
}
}
return this;
},
once: function (eventName, targetSelector, listener, capture) {
var dom = this;
if (typeof targetSelector === 'function') {
targetSelector = false;
listener = arguments[1];
capture = arguments[2];
}
function proxy(e) {
listener(e);
dom.off(eventName, targetSelector, proxy, capture);
}
dom.on(eventName, targetSelector, proxy, capture);
},
trigger: function (eventName, eventData) {
for (var i = 0; i < this.length; i++) {
var evt;
try {
evt = new CustomEvent(eventName, {detail: eventData, bubbles: true, cancelable: true});
}
catch (e) {
evt = document.createEvent('Event');
evt.initEvent(eventName, true, true);
evt.detail = eventData;
}
this[i].dispatchEvent(evt);
}
return this;
},
transitionEnd: function (callback) {
var events = ['webkitTransitionEnd', 'transitionend', 'oTransitionEnd', 'MSTransitionEnd', 'msTransitionEnd'],
i, j, dom = this;
function fireCallBack(e) {
/*jshint validthis:true */
if (e.target !== this) return;
callback.call(this, e);
for (i = 0; i < events.length; i++) {
dom.off(events[i], fireCallBack);
}
}
if (callback) {
for (i = 0; i < events.length; i++) {
dom.on(events[i], fireCallBack);
}
}
return this;
},
animationEnd: function (callback) {
var events = ['webkitAnimationEnd', 'OAnimationEnd', 'MSAnimationEnd', 'animationend'],
i, j, dom = this;
function fireCallBack(e) {
callback(e);
for (i = 0; i < events.length; i++) {
dom.off(events[i], fireCallBack);
}
}
if (callback) {
for (i = 0; i < events.length; i++) {
dom.on(events[i], fireCallBack);
}
}
return this;
},
// Sizing/Styles
width: function () {
if (this[0] === window) {
return window.innerWidth;
}
else {
if (this.length > 0) {
return parseFloat(this.css('width'));
}
else {
return null;
}
}
},
outerWidth: function (includeMargins) {
if (this.length > 0) {
if (includeMargins) {
var styles = this.styles();
return this[0].offsetWidth + parseFloat(styles.getPropertyValue('margin-right')) + parseFloat(styles.getPropertyValue('margin-left'));
}
else
return this[0].offsetWidth;
}
else return null;
},
height: function () {
if (this[0] === window) {
return window.innerHeight;
}
else {
if (this.length > 0) {
return parseFloat(this.css('height'));
}
else {
return null;
}
}
},
outerHeight: function (includeMargins) {
if (this.length > 0) {
if (includeMargins) {
var styles = this.styles();
return this[0].offsetHeight + parseFloat(styles.getPropertyValue('margin-top')) + parseFloat(styles.getPropertyValue('margin-bottom'));
}
else
return this[0].offsetHeight;
}
else return null;
},
offset: function () {
if (this.length > 0) {
var el = this[0];
var box = el.getBoundingClientRect();
var body = document.body;
var clientTop = el.clientTop || body.clientTop || 0;
var clientLeft = el.clientLeft || body.clientLeft || 0;
var scrollTop = window.pageYOffset || el.scrollTop;
var scrollLeft = window.pageXOffset || el.scrollLeft;
return {
top: box.top + scrollTop - clientTop,
left: box.left + scrollLeft - clientLeft
};
}
else {
return null;
}
},
hide: function () {
for (var i = 0; i < this.length; i++) {
this[i].style.display = 'none';
}
return this;
},
show: function () {
for (var i = 0; i < this.length; i++) {
this[i].style.display = 'block';
}
return this;
},
styles: function () {
var i, styles;
if (this[0]) return window.getComputedStyle(this[0], null);
else return undefined;
},
css: function (props, value) {
var i;
if (arguments.length === 1) {
if (typeof props === 'string') {
if (this[0]) return window.getComputedStyle(this[0], null).getPropertyValue(props);
}
else {
for (i = 0; i < this.length; i++) {
for (var prop in props) {
this[i].style[prop] = props[prop];
}
}
return this;
}
}
if (arguments.length === 2 && typeof props === 'string') {
for (i = 0; i < this.length; i++) {
this[i].style[props] = value;
}
return this;
}
return this;
},
//Dom manipulation
each: function (callback) {
for (var i = 0; i < this.length; i++) {
callback.call(this[i], i, this[i]);
}
return this;
},
html: function (html) {
if (typeof html === 'undefined') {
return this[0] ? this[0].innerHTML : undefined;
}
else {
for (var i = 0; i < this.length; i++) {
this[i].innerHTML = html;
}
return this;
}
},
text: function (text) {
if (typeof text === 'undefined') {
if (this[0]) {
return this[0].textContent.trim();
}
else return null;
}
else {
for (var i = 0; i < this.length; i++) {
this[i].textContent = text;
}
}
},
is: function (selector) {
if (!this[0] || typeof selector === 'undefined') return false;
var compareWith, i;
if (typeof selector === 'string') {
var el = this[0];
if (el === document) return selector === document;
if (el === window) return selector === window;
if (el.matches) return el.matches(selector);
else if (el.webkitMatchesSelector) return el.webkitMatchesSelector(selector);
else if (el.mozMatchesSelector) return el.mozMatchesSelector(selector);
else if (el.msMatchesSelector) return el.msMatchesSelector(selector);
else {
compareWith = $(selector);
for (i = 0; i < compareWith.length; i++) {
if (compareWith[i] === this[0]) return true;
}
return false;
}
}
else if (selector === document) return this[0] === document;
else if (selector === window) return this[0] === window;
else {
if (selector.nodeType || selector instanceof Dom7) {
compareWith = selector.nodeType ? [selector] : selector;
for (i = 0; i < compareWith.length; i++) {
if (compareWith[i] === this[0]) return true;
}
return false;
}
return false;
}
},
indexOf: function (el) {
for (var i = 0; i < this.length; i++) {
if (this[i] === el) return i;
}
},
index: function () {
if (this[0]) {
var child = this[0];
var i = 0;
while ((child = child.previousSibling) !== null) {
if (child.nodeType === 1) i++;
}
return i;
}
else return undefined;
},
eq: function (index) {
if (typeof index === 'undefined') return this;
var length = this.length;
var returnIndex;
if (index > length - 1) {
return new Dom7([]);
}
if (index < 0) {
returnIndex = length + index;
if (returnIndex < 0) return new Dom7([]);
else return new Dom7([this[returnIndex]]);
}
return new Dom7([this[index]]);
},
append: function (newChild) {
var i, j;
for (i = 0; i < this.length; i++) {
if (typeof newChild === 'string') {
var tempDiv = document.createElement('div');
tempDiv.innerHTML = newChild;
while (tempDiv.firstChild) {
this[i].appendChild(tempDiv.firstChild);
}
}
else if (newChild instanceof Dom7) {
for (j = 0; j < newChild.length; j++) {
this[i].appendChild(newChild[j]);
}
}
else {
this[i].appendChild(newChild);
}
}
return this;
},
prepend: function (newChild) {
var i, j;
for (i = 0; i < this.length; i++) {
if (typeof newChild === 'string') {
var tempDiv = document.createElement('div');
tempDiv.innerHTML = newChild;
for (j = tempDiv.childNodes.length - 1; j >= 0; j--) {
this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
}
// this[i].insertAdjacentHTML('afterbegin', newChild);
}
else if (newChild instanceof Dom7) {
for (j = 0; j < newChild.length; j++) {
this[i].insertBefore(newChild[j], this[i].childNodes[0]);
}
}
else {
this[i].insertBefore(newChild, this[i].childNodes[0]);
}
}
return this;
},
insertBefore: function (selector) {
var before = $(selector);
for (var i = 0; i < this.length; i++) {
if (before.length === 1) {
before[0].parentNode.insertBefore(this[i], before[0]);
}
else if (before.length > 1) {
for (var j = 0; j < before.length; j++) {
before[j].parentNode.insertBefore(this[i].cloneNode(true), before[j]);
}
}
}
},
insertAfter: function (selector) {
var after = $(selector);
for (var i = 0; i < this.length; i++) {
if (after.length === 1) {
after[0].parentNode.insertBefore(this[i], after[0].nextSibling);
}
else if (after.length > 1) {
for (var j = 0; j < after.length; j++) {
after[j].parentNode.insertBefore(this[i].cloneNode(true), after[j].nextSibling);
}
}
}
},
next: function (selector) {
if (this.length > 0) {
if (selector) {
if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) return new Dom7([this[0].nextElementSibling]);
else return new Dom7([]);
}
else {
if (this[0].nextElementSibling) return new Dom7([this[0].nextElementSibling]);
else return new Dom7([]);
}
}
else return new Dom7([]);
},
nextAll: function (selector) {
var nextEls = [];
var el = this[0];
if (!el) return new Dom7([]);
while (el.nextElementSibling) {
var next = el.nextElementSibling;
if (selector) {
if($(next).is(selector)) nextEls.push(next);
}
else nextEls.push(next);
el = next;
}
return new Dom7(nextEls);
},
prev: function (selector) {
if (this.length > 0) {
if (selector) {
if (this[0].previousElementSibling && $(this[0].previousElementSibling).is(selector)) return new Dom7([this[0].previousElementSibling]);
else return new Dom7([]);
}
else {
if (this[0].previousElementSibling) return new Dom7([this[0].previousElementSibling]);
else return new Dom7([]);
}
}
else return new Dom7([]);
},
prevAll: function (selector) {
var prevEls = [];
var el = this[0];
if (!el) return new Dom7([]);
while (el.previousElementSibling) {
var prev = el.previousElementSibling;
if (selector) {
if($(prev).is(selector)) prevEls.push(prev);
}
else prevEls.push(prev);
el = prev;
}
return new Dom7(prevEls);
},
parent: function (selector) {
var parents = [];
for (var i = 0; i < this.length; i++) {
if (selector) {
if ($(this[i].parentNode).is(selector)) parents.push(this[i].parentNode);
}
else {
parents.push(this[i].parentNode);
}
}
return $($.unique(parents));
},
parents: function (selector) {
var parents = [];
for (var i = 0; i < this.length; i++) {
var parent = this[i].parentNode;
while (parent) {
if (selector) {
if ($(parent).is(selector)) parents.push(parent);
}
else {
parents.push(parent);
}
parent = parent.parentNode;
}
}
return $($.unique(parents));
},
find : function (selector) {
var foundElements = [];
for (var i = 0; i < this.length; i++) {
var found = this[i].querySelectorAll(selector);
for (var j = 0; j < found.length; j++) {
foundElements.push(found[j]);
}
}
return new Dom7(foundElements);
},
children: function (selector) {
var children = [];
for (var i = 0; i < this.length; i++) {
var childNodes = this[i].childNodes;
for (var j = 0; j < childNodes.length; j++) {
if (!selector) {
if (childNodes[j].nodeType === 1) children.push(childNodes[j]);
}
else {
if (childNodes[j].nodeType === 1 && $(childNodes[j]).is(selector)) children.push(childNodes[j]);
}
}
}
return new Dom7($.unique(children));
},
remove: function () {
for (var i = 0; i < this.length; i++) {
if (this[i].parentNode) this[i].parentNode.removeChild(this[i]);
}
return this;
},
detach: function () {
return this.remove();
},
add: function () {
var dom = this;
var i, j;
for (i = 0; i < arguments.length; i++) {
var toAdd = $(arguments[i]);
for (j = 0; j < toAdd.length; j++) {
dom[dom.length] = toAdd[j];
dom.length++;
}
}
return dom;
}
};
// Shortcuts
(function () {
var shortcuts = ('click blur focus focusin focusout keyup keydown keypress submit change mousedown mousemove mouseup mouseenter mouseleave mouseout mouseover touchstart touchend touchmove resize scroll').split(' ');
var notTrigger = ('resize scroll').split(' ');
function createMethod(name) {
Dom7.prototype[name] = function (handler) {
var i;
if (typeof handler === 'undefined') {
for (i = 0; i < this.length; i++) {
if (notTrigger.indexOf(name) < 0) {
if (name in this[i]) this[i][name]();
else {
$(this[i]).trigger(name);
}
}
}
return this;
}
else {
return this.on(name, handler);
}
};
}
for (var i = 0; i < shortcuts.length; i++) {
createMethod(shortcuts[i]);
}
})();
// Global Ajax Setup
var globalAjaxOptions = {};
$.ajaxSetup = function (options) {
if (options.type) options.method = options.type;
$.each(options, function (optionName, optionValue) {
globalAjaxOptions[optionName] = optionValue;
});
};
// Ajax
var _jsonpRequests = 0;
$.ajax = function (options) {
var defaults = {
method: 'GET',
data: false,
async: true,
cache: true,
user: '',
password: '',
headers: {},
xhrFields: {},
statusCode: {},
processData: true,
dataType: 'text',
contentType: 'application/x-www-form-urlencoded',
timeout: 0
};
var callbacks = ['beforeSend', 'error', 'complete', 'success', 'statusCode'];
//For jQuery guys
if (options.type) options.method = options.type;
// Merge global and defaults
$.each(globalAjaxOptions, function (globalOptionName, globalOptionValue) {
if (callbacks.indexOf(globalOptionName) < 0) defaults[globalOptionName] = globalOptionValue;
});
// Function to run XHR callbacks and events
function fireAjaxCallback (eventName, eventData, callbackName) {
var a = arguments;
if (eventName) $(document).trigger(eventName, eventData);
if (callbackName) {
// Global callback
if (callbackName in globalAjaxOptions) globalAjaxOptions[callbackName](a[3], a[4], a[5], a[6]);
// Options callback
if (options[callbackName]) options[callbackName](a[3], a[4], a[5], a[6]);
}
}
// Merge options and defaults
$.each(defaults, function (prop, defaultValue) {
if (!(prop in options)) options[prop] = defaultValue;
});
// Default URL
if (!options.url) {
options.url = window.location.toString();
}
// Parameters Prefix
var paramsPrefix = options.url.indexOf('?') >= 0 ? '&' : '?';
// UC method
var _method = options.method.toUpperCase();
// Data to modify GET URL
if ((_method === 'GET' || _method === 'HEAD') && options.data) {
var stringData;
if (typeof options.data === 'string') {
// Should be key=value string
if (options.data.indexOf('?') >= 0) stringData = options.data.split('?')[1];
else stringData = options.data;
}
else {
// Should be key=value object
stringData = $.serializeObject(options.data);
}
options.url += paramsPrefix + stringData;
}
// JSONP
if (options.dataType === 'json' && options.url.indexOf('callback=') >= 0) {
var callbackName = 'f7jsonp_' + Date.now() + (_jsonpRequests++);
var abortTimeout;
var callbackSplit = options.url.split('callback=');
var requestUrl = callbackSplit[0] + 'callback=' + callbackName;
if (callbackSplit[1].indexOf('&') >= 0) {
var addVars = callbackSplit[1].split('&').filter(function (el) { return el.indexOf('=') > 0; }).join('&');
if (addVars.length > 0) requestUrl += '&' + addVars;
}
// Create script
var script = document.createElement('script');
script.type = 'text/javascript';
script.onerror = function() {
clearTimeout(abortTimeout);
fireAjaxCallback(undefined, undefined, 'error', null, 'scripterror');
};
script.src = requestUrl;
// Handler
window[callbackName] = function (data) {
clearTimeout(abortTimeout);
fireAjaxCallback(undefined, undefined, 'success', data);
script.parentNode.removeChild(script);
script = null;
delete window[callbackName];
};
document.querySelector('head').appendChild(script);
if (options.timeout > 0) {
abortTimeout = setTimeout(function () {
script.parentNode.removeChild(script);
script = null;
fireAjaxCallback(undefined, undefined, 'error', null, 'timeout');
}, options.timeout);
}
return;
}
// Cache for GET/HEAD requests
if (_method === 'GET' || _method === 'HEAD') {
if (options.cache === false) {
options.url += (paramsPrefix + '_nocache=' + Date.now());
}
}
// Create XHR
var xhr = new XMLHttpRequest();
// Save Request URL
xhr.requestUrl = options.url;
// Open XHR
xhr.open(_method, options.url, options.async, options.user, options.password);
// Create POST Data
var postData = null;
if ((_method === 'POST' || _method === 'PUT') && options.data) {
if (options.processData) {
var postDataInstances = [ArrayBuffer, Blob, Document, FormData];
// Post Data
if (postDataInstances.indexOf(options.data.constructor) >= 0) {
postData = options.data;
}
else {
// POST Headers
var boundary = '---------------------------' + Date.now().toString(16);
if (options.contentType === 'multipart\/form-data') {
xhr.setRequestHeader('Content-Type', 'multipart\/form-data; boundary=' + boundary);
}
else {
xhr.setRequestHeader('Content-Type', options.contentType);
}
postData = '';
var _data = $.serializeObject(options.data);
if (options.contentType === 'multipart\/form-data') {
boundary = '---------------------------' + Date.now().toString(16);
_data = _data.split('&');
var _newData = [];
for (var i = 0; i < _data.length; i++) {
_newData.push('Content-Disposition: form-data; name="' + _data[i].split('=')[0] + '"\r\n\r\n' + _data[i].split('=')[1] + '\r\n');
}
postData = '--' + boundary + '\r\n' + _newData.join('--' + boundary + '\r\n') + '--' + boundary + '--\r\n';
}
else {
postData = options.contentType === 'application/x-www-form-urlencoded' ? _data : _data.replace(/&/g, '\r\n');
}
}
}
else {
postData = options.data;
}
}
// Additional headers
if (options.headers) {
$.each(options.headers, function (headerName, headerCallback) {
xhr.setRequestHeader(headerName, headerCallback);
});
}
// Check for crossDomain
if (typeof options.crossDomain === 'undefined') {
options.crossDomain = /^([\w-]+:)?\/\/([^\/]+)/.test(options.url) && RegExp.$2 !== window.location.host;
}
if (!options.crossDomain) {
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
}
if (options.xhrFields) {
$.each(options.xhrFields, function (fieldName, fieldValue) {
xhr[fieldName] = fieldValue;
});
}
var xhrTimeout;
// Handle XHR
xhr.onload = function (e) {
if (xhrTimeout) clearTimeout(xhrTimeout);
if ((xhr.status >= 200 && xhr.status < 300) || xhr.status === 0) {
var responseData;
if (options.dataType === 'json') {
try {
responseData = JSON.parse(xhr.responseText);
fireAjaxCallback('ajaxSuccess', {xhr: xhr}, 'success', responseData, xhr.status, xhr);
}
catch (err) {
fireAjaxCallback('ajaxError', {xhr: xhr, parseerror: true}, 'error', xhr, 'parseerror');
}
}
else {
fireAjaxCallback('ajaxSuccess', {xhr: xhr}, 'success', xhr.responseText, xhr.status, xhr);
}
}
else {
fireAjaxCallback('ajaxError', {xhr: xhr}, 'error', xhr, xhr.status);
}
if (options.statusCode) {
if (globalAjaxOptions.statusCode && globalAjaxOptions.statusCode[xhr.status]) globalAjaxOptions.statusCode[xhr.status](xhr);
if (options.statusCode[xhr.status]) options.statusCode[xhr.status](xhr);
}
fireAjaxCallback('ajaxComplete', {xhr: xhr}, 'complete', xhr, xhr.status);
};
xhr.onerror = function (e) {
if (xhrTimeout) clearTimeout(xhrTimeout);
fireAjaxCallback('ajaxError', {xhr: xhr}, 'error', xhr, xhr.status);
};
// Ajax start callback
fireAjaxCallback('ajaxStart', {xhr: xhr}, 'start', xhr);
fireAjaxCallback(undefined, undefined, 'beforeSend', xhr);
// Send XHR
xhr.send(postData);
// Timeout
if (options.timeout > 0) {
xhrTimeout = setTimeout(function () {
xhr.abort();
fireAjaxCallback('ajaxError', {xhr: xhr, timeout: true}, 'error', xhr, 'timeout');
fireAjaxCallback('ajaxComplete', {xhr: xhr, timeout: true}, 'complete', xhr, 'timeout');
}, options.timeout);
}
// Return XHR object
return xhr;
};
// Shrotcuts
(function () {
var methods = ('get post getJSON').split(' ');
function createMethod(method) {
$[method] = function (url, data, success) {
return $.ajax({
url: url,
method: method === 'post' ? 'POST' : 'GET',
data: typeof data === 'function' ? undefined : data,
success: typeof data === 'function' ? data : success,
dataType: method === 'getJSON' ? 'json' : undefined
});
};
}
for (var i = 0; i < methods.length; i++) {
createMethod(methods[i]);
}
})();
// DOM Library Utilites
$.parseUrlQuery = function (url) {
var query = {}, i, params, param;
if (url.indexOf('?') >= 0) url = url.split('?')[1];
else return query;
params = url.split('&');
for (i = 0; i < params.length; i++) {
param = params[i].split('=');
query[param[0]] = param[1];
}
return query;
};
$.isArray = function (arr) {
if (Object.prototype.toString.apply(arr) === '[object Array]') return true;
else return false;
};
$.each = function (obj, callback) {
if (typeof obj !== 'object') return;
if (!callback) return;
var i, prop;
if ($.isArray(obj) || obj instanceof Dom7) {
// Array
for (i = 0; i < obj.length; i++) {
callback(i, obj[i]);
}
}
else {
// Object
for (prop in obj) {
if (obj.hasOwnProperty(prop)) {
callback(prop, obj[prop]);
}
}
}
};
$.unique = function (arr) {
var unique = [];
for (var i = 0; i < arr.length; i++) {
if (unique.indexOf(arr[i]) === -1) unique.push(arr[i]);
}
return unique;
};
$.serializeObject = function (obj) {
if (typeof obj === 'string') return obj;
var resultArray = [];
var separator = '&';
for (var prop in obj) {
if (obj.hasOwnProperty(prop)) {
if ($.isArray(obj[prop])) {
var toPush = [];
for (var i = 0; i < obj[prop].length; i ++) {
toPush.push(encodeURIComponent(prop) + '=' + encodeURIComponent(obj[prop][i]));
}
if (toPush.length > 0) resultArray.push(toPush.join(separator));
}
else {
// Should be string
resultArray.push(encodeURIComponent(prop) + '=' + encodeURIComponent(obj[prop]));
}
}
}
return resultArray.join(separator);
};
$.toCamelCase = function (string) {
return string.toLowerCase().replace(/-(.)/g, function(match, group1) {
return group1.toUpperCase();
});
};
$.dataset = function (el) {
return $(el).dataset();
};
$.getTranslate = function (el, axis) {
var matrix, curTransform, curStyle, transformMatrix;
// automatic axis detection
if (typeof axis === 'undefined') {
axis = 'x';
}
curStyle = window.getComputedStyle(el, null);
if (window.WebKitCSSMatrix) {
// Some old versions of Webkit choke when 'none' is passed; pass
// empty string instead in this case
transformMatrix = new WebKitCSSMatrix(curStyle.webkitTransform === 'none' ? '' : curStyle.webkitTransform);
}
else {
transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
matrix = transformMatrix.toString().split(',');
}
if (axis === 'x') {
//Latest Chrome and webkits Fix
if (window.WebKitCSSMatrix)
curTransform = transformMatrix.m41;
//Crazy IE10 Matrix
else if (matrix.length === 16)
curTransform = parseFloat(matrix[12]);
//Normal Browsers
else
curTransform = parseFloat(matrix[4]);
}
if (axis === 'y') {
//Latest Chrome and webkits Fix
if (window.WebKitCSSMatrix)
curTransform = transformMatrix.m42;
//Crazy IE10 Matrix
else if (matrix.length === 16)
curTransform = parseFloat(matrix[13]);
//Normal Browsers
else
curTransform = parseFloat(matrix[5]);
}
return curTransform || 0;
};
$.requestAnimationFrame = function (callback) {
if (window.requestAnimationFrame) return window.requestAnimationFrame(callback);
else if (window.webkitRequestAnimationFrame) return window.webkitRequestAnimationFrame(callback);
else if (window.mozRequestAnimationFrame) return window.mozRequestAnimationFrame(callback);
else {
return window.setTimeout(callback, 1000 / 60);
}
};
$.cancelAnimationFrame = function (id) {
if (window.cancelAnimationFrame) return window.cancelAnimationFrame(id);
else if (window.webkitCancelAnimationFrame) return window.webkitCancelAnimationFrame(id);
else if (window.mozCancelAnimationFrame) return window.mozCancelAnimationFrame(id);
else {
return window.clearTimeout(id);
}
};
$.supportTouch = !!(('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch);
// Link to prototype
$.fn = Dom7.prototype;
// Plugins
$.fn.scrollTo = function (left, top, duration, easing, callback) {
if (arguments.length === 4 && typeof easing === 'function') {
callback = easing;
easing = undefined;
}
return this.each(function () {
var el = this;
var currentTop, currentLeft, maxTop, maxLeft, newTop, newLeft, scrollTop, scrollLeft;
var animateTop = top > 0 || top === 0;
var animateLeft = left > 0 || left === 0;
if (typeof easing === 'undefined') {
easing = 'swing';
}
if (animateTop) {
currentTop = el.scrollTop;
if (!duration) {
el.scrollTop = top;
}
}
if (animateLeft) {
currentLeft = el.scrollLeft;
if (!duration) {
el.scrollLeft = left;
}
}
if (!duration) return;
if (animateTop) {
maxTop = el.scrollHeight - el.offsetHeight;
newTop = Math.max(Math.min(top, maxTop), 0);
}
if (animateLeft) {
maxLeft = el.scrollWidth - el.offsetWidth;
newLeft = Math.max(Math.min(left, maxLeft), 0);
}
var startTime = null;
if (animateTop && newTop === currentTop) animateTop = false;
if (animateLeft && newLeft === currentLeft) animateLeft = false;
function render(time) {
if (time === undefined) {
time = new Date().getTime();
}
if (startTime === null) {
startTime = time;
}
var doneLeft, doneTop, done;
var progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
var easeProgress = easing === 'linear' ? progress : (0.5 - Math.cos( progress * Math.PI ) / 2);
if (animateTop) scrollTop = currentTop + (easeProgress * (newTop - currentTop));
if (animateLeft) scrollLeft = currentLeft + (easeProgress * (newLeft - currentLeft));
if (animateTop && newTop > currentTop && scrollTop >= newTop) {
el.scrollTop = newTop;
done = true;
}
if (animateTop && newTop < currentTop && scrollTop <= newTop) {
el.scrollTop = newTop;
done = true;
}
if (animateLeft && newLeft > currentLeft && scrollLeft >= newLeft) {
el.scrollLeft = newLeft;
done = true;
}
if (animateLeft && newLeft < currentLeft && scrollLeft <= newLeft) {
el.scrollLeft = newLeft;
done = true;
}
if (done) {
if (callback) callback();
return;
}
if (animateTop) el.scrollTop = scrollTop;
if (animateLeft) el.scrollLeft = scrollLeft;
$.requestAnimationFrame(render);
}
$.requestAnimationFrame(render);
});
};
$.fn.scrollTop = function (top, duration, easing, callback) {
if (arguments.length === 3 && typeof easing === 'function') {
callback = easing;
easing = undefined;
}
var dom = this;
if (typeof top === 'undefined') {
if (dom.length > 0) return dom[0].scrollTop;
else return null;
}
return dom.scrollTo(undefined, top, duration, easing, callback);
};
$.fn.scrollLeft = function (left, duration, easing, callback) {
if (arguments.length === 3 && typeof easing === 'function') {
callback = easing;
easing = undefined;
}
var dom = this;
if (typeof left === 'undefined') {
if (dom.length > 0) return dom[0].scrollLeft;
else return null;
}
return dom.scrollTo(left, undefined, duration, easing, callback);
};
return $;
})();
// Export Dom7 to Framework7
Framework7.$ = Dom7;
// Export to local scope
var $ = Dom7;
// Export to Window
window.Dom7 = Dom7;
/*===========================
Features Support Detection
===========================*/
Framework7.prototype.support = (function () {
var support = {
touch: !!(('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch)
};
// Export object
return support;
})();
/*===========================
Device/OS Detection
===========================*/
Framework7.prototype.device = (function () {
var device = {};
var ua = navigator.userAgent;
var $ = Dom7;
var android = ua.match(/(Android);?[\s\/]+([\d.]+)?/);
var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
var iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/);
device.ios = device.android = device.iphone = device.ipad = device.androidChrome = false;
// Android
if (android) {
device.os = 'android';
device.osVersion = android[2];
device.android = true;
device.androidChrome = ua.toLowerCase().indexOf('chrome') >= 0;
}
if (ipad || iphone || ipod) {
device.os = 'ios';
device.ios = true;
}
// iOS
if (iphone && !ipod) {
device.osVersion = iphone[2].replace(/_/g, '.');
device.iphone = true;
}
if (ipad) {
device.osVersion = ipad[2].replace(/_/g, '.');
device.ipad = true;
}
if (ipod) {
device.osVersion = ipod[3] ? ipod[3].replace(/_/g, '.') : null;
device.iphone = true;
}
// iOS 8+ changed UA
if (device.ios && device.osVersion && ua.indexOf('Version/') >= 0) {
if (device.osVersion.split('.')[0] === '10') {
device.osVersion = ua.toLowerCase().split('version/')[1].split(' ')[0];
}
}
// Webview
device.webView = (iphone || ipad || ipod) && ua.match(/.*AppleWebKit(?!.*Safari)/i);
// Minimal UI
if (device.os && device.os === 'ios') {
var osVersionArr = device.osVersion.split('.');
device.minimalUi = !device.webView &&
(ipod || iphone) &&
(osVersionArr[0] * 1 === 7 ? osVersionArr[1] * 1 >= 1 : osVersionArr[0] * 1 > 7) &&
$('meta[name="viewport"]').length > 0 && $('meta[name="viewport"]').attr('content').indexOf('minimal-ui') >= 0;
}
// Check for status bar and fullscreen app mode
var windowWidth = $(window).width();
var windowHeight = $(window).height();
device.statusBar = false;
if (device.webView && (windowWidth * windowHeight === screen.width * screen.height)) {
device.statusBar = true;
}
else {
device.statusBar = false;
}
// Classes
var classNames = [];
// Pixel Ratio
device.pixelRatio = window.devicePixelRatio || 1;
classNames.push('pixel-ratio-' + Math.floor(device.pixelRatio));
if (device.pixelRatio >= 2) {
classNames.push('retina');
}
// OS classes
if (device.os) {
classNames.push(device.os, device.os + '-' + device.osVersion.split('.')[0], device.os + '-' + device.osVersion.replace(/\./g, '-'));
if (device.os === 'ios') {
var major = parseInt(device.osVersion.split('.')[0], 10);
for (var i = major - 1; i >= 6; i--) {
classNames.push('ios-gt-' + i);
}
}
}
// Status bar classes
if (device.statusBar) {
classNames.push('with-statusbar-overlay');
}
else {
$('html').removeClass('with-statusbar-overlay');
}
// Add html classes
if (classNames.length > 0) $('html').addClass(classNames.join(' '));
// Export object
return device;
})();
/*===========================
Plugins prototype
===========================*/
Framework7.prototype.plugins = {};
/*===========================
Template7 Template engine
===========================*/
window.Template7 = (function () {
function isArray(arr) {
return Object.prototype.toString.apply(arr) === '[object Array]';
}
function isObject(obj) {
return obj instanceof Object;
}
function isFunction(func) {
return typeof func === 'function';
}
var cache = {};
function helperToSlices(string) {
var helperParts = string.replace(/[{}#}]/g, '').split(' ');
var slices = [];
var shiftIndex, i, j;
for (i = 0; i < helperParts.length; i++) {
var part = helperParts[i];
if (i === 0) slices.push(part);
else {
if (part.indexOf('"') === 0) {
// Plain String
if (part.match(/"/g).length === 2) {
// One word string
slices.push(part);
}
else {
// Find closed Index
shiftIndex = 0;
for (j = i + 1; j < helperParts.length; j++) {
part += ' ' + helperParts[j];
if (helperParts[j].indexOf('"') >= 0) {
shiftIndex = j;
slices.push(part);
break;
}
}
if (shiftIndex) i = shiftIndex;
}
}
else {
if (part.indexOf('=') > 0) {
// Hash
var hashParts = part.split('=');
var hashName = hashParts[0];
var hashContent = hashParts[1];
if (hashContent.match(/"/g).length !== 2) {
shiftIndex = 0;
for (j = i + 1; j < helperParts.length; j++) {
hashContent += ' ' + helperParts[j];
if (helperParts[j].indexOf('"') >= 0) {
shiftIndex = j;
break;
}
}
if (shiftIndex) i = shiftIndex;
}
var hash = [hashName, hashContent.replace(/"/g,'')];
slices.push(hash);
}
else {
// Plain variable
slices.push(part);
}
}
}
}
return slices;
}
function stringToBlocks(string) {
var blocks = [], i, j, k;
if (!string) return [];
var _blocks = string.split(/({{[^{^}]*}})/);
for (i = 0; i < _blocks.length; i++) {
var block = _blocks[i];
if (block === '') continue;
if (block.indexOf('{{') < 0) {
blocks.push({
type: 'plain',
content: block
});
}
else {
if (block.indexOf('{/') >= 0) {
continue;
}
if (block.indexOf('{#') < 0 && block.indexOf(' ') < 0 && block.indexOf('else') < 0) {
// Simple variable
blocks.push({
type: 'variable',
contextName: block.replace(/[{}]/g, '')
});
continue;
}
// Helpers
var helperSlices = helperToSlices(block);
var helperName = helperSlices[0];
var helperContext = [];
var helperHash = {};
for (j = 1; j < helperSlices.length; j++) {
var slice = helperSlices[j];
if (isArray(slice)) {
// Hash
helperHash[slice[0]] = slice[1] === 'false' ? false : slice[1];
}
else {
helperContext.push(slice);
}
}
if (block.indexOf('{#') >= 0) {
// Condition/Helper
var helperStartIndex = i;
var helperContent = '';
var elseContent = '';
var toSkip = 0;
var shiftIndex;
var foundClosed = false, foundElse = false, foundClosedElse = false, depth = 0;
for (j = i + 1; j < _blocks.length; j++) {
if (_blocks[j].indexOf('{{#') >= 0) {
depth ++;
}
if (_blocks[j].indexOf('{{/') >= 0) {
depth --;
}
if (_blocks[j].indexOf('{{#' + helperName) >= 0) {
helperContent += _blocks[j];
if (foundElse) elseContent += _blocks[j];
toSkip ++;
}
else if (_blocks[j].indexOf('{{/' + helperName) >= 0) {
if (toSkip > 0) {
toSkip--;
helperContent += _blocks[j];
if (foundElse) elseContent += _blocks[j];
}
else {
shiftIndex = j;
foundClosed = true;
break;
}
}
else if (_blocks[j].indexOf('else') >= 0 && depth === 0) {
foundElse = true;
}
else {
if (!foundElse) helperContent += _blocks[j];
if (foundElse) elseContent += _blocks[j];
}
}
if (foundClosed) {
if (shiftIndex) i = shiftIndex;
blocks.push({
type: 'helper',
helperName: helperName,
contextName: helperContext,
content: helperContent,
inverseContent: elseContent,
hash: helperHash
});
}
}
else if (block.indexOf(' ') > 0) {
blocks.push({
type: 'helper',
helperName: helperName,
contextName: helperContext,
hash: helperHash
});
}
}
}
return blocks;
}
var Template7 = function (template) {
var t = this;
t.template = template;
function getCompileFn(block, depth) {
if (block.content) return compile(block.content, depth);
else return function () {return ''; };
}
function getCompileInverse(block, depth) {
if (block.inverseContent) return compile(block.inverseContent, depth);
else return function () {return ''; };
}
function getCompileVar(name, ctx) {
var variable, parts, levelsUp = 0, initialCtx = ctx;
if (name.indexOf('../') === 0) {
levelsUp = name.split('../').length - 1;
var newDepth = ctx.split('_')[1] - levelsUp;
ctx = 'ctx_' + (newDepth >= 1 ? newDepth : 1);
parts = name.split('../')[levelsUp].split('.');
}
else if (name.indexOf('@global') === 0) {
ctx = 'Template7.global';
parts = name.split('@global.')[1].split('.');
}
else if (name.indexOf('@root') === 0) {
ctx = 'ctx_1';
parts = name.split('@root.')[1].split('.');
}
else {
parts = name.split('.');
}
variable = ctx;
for (var i = 0; i < parts.length; i++) {
var part = parts[i];
if (part.indexOf('@') === 0) {
if (i > 0) {
variable += '[(data && data.' + part.replace('@', '') + ')]';
}
else {
variable = '(data && data.' + name.replace('@', '') + ')';
}
}
else {
if (isFinite(part)) {
variable += '[' + part + ']';
}
else {
if (part.indexOf('this') === 0) {
variable = part.replace('this', ctx);
}
else {
variable += '.' + part;
}
}
}
}
return variable;
}
function getCompiledArguments(contextArray, ctx) {
var arr = [];
for (var i = 0; i < contextArray.length; i++) {
if (contextArray[i].indexOf('"') === 0) arr.push(contextArray[i]);
else {
arr.push(getCompileVar(contextArray[i], ctx));
}
}
return arr.join(', ');
}
function compile(template, depth) {
depth = depth || 1;
template = template || t.template;
if (typeof template !== 'string') {
throw new Error('Template7: Template must be a string');
}
var blocks = stringToBlocks(template);
if (blocks.length === 0) {
return function () { return ''; };
}
var ctx = 'ctx_' + depth;
var resultString = '(function (' + ctx + ', data) {\n';
if (depth === 1) {
resultString += 'function isArray(arr){return Object.prototype.toString.apply(arr) === \'[object Array]\';}\n';
resultString += 'function isFunction(func){return (typeof func === \'function\');}\n';
resultString += 'function c(val, ctx) {if (typeof val !== "undefined") {if (isFunction(val)) {return val.call(ctx);} else return val;} else return "";}\n';
}
resultString += 'var r = \'\';\n';
var i, j, context;
for (i = 0; i < blocks.length; i++) {
var block = blocks[i];
// Plain block
if (block.type === 'plain') {
resultString += 'r +=\'' + (block.content).replace(/\r/g, '\\r').replace(/\n/g, '\\n').replace(/'/g, '\\' + '\'') + '\';';
continue;
}
var variable, compiledArguments;
// Variable block
if (block.type === 'variable') {
variable = getCompileVar(block.contextName, ctx);
resultString += 'r += c(' + variable + ', ' + ctx + ');';
}
// Helpers block
if (block.type === 'helper') {
if (block.helperName in t.helpers) {
compiledArguments = getCompiledArguments(block.contextName, ctx);
resultString += 'r += (Template7.helpers.' + block.helperName + ').call(' + ctx + ', ' + (compiledArguments && (compiledArguments + ', ')) +'{hash:' + JSON.stringify(block.hash) + ', data: data || {}, fn: ' + getCompileFn(block, depth+1) + ', inverse: ' + getCompileInverse(block, depth+1) + ', root: ctx_1});';
}
else {
if (block.contextName.length > 0) {
throw new Error('Template7: Missing helper: "' + block.helperName + '"');
}
else {
variable = getCompileVar(block.helperName, ctx);
resultString += 'if (' + variable + ') {';
resultString += 'if (isArray(' + variable + ')) {';
resultString += 'r += (Template7.helpers.each).call(' + ctx + ', ' + variable + ', {hash:' + JSON.stringify(block.hash) + ', data: data || {}, fn: ' + getCompileFn(block, depth+1) + ', inverse: ' + getCompileInverse(block, depth+1) + ', root: ctx_1});';
resultString += '}else {';
resultString += 'r += (Template7.helpers.with).call(' + ctx + ', ' + variable + ', {hash:' + JSON.stringify(block.hash) + ', data: data || {}, fn: ' + getCompileFn(block, depth+1) + ', inverse: ' + getCompileInverse(block, depth+1) + ', root: ctx_1});';
resultString += '}}';
}
}
}
}
resultString += '\nreturn r;})';
return eval.call(window, resultString);
}
t.compile = function (template) {
if (!t.compiled) {
t.compiled = compile(template);
}
return t.compiled;
};
};
Template7.prototype = {
options: {},
helpers: {
'if': function (context, options) {
if (isFunction(context)) { context = context.call(this); }
if (context) {
return options.fn(this, options.data);
}
else {
return options.inverse(this, options.data);
}
},
'unless': function (context, options) {
if (isFunction(context)) { context = context.call(this); }
if (!context) {
return options.fn(this, options.data);
}
else {
return options.inverse(this, options.data);
}
},
'each': function (context, options) {
var ret = '', i = 0;
if (isFunction(context)) { context = context.call(this); }
if (isArray(context)) {
if (options.hash.reverse) {
context = context.reverse();
}
for (i = 0; i < context.length; i++) {
ret += options.fn(context[i], {first: i === 0, last: i === context.length - 1, index: i});
}
if (options.hash.reverse) {
context = context.reverse();
}
}
else {
for (var key in context) {
i++;
ret += options.fn(context[key], {key: key});
}
}
if (i > 0) return ret;
else return options.inverse(this);
},
'with': function (context, options) {
if (isFunction(context)) { context = context.call(this); }
return options.fn(context);
},
'join': function (context, options) {
if (isFunction(context)) { context = context.call(this); }
return context.join(options.hash.delimiter || options.hash.delimeter);
},
'js': function (expression, options) {
var func;
if (expression.indexOf('return')>=0) {
func = '(function(){'+expression+'})';
}
else {
func = '(function(){return ('+expression+')})';
}
return eval.call(this, func).call(this);
},
'js_compare': function (expression, options) {
var func;
if (expression.indexOf('return')>=0) {
func = '(function(){'+expression+'})';
}
else {
func = '(function(){return ('+expression+')})';
}
var condition = eval.call(this, func).call(this);
if (condition) {
return options.fn(this, options.data);
}
else {
return options.inverse(this, options.data);
}
}
}
};
var t7 = function (template, data) {
if (arguments.length === 2) {
var instance = new Template7(template);
var rendered = instance.compile()(data);
instance = null;
return (rendered);
}
else return new Template7(template);
};
t7.registerHelper = function (name, fn) {
Template7.prototype.helpers[name] = fn;
};
t7.unregisterHelper = function (name) {
Template7.prototype.helpers[name] = undefined;
delete Template7.prototype.helpers[name];
};
t7.compile = function (template, options) {
var instance = new Template7(template, options);
return instance.compile();
};
t7.options = Template7.prototype.options;
t7.helpers = Template7.prototype.helpers;
return t7;
})();
/*===========================
Swiper
===========================*/
window.Swiper = function (container, params) {
if (!(this instanceof Swiper)) return new Swiper(container, params);
var defaults = {
direction: 'horizontal',
touchEventsTarget: 'container',
initialSlide: 0,
speed: 300,
// autoplay
autoplay: false,
autoplayDisableOnInteraction: true,
// Free mode
freeMode: false,
freeModeMomentum: true,
freeModeMomentumRatio: 1,
freeModeMomentumBounce: true,
freeModeMomentumBounceRatio: 1,
freeModeSticky: false,
// Set wrapper width
setWrapperSize: false,
// Virtual Translate
virtualTranslate: false,
// Effects
effect: 'slide', // 'slide' or 'fade' or 'cube' or 'coverflow'
coverflow: {
rotate: 50,
stretch: 0,
depth: 100,
modifier: 1,
slideShadows : true
},
cube: {
slideShadows: true,
shadow: true,
shadowOffset: 20,
shadowScale: 0.94
},
fade: {
crossFade: false
},
// Parallax
parallax: false,
// Scrollbar
scrollbar: null,
scrollbarHide: true,
// Keyboard Mousewheel
keyboardControl: false,
mousewheelControl: false,
mousewheelForceToAxis: false,
// Hash Navigation
hashnav: false,
// Slides grid
spaceBetween: 0,
slidesPerView: 1,
slidesPerColumn: 1,
slidesPerColumnFill: 'column',
slidesPerGroup: 1,
centeredSlides: false,
// Touches
touchRatio: 1,
touchAngle: 45,
simulateTouch: true,
shortSwipes: true,
longSwipes: true,
longSwipesRatio: 0.5,
longSwipesMs: 300,
followFinger: true,
onlyExternal: false,
threshold: 0,
touchMoveStopPropagation: true,
// Pagination
pagination: null,
paginationClickable: false,
paginationHide: false,
paginationBulletRender: null,
// Resistance
resistance: true,
resistanceRatio: 0.85,
// Next/prev buttons
nextButton: null,
prevButton: null,
// Progress
watchSlidesProgress: false,
watchSlidesVisibility: false,
// Cursor
grabCursor: false,
// Clicks
preventClicks: true,
preventClicksPropagation: true,
slideToClickedSlide: false,
// Lazy Loading
lazyLoading: false,
lazyLoadingInPrevNext: false,
lazyLoadingOnTransitionStart: false,
// Images
preloadImages: true,
updateOnImagesReady: true,
// loop
loop: false,
loopAdditionalSlides: 0,
loopedSlides: null,
// Control
control: undefined,
controlInverse: false,
// Swiping/no swiping
allowSwipeToPrev: true,
allowSwipeToNext: true,
swipeHandler: null, //'.swipe-handler',
noSwiping: true,
noSwipingClass: 'swiper-no-swiping',
// NS
slideClass: 'swiper-slide',
slideActiveClass: 'swiper-slide-active',
slideVisibleClass: 'swiper-slide-visible',
slideDuplicateClass: 'swiper-slide-duplicate',
slideNextClass: 'swiper-slide-next',
slidePrevClass: 'swiper-slide-prev',
wrapperClass: 'swiper-wrapper',
bulletClass: 'swiper-pagination-bullet',
bulletActiveClass: 'swiper-pagination-bullet-active',
buttonDisabledClass: 'swiper-button-disabled',
paginationHiddenClass: 'swiper-pagination-hidden',
// Observer
observer: false,
observeParents: false,
// Accessibility
a11y: false,
prevSlideMessage: 'Previous slide',
nextSlideMessage: 'Next slide',
firstSlideMessage: 'This is the first slide',
lastSlideMessage: 'This is the last slide',
// Callbacks
runCallbacksOnInit: true,
/*
Callbacks:
onInit: function (swiper)
onDestroy: function (swiper)
onClick: function (swiper, e)
onTap: function (swiper, e)
onDoubleTap: function (swiper, e)
onSliderMove: function (swiper, e)
onSlideChangeStart: function (swiper)
onSlideChangeEnd: function (swiper)
onTransitionStart: function (swiper)
onTransitionEnd: function (swiper)
onImagesReady: function (swiper)
onProgress: function (swiper, progress)
onTouchStart: function (swiper, e)
onTouchMove: function (swiper, e)
onTouchMoveOpposite: function (swiper, e)
onTouchEnd: function (swiper, e)
onReachBeginning: function (swiper)
onReachEnd: function (swiper)
onSetTransition: function (swiper, duration)
onSetTranslate: function (swiper, translate)
onAutoplayStart: function (swiper)
onAutoplayStop: function (swiper),
onLazyImageLoad: function (swiper, slide, image)
onLazyImageReady: function (swiper, slide, image)
*/
};
var initialVirtualTranslate = params && params.virtualTranslate;
params = params || {};
for (var def in defaults) {
if (typeof params[def] === 'undefined') {
params[def] = defaults[def];
}
else if (typeof params[def] === 'object') {
for (var deepDef in defaults[def]) {
if (typeof params[def][deepDef] === 'undefined') {
params[def][deepDef] = defaults[def][deepDef];
}
}
}
}
// Swiper
var s = this;
// Version
s.version = '3.0.7';
// Params
s.params = params;
// Classname
s.classNames = [];
/*=========================
Dom Library and plugins
===========================*/
var $;
if (typeof Dom7 === 'undefined') {
$ = window.Dom7 || window.Zepto || window.jQuery;
}
else {
$ = Dom7;
}
if (!$) return;
// Export it to Swiper instance
s.$ = $;
/*=========================
Preparation - Define Container, Wrapper and Pagination
===========================*/
s.container = $(container);
if (s.container.length === 0) return;
if (s.container.length > 1) {
s.container.each(function () {
new Swiper(this, params);
});
return;
}
// Save instance in container HTML Element and in data
s.container[0].swiper = s;
s.container.data('swiper', s);
s.classNames.push('swiper-container-' + s.params.direction);
if (s.params.freeMode) {
s.classNames.push('swiper-container-free-mode');
}
if (!s.support.flexbox) {
s.classNames.push('swiper-container-no-flexbox');
s.params.slidesPerColumn = 1;
}
// Enable slides progress when required
if (s.params.parallax || s.params.watchSlidesVisibility) {
s.params.watchSlidesProgress = true;
}
// Coverflow / 3D
if (['cube', 'coverflow'].indexOf(s.params.effect) >= 0) {
if (s.support.transforms3d) {
s.params.watchSlidesProgress = true;
s.classNames.push('swiper-container-3d');
}
else {
s.params.effect = 'slide';
}
}
if (s.params.effect !== 'slide') {
s.classNames.push('swiper-container-' + s.params.effect);
}
if (s.params.effect === 'cube') {
s.params.resistanceRatio = 0;
s.params.slidesPerView = 1;
s.params.slidesPerColumn = 1;
s.params.slidesPerGroup = 1;
s.params.centeredSlides = false;
s.params.spaceBetween = 0;
s.params.virtualTranslate = true;
s.params.setWrapperSize = false;
}
if (s.params.effect === 'fade') {
s.params.slidesPerView = 1;
s.params.slidesPerColumn = 1;
s.params.slidesPerGroup = 1;
s.params.watchSlidesProgress = true;
s.params.spaceBetween = 0;
if (typeof initialVirtualTranslate === 'undefined') {
s.params.virtualTranslate = true;
}
}
// Grab Cursor
if (s.params.grabCursor && s.support.touch) {
s.params.grabCursor = false;
}
// Wrapper
s.wrapper = s.container.children('.' + s.params.wrapperClass);
// Pagination
if (s.params.pagination) {
s.paginationContainer = $(s.params.pagination);
if (s.params.paginationClickable) {
s.paginationContainer.addClass('swiper-pagination-clickable');
}
}
// Is Horizontal
function isH() {
return s.params.direction === 'horizontal';
}
// RTL
s.rtl = isH() && (s.container[0].dir.toLowerCase() === 'rtl' || s.container.css('direction') === 'rtl');
if (s.rtl) {
s.classNames.push('swiper-container-rtl');
}
// Wrong RTL support
if (s.rtl) {
s.wrongRTL = s.wrapper.css('display') === '-webkit-box';
}
// Columns
if (s.params.slidesPerColumn > 1) {
s.classNames.push('swiper-container-multirow');
}
// Check for Android
if (s.device.android) {
s.classNames.push('swiper-container-android');
}
// Add classes
s.container.addClass(s.classNames.join(' '));
// Translate
s.translate = 0;
// Progress
s.progress = 0;
// Velocity
s.velocity = 0;
// Locks, unlocks
s.lockSwipeToNext = function () {
s.params.allowSwipeToNext = false;
};
s.lockSwipeToPrev = function () {
s.params.allowSwipeToPrev = false;
};
s.lockSwipes = function () {
s.params.allowSwipeToNext = s.params.allowSwipeToPrev = false;
};
s.unlockSwipeToNext = function () {
s.params.allowSwipeToNext = true;
};
s.unlockSwipeToPrev = function () {
s.params.allowSwipeToPrev = true;
};
s.unlockSwipes = function () {
s.params.allowSwipeToNext = s.params.allowSwipeToPrev = true;
};
/*=========================
Set grab cursor
===========================*/
if (s.params.grabCursor) {
s.container[0].style.cursor = 'move';
s.container[0].style.cursor = '-webkit-grab';
s.container[0].style.cursor = '-moz-grab';
s.container[0].style.cursor = 'grab';
}
/*=========================
Update on Images Ready
===========================*/
s.imagesToLoad = [];
s.imagesLoaded = 0;
s.loadImage = function (imgElement, src, checkForComplete, callback) {
var image;
function onReady () {
if (callback) callback();
}
if (!imgElement.complete || !checkForComplete) {
if (src) {
image = new window.Image();
image.onload = onReady;
image.onerror = onReady;
image.src = src;
} else {
onReady();
}
} else {//image already loaded...
onReady();
}
};
s.preloadImages = function () {
s.imagesToLoad = s.container.find('img');
function _onReady() {
if (typeof s === 'undefined' || s === null) return;
if (s.imagesLoaded !== undefined) s.imagesLoaded++;
if (s.imagesLoaded === s.imagesToLoad.length) {
if (s.params.updateOnImagesReady) s.update();
s.emit('onImagesReady', s);
}
}
for (var i = 0; i < s.imagesToLoad.length; i++) {
s.loadImage(s.imagesToLoad[i], (s.imagesToLoad[i].currentSrc || s.imagesToLoad[i].getAttribute('src')), true, _onReady);
}
};
/*=========================
Autoplay
===========================*/
s.autoplayTimeoutId = undefined;
s.autoplaying = false;
s.autoplayPaused = false;
function autoplay() {
s.autoplayTimeoutId = setTimeout(function () {
if (s.params.loop) {
s.fixLoop();
s._slideNext();
}
else {
if (!s.isEnd) {
s._slideNext();
}
else {
if (!params.autoplayStopOnLast) {
s._slideTo(0);
}
else {
s.stopAutoplay();
}
}
}
}, s.params.autoplay);
}
s.startAutoplay = function () {
if (typeof s.autoplayTimeoutId !== 'undefined') return false;
if (!s.params.autoplay) return false;
if (s.autoplaying) return false;
s.autoplaying = true;
s.emit('onAutoplayStart', s);
autoplay();
};
s.stopAutoplay = function (internal) {
if (!s.autoplayTimeoutId) return;
if (s.autoplayTimeoutId) clearTimeout(s.autoplayTimeoutId);
s.autoplaying = false;
s.autoplayTimeoutId = undefined;
s.emit('onAutoplayStop', s);
};
s.pauseAutoplay = function (speed) {
if (s.autoplayPaused) return;
if (s.autoplayTimeoutId) clearTimeout(s.autoplayTimeoutId);
s.autoplayPaused = true;
if (speed === 0) {
s.autoplayPaused = false;
autoplay();
}
else {
s.wrapper.transitionEnd(function () {
if (!s) return;
s.autoplayPaused = false;
if (!s.autoplaying) {
s.stopAutoplay();
}
else {
autoplay();
}
});
}
};
/*=========================
Min/Max Translate
===========================*/
s.minTranslate = function () {
return (-s.snapGrid[0]);
};
s.maxTranslate = function () {
return (-s.snapGrid[s.snapGrid.length - 1]);
};
/*=========================
Slider/slides sizes
===========================*/
s.updateContainerSize = function () {
var width, height;
if (typeof s.params.width !== 'undefined') {
width = s.params.width;
}
else {
width = s.container[0].clientWidth;
}
if (typeof s.params.height !== 'undefined') {
height = s.params.height;
}
else {
height = s.container[0].clientHeight;
}
if (width === 0 && isH() || height === 0 && !isH()) {
return;
}
s.width = width;
s.height = height;
s.size = isH() ? s.width : s.height;
};
s.updateSlidesSize = function () {
s.slides = s.wrapper.children('.' + s.params.slideClass);
s.snapGrid = [];
s.slidesGrid = [];
s.slidesSizesGrid = [];
var spaceBetween = s.params.spaceBetween,
slidePosition = 0,
i,
prevSlideSize = 0,
index = 0;
if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * s.size;
}
s.virtualSize = -spaceBetween;
// reset margins
if (s.rtl) s.slides.css({marginLeft: '', marginTop: ''});
else s.slides.css({marginRight: '', marginBottom: ''});
var slidesNumberEvenToRows;
if (s.params.slidesPerColumn > 1) {
if (Math.floor(s.slides.length / s.params.slidesPerColumn) === s.slides.length / s.params.slidesPerColumn) {
slidesNumberEvenToRows = s.slides.length;
}
else {
slidesNumberEvenToRows = Math.ceil(s.slides.length / s.params.slidesPerColumn) * s.params.slidesPerColumn;
}
}
// Calc slides
var slideSize;
for (i = 0; i < s.slides.length; i++) {
slideSize = 0;
var slide = s.slides.eq(i);
if (s.params.slidesPerColumn > 1) {
// Set slides order
var newSlideOrderIndex;
var column, row;
var slidesPerColumn = s.params.slidesPerColumn;
var slidesPerRow;
if (s.params.slidesPerColumnFill === 'column') {
column = Math.floor(i / slidesPerColumn);
row = i - column * slidesPerColumn;
newSlideOrderIndex = column + row * slidesNumberEvenToRows / slidesPerColumn;
slide
.css({
'-webkit-box-ordinal-group': newSlideOrderIndex,
'-moz-box-ordinal-group': newSlideOrderIndex,
'-ms-flex-order': newSlideOrderIndex,
'-webkit-order': newSlideOrderIndex,
'order': newSlideOrderIndex
});
}
else {
slidesPerRow = slidesNumberEvenToRows / slidesPerColumn;
row = Math.floor(i / slidesPerRow);
column = i - row * slidesPerRow;
}
slide
.css({
'margin-top': (row !== 0 && s.params.spaceBetween) && (s.params.spaceBetween + 'px')
})
.attr('data-swiper-column', column)
.attr('data-swiper-row', row);
}
if (slide.css('display') === 'none') continue;
if (s.params.slidesPerView === 'auto') {
slideSize = isH() ? slide.outerWidth(true) : slide.outerHeight(true);
}
else {
slideSize = (s.size - (s.params.slidesPerView - 1) * spaceBetween) / s.params.slidesPerView;
if (isH()) {
s.slides[i].style.width = slideSize + 'px';
}
else {
s.slides[i].style.height = slideSize + 'px';
}
}
s.slides[i].swiperSlideSize = slideSize;
s.slidesSizesGrid.push(slideSize);
if (s.params.centeredSlides) {
slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
if (i === 0) slidePosition = slidePosition - s.size / 2 - spaceBetween;
if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
if ((index) % s.params.slidesPerGroup === 0) s.snapGrid.push(slidePosition);
s.slidesGrid.push(slidePosition);
}
else {
if ((index) % s.params.slidesPerGroup === 0) s.snapGrid.push(slidePosition);
s.slidesGrid.push(slidePosition);
slidePosition = slidePosition + slideSize + spaceBetween;
}
s.virtualSize += slideSize + spaceBetween;
prevSlideSize = slideSize;
index ++;
}
s.virtualSize = Math.max(s.virtualSize, s.size);
var newSlidesGrid;
if (
s.rtl && s.wrongRTL && (s.params.effect === 'slide' || s.params.effect === 'coverflow')) {
s.wrapper.css({width: s.virtualSize + s.params.spaceBetween + 'px'});
}
if (!s.support.flexbox || s.params.setWrapperSize) {
if (isH()) s.wrapper.css({width: s.virtualSize + s.params.spaceBetween + 'px'});
else s.wrapper.css({height: s.virtualSize + s.params.spaceBetween + 'px'});
}
if (s.params.slidesPerColumn > 1) {
s.virtualSize = (slideSize + s.params.spaceBetween) * slidesNumberEvenToRows;
s.virtualSize = Math.ceil(s.virtualSize / s.params.slidesPerColumn) - s.params.spaceBetween;
s.wrapper.css({width: s.virtualSize + s.params.spaceBetween + 'px'});
if (s.params.centeredSlides) {
newSlidesGrid = [];
for (i = 0; i < s.snapGrid.length; i++) {
if (s.snapGrid[i] < s.virtualSize + s.snapGrid[0]) newSlidesGrid.push(s.snapGrid[i]);
}
s.snapGrid = newSlidesGrid;
}
}
// Remove last grid elements depending on width
if (!s.params.centeredSlides) {
newSlidesGrid = [];
for (i = 0; i < s.snapGrid.length; i++) {
if (s.snapGrid[i] <= s.virtualSize - s.size) {
newSlidesGrid.push(s.snapGrid[i]);
}
}
s.snapGrid = newSlidesGrid;
if (Math.floor(s.virtualSize - s.size) > Math.floor(s.snapGrid[s.snapGrid.length - 1])) {
s.snapGrid.push(s.virtualSize - s.size);
}
}
if (s.snapGrid.length === 0) s.snapGrid = [0];
if (s.params.spaceBetween !== 0) {
if (isH()) {
if (s.rtl) s.slides.css({marginLeft: spaceBetween + 'px'});
else s.slides.css({marginRight: spaceBetween + 'px'});
}
else s.slides.css({marginBottom: spaceBetween + 'px'});
}
if (s.params.watchSlidesProgress) {
s.updateSlidesOffset();
}
};
s.updateSlidesOffset = function () {
for (var i = 0; i < s.slides.length; i++) {
s.slides[i].swiperSlideOffset = isH() ? s.slides[i].offsetLeft : s.slides[i].offsetTop;
}
};
/*=========================
Slider/slides progress
===========================*/
s.updateSlidesProgress = function (translate) {
if (typeof translate === 'undefined') {
translate = s.translate || 0;
}
if (s.slides.length === 0) return;
if (typeof s.slides[0].swiperSlideOffset === 'undefined') s.updateSlidesOffset();
var offsetCenter = s.params.centeredSlides ? -translate + s.size / 2 : -translate;
if (s.rtl) offsetCenter = s.params.centeredSlides ? translate - s.size / 2 : translate;
// Visible Slides
var containerBox = s.container[0].getBoundingClientRect();
var sideBefore = isH() ? 'left' : 'top';
var sideAfter = isH() ? 'right' : 'bottom';
s.slides.removeClass(s.params.slideVisibleClass);
for (var i = 0; i < s.slides.length; i++) {
var slide = s.slides[i];
var slideCenterOffset = (s.params.centeredSlides === true) ? slide.swiperSlideSize / 2 : 0;
var slideProgress = (offsetCenter - slide.swiperSlideOffset - slideCenterOffset) / (slide.swiperSlideSize + s.params.spaceBetween);
if (s.params.watchSlidesVisibility) {
var slideBefore = -(offsetCenter - slide.swiperSlideOffset - slideCenterOffset);
var slideAfter = slideBefore + s.slidesSizesGrid[i];
var isVisible =
(slideBefore >= 0 && slideBefore < s.size) ||
(slideAfter > 0 && slideAfter <= s.size) ||
(slideBefore <= 0 && slideAfter >= s.size);
if (isVisible) {
s.slides.eq(i).addClass(s.params.slideVisibleClass);
}
}
slide.progress = s.rtl ? -slideProgress : slideProgress;
}
};
s.updateProgress = function (translate) {
if (typeof translate === 'undefined') {
translate = s.translate || 0;
}
var translatesDiff = s.maxTranslate() - s.minTranslate();
if (translatesDiff === 0) {
s.progress = 0;
s.isBeginning = s.isEnd = true;
}
else {
s.progress = (translate - s.minTranslate()) / (translatesDiff);
s.isBeginning = s.progress <= 0;
s.isEnd = s.progress >= 1;
}
if (s.isBeginning) s.emit('onReachBeginning', s);
if (s.isEnd) s.emit('onReachEnd', s);
if (s.params.watchSlidesProgress) s.updateSlidesProgress(translate);
s.emit('onProgress', s, s.progress);
};
s.updateActiveIndex = function () {
var translate = s.rtl ? s.translate : -s.translate;
var newActiveIndex, i, snapIndex;
for (i = 0; i < s.slidesGrid.length; i ++) {
if (typeof s.slidesGrid[i + 1] !== 'undefined') {
if (translate >= s.slidesGrid[i] && translate < s.slidesGrid[i + 1] - (s.slidesGrid[i + 1] - s.slidesGrid[i]) / 2) {
newActiveIndex = i;
}
else if (translate >= s.slidesGrid[i] && translate < s.slidesGrid[i + 1]) {
newActiveIndex = i + 1;
}
}
else {
if (translate >= s.slidesGrid[i]) {
newActiveIndex = i;
}
}
}
// Normalize slideIndex
if (newActiveIndex < 0 || typeof newActiveIndex === 'undefined') newActiveIndex = 0;
// for (i = 0; i < s.slidesGrid.length; i++) {
// if (- translate >= s.slidesGrid[i]) {
// newActiveIndex = i;
// }
// }
snapIndex = Math.floor(newActiveIndex / s.params.slidesPerGroup);
if (snapIndex >= s.snapGrid.length) snapIndex = s.snapGrid.length - 1;
if (newActiveIndex === s.activeIndex) {
return;
}
s.snapIndex = snapIndex;
s.previousIndex = s.activeIndex;
s.activeIndex = newActiveIndex;
s.updateClasses();
};
/*=========================
Classes
===========================*/
s.updateClasses = function () {
s.slides.removeClass(s.params.slideActiveClass + ' ' + s.params.slideNextClass + ' ' + s.params.slidePrevClass);
var activeSlide = s.slides.eq(s.activeIndex);
// Active classes
activeSlide.addClass(s.params.slideActiveClass);
activeSlide.next('.' + s.params.slideClass).addClass(s.params.slideNextClass);
activeSlide.prev('.' + s.params.slideClass).addClass(s.params.slidePrevClass);
// Pagination
if (s.bullets && s.bullets.length > 0) {
s.bullets.removeClass(s.params.bulletActiveClass);
var bulletIndex;
if (s.params.loop) {
bulletIndex = Math.ceil(s.activeIndex - s.loopedSlides)/s.params.slidesPerGroup;
if (bulletIndex > s.slides.length - 1 - s.loopedSlides * 2) {
bulletIndex = bulletIndex - (s.slides.length - s.loopedSlides * 2);
}
if (bulletIndex > s.bullets.length - 1) bulletIndex = bulletIndex - s.bullets.length;
}
else {
if (typeof s.snapIndex !== 'undefined') {
bulletIndex = s.snapIndex;
}
else {
bulletIndex = s.activeIndex || 0;
}
}
if (s.paginationContainer.length > 1) {
s.bullets.each(function () {
if ($(this).index() === bulletIndex) $(this).addClass(s.params.bulletActiveClass);
});
}
else {
s.bullets.eq(bulletIndex).addClass(s.params.bulletActiveClass);
}
}
// Next/active buttons
if (!s.params.loop) {
if (s.params.prevButton) {
if (s.isBeginning) {
$(s.params.prevButton).addClass(s.params.buttonDisabledClass);
if (s.params.a11y && s.a11y) s.a11y.disable($(s.params.prevButton));
}
else {
$(s.params.prevButton).removeClass(s.params.buttonDisabledClass);
if (s.params.a11y && s.a11y) s.a11y.enable($(s.params.prevButton));
}
}
if (s.params.nextButton) {
if (s.isEnd) {
$(s.params.nextButton).addClass(s.params.buttonDisabledClass);
if (s.params.a11y && s.a11y) s.a11y.disable($(s.params.nextButton));
}
else {
$(s.params.nextButton).removeClass(s.params.buttonDisabledClass);
if (s.params.a11y && s.a11y) s.a11y.enable($(s.params.nextButton));
}
}
}
};
/*=========================
Pagination
===========================*/
s.updatePagination = function () {
if (!s.params.pagination) return;
if (s.paginationContainer && s.paginationContainer.length > 0) {
var bulletsHTML = '';
var numberOfBullets = s.params.loop ? Math.ceil((s.slides.length - s.loopedSlides * 2) / s.params.slidesPerGroup) : s.snapGrid.length;
for (var i = 0; i < numberOfBullets; i++) {
if (s.params.paginationBulletRender) {
bulletsHTML += s.params.paginationBulletRender(i, s.params.bulletClass);
}
else {
bulletsHTML += '<span class="' + s.params.bulletClass + '"></span>';
}
}
s.paginationContainer.html(bulletsHTML);
s.bullets = s.paginationContainer.find('.' + s.params.bulletClass);
}
};
/*=========================
Common update method
===========================*/
s.update = function (updateTranslate) {
s.updateContainerSize();
s.updateSlidesSize();
s.updateProgress();
s.updatePagination();
s.updateClasses();
if (s.params.scrollbar && s.scrollbar) {
s.scrollbar.set();
}
function forceSetTranslate() {
newTranslate = Math.min(Math.max(s.translate, s.maxTranslate()), s.minTranslate());
s.setWrapperTranslate(newTranslate);
s.updateActiveIndex();
s.updateClasses();
}
if (updateTranslate) {
var translated, newTranslate;
if (s.params.freeMode) {
forceSetTranslate();
}
else {
if (s.params.slidesPerView === 'auto' && s.isEnd && !s.params.centeredSlides) {
translated = s.slideTo(s.slides.length - 1, 0, false, true);
}
else {
translated = s.slideTo(s.activeIndex, 0, false, true);
}
if (!translated) {
forceSetTranslate();
}
}
}
};
/*=========================
Resize Handler
===========================*/
s.onResize = function (forceUpdatePagination) {
s.updateContainerSize();
s.updateSlidesSize();
s.updateProgress();
if (s.params.slidesPerView === 'auto' || s.params.freeMode || forceUpdatePagination) s.updatePagination();
if (s.params.scrollbar && s.scrollbar) {
s.scrollbar.set();
}
if (s.params.freeMode) {
var newTranslate = Math.min(Math.max(s.translate, s.maxTranslate()), s.minTranslate());
s.setWrapperTranslate(newTranslate);
s.updateActiveIndex();
s.updateClasses();
}
else {
s.updateClasses();
if (s.params.slidesPerView === 'auto' && s.isEnd && !s.params.centeredSlides) {
s.slideTo(s.slides.length - 1, 0, false, true);
}
else {
s.slideTo(s.activeIndex, 0, false, true);
}
}
};
/*=========================
Events
===========================*/
//Define Touch Events
var desktopEvents = ['mousedown', 'mousemove', 'mouseup'];
if (window.navigator.pointerEnabled) desktopEvents = ['pointerdown', 'pointermove', 'pointerup'];
else if (window.navigator.msPointerEnabled) desktopEvents = ['MSPointerDown', 'MSPointerMove', 'MSPointerUp'];
s.touchEvents = {
start : s.support.touch || !s.params.simulateTouch ? 'touchstart' : desktopEvents[0],
move : s.support.touch || !s.params.simulateTouch ? 'touchmove' : desktopEvents[1],
end : s.support.touch || !s.params.simulateTouch ? 'touchend' : desktopEvents[2]
};
// WP8 Touch Events Fix
if (window.navigator.pointerEnabled || window.navigator.msPointerEnabled) {
(s.params.touchEventsTarget === 'container' ? s.container : s.wrapper).addClass('swiper-wp8-' + s.params.direction);
}
// Attach/detach events
s.initEvents = function (detach) {
var actionDom = detach ? 'off' : 'on';
var action = detach ? 'removeEventListener' : 'addEventListener';
var touchEventsTarget = s.params.touchEventsTarget === 'container' ? s.container[0] : s.wrapper[0];
var target = s.support.touch ? touchEventsTarget : document;
var moveCapture = s.params.nested ? true : false;
//Touch Events
if (s.browser.ie) {
touchEventsTarget[action](s.touchEvents.start, s.onTouchStart, false);
target[action](s.touchEvents.move, s.onTouchMove, moveCapture);
target[action](s.touchEvents.end, s.onTouchEnd, false);
}
else {
if (s.support.touch) {
touchEventsTarget[action](s.touchEvents.start, s.onTouchStart, false);
touchEventsTarget[action](s.touchEvents.move, s.onTouchMove, moveCapture);
touchEventsTarget[action](s.touchEvents.end, s.onTouchEnd, false);
}
if (params.simulateTouch && !s.device.ios && !s.device.android) {
touchEventsTarget[action]('mousedown', s.onTouchStart, false);
document[action]('mousemove', s.onTouchMove, moveCapture);
document[action]('mouseup', s.onTouchEnd, false);
}
}
window[action]('resize', s.onResize);
// Next, Prev, Index
if (s.params.nextButton) {
$(s.params.nextButton)[actionDom]('click', s.onClickNext);
if (s.params.a11y && s.a11y) $(s.params.nextButton)[actionDom]('keydown', s.a11y.onEnterKey);
}
if (s.params.prevButton) {
$(s.params.prevButton)[actionDom]('click', s.onClickPrev);
if (s.params.a11y && s.a11y) $(s.params.prevButton)[actionDom]('keydown', s.a11y.onEnterKey);
}
if (s.params.pagination && s.params.paginationClickable) {
$(s.paginationContainer)[actionDom]('click', '.' + s.params.bulletClass, s.onClickIndex);
}
// Prevent Links Clicks
if (s.params.preventClicks || s.params.preventClicksPropagation) touchEventsTarget[action]('click', s.preventClicks, true);
};
s.attachEvents = function (detach) {
s.initEvents();
};
s.detachEvents = function () {
s.initEvents(true);
};
/*=========================
Handle Clicks
===========================*/
// Prevent Clicks
s.allowClick = true;
s.preventClicks = function (e) {
if (!s.allowClick) {
if (s.params.preventClicks) e.preventDefault();
if (s.params.preventClicksPropagation) {
e.stopPropagation();
e.stopImmediatePropagation();
}
}
};
// Clicks
s.onClickNext = function (e) {
e.preventDefault();
s.slideNext();
};
s.onClickPrev = function (e) {
e.preventDefault();
s.slidePrev();
};
s.onClickIndex = function (e) {
e.preventDefault();
var index = $(this).index() * s.params.slidesPerGroup;
if (s.params.loop) index = index + s.loopedSlides;
s.slideTo(index);
};
/*=========================
Handle Touches
===========================*/
function findElementInEvent(e, selector) {
var el = $(e.target);
if (!el.is(selector)) {
if (typeof selector === 'string') {
el = el.parents(selector);
}
else if (selector.nodeType) {
var found;
el.parents().each(function (index, _el) {
if (_el === selector) found = selector;
});
if (!found) return undefined;
else return selector;
}
}
if (el.length === 0) {
return undefined;
}
return el[0];
}
s.updateClickedSlide = function (e) {
var slide = findElementInEvent(e, '.' + s.params.slideClass);
var slideFound = false;
if (slide) {
for (var i = 0; i < s.slides.length; i++) {
if (s.slides[i] === slide) slideFound = true;
}
}
if (slide && slideFound) {
s.clickedSlide = slide;
s.clickedIndex = $(slide).index();
}
else {
s.clickedSlide = undefined;
s.clickedIndex = undefined;
return;
}
if (s.params.slideToClickedSlide && s.clickedIndex !== undefined && s.clickedIndex !== s.activeIndex) {
var slideToIndex = s.clickedIndex,
realIndex;
if (s.params.loop) {
realIndex = $(s.clickedSlide).attr('data-swiper-slide-index');
if (slideToIndex > s.slides.length - s.params.slidesPerView) {
s.fixLoop();
slideToIndex = s.wrapper.children('.' + s.params.slideClass + '[data-swiper-slide-index="' + realIndex + '"]').eq(0).index();
setTimeout(function () {
s.slideTo(slideToIndex);
}, 0);
}
else if (slideToIndex < s.params.slidesPerView - 1) {
s.fixLoop();
var duplicatedSlides = s.wrapper.children('.' + s.params.slideClass + '[data-swiper-slide-index="' + realIndex + '"]');
slideToIndex = duplicatedSlides.eq(duplicatedSlides.length - 1).index();
setTimeout(function () {
s.slideTo(slideToIndex);
}, 0);
}
else {
s.slideTo(slideToIndex);
}
}
else {
s.slideTo(slideToIndex);
}
}
};
var isTouched,
isMoved,
touchStartTime,
isScrolling,
currentTranslate,
startTranslate,
allowThresholdMove,
// Form elements to match
formElements = 'input, select, textarea, button',
// Last click time
lastClickTime = Date.now(), clickTimeout,
//Velocities
velocities = [],
allowMomentumBounce;
// Animating Flag
s.animating = false;
// Touches information
s.touches = {
startX: 0,
startY: 0,
currentX: 0,
currentY: 0,
diff: 0
};
// Touch handlers
var isTouchEvent, startMoving;
s.onTouchStart = function (e) {
if (e.originalEvent) e = e.originalEvent;
isTouchEvent = e.type === 'touchstart';
if (!isTouchEvent && 'which' in e && e.which === 3) return;
if (s.params.noSwiping && findElementInEvent(e, '.' + s.params.noSwipingClass)) {
s.allowClick = true;
return;
}
if (s.params.swipeHandler) {
if (!findElementInEvent(e, s.params.swipeHandler)) return;
}
isTouched = true;
isMoved = false;
isScrolling = undefined;
startMoving = undefined;
s.touches.startX = s.touches.currentX = e.type === 'touchstart' ? e.targetTouches[0].pageX : e.pageX;
s.touches.startY = s.touches.currentY = e.type === 'touchstart' ? e.targetTouches[0].pageY : e.pageY;
touchStartTime = Date.now();
s.allowClick = true;
s.updateContainerSize();
s.swipeDirection = undefined;
if (s.params.threshold > 0) allowThresholdMove = false;
if (e.type !== 'touchstart') {
var preventDefault = true;
if ($(e.target).is(formElements)) preventDefault = false;
if (document.activeElement && $(document.activeElement).is(formElements)) {
document.activeElement.blur();
}
if (preventDefault) {
e.preventDefault();
}
}
s.emit('onTouchStart', s, e);
};
s.onTouchMove = function (e) {
if (e.originalEvent) e = e.originalEvent;
if (isTouchEvent && e.type === 'mousemove') return;
if (e.preventedByNestedSwiper) return;
if (s.params.onlyExternal) {
isMoved = true;
s.allowClick = false;
return;
}
if (isTouchEvent && document.activeElement) {
if (e.target === document.activeElement && $(e.target).is(formElements)) {
isMoved = true;
s.allowClick = false;
return;
}
}
s.emit('onTouchMove', s, e);
if (e.targetTouches && e.targetTouches.length > 1) return;
s.touches.currentX = e.type === 'touchmove' ? e.targetTouches[0].pageX : e.pageX;
s.touches.currentY = e.type === 'touchmove' ? e.targetTouches[0].pageY : e.pageY;
if (typeof isScrolling === 'undefined') {
var touchAngle = Math.atan2(Math.abs(s.touches.currentY - s.touches.startY), Math.abs(s.touches.currentX - s.touches.startX)) * 180 / Math.PI;
isScrolling = isH() ? touchAngle > s.params.touchAngle : (90 - touchAngle > s.params.touchAngle);
}
if (isScrolling) {
s.emit('onTouchMoveOpposite', s, e);
}
if (typeof startMoving === 'undefined' && s.browser.ieTouch) {
if (s.touches.currentX !== s.touches.startX || s.touches.currentY !== s.touches.startY) {
startMoving = true;
}
}
if (!isTouched) return;
if (isScrolling) {
isTouched = false;
return;
}
if (!startMoving && s.browser.ieTouch) {
return;
}
s.allowClick = false;
s.emit('onSliderMove', s, e);
e.preventDefault();
if (s.params.touchMoveStopPropagation && !s.params.nested) {
e.stopPropagation();
}
if (!isMoved) {
if (params.loop) {
s.fixLoop();
}
startTranslate = s.getWrapperTranslate();
s.setWrapperTransition(0);
if (s.animating) {
s.wrapper.trigger('webkitTransitionEnd transitionend oTransitionEnd MSTransitionEnd msTransitionEnd');
}
if (s.params.autoplay && s.autoplaying) {
if (s.params.autoplayDisableOnInteraction) {
s.stopAutoplay();
}
else {
s.pauseAutoplay();
}
}
allowMomentumBounce = false;
//Grab Cursor
if (s.params.grabCursor) {
s.container[0].style.cursor = 'move';
s.container[0].style.cursor = '-webkit-grabbing';
s.container[0].style.cursor = '-moz-grabbin';
s.container[0].style.cursor = 'grabbing';
}
}
isMoved = true;
var diff = s.touches.diff = isH() ? s.touches.currentX - s.touches.startX : s.touches.currentY - s.touches.startY;
diff = diff * s.params.touchRatio;
if (s.rtl) diff = -diff;
s.swipeDirection = diff > 0 ? 'prev' : 'next';
currentTranslate = diff + startTranslate;
var disableParentSwiper = true;
if ((diff > 0 && currentTranslate > s.minTranslate())) {
disableParentSwiper = false;
if (s.params.resistance) currentTranslate = s.minTranslate() - 1 + Math.pow(-s.minTranslate() + startTranslate + diff, s.params.resistanceRatio);
}
else if (diff < 0 && currentTranslate < s.maxTranslate()) {
disableParentSwiper = false;
if (s.params.resistance) currentTranslate = s.maxTranslate() + 1 - Math.pow(s.maxTranslate() - startTranslate - diff, s.params.resistanceRatio);
}
if (disableParentSwiper) {
e.preventedByNestedSwiper = true;
}
// Directions locks
if (!s.params.allowSwipeToNext && s.swipeDirection === 'next' && currentTranslate < startTranslate) {
currentTranslate = startTranslate;
}
if (!s.params.allowSwipeToPrev && s.swipeDirection === 'prev' && currentTranslate > startTranslate) {
currentTranslate = startTranslate;
}
if (!s.params.followFinger) return;
// Threshold
if (s.params.threshold > 0) {
if (Math.abs(diff) > s.params.threshold || allowThresholdMove) {
if (!allowThresholdMove) {
allowThresholdMove = true;
s.touches.startX = s.touches.currentX;
s.touches.startY = s.touches.currentY;
currentTranslate = startTranslate;
s.touches.diff = isH() ? s.touches.currentX - s.touches.startX : s.touches.currentY - s.touches.startY;
return;
}
}
else {
currentTranslate = startTranslate;
return;
}
}
// Update active index in free mode
if (s.params.freeMode || s.params.watchSlidesProgress) {
s.updateActiveIndex();
}
if (s.params.freeMode) {
//Velocity
if (velocities.length === 0) {
velocities.push({
position: s.touches[isH() ? 'startX' : 'startY'],
time: touchStartTime
});
}
velocities.push({
position: s.touches[isH() ? 'currentX' : 'currentY'],
time: (new window.Date()).getTime()
});
}
// Update progress
s.updateProgress(currentTranslate);
// Update translate
s.setWrapperTranslate(currentTranslate);
};
s.onTouchEnd = function (e) {
if (e.originalEvent) e = e.originalEvent;
s.emit('onTouchEnd', s, e);
if (!isTouched) return;
//Return Grab Cursor
if (s.params.grabCursor && isMoved && isTouched) {
s.container[0].style.cursor = 'move';
s.container[0].style.cursor = '-webkit-grab';
s.container[0].style.cursor = '-moz-grab';
s.container[0].style.cursor = 'grab';
}
// Time diff
var touchEndTime = Date.now();
var timeDiff = touchEndTime - touchStartTime;
// Tap, doubleTap, Click
if (s.allowClick) {
s.updateClickedSlide(e);
s.emit('onTap', s, e);
if (timeDiff < 300 && (touchEndTime - lastClickTime) > 300) {
if (clickTimeout) clearTimeout(clickTimeout);
clickTimeout = setTimeout(function () {
if (!s) return;
if (s.params.paginationHide && s.paginationContainer.length > 0 && !$(e.target).hasClass(s.params.bulletClass)) {
s.paginationContainer.toggleClass(s.params.paginationHiddenClass);
}
s.emit('onClick', s, e);
}, 300);
}
if (timeDiff < 300 && (touchEndTime - lastClickTime) < 300) {
if (clickTimeout) clearTimeout(clickTimeout);
s.emit('onDoubleTap', s, e);
}
}
lastClickTime = Date.now();
setTimeout(function () {
if (s && s.allowClick) s.allowClick = true;
}, 0);
if (!isTouched || !isMoved || !s.swipeDirection || s.touches.diff === 0 || currentTranslate === startTranslate) {
isTouched = isMoved = false;
return;
}
isTouched = isMoved = false;
var currentPos;
if (s.params.followFinger) {
currentPos = s.rtl ? s.translate : -s.translate;
}
else {
currentPos = -currentTranslate;
}
if (s.params.freeMode) {
if (currentPos < -s.minTranslate()) {
s.slideTo(s.activeIndex);
return;
}
else if (currentPos > -s.maxTranslate()) {
if (s.slides.length < s.snapGrid.length) {
s.slideTo(s.snapGrid.length - 1);
}
else {
s.slideTo(s.slides.length - 1);
}
return;
}
if (s.params.freeModeMomentum) {
if (velocities.length > 1) {
var lastMoveEvent = velocities.pop(), velocityEvent = velocities.pop();
var distance = lastMoveEvent.position - velocityEvent.position;
var time = lastMoveEvent.time - velocityEvent.time;
s.velocity = distance / time;
s.velocity = s.velocity / 2;
if (Math.abs(s.velocity) < 0.02) {
s.velocity = 0;
}
// this implies that the user stopped moving a finger then released.
// There would be no events with distance zero, so the last event is stale.
if (time > 150 || (new window.Date().getTime() - lastMoveEvent.time) > 300) {
s.velocity = 0;
}
} else {
s.velocity = 0;
}
velocities.length = 0;
var momentumDuration = 1000 * s.params.freeModeMomentumRatio;
var momentumDistance = s.velocity * momentumDuration;
var newPosition = s.translate + momentumDistance;
if (s.rtl) newPosition = - newPosition;
var doBounce = false;
var afterBouncePosition;
var bounceAmount = Math.abs(s.velocity) * 20 * s.params.freeModeMomentumBounceRatio;
if (newPosition < s.maxTranslate()) {
if (s.params.freeModeMomentumBounce) {
if (newPosition + s.maxTranslate() < -bounceAmount) {
newPosition = s.maxTranslate() - bounceAmount;
}
afterBouncePosition = s.maxTranslate();
doBounce = true;
allowMomentumBounce = true;
}
else {
newPosition = s.maxTranslate();
}
}
else if (newPosition > s.minTranslate()) {
if (s.params.freeModeMomentumBounce) {
if (newPosition - s.minTranslate() > bounceAmount) {
newPosition = s.minTranslate() + bounceAmount;
}
afterBouncePosition = s.minTranslate();
doBounce = true;
allowMomentumBounce = true;
}
else {
newPosition = s.minTranslate();
}
}
else if (s.params.freeModeSticky) {
var j = 0,
nextSlide;
for (j = 0; j < s.snapGrid.length; j += 1) {
if (s.snapGrid[j] > -newPosition) {
nextSlide = j;
break;
}
}
if (Math.abs(s.snapGrid[nextSlide] - newPosition) < Math.abs(s.snapGrid[nextSlide - 1] - newPosition) || s.swipeDirection === 'next') {
newPosition = s.snapGrid[nextSlide];
} else {
newPosition = s.snapGrid[nextSlide - 1];
}
if (!s.rtl) newPosition = - newPosition;
}
//Fix duration
if (s.velocity !== 0) {
if (s.rtl) {
momentumDuration = Math.abs((-newPosition - s.translate) / s.velocity);
}
else {
momentumDuration = Math.abs((newPosition - s.translate) / s.velocity);
}
}
else if (s.params.freeModeSticky) {
s.slideReset();
return;
}
if (s.params.freeModeMomentumBounce && doBounce) {
s.updateProgress(afterBouncePosition);
s.setWrapperTransition(momentumDuration);
s.setWrapperTranslate(newPosition);
s.onTransitionStart();
s.animating = true;
s.wrapper.transitionEnd(function () {
if (!s || !allowMomentumBounce) return;
s.emit('onMomentumBounce', s);
s.setWrapperTransition(s.params.speed);
s.setWrapperTranslate(afterBouncePosition);
s.wrapper.transitionEnd(function () {
if (!s) return;
s.onTransitionEnd();
});
});
} else if (s.velocity) {
s.updateProgress(newPosition);
s.setWrapperTransition(momentumDuration);
s.setWrapperTranslate(newPosition);
s.onTransitionStart();
if (!s.animating) {
s.animating = true;
s.wrapper.transitionEnd(function () {
if (!s) return;
s.onTransitionEnd();
});
}
} else {
s.updateProgress(newPosition);
}
s.updateActiveIndex();
}
if (!s.params.freeModeMomentum || timeDiff >= s.params.longSwipesMs) {
s.updateProgress();
s.updateActiveIndex();
}
return;
}
// Find current slide
var i, stopIndex = 0, groupSize = s.slidesSizesGrid[0];
for (i = 0; i < s.slidesGrid.length; i += s.params.slidesPerGroup) {
if (typeof s.slidesGrid[i + s.params.slidesPerGroup] !== 'undefined') {
if (currentPos >= s.slidesGrid[i] && currentPos < s.slidesGrid[i + s.params.slidesPerGroup]) {
stopIndex = i;
groupSize = s.slidesGrid[i + s.params.slidesPerGroup] - s.slidesGrid[i];
}
}
else {
if (currentPos >= s.slidesGrid[i]) {
stopIndex = i;
groupSize = s.slidesGrid[s.slidesGrid.length - 1] - s.slidesGrid[s.slidesGrid.length - 2];
}
}
}
// Find current slide size
var ratio = (currentPos - s.slidesGrid[stopIndex]) / groupSize;
if (timeDiff > s.params.longSwipesMs) {
// Long touches
if (!s.params.longSwipes) {
s.slideTo(s.activeIndex);
return;
}
if (s.swipeDirection === 'next') {
if (ratio >= s.params.longSwipesRatio) s.slideTo(stopIndex + s.params.slidesPerGroup);
else s.slideTo(stopIndex);
}
if (s.swipeDirection === 'prev') {
if (ratio > (1 - s.params.longSwipesRatio)) s.slideTo(stopIndex + s.params.slidesPerGroup);
else s.slideTo(stopIndex);
}
}
else {
// Short swipes
if (!s.params.shortSwipes) {
s.slideTo(s.activeIndex);
return;
}
if (s.swipeDirection === 'next') {
s.slideTo(stopIndex + s.params.slidesPerGroup);
}
if (s.swipeDirection === 'prev') {
s.slideTo(stopIndex);
}
}
};
/*=========================
Transitions
===========================*/
s._slideTo = function (slideIndex, speed) {
return s.slideTo(slideIndex, speed, true, true);
};
s.slideTo = function (slideIndex, speed, runCallbacks, internal) {
if (typeof runCallbacks === 'undefined') runCallbacks = true;
if (typeof slideIndex === 'undefined') slideIndex = 0;
if (slideIndex < 0) slideIndex = 0;
s.snapIndex = Math.floor(slideIndex / s.params.slidesPerGroup);
if (s.snapIndex >= s.snapGrid.length) s.snapIndex = s.snapGrid.length - 1;
var translate = - s.snapGrid[s.snapIndex];
// Directions locks
if (!s.params.allowSwipeToNext && translate < s.translate) {
return false;
}
if (!s.params.allowSwipeToPrev && translate > s.translate) {
return false;
}
// Stop autoplay
if (s.params.autoplay && s.autoplaying) {
if (internal || !s.params.autoplayDisableOnInteraction) {
s.pauseAutoplay(speed);
}
else {
s.stopAutoplay();
}
}
// Update progress
s.updateProgress(translate);
// Normalize slideIndex
for (var i = 0; i < s.slidesGrid.length; i++) {
if (- translate >= s.slidesGrid[i]) {
slideIndex = i;
}
}
if (typeof speed === 'undefined') speed = s.params.speed;
s.previousIndex = s.activeIndex || 0;
s.activeIndex = slideIndex;
if (translate === s.translate) {
s.updateClasses();
return false;
}
s.updateClasses();
s.onTransitionStart(runCallbacks);
var translateX = isH() ? translate : 0, translateY = isH() ? 0 : translate;
if (speed === 0) {
s.setWrapperTransition(0);
s.setWrapperTranslate(translate);
s.onTransitionEnd(runCallbacks);
}
else {
s.setWrapperTransition(speed);
s.setWrapperTranslate(translate);
if (!s.animating) {
s.animating = true;
s.wrapper.transitionEnd(function () {
if (!s) return;
s.onTransitionEnd(runCallbacks);
});
}
}
return true;
};
s.onTransitionStart = function (runCallbacks) {
if (typeof runCallbacks === 'undefined') runCallbacks = true;
if (s.lazy) s.lazy.onTransitionStart();
if (runCallbacks) {
s.emit('onTransitionStart', s);
if (s.activeIndex !== s.previousIndex) {
s.emit('onSlideChangeStart', s);
}
}
};
s.onTransitionEnd = function (runCallbacks) {
s.animating = false;
s.setWrapperTransition(0);
if (typeof runCallbacks === 'undefined') runCallbacks = true;
if (s.lazy) s.lazy.onTransitionEnd();
if (runCallbacks) {
s.emit('onTransitionEnd', s);
if (s.activeIndex !== s.previousIndex) {
s.emit('onSlideChangeEnd', s);
}
}
if (s.params.hashnav && s.hashnav) {
s.hashnav.setHash();
}
};
s.slideNext = function (runCallbacks, speed, internal) {
if (s.params.loop) {
if (s.animating) return false;
s.fixLoop();
var clientLeft = s.container[0].clientLeft;
return s.slideTo(s.activeIndex + s.params.slidesPerGroup, speed, runCallbacks, internal);
}
else return s.slideTo(s.activeIndex + s.params.slidesPerGroup, speed, runCallbacks, internal);
};
s._slideNext = function (speed) {
return s.slideNext(true, speed, true);
};
s.slidePrev = function (runCallbacks, speed, internal) {
if (s.params.loop) {
if (s.animating) return false;
s.fixLoop();
var clientLeft = s.container[0].clientLeft;
return s.slideTo(s.activeIndex - 1, speed, runCallbacks, internal);
}
else return s.slideTo(s.activeIndex - 1, speed, runCallbacks, internal);
};
s._slidePrev = function (speed) {
return s.slidePrev(true, speed, true);
};
s.slideReset = function (runCallbacks, speed, internal) {
return s.slideTo(s.activeIndex, speed, runCallbacks);
};
/*=========================
Translate/transition helpers
===========================*/
s.setWrapperTransition = function (duration, byController) {
s.wrapper.transition(duration);
if (s.params.effect !== 'slide' && s.effects[s.params.effect]) {
s.effects[s.params.effect].setTransition(duration);
}
if (s.params.parallax && s.parallax) {
s.parallax.setTransition(duration);
}
if (s.params.scrollbar && s.scrollbar) {
s.scrollbar.setTransition(duration);
}
if (s.params.control && s.controller) {
s.controller.setTransition(duration, byController);
}
s.emit('onSetTransition', s, duration);
};
s.setWrapperTranslate = function (translate, updateActiveIndex, byController) {
var x = 0, y = 0, z = 0;
if (isH()) {
x = s.rtl ? -translate : translate;
}
else {
y = translate;
}
if (!s.params.virtualTranslate) {
if (s.support.transforms3d) s.wrapper.transform('translate3d(' + x + 'px, ' + y + 'px, ' + z + 'px)');
else s.wrapper.transform('translate(' + x + 'px, ' + y + 'px)');
}
s.translate = isH() ? x : y;
if (updateActiveIndex) s.updateActiveIndex();
if (s.params.effect !== 'slide' && s.effects[s.params.effect]) {
s.effects[s.params.effect].setTranslate(s.translate);
}
if (s.params.parallax && s.parallax) {
s.parallax.setTranslate(s.translate);
}
if (s.params.scrollbar && s.scrollbar) {
s.scrollbar.setTranslate(s.translate);
}
if (s.params.control && s.controller) {
s.controller.setTranslate(s.translate, byController);
}
s.emit('onSetTranslate', s, s.translate);
};
s.getTranslate = function (el, axis) {
var matrix, curTransform, curStyle, transformMatrix;
// automatic axis detection
if (typeof axis === 'undefined') {
axis = 'x';
}
if (s.params.virtualTranslate) {
return s.rtl ? -s.translate : s.translate;
}
curStyle = window.getComputedStyle(el, null);
if (window.WebKitCSSMatrix) {
// Some old versions of Webkit choke when 'none' is passed; pass
// empty string instead in this case
transformMatrix = new window.WebKitCSSMatrix(curStyle.webkitTransform === 'none' ? '' : curStyle.webkitTransform);
}
else {
transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
matrix = transformMatrix.toString().split(',');
}
if (axis === 'x') {
//Latest Chrome and webkits Fix
if (window.WebKitCSSMatrix)
curTransform = transformMatrix.m41;
//Crazy IE10 Matrix
else if (matrix.length === 16)
curTransform = parseFloat(matrix[12]);
//Normal Browsers
else
curTransform = parseFloat(matrix[4]);
}
if (axis === 'y') {
//Latest Chrome and webkits Fix
if (window.WebKitCSSMatrix)
curTransform = transformMatrix.m42;
//Crazy IE10 Matrix
else if (matrix.length === 16)
curTransform = parseFloat(matrix[13]);
//Normal Browsers
else
curTransform = parseFloat(matrix[5]);
}
if (s.rtl && curTransform) curTransform = -curTransform;
return curTransform || 0;
};
s.getWrapperTranslate = function (axis) {
if (typeof axis === 'undefined') {
axis = isH() ? 'x' : 'y';
}
return s.getTranslate(s.wrapper[0], axis);
};
/*=========================
Observer
===========================*/
s.observers = [];
function initObserver(target, options) {
options = options || {};
// create an observer instance
var ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
var observer = new ObserverFunc(function (mutations) {
mutations.forEach(function (mutation) {
s.onResize(true);
s.emit('onObserverUpdate', s, mutation);
});
});
observer.observe(target, {
attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
childList: typeof options.childList === 'undefined' ? true : options.childList,
characterData: typeof options.characterData === 'undefined' ? true : options.characterData
});
s.observers.push(observer);
}
s.initObservers = function () {
if (s.params.observeParents) {
var containerParents = s.container.parents();
for (var i = 0; i < containerParents.length; i++) {
initObserver(containerParents[i]);
}
}
// Observe container
initObserver(s.container[0], {childList: false});
// Observe wrapper
initObserver(s.wrapper[0], {attributes: false});
};
s.disconnectObservers = function () {
for (var i = 0; i < s.observers.length; i++) {
s.observers[i].disconnect();
}
s.observers = [];
};
/*=========================
Loop
===========================*/
// Create looped slides
s.createLoop = function () {
// Remove duplicated slides
s.wrapper.children('.' + s.params.slideClass + '.' + s.params.slideDuplicateClass).remove();
var slides = s.wrapper.children('.' + s.params.slideClass);
s.loopedSlides = parseInt(s.params.loopedSlides || s.params.slidesPerView, 10);
s.loopedSlides = s.loopedSlides + s.params.loopAdditionalSlides;
if (s.loopedSlides > slides.length) {
s.loopedSlides = slides.length;
}
var prependSlides = [], appendSlides = [], i;
slides.each(function (index, el) {
var slide = $(this);
if (index < s.loopedSlides) appendSlides.push(el);
if (index < slides.length && index >= slides.length - s.loopedSlides) prependSlides.push(el);
slide.attr('data-swiper-slide-index', index);
});
for (i = 0; i < appendSlides.length; i++) {
s.wrapper.append($(appendSlides[i].cloneNode(true)).addClass(s.params.slideDuplicateClass));
}
for (i = prependSlides.length - 1; i >= 0; i--) {
s.wrapper.prepend($(prependSlides[i].cloneNode(true)).addClass(s.params.slideDuplicateClass));
}
};
s.destroyLoop = function () {
s.wrapper.children('.' + s.params.slideClass + '.' + s.params.slideDuplicateClass).remove();
s.slides.removeAttr('data-swiper-slide-index');
};
s.fixLoop = function () {
var newIndex;
//Fix For Negative Oversliding
if (s.activeIndex < s.loopedSlides) {
newIndex = s.slides.length - s.loopedSlides * 3 + s.activeIndex;
newIndex = newIndex + s.loopedSlides;
s.slideTo(newIndex, 0, false, true);
}
//Fix For Positive Oversliding
else if ((s.params.slidesPerView === 'auto' && s.activeIndex >= s.loopedSlides * 2) || (s.activeIndex > s.slides.length - s.params.slidesPerView * 2)) {
newIndex = -s.slides.length + s.activeIndex + s.loopedSlides;
newIndex = newIndex + s.loopedSlides;
s.slideTo(newIndex, 0, false, true);
}
};
/*=========================
Append/Prepend/Remove Slides
===========================*/
s.appendSlide = function (slides) {
if (s.params.loop) {
s.destroyLoop();
}
if (typeof slides === 'object' && slides.length) {
for (var i = 0; i < slides.length; i++) {
if (slides[i]) s.wrapper.append(slides[i]);
}
}
else {
s.wrapper.append(slides);
}
if (s.params.loop) {
s.createLoop();
}
if (!(s.params.observer && s.support.observer)) {
s.update(true);
}
};
s.prependSlide = function (slides) {
if (s.params.loop) {
s.destroyLoop();
}
var newActiveIndex = s.activeIndex + 1;
if (typeof slides === 'object' && slides.length) {
for (var i = 0; i < slides.length; i++) {
if (slides[i]) s.wrapper.prepend(slides[i]);
}
newActiveIndex = s.activeIndex + slides.length;
}
else {
s.wrapper.prepend(slides);
}
if (s.params.loop) {
s.createLoop();
}
if (!(s.params.observer && s.support.observer)) {
s.update(true);
}
s.slideTo(newActiveIndex, 0, false);
};
s.removeSlide = function (slidesIndexes) {
if (s.params.loop) {
s.destroyLoop();
s.slides = s.wrapper.children('.' + s.params.slideClass);
}
var newActiveIndex = s.activeIndex,
indexToRemove;
if (typeof slidesIndexes === 'object' && slidesIndexes.length) {
for (var i = 0; i < slidesIndexes.length; i++) {
indexToRemove = slidesIndexes[i];
if (s.slides[indexToRemove]) s.slides.eq(indexToRemove).remove();
if (indexToRemove < newActiveIndex) newActiveIndex--;
}
newActiveIndex = Math.max(newActiveIndex, 0);
}
else {
indexToRemove = slidesIndexes;
if (s.slides[indexToRemove]) s.slides.eq(indexToRemove).remove();
if (indexToRemove < newActiveIndex) newActiveIndex--;
newActiveIndex = Math.max(newActiveIndex, 0);
}
if (s.params.loop) {
s.createLoop();
}
if (!(s.params.observer && s.support.observer)) {
s.update(true);
}
if (s.params.loop) {
s.slideTo(newActiveIndex + s.loopedSlides, 0, false);
}
else {
s.slideTo(newActiveIndex, 0, false);
}
};
s.removeAllSlides = function () {
var slidesIndexes = [];
for (var i = 0; i < s.slides.length; i++) {
slidesIndexes.push(i);
}
s.removeSlide(slidesIndexes);
};
/*=========================
Effects
===========================*/
s.effects = {
fade: {
fadeIndex: null,
setTranslate: function () {
for (var i = 0; i < s.slides.length; i++) {
var slide = s.slides.eq(i);
var offset = slide[0].swiperSlideOffset;
var tx = -offset;
if (!s.params.virtualTranslate) tx = tx - s.translate;
var ty = 0;
if (!isH()) {
ty = tx;
tx = 0;
}
var slideOpacity = s.params.fade.crossFade ?
Math.max(1 - Math.abs(slide[0].progress), 0) :
1 + Math.min(Math.max(slide[0].progress, -1), 0);
if (slideOpacity > 0 && slideOpacity < 1) {
s.effects.fade.fadeIndex = i;
}
slide
.css({
opacity: slideOpacity
})
.transform('translate3d(' + tx + 'px, ' + ty + 'px, 0px)');
}
},
setTransition: function (duration) {
s.slides.transition(duration);
if (s.params.virtualTranslate && duration !== 0) {
var fadeIndex = s.effects.fade.fadeIndex !== null ? s.effects.fade.fadeIndex : s.activeIndex;
if (!(s.params.loop || s.params.fade.crossFade) && fadeIndex === 0) {
fadeIndex = s.slides.length - 1;
}
s.slides.eq(fadeIndex).transitionEnd(function () {
if (!s) return;
var triggerEvents = ['webkitTransitionEnd', 'transitionend', 'oTransitionEnd', 'MSTransitionEnd', 'msTransitionEnd'];
for (var i = 0; i < triggerEvents.length; i++) {
s.wrapper.trigger(triggerEvents[i]);
}
});
}
}
},
cube: {
setTranslate: function () {
var wrapperRotate = 0, cubeShadow;
if (s.params.cube.shadow) {
if (isH()) {
cubeShadow = s.wrapper.find('.swiper-cube-shadow');
if (cubeShadow.length === 0) {
cubeShadow = $('<div class="swiper-cube-shadow"></div>');
s.wrapper.append(cubeShadow);
}
cubeShadow.css({height: s.width + 'px'});
}
else {
cubeShadow = s.container.find('.swiper-cube-shadow');
if (cubeShadow.length === 0) {
cubeShadow = $('<div class="swiper-cube-shadow"></div>');
s.container.append(cubeShadow);
}
}
}
for (var i = 0; i < s.slides.length; i++) {
var slide = s.slides.eq(i);
var slideAngle = i * 90;
var round = Math.floor(slideAngle / 360);
if (s.rtl) {
slideAngle = -slideAngle;
round = Math.floor(-slideAngle / 360);
}
var progress = Math.max(Math.min(slide[0].progress, 1), -1);
var tx = 0, ty = 0, tz = 0;
if (i % 4 === 0) {
tx = - round * 4 * s.size;
tz = 0;
}
else if ((i - 1) % 4 === 0) {
tx = 0;
tz = - round * 4 * s.size;
}
else if ((i - 2) % 4 === 0) {
tx = s.size + round * 4 * s.size;
tz = s.size;
}
else if ((i - 3) % 4 === 0) {
tx = - s.size;
tz = 3 * s.size + s.size * 4 * round;
}
if (s.rtl) {
tx = -tx;
}
if (!isH()) {
ty = tx;
tx = 0;
}
var transform = 'rotateX(' + (isH() ? 0 : -slideAngle) + 'deg) rotateY(' + (isH() ? slideAngle : 0) + 'deg) translate3d(' + tx + 'px, ' + ty + 'px, ' + tz + 'px)';
if (progress <= 1 && progress > -1) {
wrapperRotate = i * 90 + progress * 90;
if (s.rtl) wrapperRotate = -i * 90 - progress * 90;
}
slide.transform(transform);
if (s.params.cube.slideShadows) {
//Set shadows
var shadowBefore = isH() ? slide.find('.swiper-slide-shadow-left') : slide.find('.swiper-slide-shadow-top');
var shadowAfter = isH() ? slide.find('.swiper-slide-shadow-right') : slide.find('.swiper-slide-shadow-bottom');
if (shadowBefore.length === 0) {
shadowBefore = $('<div class="swiper-slide-shadow-' + (isH() ? 'left' : 'top') + '"></div>');
slide.append(shadowBefore);
}
if (shadowAfter.length === 0) {
shadowAfter = $('<div class="swiper-slide-shadow-' + (isH() ? 'right' : 'bottom') + '"></div>');
slide.append(shadowAfter);
}
var shadowOpacity = slide[0].progress;
if (shadowBefore.length) shadowBefore[0].style.opacity = -slide[0].progress;
if (shadowAfter.length) shadowAfter[0].style.opacity = slide[0].progress;
}
}
s.wrapper.css({
'-webkit-transform-origin': '50% 50% -' + (s.size / 2) + 'px',
'-moz-transform-origin': '50% 50% -' + (s.size / 2) + 'px',
'-ms-transform-origin': '50% 50% -' + (s.size / 2) + 'px',
'transform-origin': '50% 50% -' + (s.size / 2) + 'px'
});
if (s.params.cube.shadow) {
if (isH()) {
cubeShadow.transform('translate3d(0px, ' + (s.width / 2 + s.params.cube.shadowOffset) + 'px, ' + (-s.width / 2) + 'px) rotateX(90deg) rotateZ(0deg) scale(' + (s.params.cube.shadowScale) + ')');
}
else {
var shadowAngle = Math.abs(wrapperRotate) - Math.floor(Math.abs(wrapperRotate) / 90) * 90;
var multiplier = 1.5 - (Math.sin(shadowAngle * 2 * Math.PI / 360) / 2 + Math.cos(shadowAngle * 2 * Math.PI / 360) / 2);
var scale1 = s.params.cube.shadowScale,
scale2 = s.params.cube.shadowScale / multiplier,
offset = s.params.cube.shadowOffset;
cubeShadow.transform('scale3d(' + scale1 + ', 1, ' + scale2 + ') translate3d(0px, ' + (s.height / 2 + offset) + 'px, ' + (-s.height / 2 / scale2) + 'px) rotateX(-90deg)');
}
}
var zFactor = (s.isSafari || s.isUiWebView) ? (-s.size / 2) : 0;
s.wrapper.transform('translate3d(0px,0,' + zFactor + 'px) rotateX(' + (isH() ? 0 : wrapperRotate) + 'deg) rotateY(' + (isH() ? -wrapperRotate : 0) + 'deg)');
},
setTransition: function (duration) {
s.slides.transition(duration).find('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').transition(duration);
if (s.params.cube.shadow && !isH()) {
s.container.find('.swiper-cube-shadow').transition(duration);
}
}
},
coverflow: {
setTranslate: function () {
var transform = s.translate;
var center = isH() ? -transform + s.width / 2 : -transform + s.height / 2;
var rotate = isH() ? s.params.coverflow.rotate: -s.params.coverflow.rotate;
var translate = s.params.coverflow.depth;
//Each slide offset from center
for (var i = 0, length = s.slides.length; i < length; i++) {
var slide = s.slides.eq(i);
var slideSize = s.slidesSizesGrid[i];
var slideOffset = slide[0].swiperSlideOffset;
var offsetMultiplier = (center - slideOffset - slideSize / 2) / slideSize * s.params.coverflow.modifier;
var rotateY = isH() ? rotate * offsetMultiplier : 0;
var rotateX = isH() ? 0 : rotate * offsetMultiplier;
// var rotateZ = 0
var translateZ = -translate * Math.abs(offsetMultiplier);
var translateY = isH() ? 0 : s.params.coverflow.stretch * (offsetMultiplier);
var translateX = isH() ? s.params.coverflow.stretch * (offsetMultiplier) : 0;
//Fix for ultra small values
if (Math.abs(translateX) < 0.001) translateX = 0;
if (Math.abs(translateY) < 0.001) translateY = 0;
if (Math.abs(translateZ) < 0.001) translateZ = 0;
if (Math.abs(rotateY) < 0.001) rotateY = 0;
if (Math.abs(rotateX) < 0.001) rotateX = 0;
var slideTransform = 'translate3d(' + translateX + 'px,' + translateY + 'px,' + translateZ + 'px) rotateX(' + rotateX + 'deg) rotateY(' + rotateY + 'deg)';
slide.transform(slideTransform);
slide[0].style.zIndex = -Math.abs(Math.round(offsetMultiplier)) + 1;
if (s.params.coverflow.slideShadows) {
//Set shadows
var shadowBefore = isH() ? slide.find('.swiper-slide-shadow-left') : slide.find('.swiper-slide-shadow-top');
var shadowAfter = isH() ? slide.find('.swiper-slide-shadow-right') : slide.find('.swiper-slide-shadow-bottom');
if (shadowBefore.length === 0) {
shadowBefore = $('<div class="swiper-slide-shadow-' + (isH() ? 'left' : 'top') + '"></div>');
slide.append(shadowBefore);
}
if (shadowAfter.length === 0) {
shadowAfter = $('<div class="swiper-slide-shadow-' + (isH() ? 'right' : 'bottom') + '"></div>');
slide.append(shadowAfter);
}
if (shadowBefore.length) shadowBefore[0].style.opacity = offsetMultiplier > 0 ? offsetMultiplier : 0;
if (shadowAfter.length) shadowAfter[0].style.opacity = (-offsetMultiplier) > 0 ? -offsetMultiplier : 0;
}
}
//Set correct perspective for IE10
if (s.browser.ie) {
var ws = s.wrapper[0].style;
ws.perspectiveOrigin = center + 'px 50%';
}
},
setTransition: function (duration) {
s.slides.transition(duration).find('.swiper-slide-shadow-top, .swiper-slide-shadow-right, .swiper-slide-shadow-bottom, .swiper-slide-shadow-left').transition(duration);
}
}
};
/*=========================
Images Lazy Loading
===========================*/
s.lazy = {
initialImageLoaded: false,
loadImageInSlide: function (index, loadInDuplicate) {
if (typeof index === 'undefined') return;
if (typeof loadInDuplicate === 'undefined') loadInDuplicate = true;
if (s.slides.length === 0) return;
var slide = s.slides.eq(index);
var img = slide.find('.swiper-lazy:not(.swiper-lazy-loaded):not(.swiper-lazy-loading)');
if (slide.hasClass('swiper-lazy') && !slide.hasClass('swiper-lazy-loaded') && !slide.hasClass('swiper-lazy-loading')) {
img.add(slide[0]);
}
if (img.length === 0) return;
img.each(function () {
var _img = $(this);
_img.addClass('swiper-lazy-loading');
var background = _img.attr('data-background');
var src = _img.attr('data-src');
s.loadImage(_img[0], (src || background), false, function () {
if (background) {
_img.css('background-image', 'url(' + background + ')');
_img.removeAttr('data-background');
}
else {
_img.attr('src', src);
_img.removeAttr('data-src');
}
_img.addClass('swiper-lazy-loaded').removeClass('swiper-lazy-loading');
slide.find('.swiper-lazy-preloader, .preloader').remove();
if (s.params.loop && loadInDuplicate) {
var slideOriginalIndex = slide.attr('data-swiper-slide-index');
if (slide.hasClass(s.params.slideDuplicateClass)) {
var originalSlide = s.wrapper.children('[data-swiper-slide-index="' + slideOriginalIndex + '"]:not(.' + s.params.slideDuplicateClass + ')');
s.lazy.loadImageInSlide(originalSlide.index(), false);
}
else {
var duplicatedSlide = s.wrapper.children('.' + s.params.slideDuplicateClass + '[data-swiper-slide-index="' + slideOriginalIndex + '"]');
s.lazy.loadImageInSlide(duplicatedSlide.index(), false);
}
}
s.emit('onLazyImageReady', s, slide[0], _img[0]);
});
s.emit('onLazyImageLoad', s, slide[0], _img[0]);
});
},
load: function () {
if (s.params.watchSlidesVisibility) {
s.wrapper.children('.' + s.params.slideVisibleClass).each(function () {
s.lazy.loadImageInSlide($(this).index());
});
}
else {
if (s.params.slidesPerView > 1) {
for (var i = s.activeIndex; i < s.activeIndex + s.params.slidesPerView ; i++) {
if (s.slides[i]) s.lazy.loadImageInSlide(i);
}
}
else {
s.lazy.loadImageInSlide(s.activeIndex);
}
}
if (s.params.lazyLoadingInPrevNext) {
var nextSlide = s.wrapper.children('.' + s.params.slideNextClass);
if (nextSlide.length > 0) s.lazy.loadImageInSlide(nextSlide.index());
var prevSlide = s.wrapper.children('.' + s.params.slidePrevClass);
if (prevSlide.length > 0) s.lazy.loadImageInSlide(prevSlide.index());
}
},
onTransitionStart: function () {
if (s.params.lazyLoading) {
if (s.params.lazyLoadingOnTransitionStart || (!s.params.lazyLoadingOnTransitionStart && !s.lazy.initialImageLoaded)) {
s.lazy.load();
}
}
},
onTransitionEnd: function () {
if (s.params.lazyLoading && !s.params.lazyLoadingOnTransitionStart) {
s.lazy.load();
}
}
};
/*=========================
Scrollbar
===========================*/
s.scrollbar = {
set: function () {
if (!s.params.scrollbar) return;
var sb = s.scrollbar;
sb.track = $(s.params.scrollbar);
sb.drag = sb.track.find('.swiper-scrollbar-drag');
if (sb.drag.length === 0) {
sb.drag = $('<div class="swiper-scrollbar-drag"></div>');
sb.track.append(sb.drag);
}
sb.drag[0].style.width = '';
sb.drag[0].style.height = '';
sb.trackSize = isH() ? sb.track[0].offsetWidth : sb.track[0].offsetHeight;
sb.divider = s.size / s.virtualSize;
sb.moveDivider = sb.divider * (sb.trackSize / s.size);
sb.dragSize = sb.trackSize * sb.divider;
if (isH()) {
sb.drag[0].style.width = sb.dragSize + 'px';
}
else {
sb.drag[0].style.height = sb.dragSize + 'px';
}
if (sb.divider >= 1) {
sb.track[0].style.display = 'none';
}
else {
sb.track[0].style.display = '';
}
if (s.params.scrollbarHide) {
sb.track[0].style.opacity = 0;
}
},
setTranslate: function () {
if (!s.params.scrollbar) return;
var diff;
var sb = s.scrollbar;
var translate = s.translate || 0;
var newPos;
var newSize = sb.dragSize;
newPos = (sb.trackSize - sb.dragSize) * s.progress;
if (s.rtl && isH()) {
newPos = -newPos;
if (newPos > 0) {
newSize = sb.dragSize - newPos;
newPos = 0;
}
else if (-newPos + sb.dragSize > sb.trackSize) {
newSize = sb.trackSize + newPos;
}
}
else {
if (newPos < 0) {
newSize = sb.dragSize + newPos;
newPos = 0;
}
else if (newPos + sb.dragSize > sb.trackSize) {
newSize = sb.trackSize - newPos;
}
}
if (isH()) {
if (s.support.transforms3d) {
sb.drag.transform('translate3d(' + (newPos) + 'px, 0, 0)');
}
else {
sb.drag.transform('translateX(' + (newPos) + 'px)');
}
sb.drag[0].style.width = newSize + 'px';
}
else {
if (s.support.transforms3d) {
sb.drag.transform('translate3d(0px, ' + (newPos) + 'px, 0)');
}
else {
sb.drag.transform('translateY(' + (newPos) + 'px)');
}
sb.drag[0].style.height = newSize + 'px';
}
if (s.params.scrollbarHide) {
clearTimeout(sb.timeout);
sb.track[0].style.opacity = 1;
sb.timeout = setTimeout(function () {
sb.track[0].style.opacity = 0;
sb.track.transition(400);
}, 1000);
}
},
setTransition: function (duration) {
if (!s.params.scrollbar) return;
s.scrollbar.drag.transition(duration);
}
};
/*=========================
Controller
===========================*/
s.controller = {
setTranslate: function (translate, byController) {
var controlled = s.params.control;
var multiplier, controlledTranslate;
function setControlledTranslate(c) {
translate = c.rtl && c.params.direction === 'horizontal' ? -s.translate : s.translate;
multiplier = (c.maxTranslate() - c.minTranslate()) / (s.maxTranslate() - s.minTranslate());
controlledTranslate = (translate - s.minTranslate()) * multiplier + c.minTranslate();
if (s.params.controlInverse) {
controlledTranslate = c.maxTranslate() - controlledTranslate;
}
c.updateProgress(controlledTranslate);
c.setWrapperTranslate(controlledTranslate, false, s);
c.updateActiveIndex();
}
if (s.isArray(controlled)) {
for (var i = 0; i < controlled.length; i++) {
if (controlled[i] !== byController && controlled[i] instanceof Swiper) {
setControlledTranslate(controlled[i]);
}
}
}
else if (controlled instanceof Swiper && byController !== controlled) {
setControlledTranslate(controlled);
}
},
setTransition: function (duration, byController) {
var controlled = s.params.control;
var i;
function setControlledTransition(c) {
c.setWrapperTransition(duration, s);
if (duration !== 0) {
c.onTransitionStart();
c.wrapper.transitionEnd(function(){
if (!controlled) return;
c.onTransitionEnd();
});
}
}
if (s.isArray(controlled)) {
for (i = 0; i < controlled.length; i++) {
if (controlled[i] !== byController && controlled[i] instanceof Swiper) {
setControlledTransition(controlled[i]);
}
}
}
else if (controlled instanceof Swiper && byController !== controlled) {
setControlledTransition(controlled);
}
}
};
/*=========================
Parallax
===========================*/
function setParallaxTransform(el, progress) {
el = $(el);
var p, pX, pY;
p = el.attr('data-swiper-parallax') || '0';
pX = el.attr('data-swiper-parallax-x');
pY = el.attr('data-swiper-parallax-y');
if (pX || pY) {
pX = pX || '0';
pY = pY || '0';
}
else {
if (isH()) {
pX = p;
pY = '0';
}
else {
pY = p;
pX = '0';
}
}
if ((pX).indexOf('%') >= 0) {
pX = parseInt(pX, 10) * progress + '%';
}
else {
pX = pX * progress + 'px' ;
}
if ((pY).indexOf('%') >= 0) {
pY = parseInt(pY, 10) * progress + '%';
}
else {
pY = pY * progress + 'px' ;
}
el.transform('translate3d(' + pX + ', ' + pY + ',0px)');
}
s.parallax = {
setTranslate: function () {
s.container.children('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y]').each(function(){
setParallaxTransform(this, s.progress);
});
s.slides.each(function () {
var slide = $(this);
slide.find('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y]').each(function () {
var progress = Math.min(Math.max(slide[0].progress, -1), 1);
setParallaxTransform(this, progress);
});
});
},
setTransition: function (duration) {
if (typeof duration === 'undefined') duration = s.params.speed;
s.container.find('[data-swiper-parallax], [data-swiper-parallax-x], [data-swiper-parallax-y]').each(function(){
var el = $(this);
var parallaxDuration = parseInt(el.attr('data-swiper-parallax-duration'), 10) || duration;
if (duration === 0) parallaxDuration = 0;
el.transition(parallaxDuration);
});
}
};
/*=========================
Plugins API. Collect all and init all plugins
===========================*/
s._plugins = [];
for (var plugin in s.plugins) {
var p = s.plugins[plugin](s, s.params[plugin]);
if (p) s._plugins.push(p);
}
// Method to call all plugins event/method
s.callPlugins = function (eventName) {
for (var i = 0; i < s._plugins.length; i++) {
if (eventName in s._plugins[i]) {
s._plugins[i][eventName](arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
}
}
};
/*=========================
Events/Callbacks/Plugins Emitter
===========================*/
function normalizeEventName (eventName) {
if (eventName.indexOf('on') !== 0) {
if (eventName[0] !== eventName[0].toUpperCase()) {
eventName = 'on' + eventName[0].toUpperCase() + eventName.substring(1);
}
else {
eventName = 'on' + eventName;
}
}
return eventName;
}
s.emitterEventListeners = {
};
s.emit = function (eventName) {
// Trigger callbacks
if (s.params[eventName]) {
s.params[eventName](arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
}
var i;
// Trigger events
if (s.emitterEventListeners[eventName]) {
for (i = 0; i < s.emitterEventListeners[eventName].length; i++) {
s.emitterEventListeners[eventName][i](arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
}
}
// Trigger plugins
if (s.callPlugins) s.callPlugins(eventName, arguments[1], arguments[2], arguments[3], arguments[4], arguments[5]);
};
s.on = function (eventName, handler) {
eventName = normalizeEventName(eventName);
if (!s.emitterEventListeners[eventName]) s.emitterEventListeners[eventName] = [];
s.emitterEventListeners[eventName].push(handler);
return s;
};
s.off = function (eventName, handler) {
var i;
eventName = normalizeEventName(eventName);
if (typeof handler === 'undefined') {
// Remove all handlers for such event
s.emitterEventListeners[eventName] = [];
return s;
}
if (!s.emitterEventListeners[eventName] || s.emitterEventListeners[eventName].length === 0) return;
for (i = 0; i < s.emitterEventListeners[eventName].length; i++) {
if(s.emitterEventListeners[eventName][i] === handler) s.emitterEventListeners[eventName].splice(i, 1);
}
return s;
};
s.once = function (eventName, handler) {
eventName = normalizeEventName(eventName);
var _handler = function () {
handler(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4]);
s.off(eventName, _handler);
};
s.on(eventName, _handler);
return s;
};
// Accessibility tools
s.a11y = {
makeFocusable: function ($el) {
$el[0].tabIndex = '0';
return $el;
},
addRole: function ($el, role) {
$el.attr('role', role);
return $el;
},
addLabel: function ($el, label) {
$el.attr('aria-label', label);
return $el;
},
disable: function ($el) {
$el.attr('aria-disabled', true);
return $el;
},
enable: function ($el) {
$el.attr('aria-disabled', false);
return $el;
},
onEnterKey: function (event) {
if (event.keyCode !== 13) return;
if ($(event.target).is(s.params.nextButton)) {
s.onClickNext(event);
if (s.isEnd) {
s.a11y.notify(s.params.lastSlideMsg);
}
else {
s.a11y.notify(s.params.nextSlideMsg);
}
}
else if ($(event.target).is(s.params.prevButton)) {
s.onClickPrev(event);
if (s.isBeginning) {
s.a11y.notify(s.params.firstSlideMsg);
}
else {
s.a11y.notify(s.params.prevSlideMsg);
}
}
},
liveRegion: $('<span class="swiper-notification" aria-live="assertive" aria-atomic="true"></span>'),
notify: function (message) {
var notification = s.a11y.liveRegion;
if (notification.length === 0) return;
notification.html('');
notification.html(message);
},
init: function () {
// Setup accessibility
if (s.params.nextButton) {
var nextButton = $(s.params.nextButton);
s.a11y.makeFocusable(nextButton);
s.a11y.addRole(nextButton, 'button');
s.a11y.addLabel(nextButton, s.params.nextSlideMsg);
}
if (s.params.prevButton) {
var prevButton = $(s.params.prevButton);
s.a11y.makeFocusable(prevButton);
s.a11y.addRole(prevButton, 'button');
s.a11y.addLabel(prevButton, s.params.prevSlideMsg);
}
$(s.container).append(s.a11y.liveRegion);
},
destroy: function () {
if (s.a11y.liveRegion && s.a11y.liveRegion.length > 0) s.a11y.liveRegion.remove();
}
};
/*=========================
Init/Destroy
===========================*/
s.init = function () {
if (s.params.loop) s.createLoop();
s.updateContainerSize();
s.updateSlidesSize();
s.updatePagination();
if (s.params.scrollbar && s.scrollbar) {
s.scrollbar.set();
}
if (s.params.effect !== 'slide' && s.effects[s.params.effect]) {
if (!s.params.loop) s.updateProgress();
s.effects[s.params.effect].setTranslate();
}
if (s.params.loop) {
s.slideTo(s.params.initialSlide + s.loopedSlides, 0, s.params.runCallbacksOnInit);
}
else {
s.slideTo(s.params.initialSlide, 0, s.params.runCallbacksOnInit);
if (s.params.initialSlide === 0) {
if (s.parallax && s.params.parallax) s.parallax.setTranslate();
if (s.lazy && s.params.lazyLoading) {
s.lazy.load();
s.lazy.initialImageLoaded = true;
}
}
}
s.attachEvents();
if (s.params.observer && s.support.observer) {
s.initObservers();
}
if (s.params.preloadImages && !s.params.lazyLoading) {
s.preloadImages();
}
if (s.params.autoplay) {
s.startAutoplay();
}
if (s.params.keyboardControl) {
if (s.enableKeyboardControl) s.enableKeyboardControl();
}
if (s.params.mousewheelControl) {
if (s.enableMousewheelControl) s.enableMousewheelControl();
}
if (s.params.hashnav) {
if (s.hashnav) s.hashnav.init();
}
if (s.params.a11y && s.a11y) s.a11y.init();
s.emit('onInit', s);
};
// Cleanup dynamic styles
s.cleanupStyles = function () {
// Container
s.container.removeClass(s.classNames.join(' ')).removeAttr('style');
// Wrapper
s.wrapper.removeAttr('style');
// Slides
if (s.slides && s.slides.length) {
s.slides
.removeClass([
s.params.slideVisibleClass,
s.params.slideActiveClass,
s.params.slideNextClass,
s.params.slidePrevClass
].join(' '))
.removeAttr('style')
.removeAttr('data-swiper-column')
.removeAttr('data-swiper-row');
}
// Pagination/Bullets
if (s.paginationContainer && s.paginationContainer.length) {
s.paginationContainer.removeClass(s.params.paginationHiddenClass);
}
if (s.bullets && s.bullets.length) {
s.bullets.removeClass(s.params.bulletActiveClass);
}
// Buttons
if (s.params.prevButton) $(s.params.prevButton).removeClass(s.params.buttonDisabledClass);
if (s.params.nextButton) $(s.params.nextButton).removeClass(s.params.buttonDisabledClass);
// Scrollbar
if (s.params.scrollbar && s.scrollbar) {
if (s.scrollbar.track && s.scrollbar.track.length) s.scrollbar.track.removeAttr('style');
if (s.scrollbar.drag && s.scrollbar.drag.length) s.scrollbar.drag.removeAttr('style');
}
};
// Destroy
s.destroy = function (deleteInstance, cleanupStyles) {
// Detach evebts
s.detachEvents();
// Stop autoplay
s.stopAutoplay();
// Destroy loop
if (s.params.loop) {
s.destroyLoop();
}
// Cleanup styles
if (cleanupStyles) {
s.cleanupStyles();
}
// Disconnect observer
s.disconnectObservers();
// Disable keyboard/mousewheel
if (s.params.keyboardControl) {
if (s.disableKeyboardControl) s.disableKeyboardControl();
}
if (s.params.mousewheelControl) {
if (s.disableMousewheelControl) s.disableMousewheelControl();
}
// Disable a11y
if (s.params.a11y && s.a11y) s.a11y.destroy();
// Destroy callback
s.emit('onDestroy');
// Delete instance
if (deleteInstance !== false) s = null;
};
s.init();
// Return swiper instance
return s;
};
/*==================================================
Prototype
====================================================*/
Swiper.prototype = {
isSafari: (function () {
var ua = navigator.userAgent.toLowerCase();
return (ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0);
})(),
isUiWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(navigator.userAgent),
isArray: function (arr) {
return Object.prototype.toString.apply(arr) === '[object Array]';
},
/*==================================================
Browser
====================================================*/
browser: {
ie: window.navigator.pointerEnabled || window.navigator.msPointerEnabled,
ieTouch: (window.navigator.msPointerEnabled && window.navigator.msMaxTouchPoints > 1) || (window.navigator.pointerEnabled && window.navigator.maxTouchPoints > 1),
},
/*==================================================
Devices
====================================================*/
device: (function () {
var ua = navigator.userAgent;
var android = ua.match(/(Android);?[\s\/]+([\d.]+)?/);
var ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
var ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
var iphone = !ipad && ua.match(/(iPhone\sOS)\s([\d_]+)/);
return {
ios: ipad || iphone || ipad,
android: android
};
})(),
/*==================================================
Feature Detection
====================================================*/
support: {
touch : (window.Modernizr && Modernizr.touch === true) || (function () {
return !!(('ontouchstart' in window) || window.DocumentTouch && document instanceof DocumentTouch);
})(),
transforms3d : (window.Modernizr && Modernizr.csstransforms3d === true) || (function () {
var div = document.createElement('div').style;
return ('webkitPerspective' in div || 'MozPerspective' in div || 'OPerspective' in div || 'MsPerspective' in div || 'perspective' in div);
})(),
flexbox: (function () {
var div = document.createElement('div').style;
var styles = ('alignItems webkitAlignItems webkitBoxAlign msFlexAlign mozBoxAlign webkitFlexDirection msFlexDirection mozBoxDirection mozBoxOrient webkitBoxDirection webkitBoxOrient').split(' ');
for (var i = 0; i < styles.length; i++) {
if (styles[i] in div) return true;
}
})(),
observer: (function () {
return ('MutationObserver' in window || 'WebkitMutationObserver' in window);
})()
},
/*==================================================
Plugins
====================================================*/
plugins: {}
};
})();
//# sourceMappingURL=framework7.js.map |
'use strict';
/* Filters */
angular.module('activity.filters', []).
filter('relativetime', function() {
return function(timestamp) {
// see http://momentjs.com/docs/
return moment(timestamp).fromNow();
};
});
|
module.exports['crlf.http'] = [
{type: 'file', name: 'upload', filename: 'plain.txt', fixture: 'plain.txt'},
];
module.exports['preamble.http'] = [
{type: 'file', name: 'upload', filename: 'plain.txt', fixture: 'plain.txt'},
];
|
(function () {
// XXX come up with a serialization method which canonicalizes object key
// order, which would allow us to use objects as values for equals.
var stringify = function (value) {
if (value === undefined)
return 'undefined';
return JSON.stringify(value);
};
var parse = function (serialized) {
if (serialized === undefined || serialized === 'undefined')
return undefined;
return JSON.parse(serialized);
};
Session = _.extend({}, {
keys: {}, // key -> value
keyDeps: {}, // key -> _ContextSet
keyValueDeps: {}, // key -> value -> _ContextSet
set: function (key, value) {
var self = this;
value = stringify(value);
var oldSerializedValue = 'undefined';
if (_.has(self.keys, key)) oldSerializedValue = self.keys[key];
if (value === oldSerializedValue)
return;
self.keys[key] = value;
var invalidateAll = function (cset) {
cset && cset.invalidateAll();
};
invalidateAll(self.keyDeps[key]);
if (self.keyValueDeps[key]) {
invalidateAll(self.keyValueDeps[key][oldSerializedValue]);
invalidateAll(self.keyValueDeps[key][value]);
}
},
get: function (key) {
var self = this;
self._ensureKey(key);
self.keyDeps[key].addCurrentContext();
return parse(self.keys[key]);
},
equals: function (key, value) {
var self = this;
var context = Meteor.deps.Context.current;
// We don't allow objects (or arrays that might include objects) for
// .equals, because JSON.stringify doesn't canonicalize object key
// order. (We can make equals have the right return value by parsing the
// current value and using _.isEqual, but we won't have a canonical
// element of keyValueDeps[key] to store the context.) You can still use
// "_.isEqual(Session.get(key), value)".
//
// XXX we could allow arrays as long as we recursively check that there
// are no objects
if (typeof value !== 'string' &&
typeof value !== 'number' &&
typeof value !== 'boolean' &&
typeof value !== 'undefined' &&
value !== null)
throw new Error("Session.equals: value must be scalar");
var serializedValue = stringify(value);
if (context) {
self._ensureKey(key);
if (! _.has(self.keyValueDeps[key], serializedValue))
self.keyValueDeps[key][serializedValue] = new Meteor.deps._ContextSet;
var isNew = self.keyValueDeps[key][serializedValue].add(context);
if (isNew) {
context.onInvalidate(function () {
// clean up [key][serializedValue] if it's now empty, so we don't
// use O(n) memory for n = values seen ever
if (self.keyValueDeps[key][serializedValue].isEmpty())
delete self.keyValueDeps[key][serializedValue];
});
}
}
var oldValue = undefined;
if (_.has(self.keys, key)) oldValue = parse(self.keys[key]);
return oldValue === value;
},
_ensureKey: function (key) {
var self = this;
if (!(key in self.keyDeps)) {
self.keyDeps[key] = new Meteor.deps._ContextSet;
self.keyValueDeps[key] = {};
}
}
});
if (Meteor._reload) {
Meteor._reload.onMigrate('session', function () {
// XXX sanitize and make sure it's JSONible?
return [true, {keys: Session.keys}];
});
(function () {
var migrationData = Meteor._reload.migrationData('session');
if (migrationData && migrationData.keys) {
Session.keys = migrationData.keys;
}
})();
}
}());
|
(function (widnow, Backbone, undefined) {
'use strict';
var GpsModel = Backbone.Model.extend({
defaults: {
lat: 0,
lng: 0,
altitude: 0,
time: 0
}
}),
GpsCollection = Backbone.Collection.extend({
model: GpsModel
});
window.gpsCollection = new GpsCollection();
})(window, window.Backbone); |
(function () {
var EventEmitter2 = require('eventemitter2').EventEmitter2;
var CockpitMessaging = function (io, opts) {
var listeners = [];
var sockets = [];
var ignoreEvents = [
'newListener',
'removeListener'
];
this.volatile = {
emit: function () {
if (ignoreEvents.includes(arguments[0])) {
return;
}
var args = new Array(arguments.length);
for (var i = 0; i < args.length; ++i) {
//i is always valid index in the arguments object
args[i] = arguments[i];
}
if (args[0] == [args[1]]) {
args.shift(); //After an upgrade of eventemitter, it appears the arguments now include the event type.
}
sockets.forEach(function (socket) {
socket.volatile.emit.apply(socket, args);
});
}
};
this.onAny(function () {
if (ignoreEvents.includes(arguments[0])) {
return;
}
var event = this.event;
var args = new Array(arguments.length);
for (var i = 0; i < args.length; ++i) {
//i is always valid index in the arguments object
args[i] = arguments[i];
}
if (args[0] == [args[1]]) {
args.shift(); //After an upgrade of eventemitter, it appears the arguments now include the event type.
}
sockets.forEach(function (socket) {
socket.emit.apply(socket, args);
});
});
this.on('newListener', function (aType, aListener) {
if (aType !== 'newListener') {
listeners.push({
type: aType,
fn: aListener
});
}
});
io.on('connection', function (socket) {
sockets.push(socket);
listeners.forEach(function (listener) {
socket.on(listener.type, listener.fn);
});
socket.on('disconnect', function () {
var i = sockets.indexOf(socket);
delete sockets[i];
});
});
};
CockpitMessaging.prototype = new EventEmitter2({
wildcard: true,
newListener: true
});
CockpitMessaging.prototype.constructor = CockpitMessaging;
module.exports = CockpitMessaging;
}()); |
(function($){
$.fn.time = function(options) {
var dataintera = new Date();
var HH = dataintera.getHours();
var MM = dataintera.getMinutes();
var SS = dataintera.getSeconds();
var defaults = {font_size:22 , color:'red'};
var options = $.extend(defaults, options);
return this.each(function() {
var str = '<span class="hh"></span> : <span class="mm"></span> : <span class="ss"></span>';
$(this).html(str).css({'font-size': options.font_size+'px', 'color': options.color});
if(SS<=9){
$(' span.ss').html('0'+SS);
}
else{
$(' span.ss').html(SS);
};
if(MM<=9){
$(' span.mm').html('0'+MM);
}else{
$(' span.mm').html(MM);
};
if(HH<=9){
$(' span.hh').html('0'+HH);
}else{
$(' span.hh').html(HH);
};
setInterval(function(){
var dataintera = new Date();
var HH = dataintera.getHours();
var MM = dataintera.getMinutes();
var SS = dataintera.getSeconds();
if(SS<=9){$('span.ss').html('0'+SS);
} else{$('span.ss').html(SS);
};
if(MM<=9){$('span.mm').html('0'+MM);
}else{$('span.mm').html(MM);
};
if(HH<=9){$('span.hh').html('0'+HH);
}else{$('span.hh').html(HH);
};
},1000);
});
};
})(jQuery);
|
const mongoose = require('mongoose'),
Schema = mongoose.Schema;
const userSchema = new Schema({
alias: { type: String, default: "", index: { unique: true, dropDups: true } },
slug: { type: String, index: { unique: true, dropDups: true }},
fb: {
id: { type: String, default: "", index: true },
name: { type: String, default: "" },
picture: {
data: {
url: { type: String, default: "" }
}
},
email: { type: String, default: "" }
},
hasPassword: { type: Boolean, default: true },
mergedWithFB: { type: Boolean, default: false },
email: { type: String, index: { unique: true, sparse: true, dropDups: true } },
name: { type: String, default: "" },
pwd: {
hash: { type: String, default: "" },
salt: { type: String, default: "" },
iterations: { type: Number, default: 10000 }
},
profilePic: { type: String, default: "" },
role: { type: String, default: "user" }
});
mongoose.model('UserModel', userSchema); |
const path = require('path')
const nodeExternals = require('webpack-node-externals')
module.exports = {
target: 'node',
externals: [nodeExternals()],
entry: {
index: './src/index.js',
browser: './src/index.browser.js'
},
output: {
filename: '[name].js',
path: path.resolve(__dirname, 'dist'),
library: 'clevr',
libraryTarget: 'umd'
},
module: {
rules: [
{
test: /\.js$/,
exclude: [/node_modules/],
use: [{
loader: 'babel-loader',
options: {
presets: ['stage-3']
}
}]
},
{
test: /\.node$/,
use: 'node-loader'
}
]
}
}
|
define("ace/snippets/razor",["require","exports","module"],function(e,n,t){"use strict";n.snippetText="snippet if\n(${1} == ${2}) {\n\t${3}\n}",n.scope="razor"});
//# sourceMappingURL=node_modules/ace-builds/src-min/snippets/razor.js.map |
var expect = require('chai').expect;
var stdout = require("test-console").stdout;
var stderr = require("test-console").stderr;
var MockCache = require("../mock_cache_handler");
var cacheName = "MOCHA_Mock_Test_Cache";
var testCache = new MockCache(cacheName);
var testEntry = {};
testEntry.data = "This is some string data";
testEntry.boolean = true;
testEntry.number = 6;
describe("Mock Cache Services", function(){
//Insert some dummy data
before(function(done){
testCache.put("MOCHAtestKey1", "testVal1", function(err){
if(err){
console.log(err);
done(err);
}
testCache.put("MOCHAtestKey2", testEntry, function(err){
if(err){
console.log(err);
}
testCache.put("MOCHANumericKey", 15, function(err){
if(err){
console.log(err);
}
testCache.put("MOCHAArrayKey", new Array(1,2,3,4,5), function(err){
if(err){
console.log(err);
}
done();
});
});
});
});
});
describe("Cache Initialisation", function(){
//Test local fallback works
it("Create an ACCS Cache without CACHING_INTERNAL_CACHE_URL set creates MockCache", function(done){
delete process.env.CACHING_INTERNAL_CACHE_URL;
var Cache = require("../cache_handler.js");
var inspect = stderr.inspect();
var newCache = new Cache("Test-Cache-No-Url");
inspect.restore();
expect(newCache).to.have.property('_cache');
expect(inspect.output).to.have.members(["Internal Caching URL is not set. Falling back on using a local hashmap instead.\n"]);
newCache.put("MOCHAFirstMockKey", "testVal", function(err){
if(err){
done(err);
}
newCache.get("MOCHAFirstMockKey", function(err, res){
if(err){
done(err);
}
expect(res).to.equal("testVal");
done();
})
})
});
//Test remote fallback works
it("Create an ACCS Cache without CACHING_INTERNAL_CACHE_URL but other ACCS vars set creates MockCache and warns", function(){
delete process.env.CACHING_INTERNAL_CACHE_URL;
process.env.HOSTNAME = "dummy";
process.env.PORT = "dummy";
var Cache = require("../cache_handler.js");
var inspect = stderr.inspect();
var newCache = new Cache("Test-Cache-No-Url-ACCS-flags");
inspect.restore();
expect(newCache).to.have.property('_cache');
expect(inspect.output).to.have.members(
["Internal Caching URL is not set. Falling back on using a local hashmap instead.\n",
"If this application is running on ACCS, ensure that you have correctly bound to a caching service.\n"]);
});
//Test explicit MockCache class creation from Cache works
it("Create a MockCache explicitly from the Cache export", function(){
var Cache = require("../cache_handler.js");
var TestMockCache = Cache.MockCache;
var newCache = new TestMockCache("Test-Mock-Cache-Explicit");
expect(newCache).to.have.property('_cache');
});
});
//Test reads
describe("Test getting entries from the cache", function(){
//Test Cache Read
it("Get a string", function(done){
testCache.get("MOCHAtestKey1", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.equal("testVal1");
expect(res).to.be.a('string');
done();
});
});
//Test Cache Read
it("Get a non-existant object", function(done){
testCache.get("MOCHAnotRealKey", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.not.exist;
done();
});
});
//Test Cache Read JSON
it("Get a JSON object", function(done){
testCache.get("MOCHAtestKey2", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.deep.equal(testEntry);
done();
});
});
//Test object type coercion
it("Gets an number using an object type hint", function(done){
testCache.get("MOCHANumericKey", 'number', function(err, res){
if(err){
done(err);
return;
}
expect(res).to.be.a('number');
expect(res).to.equal(15);
done();
})
});
//Test object type coercion
it("Fails when the object type hint for number cannot obtain a number", function(done){
testCache.get("MOCHAtestKey1", 'number', function(err, res){
expect(err).to.exist;
expect(err.message).to.contain('NaN');
done();
})
});
//Test object type coercion
it("Gets an array using an object type hint", function(done){
testCache.get("MOCHAArrayKey", 'array', function(err, res){
if(err){
done(err);
return;
}
expect(res).to.be.instanceof(Array);
expect(res).to.deep.equal(new Array(1,2,3,4,5));
done();
})
});
it("Throw TypeErrors for non-string keys", function(done){
try{
expect(testCache.get(true, function(err, res){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
done();
}
});
it("Throw SyntaxError when key not supplied", function(done){
try{
expect(testCache.get(function(err, res){
done("Should have thrown a SyntaxError!");
})).to.throw(SyntaxError);
}catch(e){
done();
}
});
});
//Test Cache insertion
describe("Test inserting entries into the cache", function(){
it("Insert a simple value", function(done){
testCache.put("MOCHAtestInsertedVal1", "TestInsert", function(err){
if(err){
done(err);
return;
}
testCache.get("MOCHAtestInsertedVal1", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.equal("TestInsert");
done();
});
});
});
//Test Cache 'put if absent'
it("Insert a duplicate key, with 'putIfAbsent'", function(done){
testCache.put("MOCHAduplicatedKey", "value", function(err){
if(err){
done(err);
return;
}
testCache.putIfAbsent("MOCHAduplicatedKey", "value2", function(err){
expect(err).to.exist;
expect(err.message).to.contain('key already exists');
done();
});
});
});
//Test Cache put with time to live
it("Insert a value with TTL", function(done){
this.timeout(5000);
testCache.put("MOCHAtemporaryKey", "value", 500, function(err){
if(err){
done(err);
return;
}
setTimeout(function(){
testCache.get("MOCHAtemporaryKey", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.not.exist;
done();
});
}, 2000);
});
});
it("Coerces numeric keys into strings", function(done){
testCache.put(155, "One-Hundred-and-Fifty-Five", function(err){
if(err){
done(err);
return;
}
testCache.get(155, function(err, res){
if(err){
done(err);
return;
}
expect(res).to.equal("One-Hundred-and-Fifty-Five");
testCache.get("155", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.equal("One-Hundred-and-Fifty-Five");
done();
});
});
});
});
it("Throw TypeErrors for non-string/numeric keys", function(done){
try{
expect(testCache.put(true, "value", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
var objKey = { "attr": "attr-val", "attr2": "attr2-val"};
try{
expect(testCache.putIfAbsent(objKey, "value", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
done()
}
}
});
it("Throw SyntaxErrors for missing parameters", function(done){
try{
expect(testCache.put("value", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
try{
expect(testCache.putIfAbsent(function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
done()
}
}
});
it("Throw TypeErrors for invalid ttl values", function(done){
try{
expect(testCache.put("MOCHAinvalidTTLKey", "value", "ttlString", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
try{
expect(testCache.putIfAbsent("MOCHAinvalidTTLKey", "value", "ttlString", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
done();
}
}
});
});
//Test Cache Replace Operation
describe("Test replacing entries in the cache", function(){
it("Replace a simple value", function(done){
testCache.put("MOCHAtestReplaceValue", "TestInsertBefore", function(err){
if(err){
done(err);
return;
}
testCache.replace("MOCHAtestReplaceValue", "TestInsertAfter", "TestInsertBefore", function(err){
if(err){
done(err);
return;
}
testCache.get("MOCHAtestReplaceValue", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.equal("TestInsertAfter");
done();
});
});
});
});
it("Replace a complex value", function(done){
var oldValue = { name: "TestInsertName",
parameter: true
};
testCache.put("MOCHAtestReplaceValueComplex", oldValue, function(err){
if(err){
done(err);
return;
}
var newValue = { name: "TestInsertName",
parameter: false
};
testCache.replace("MOCHAtestReplaceValueComplex", newValue, oldValue, function(err){
if(err){
done(err);
return;
}
testCache.get("MOCHAtestReplaceValueComplex", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.deep.equal(newValue);
done();
});
});
});
});
it("Attempt to replace a simple value with wrong old value", function(done){
testCache.put("MOCHAtestReplaceValue", "TestInsertBefore", function(err){
if(err){
done(err);
return;
}
testCache.replace("MOCHAtestReplaceValue", "TestInsertAfter", "TestInsertEvenOlder", function(err){
expect(err).to.exist;
expect(err.message).to.contain('cached value does not equal oldVal');
testCache.get("MOCHAtestReplaceValue", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.equal("TestInsertBefore");
done();
});
});
});
});
it("Attempt to replace a complex value with wrong old value", function(done){
var oldValue = { name: "TestInsertName",
parameter: true
};
testCache.put("MOCHAtestReplaceValueComplex", oldValue, function(err){
if(err){
done(err);
return;
}
var newValue = { name: "TestInsertName",
parameter: false
};
testCache.replace("MOCHAtestReplaceValueComplex", newValue, {name: "Wrong entry!"}, function(err){
expect(err).to.exist;
expect(err.message).to.contain('cached value does not equal oldVal');
testCache.get("MOCHAtestReplaceValueComplex", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.deep.equal(oldValue);
done();
});
});
});
});
it("Throw TypeErrors for non-string/numeric keys", function(done){
try{
expect(testCache.replace(true, "value", "old", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
var objKey = { "attr": "attr-val", "attr2": "attr2-val"};
try{
expect(testCache.replace(objKey, "value", "old", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
done()
}
}
});
it("Throw SyntaxErrors for missing parameters", function(done){
try{
expect(testCache.replace("value", "oldVal", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
try{
expect(testCache.replace(function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
done()
}
}
});
it("Throw TypeErrors for invalid ttl values", function(done){
try{
expect(testCache.replace("MOCHAinvalidTTLKey", "value", "oldValue", "ttlString", function(err){
done("Should have thrown a TypeError!");
})).to.throw(TypeError);
}catch(e){
done();
}
});
});
describe("Test Deleting entries from the cache", function(){
//Test deleting a value
it("Delete a value", function(done){
testCache.put("MOCHAvalueToDelete", "value", function(err){
if(err){
done(err);
return;
}
testCache.delete("MOCHAvalueToDelete", function(err){
if(err){
done(err);
return;
}
testCache.get("MOCHAvalueToDelete", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.not.exist;
done();
});
});
});
});
//Create a new cache, then clear it.
it("Clear an entire cache", function(done){
var cacheToClear = new MockCache("MOCHA_Cache_To_Clear");
cacheToClear.put("TestKey1", "TestVal", function(err){
if(err){
done(err);
return;
}
cacheToClear.clear(function(err){
if(err){
done(err);
return;
}
cacheToClear.stats(function(err, res){
if(err){
done(err);
return;
}
expect(res.count).to.equal(0);
cacheToClear = null;
done();
});
});
});
});
it("Coerces numeric keys into strings", function(done){
testCache.put("156", "One-Hundred-and-Fifty-Six", function(err){
if(err){
done(err);
return;
}
testCache.delete(156, function(err){
if(err){
done(err);
return;
}
testCache.get("156", function(err, res){
if(err){
done(err);
return;
}
expect(res).to.not.exist;
done();
});
});
});
});
it("Throw TypeErrors for non-string/numeric keys", function(){
try{
expect(testCache.delete(true, function(err){})).to.throw(TypeError);
}catch(e){}
});
});
describe("Test Buffer behaviour", function(){
//Test behaviour with binary streams
it("Do buffer stuffs with the cache", function(done){
var blobbyBuffer = Buffer.alloc(512, true, 'binary');
var longInt8View = new Uint8Array(blobbyBuffer);
for (var i=0; i< longInt8View.length; i++) {
longInt8View[i] = i % 128;
}
testCache.put("MOCHABlobKey", Buffer.from(longInt8View), true, function(err, res){
if(err){
done(err);
return;
}
testCache.get("MOCHABlobKey", 'buffer', function(err, res){
if(err){
done(err);
return;
}
expect(res).to.be.ok;
expect(res).to.have.lengthOf(512);
var resBytes = new Uint8Array(res);
expect(resBytes).to.deep.equal(longInt8View);
done();
});
});
});
});
describe("Global Cache Behaviour", function(){
it("Value survives cache object teardown", function(done){
var testingGlobalCacheName = "MOCHA_Global_Cache_Testing";
var newMockCacheOne = new MockCache(testingGlobalCacheName);
newMockCacheOne.put("GlobalTestKey","TestValue", function(err){
delete newMockCacheOne;
var newMockCacheTwo = new MockCache(testingGlobalCacheName);
newMockCacheTwo.get("GlobalTestKey", function(err, res){
expect(res).to.equal("TestValue");
done();
});
});
});
});
describe("Misc", function(){
//Call 'get cache metrics' on our testing cache.
//The cache contents is not really checked, just that valid results come back.
it("Get cache metrics", function(done){
testCache.stats(function(err, res){
if(err){
done(err);
return;
}
expect(res).to.include.keys('cache');
expect(res.cache).to.equal(cacheName);
expect(res).to.include.keys('count');
expect(res.count).to.be.at.least(1);
expect(res).to.include.keys('size');
expect(res.size).to.be.at.least(1);
done();
});
});
it("Get cache metrics is correctly empty for non-existant caches", function(done){
var testMetricsCache = new MockCache("MOCHA_Cache_For_Metrics");
testMetricsCache.stats(function(err, res){
if(err){
done(err);
return;
}
expect(res).to.include.keys('cache');
expect(res.cache).to.equal("MOCHA_Cache_For_Metrics");
expect(res).to.include.keys('count');
expect(res.count).to.equal(0);
expect(res).to.include.keys('size');
expect(res.size).to.equal(0);
done();
});
});
});
//Clear our testingData
after(function(){
testCache.clear(function(err){});
});
}); |
'use strict';
/**
* Module dependencies
*/
var path = require('path'),
mongoose = require('mongoose'),
User = mongoose.model('User'),
errorHandler = require(path.resolve('./modules/core/server/controllers/errors.server.controller'));
/**
* Show the current user
*/
exports.read = function (req, res) {
res.json(req.model);
};
/**
* Update a User
*/
exports.update = function (req, res) {
var user = req.model;
// For security purposes only merge these parameters
// user.firstName = req.body.firstName;
// user.lastName = req.body.lastName;
// user.displayName = req.body.displayName;
user.roles = req.body.roles;
user.save(function (err) {
if (err) {
return res.status(422).send({
message: errorHandler.getErrorMessage(err)
});
}
res.json(user);
});
};
/**
* Delete a user
*/
exports.delete = function (req, res) {
var user = req.model;
user.remove(function (err) {
if (err) {
return res.status(422).send({
message: errorHandler.getErrorMessage(err)
});
}
res.json(user);
});
};
/**
* List of Users
*/
exports.list = function (req, res) {
User.find({}, '-salt -password -providerData').sort('-created').populate('user', 'displayName').exec(function (err, users) {
if (err) {
return res.status(422).send({
message: errorHandler.getErrorMessage(err)
});
}
res.json(users);
});
};
/**
* User middleware
*/
exports.userByID = function (req, res, next, id) {
if (!mongoose.Types.ObjectId.isValid(id)) {
return res.status(400).send({
message: 'User is invalid'
});
}
User.findById(id, '-salt -password -providerData').exec(function (err, user) {
if (err) {
return next(err);
} else if (!user) {
return next(new Error('Failed to load user ' + id));
}
req.model = user;
next();
});
};
|
/**
* This is a self-contained module that defines its routes, callbacks, models and views
* all internally. Such approach to code organization follows the recommendations of TJ:
*
* http://vimeo.com/56166857
*
*/
// Third-party libraries
var _ = require('underscore')
, express = require('express')
, app = exports = module.exports = express();
// Don't just use, but also export in case another module needs to use these as well.
exports.callbacks = require('./controllers/movietime');
exports.models = require('./models');
//-- You could also serve templates with local paths, but using shared layouts and partials may become tricky
//var hbs = require('hbs');
//app.set('views', __dirname + '/views');
//app.set('view engine', 'handlebars');
//app.engine('handlebars', hbs.__express);
// Module's Routes. Please note this is actually under /hello, because module is attached under /hello
app.get('/', exports.callbacks.sayHello);
|
/// <reference types="cypress" />
context('Standard User Session', () => {
it('Login and Logout', () => {
cy.loginStandard('v2/dashboard');
cy.visit('/session/end');
});
it('UserName prefilled', () => {
cy.loginStandard('session/begin?username=test@user.com');
cy.get('input[id="UserBox"]').should('have.value', "test@user.com");
});
});
|
import cmdExport from './cmdExport';
const cache = {};
export default function profile(username) {
if (!cache[username]) {
cache[username] = cmdExport({ player_username: username, subcmd: 'profile' });
}
return cache[username];
}
|
import React from 'react';
import ReactDOM from 'react-dom';
import Terminal from 'rebash';
// custom commands
const commands = {
'open-window': args => { alert(args.targets[0]); },
'ghetto-cowsay': args => `cow says: "${args.targets[0]}"`,
};
// map of files
const files = {
'/test.txt': 'I am a test',
'/home/lawrence/greet.txt': 'Hello',
'.config/nvim/init.vim': 'lmao',
};
// a list of directories
const directories = [
'/home/lpan',
'/etc/nginx/',
];
// The initial path of the shell when the component rendered
const initialPath = '/home';
ReactDOM.render(
<Terminal
files={files}
directories={directories}
commands={commands}
initialPath={initialPath}
/>,
document.getElementById('root')
);
|
var define, require;
(function() {
var registry = {}, seen = {};
define = function(name, deps, callback) {
registry[name] = { deps: deps, callback: callback };
};
require = function(name) {
if (seen[name]) { return seen[name]; }
seen[name] = {};
if (!registry[name]) {
throw new Error("Could not find module " + name);
}
var mod = registry[name],
deps = mod.deps,
callback = mod.callback,
reified = [],
exports;
for (var i=0, l=deps.length; i<l; i++) {
if (deps[i] === 'exports') {
reified.push(exports = {});
} else {
reified.push(require(resolve(deps[i])));
}
}
var value = callback.apply(this, reified);
return seen[name] = exports || value;
function resolve(child) {
if (child.charAt(0) !== '.') { return child; }
var parts = child.split("/");
var parentBase = name.split("/").slice(0, -1);
for (var i=0, l=parts.length; i<l; i++) {
var part = parts[i];
if (part === '..') { parentBase.pop(); }
else if (part === '.') { continue; }
else { parentBase.push(part); }
}
return parentBase.join("/");
}
};
require.entries = registry;
})();
|
import imported from 'react-imported-component';
const test = 115582;
export default imported(() => import('../Counter'));
|
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var assert = require('assert');
var readline = require('readline');
var EventEmitter = require('events').EventEmitter;
var inherits = require('util').inherits;
function FakeInput() {
EventEmitter.call(this);
}
inherits(FakeInput, EventEmitter);
FakeInput.prototype.resume = function() {};
FakeInput.prototype.pause = function() {};
FakeInput.prototype.write = function() {};
FakeInput.prototype.end = function() {};
[ true, false ].forEach(function(terminal) {
var fi;
var rli;
var called;
// sending a full line
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
called = false;
rli.on('line', function(line) {
called = true;
assert.equal(line, 'asdf');
});
fi.emit('data', 'asdf\n');
assert.ok(called);
// sending a blank line
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
called = false;
rli.on('line', function(line) {
called = true;
assert.equal(line, '');
});
fi.emit('data', '\n');
assert.ok(called);
// sending a single character with no newline
fi = new FakeInput();
rli = new readline.Interface(fi, {});
called = false;
rli.on('line', function(line) {
called = true;
});
fi.emit('data', 'a');
assert.ok(!called);
rli.close();
// sending a single character with no newline and then a newline
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
called = false;
rli.on('line', function(line) {
called = true;
assert.equal(line, 'a');
});
fi.emit('data', 'a');
assert.ok(!called);
fi.emit('data', '\n');
assert.ok(called);
rli.close();
// sending multiple newlines at once
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
var expectedLines = ['foo', 'bar', 'baz'];
var callCount = 0;
rli.on('line', function(line) {
assert.equal(line, expectedLines[callCount]);
callCount++;
});
fi.emit('data', expectedLines.join('\n') + '\n');
assert.equal(callCount, expectedLines.length);
rli.close();
// sending multiple newlines at once that does not end with a new line
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
expectedLines = ['foo', 'bar', 'baz', 'bat'];
callCount = 0;
rli.on('line', function(line) {
assert.equal(line, expectedLines[callCount]);
callCount++;
});
fi.emit('data', expectedLines.join('\n'));
assert.equal(callCount, expectedLines.length - 1);
rli.close();
// \r\n should emit one line event, not two
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
expectedLines = ['foo', 'bar', 'baz', 'bat'];
callCount = 0;
rli.on('line', function(line) {
assert.equal(line, expectedLines[callCount]);
callCount++;
});
fi.emit('data', expectedLines.join('\r\n'));
assert.equal(callCount, expectedLines.length - 1);
rli.close();
// \r\n should emit one line event when split across multiple writes.
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
expectedLines = ['foo', 'bar', 'baz', 'bat'];
callCount = 0;
rli.on('line', function(line) {
assert.equal(line, expectedLines[callCount]);
callCount++;
});
expectedLines.forEach(function(line) {
fi.emit('data', line + '\r');
fi.emit('data', '\n');
});
assert.equal(callCount, expectedLines.length);
rli.close();
// \r should behave like \n when alone
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: true });
expectedLines = ['foo', 'bar', 'baz', 'bat'];
callCount = 0;
rli.on('line', function(line) {
assert.equal(line, expectedLines[callCount]);
callCount++;
});
fi.emit('data', expectedLines.join('\r'));
assert.equal(callCount, expectedLines.length - 1);
rli.close();
// sending a multi-byte utf8 char over multiple writes
var buf = Buffer('☮', 'utf8');
fi = new FakeInput();
rli = new readline.Interface({ input: fi, output: fi, terminal: terminal });
callCount = 0;
rli.on('line', function(line) {
callCount++;
assert.equal(line, buf.toString('utf8'));
});
[].forEach.call(buf, function(i) {
fi.emit('data', Buffer([i]));
});
assert.equal(callCount, 0);
fi.emit('data', '\n');
assert.equal(callCount, 1);
rli.close();
assert.deepEqual(fi.listeners('end'), []);
assert.deepEqual(fi.listeners(terminal ? 'keypress' : 'data'), []);
});
|
// All code points in the Optical Character Recognition block as per Unicode v4.1.0:
[
0x2440,
0x2441,
0x2442,
0x2443,
0x2444,
0x2445,
0x2446,
0x2447,
0x2448,
0x2449,
0x244A,
0x244B,
0x244C,
0x244D,
0x244E,
0x244F,
0x2450,
0x2451,
0x2452,
0x2453,
0x2454,
0x2455,
0x2456,
0x2457,
0x2458,
0x2459,
0x245A,
0x245B,
0x245C,
0x245D,
0x245E,
0x245F
]; |
const validate = (input) => {
const errors = {};
const values = input.toJS();
if (!values.oldPassword) {
errors.oldPassword = 'Required';
}
if (!values.newPassword) {
errors.newPassword = 'Required';
}
if (values.passwordConfirmation !== values.newPassword) {
errors.passwordConfirmation = 'Passwords dont match';
}
return errors;
};
export default validate;
|
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.buildContract = void 0;
var n = require('./Nethereum.Generators.DuoCode.js');
var functionAbi = Nethereum.Generators.Model.FunctionABI;
var eventAbi = Nethereum.Generators.Model.EventABI;
var constructorAbi = Nethereum.Generators.Model.ConstructorABI;
var contractAbi = Nethereum.Generators.Model.ContractABI;
var parameterAbi = Nethereum.Generators.Model.ParameterABI;
var structAbi = Nethereum.Generators.Model.StructABI;
function buildConstructor(item) {
var constructorItem = new constructorAbi();
constructorItem.set_InputParameters(buildFunctionParameters(item.inputs));
return constructorItem;
}
function buildFunction(item, contractAbi) {
var constant = false;
if (item.constant !== undefined) {
constant = item.constant;
}
else {
// for solidity >=0.6.0
if (item.stateMutability !== undefined && (item.stateMutability === "view" || item.stateMutability === "pure"))
constant = true;
}
var functionItem = new functionAbi(item.name, constant, contractAbi, false);
functionItem.set_InputParameters(buildFunctionParameters(item.inputs));
functionItem.set_OutputParameters(buildFunctionParameters(item.outputs));
return functionItem;
}
function buildEvent(item, contractAbi) {
var eventItem = new eventAbi(item.name, contractAbi);
eventItem.set_InputParameters(buildEventParameters(item.inputs));
return eventItem;
}
function getStructTypeName(item) {
if (item.internalType !== undefined && item.internalType.startsWith("struct")) {
var internalType = item.internalType;
var structName = internalType.substring(internalType.lastIndexOf(".") + 1);
if (structName.indexOf("[") > 0) {
structName = structName.substring(0, structName.indexOf("["));
}
return structName;
}
// simple hack until 0.5.8 type name is the same as the parameter name
return item.name;
}
function buildStructsFromParameters(items) {
var structs = [];
if (items !== null && items !== undefined) {
for (var i = 0, len = items.length; i < len; i++) {
if (items[i].type.startsWith("tuple")) {
structs = structs.concat(buildStructsFromTuple(items[i]));
}
}
}
return structs;
}
function buildStructsFromTuple(item) {
var structs = [];
var struct = new structAbi(getStructTypeName(item));
var parameterOrder = 0;
var parameters = [];
for (var x = 0, len = item.components.length; x < len; x++) {
var component = item.components[x];
parameterOrder = parameterOrder + 1;
if (component.type.startsWith("tuple")) {
var parameter = new parameterAbi.ctor$1(component.type, component.name, parameterOrder, getStructTypeName(component));
structs = structs.concat(buildStructsFromTuple(component));
}
else {
var parameter = new parameterAbi.ctor$1(component.type, component.name, parameterOrder);
}
parameters.push(parameter);
}
struct.set_InputParameters(parameters);
structs.push(struct);
return structs;
}
function buildFunctionParameters(items) {
var parameterOrder = 0;
var parameters = [];
for (var i = 0, len = items.length; i < len; i++) {
parameterOrder = parameterOrder + 1;
if (items[i].type.startsWith("tuple")) {
var parameter = new parameterAbi.ctor$1(items[i].type, items[i].name, parameterOrder, getStructTypeName(items[i]));
}
else {
var parameter = new parameterAbi.ctor$1(items[i].type, items[i].name, parameterOrder);
}
parameters.push(parameter);
}
return parameters;
}
function buildEventParameters(items) {
var parameterOrder = 0;
var parameters = [];
for (var i = 0, len = items.length; i < len; i++) {
parameterOrder = parameterOrder + 1;
if (items[i].type.startsWith("tuple")) {
var parameter = new parameterAbi.ctor$1(items[i].type, items[i].name, parameterOrder, getStructTypeName(items[i]));
}
else {
var parameter = new parameterAbi.ctor$1(items[i].type, items[i].name, parameterOrder);
}
parameter.set_Indexed(items[i].indexed);
parameters.push(parameter);
}
return parameters;
}
function buildContract(abiStr) {
var abi = JSON.parse(abiStr);
var functions = [];
var events = [];
var structs = [];
var constructor = new constructorAbi();
var contract = new contractAbi();
for (var i = 0, len = abi.length; i < len; i++) {
if (abi[i].type === "function") {
functions.push(buildFunction(abi[i], contract));
var temp = buildStructsFromParameters(abi[i].outputs);
var _loop_1 = function (item) {
if (!structs.some(function (x) { return x.get_Name() === item.get_Name(); })) {
structs.push(item);
}
};
for (var _i = 0, temp_1 = temp; _i < temp_1.length; _i++) {
var item = temp_1[_i];
_loop_1(item);
}
}
if (abi[i].type === "event") {
events.push(buildEvent(abi[i], contract));
}
if (abi[i].type === "constructor") {
constructor = buildConstructor(abi[i]);
}
var temp = buildStructsFromParameters(abi[i].inputs);
var _loop_2 = function (item) {
if (!structs.some(function (x) { return x.get_Name() === item.get_Name(); })) {
structs.push(item);
}
};
for (var _a = 0, temp_2 = temp; _a < temp_2.length; _a++) {
var item = temp_2[_a];
_loop_2(item);
}
}
contract.set_Constructor(constructor);
contract.set_Functions(functions);
contract.set_Events(events);
contract.set_Structs(structs);
return contract;
}
exports.buildContract = buildContract;
//# sourceMappingURL=AbiDeserialiser.js.map |
var OS = require('./OS');
var Browser = require('./Browser');
var Input = {
// @property {boolean} touch - Is touch available?
touch: false,
// @property {boolean} mspointer - Is mspointer available?
mspointer: false,
// @property {?string} wheelType - The newest type of Wheel/Scroll event supported: 'wheel', 'mousewheel', 'DOMMouseScroll'
wheelEvent: null,
// @property {boolean} gamepads - Is navigator.getGamepads available?
gamepads: false
};
function init ()
{
if ('ontouchstart' in document.documentElement || (navigator.maxTouchPoints && navigator.maxTouchPoints >= 1))
{
Input.touch = true;
}
if (navigator.msPointerEnabled || navigator.pointerEnabled)
{
Input.mspointer = true;
}
if (navigator.getGamepads)
{
Input.gamepads = true;
}
if (!OS.cocoonJS)
{
// See https://developer.mozilla.org/en-US/docs/Web/Events/wheel
if ('onwheel' in window || (Browser.ie && 'WheelEvent' in window))
{
// DOM3 Wheel Event: FF 17+, IE 9+, Chrome 31+, Safari 7+
Input.wheelEvent = 'wheel';
}
else if ('onmousewheel' in window)
{
// Non-FF legacy: IE 6-9, Chrome 1-31, Safari 5-7.
Input.wheelEvent = 'mousewheel';
}
else if (Browser.firefox && 'MouseScrollEvent' in window)
{
// FF prior to 17. This should probably be scrubbed.
Input.wheelEvent = 'DOMMouseScroll';
}
}
return Input;
}
module.exports = init();
|
import 'babel-polyfill'
import Waiter from './waiter'
import Talker from './talker'
export default class Weixin {
constructor(options) {
this.waiter = new Waiter(options)
this.talker = new Talker(options)
}
getWaiter() {
return this.waiter
}
getTalker() {
return this.talker
}
setReplyPopulatorOfWaiter(populator) {
if(this.waiter) {
this.waiter.populateReply = populator
}
}
setTokenStore(tokenStore) {
if(this.talker && this.talker.tokenKeeper) {
this.talker.tokenKeeper.store = tokenStore
}
}
}
export * from './managers/'
|
/*jslint indent: 4, nomen: true */
/*global require, __dirname, process */
(function () {
'use strict';
//
// load env variables
require('dotenv').load();
var // variables
server, paths, app,
port = process.env.PORT || 9080,
debug = process.env.DEBUG || false,
livereload_port = process.env.LIVERELOAD_PORT || false,
//
// requires
path = require('path'),
multer = require('multer'),
express = require('express'),
bodyParser = require('body-parser'),
compression = require('compression'),
serveFavicon = require('serve-favicon'),
livereload = require('express-livereload'),
//
// main app entry point
Application = require('./server/app');
//
// app paths
paths = {
www: path.join(__dirname, 'public'),
app: path.join(__dirname, 'server'),
storage: path.join(__dirname, 'data')
};
//
// express
server = express();
//
// livereload
if (debug) {
livereload(server, {
watchDir: paths.www,
port: livereload_port,
exclusions: ['git/', '.svn/'],
exts: ['html', 'css', 'js', 'png', 'gif', 'jpg', 'svg']
});
}
//
// express middlewares
server.use(compression()); // gzip
server.use(serveFavicon(path.join(paths.www, 'favicon.ico'))); // utilisation du favicon
server.use(multer()); // for parsing multipart/form-data
server.use(bodyParser.json()); // for parsing application/json
server.use(bodyParser.urlencoded({ // for parsing application/x-www-form-urlencoded
extended: true
}));
//
// le serveur express sert des ressouces statiques
// pour l'app AngularJS/Front
server.use('/', express.static(paths.www));
//server.use('/docs', express.static(path.join(paths.www, '..', 'docs')));
//
console.log(Application);
app = Application.getInstance();
app.init(server, function (err) {
if (err) {
} else {
console.log('init');
}
/*
server.listen(port, function () {
if (devmode) {
console.log('ReadmePad now running under http://localhost:%d', port);
}
if (devmode && livereload_port) {
console.log('Livereload is running on port %d\n', livereload_port);
}
});
*/
});
}());
|
const {test} = require('ava');
const {Database, Collection, Document, plugins} = require('../');
const db = new Database('localhost/mongorite_test_Collection_refresh');
class TestDocument extends Document {}
class TestCollection extends Collection {
get Document () {
return TestDocument;
}
}
const inspect = (obj, depth) => {
console.log(require('util').inspect(obj, {colors: true, breakLength: 0, depth: depth}));
};
test('something', assert => {
assert.pass();
});
/*
test('prototype.schema - no collection', assert => {
let document = new Document();
let schema = {foo: 'bar', bleh: {foo: 'koo'}};
let options = {foo2: 'bar2', bleh2: {foo2: 'koo2'}};
document.schema(schema, options);
assert.deepEqual(document.schema().schema, schema);
assert.deepEqual(document.schema().options, options);
document.schema({}, {});
assert.deepEqual(document.schema().schema, {});
assert.deepEqual(document.schema().options, {});
});
test('prototype.schema - with collection', assert => {
let collection = new Collection();
let document = new Document(collection);
let schema = {foo: 'bar', bleh: {foo: 'koo'}};
let options = {foo2: 'bar2', bleh2: {foo2: 'koo2'}};
document.schema(schema, options);
assert.deepEqual(document.schema().schema, schema);
assert.deepEqual(document.schema().options, options);
document.schema({}, {});
assert.deepEqual(document.schema().schema, {});
assert.deepEqual(document.schema().options, {});
});
test('prototype.schema - with collection, after schema', assert => {
let collection = new Collection();
let document = new Document();
let schema = {foo: 'bar', bleh: {foo: 'koo'}};
let options = {foo2: 'bar2', bleh2: {foo2: 'koo2'}};
document.schema(schema, options);
assert.deepEqual(document.schema().schema, schema);
assert.deepEqual(document.schema().options, options);
document.collection = collection;
document.schema({}, {});
assert.deepEqual(document.schema().schema, {});
assert.deepEqual(document.schema().options, {});
});
test('prototype.validate, no collection', assert => {
let document = new Document();
let schema = {
properties: {
val1: { type: 'string' },
val2: { type: 'number' }
}
};
document.schema(schema, {allErrors: true});
assert.is(document.set({val1: 'val1', val2: 100}).validate(), null);
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 2);
document.schema(null, {allErrors: false});
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 1);
document.schema(null, {allErrors: true});
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 2);
document.schema({
properties: {
val1: { type: 'number' },
val2: { type: 'string' }
}
}, {allErrors: true});
assert.is(document.set({val1: 100, val2: '100'}).validate(), null);
document.schema(false);
assert.is(document.set({val1: 100, val2: '100'}).validate(), null);
});
test('prototype.validate - with collection', assert => {
let collection = new Collection();
let document = new Document(collection);
let schema = {
properties: {
val1: { type: 'string' },
val2: { type: 'number' }
}
};
document.schema(schema, {allErrors: true});
assert.is(document.set({val1: 'val1', val2: 100}).validate(), null);
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 2);
document.schema(null, {allErrors: false});
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 1);
document.schema(null, {allErrors: true});
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 2);
document.schema({
properties: {
val1: { type: 'number' },
val2: { type: 'string' }
}
}, {allErrors: true});
assert.is(document.set({val1: 100, val2: '100'}).validate(), null);
document.schema(false);
assert.is(document.set({val1: 100, val2: '100'}).validate(), null);
});
test('prototype.validate - with collection, after schema', assert => {
let collection = new Collection();
let document = new Document(collection);
let schema = {
properties: {
val1: { type: 'string' },
val2: { type: 'number' }
}
};
document.schema(schema, {allErrors: true});
document.collection = collection;
assert.is(document.set({val1: 'val1', val2: 100}).validate(), null);
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 2);
document.schema(null, {allErrors: false});
assert.is(document.set({val1: 100, val2: '100'}).validate().length, 1);
});
*/ |
const REQUEST_GOOGLE_SIGN_IN = 'REQUEST_GOOGLE_SIGN_IN';
export function requestGoogleSignIn() {
return {
type: REQUEST_GOOGLE_SIGN_IN
};
}
export default function(state = {}, action) {
switch (action.type) {
case REQUEST_GOOGLE_SIGN_IN:
// TODO: change state and start login with firebase
return state;
default:
return state;
}
}
|
'use babel'
import { Point, Range } from 'atom'
import { it } from 'jasmine-fix'
import ProviderList from '../lib/provider-list'
describe('ProviderList', function() {
let editor
let providerList
let providerParams
beforeEach(function() {
if (providerList) {
providerList.dispose()
}
providerList = new ProviderList()
atom.packages.activatePackage('language-javascript')
atom.workspace.destroyActivePane()
waitsForPromise(function() {
return atom.workspace.open(__filename).then(function() {
editor = atom.workspace.getActiveTextEditor()
providerParams = { textEditor: editor, bufferPosition: Point.fromObject([1, 2]) }
})
})
})
it('works', async function() {
let requestIntentionsCalled = false
providerList.onShouldProvideDeclarations(function(e) {
expect(e.parameters.visibleRange).toEqual([[1, 0], [1, Infinity]])
if (requestIntentionsCalled) {
return
}
requestIntentionsCalled = true
e.result = [{
range: Range.fromObject([[1, 1], [1, Infinity]]),
}]
})
let results
results = await providerList.getIntentions(providerParams)
expect(results).toEqual([{
priority: 100,
icon: 'alignment-align',
title: 'Jump to declaration',
selected: results[0].selected,
}])
expect(requestIntentionsCalled).toBe(true)
results = await providerList.getIntentions(providerParams)
expect(results).toEqual([])
})
})
|
/*! jQuery UI - v1.10.3 - 2013-09-17
* http://jqueryui.com
* Copyright 2013 jQuery Foundation and other contributors; Licensed MIT */
jQuery(function(e){e.datepicker.regional.sl={closeText:"Zapri",prevText:"<Prejšnji",nextText:"Naslednji>",currentText:"Trenutni",monthNames:["Januar","Februar","Marec","April","Maj","Junij","Julij","Avgust","September","Oktober","November","December"],monthNamesShort:["Jan","Feb","Mar","Apr","Maj","Jun","Jul","Avg","Sep","Okt","Nov","Dec"],dayNames:["Nedelja","Ponedeljek","Torek","Sreda","Četrtek","Petek","Sobota"],dayNamesShort:["Ned","Pon","Tor","Sre","Čet","Pet","Sob"],dayNamesMin:["Ne","Po","To","Sr","Če","Pe","So"],weekHeader:"Teden",dateFormat:"dd.mm.yy",firstDay:1,isRTL:!1,showMonthAfterYear:!1,yearSuffix:""},e.datepicker.setDefaults(e.datepicker.regional.sl)}); |
/* jshint node: true */
module.exports = function(environment) {
var ENV = {
modulePrefix: 'ember-webrtc',
environment: environment,
baseURL: '/',
locationType: 'auto',
EmberENV: {
FEATURES: {
// Here you can enable experimental features on an ember canary build
// e.g. 'with-controller': true
}
},
APP: {
// Here you can pass flags/options to your application instance
// when it is created
}
};
if (environment === 'development') {
// ENV.APP.LOG_RESOLVER = true;
// ENV.APP.LOG_ACTIVE_GENERATION = true;
// ENV.APP.LOG_TRANSITIONS = true;
// ENV.APP.LOG_TRANSITIONS_INTERNAL = true;
// ENV.APP.LOG_VIEW_LOOKUPS = true;
}
if (environment === 'test') {
// Testem prefers this...
ENV.baseURL = '/';
ENV.locationType = 'none';
// keep test console output quieter
ENV.APP.LOG_ACTIVE_GENERATION = false;
ENV.APP.LOG_VIEW_LOOKUPS = false;
ENV.APP.rootElement = '#ember-testing';
}
if (environment === 'production') {
}
return ENV;
};
|
/*
* Copyright 2010, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/**
* @fileoverview This file contains functions every webgl program will need
* a version of one way or another.
*
* Instead of setting up a context manually it is recommended to
* use. This will check for success or failure. On failure it
* will attempt to present an approriate message to the user.
*
* gl = WebGLUtils.setupWebGL(canvas);
*
* For animated WebGL apps use of setTimeout or setInterval are
* discouraged. It is recommended you structure your rendering
* loop like this.
*
* function render() {
* WebGLUtils.requestAnimationFrame(canvas, render);
*
* // do rendering
* ...
* }
* render();
*
* This will call your rendering function up to the refresh rate
* of your display but will stop rendering if your app is not
* visible.
*
* To get an animationTime call
*
* timeInMilliSeconds = WebGLUtils.animationFrame();
*/
WebGLUtils = function() {
var requestAnimationFrameImpl_;
var getAnimationTimeImpl_;
/**
* Creates the HTLM for a failure message
* @param {string} canvasContainerId id of container of th
* canvas.
* @return {string} The html.
*/
// changed by Johannes
var makeFailHTML = function(msg) {
return '' +
'<table style="background-color: black; width: 100%; height: 100%;"><tr>' +
'<td align="center">' +
msg +
'</div>' +
'</td></tr></table>';
};
// changed by Johannes
var setFailHTML = function (newFailHTML) {
makeFailHTML = newFailHTML;
};
/**
* Mesasge for getting a webgl browser
* @type {string}
*/
var GET_A_WEBGL_BROWSER = '' +
'This page requires a browser that supports WebGL.<br/>' +
'<a href="http://get.webgl.org">Click here to upgrade your browser.</a>';
/**
* Mesasge for need better hardware
* @type {string}
*/
var OTHER_PROBLEM = '' +
"It doesn't appear your computer can support WebGL.<br/>" +
'<a href="http://get.webgl.org/troubleshooting/">Click here for more information.</a>';
/**
* Creates a webgl context. If creation fails it will
* change the contents of the container of the <canvas>
* tag to an error message with the correct links for WebGL.
* @param {Element} canvas. The canvas element to create a
* context from.
* @param {WebGLContextCreationAttirbutes} opt_attribs Any
* creation attributes you want to pass in.
* @param {function:(msg)} opt_onError An function to call
* if there is an error during creation.
* @return {WebGLRenderingContext} The created context.
*/
var setupWebGL = function(canvas, opt_attribs, opt_onError) {
function handleCreationError(msg) {
var container = canvas.parentNode;
if (container) {
var str = window.WebGLRenderingContext ?
OTHER_PROBLEM :
GET_A_WEBGL_BROWSER;
if (msg) {
str += "<br/><br/>Status: " + msg;
}
container.innerHTML = makeFailHTML(str);
}
};
opt_onError = opt_onError || handleCreationError;
if (canvas.addEventListener) {
canvas.addEventListener("webglcontextcreationerror", function(event) {
opt_onError(event.statusMessage);
}, false);
}
var context = create3DContext(canvas, opt_attribs);
if (!context) {
if (!window.WebGLRenderingContext) {
opt_onError("");
}
}
return context;
};
/**
* Creates a webgl context.
* @param {!Canvas} canvas The canvas tag to get context
* from. If one is not passed in one will be created.
* @return {!WebGLContext} The created context.
*/
var create3DContext = function(canvas, opt_attribs) {
var names = ["webgl", "experimental-webgl", "webkit-3d", "moz-webgl"];
var context = null;
for (var ii = 0; ii < names.length; ++ii) {
try {
context = canvas.getContext(names[ii], opt_attribs);
} catch(e) {}
if (context) {
break;
}
}
return context;
}
/**
* Returns the animationTime in a cross browser way.
* @return {number} The current animationTime
*/
var animationTime = function() {
if (!getAnimationTimeImpl_) {
getAnimationTimeImpl_ = function() {
var attribNames = [
"animationTime",
"webkitAnimationTime",
"mozAnimationTime",
"oAnimationTime",
"msAnimationTime"
];
for (var ii = 0; ii < attribNames.length; ++ii) {
var name = attribNames[ii];
if (window[name]) {
return function() {
return window[name];
};
}
}
return function() {
return (new Date()).getTime();
}
}();
}
return getAnimationTimeImpl_();
};
/**
* Provides requestAnimationFrame in a cross browser
* way.
*
* @param {!Element} element Element to request an animation frame for.
* @param {function(number): void} callback. Callback that
* will be called when a frame is ready.
*/
var requestAnimationFrame = function(element, callback) {
if (!requestAnimationFrameImpl_) {
requestAnimationFrameImpl_ = function() {
var functionNames = [
"requestAnimationFrame",
"webkitRequestAnimationFrame",
"mozRequestAnimationFrame",
"oRequestAnimationFrame",
"msRequestAnimationFrame"
];
for (var jj = 0; jj < functionNames.length; ++jj) {
var functionName = functionNames[jj];
if (window[functionName]) {
return function (name) {
return function(element, callback) {
window[name].call(window, callback, element);
};
}(functionName);
}
}
return function(element, callback) {
window.setTimeout(callback, 1000 / 70);
};
}();
}
requestAnimationFrameImpl_(element, callback)
};
return {
animationTime: animationTime,
create3DContext: create3DContext,
requestAnimationFrame: requestAnimationFrame,
setupWebGL: setupWebGL,
setFailHTML: setFailHTML,
};
}();
|
(function($) {
$("#gallery-recipes").gridalicious({
selector: '.item',
gutter: 20,
width: 250,
animate: true
});
$("#feature-recipes").gridalicious({
selector: '.recipe',
gutter: 20,
width: 250,
animate: true
});
$("#trending-recipes").gridalicious({
selector: '.trending',
gutter: 20,
width: 250,
animate: true
});
})(jQuery); |
'use strict';
var log = require('debug')('compute_modules:source-data-access');
var loopback = require('loopback');
var LoopbackModelHelper = require('../util/loopback-model-helper');
var _ = require('lodash');
module.exports = class {
constructor(app) {
this.app = app;
this.geoTweetHelper = new LoopbackModelHelper('GeoTweet');
this.hashtagEventsSourceHelper = new LoopbackModelHelper('HashtagEventsSource');
}
getSourceDataById(id){
var context = this;
return new Promise(function(resolve,reject){
if(!id){
resolve(null);
return;
}
context.geoTweetHelper.findOne({where:{tweet_id:id}},function(err,source){
if(!source){
resolve(null);
return;
}
var tweet = JSON.parse(source.full_tweet);
var data = {
text: tweet.text,
id: tweet.id,
url: 'https://twitter.com/' + source.username + '/statuses/' + tweet.id_str,
lat: source.lat,
lng: source.lng,
author: source.username,
image_url: tweet.user.profile_image_url,
post_date: source.post_date
};
resolve(data);
})
})
}
getEventSourceData(eventInfo){
var context = this;
return new Promise(function(resolve,reject){
if(!eventInfo || eventInfo.event_source != 'hashtag'){
resolve(null);
return;
}
context.hashtagEventsSourceHelper
.findOne({where: {event_id: eventInfo.event_id}}, function(err,eventSource){
if(err || !eventSource){
resolve(null);
return;
}
var source_data = eventSource.source_data;
Promise.all(source_data.map(context.getSourceDataById.bind(context)))
.then(function(result){
resolve(result);
})
})
})
}
post_sourceData(options, cb) {
options = options || {};
var events = options.events;
Promise.all(events.map(this.getEventSourceData.bind(this)))
.then(result => {
if (!result || !result.length){
cb(null, []);
return;
}
// remove nils and flatten
result = _(result).filter(n => n).flatten();
cb(null, result);
})
.catch(cb);
}
};
|
(function () {
"use strict";
angular
.module("app")
.config(appStateConfig);
appStateConfig.$inject = ["$urlRouterProvider"];
function appStateConfig($urlRouterProvider) {
$urlRouterProvider.otherwise("/");
}
})(); |
const path = require('path'),
fsUtil = require('../util/fs-util'),
aws = require('aws-sdk'),
zipdir = require('../tasks/zipdir'),
collectFiles = require('../tasks/collect-files'),
cleanUpPackage = require('../tasks/clean-up-package'),
addPolicy = require('../tasks/add-policy'),
markAlias = require('../tasks/mark-alias'),
templateFile = require('../util/template-file'),
validatePackage = require('../tasks/validate-package'),
retriableWrap = require('../util/retriable-wrap'),
loggingWrap = require('../util/logging-wrap'),
rebuildWebApi = require('../tasks/rebuild-web-api'),
readjson = require('../util/readjson'),
apiGWUrl = require('../util/apigw-url'),
lambdaNameSanitize = require('../util/lambda-name-sanitize'),
retry = require('oh-no-i-insist'),
fs = require('../util/fs-promise'),
os = require('os'),
sequentialPromiseMap = require('../util/sequential-promise-map'),
lambdaCode = require('../tasks/lambda-code'),
initEnvVarsFromOptions = require('../util/init-env-vars-from-options'),
NullLogger = require('../util/null-logger');
module.exports = function create(options, optionalLogger) {
'use strict';
let roleMetadata,
s3Key,
packageArchive,
functionDesc,
customEnvVars,
functionName,
packageFileDir;
const logger = optionalLogger || new NullLogger(),
awsDelay = options && options['aws-delay'] && parseInt(options['aws-delay'], 10) || (process.env.AWS_DELAY && parseInt(process.env.AWS_DELAY, 10)) || 5000,
awsRetries = options && options['aws-retries'] && parseInt(options['aws-retries'], 10) || 15,
source = (options && options.source) || process.cwd(),
configFile = (options && options.config) || path.join(source, 'claudia.json'),
iam = loggingWrap(new aws.IAM(), {log: logger.logApiCall, logName: 'iam'}),
lambda = loggingWrap(new aws.Lambda({region: options.region}), {log: logger.logApiCall, logName: 'lambda'}),
apiGatewayPromise = retriableWrap(
loggingWrap(new aws.APIGateway({region: options.region}), {log: logger.logApiCall, logName: 'apigateway'}),
() => logger.logStage('rate-limited by AWS, waiting before retry')
),
policyFiles = function () {
let files = fsUtil.recursiveList(options.policies);
if (fsUtil.isDir(options.policies)) {
files = files.map(filePath => path.join(options.policies, filePath));
}
return files.filter(fsUtil.isFile);
},
validationError = function () {
if (source === os.tmpdir()) {
return 'Source directory is the Node temp directory. Cowardly refusing to fill up disk with recursive copy.';
}
if (!options.region) {
return 'AWS region is missing. please specify with --region';
}
if (options['optional-dependencies'] === false && options['use-local-dependencies']) {
return 'incompatible arguments --use-local-dependencies and --no-optional-dependencies';
}
if (!options.handler && !options['api-module']) {
return 'Lambda handler is missing. please specify with --handler';
}
if (options.handler && options['api-module']) {
return 'incompatible arguments: cannot specify handler and api-module at the same time.';
}
if (!options.handler && options['deploy-proxy-api']) {
return 'deploy-proxy-api requires a handler. please specify with --handler';
}
if (!options['security-group-ids'] && options['subnet-ids']) {
return 'VPC access requires at least one security group id *and* one subnet id';
}
if (options['security-group-ids'] && !options['subnet-ids']) {
return 'VPC access requires at least one security group id *and* one subnet id';
}
if (options.handler && options.handler.indexOf('.') < 0) {
return 'Lambda handler function not specified. Please specify with --handler module.function';
}
if (options['api-module'] && options['api-module'].indexOf('.') >= 0) {
return 'API module must be a module name, without the file extension or function name';
}
if (fsUtil.fileExists(configFile)) {
if (options && options.config) {
return options.config + ' already exists';
}
return 'claudia.json already exists in the source folder';
}
if (!fsUtil.fileExists(path.join(source, 'package.json'))) {
return 'package.json does not exist in the source folder';
}
if (options.policies && !policyFiles().length) {
return 'no files match additional policies (' + options.policies + ')';
}
if (options.memory || options.memory === 0) {
if (options.memory < 128) {
return 'the memory value provided must be greater than or equal to 128';
}
if (options.memory > 1536) {
return 'the memory value provided must be less than or equal to 1536';
}
if (options.memory % 64 !== 0) {
return 'the memory value provided must be a multiple of 64';
}
}
if (options.timeout || options.timeout === 0) {
if (options.timeout < 1) {
return 'the timeout value provided must be greater than or equal to 1';
}
if (options.timeout > 300) {
return 'the timeout value provided must be less than or equal to 300';
}
}
},
getPackageInfo = function () {
logger.logStage('loading package config');
return readjson(path.join(source, 'package.json'))
.then(jsonConfig => {
const name = options.name || lambdaNameSanitize(jsonConfig.name),
description = options.description || (jsonConfig.description && jsonConfig.description.trim());
if (!name) {
return Promise.reject('project name is missing. please specify with --name or in package.json');
}
return {
name: name,
description: description
};
});
},
createLambda = function (functionName, functionDesc, functionCode, roleArn) {
return retry(
() => {
logger.logStage('creating Lambda');
return lambda.createFunction({
Code: functionCode,
FunctionName: functionName,
Description: functionDesc,
MemorySize: options.memory,
Timeout: options.timeout,
Environment: customEnvVars,
KMSKeyArn: options['env-kms-key-arn'],
Handler: options.handler || (options['api-module'] + '.proxyRouter'),
Role: roleArn,
Runtime: options.runtime || 'nodejs4.3',
Publish: true,
VpcConfig: options['security-group-ids'] && options['subnet-ids'] && {
SecurityGroupIds: (options['security-group-ids'] && options['security-group-ids'].split(',')),
SubnetIds: (options['subnet-ids'] && options['subnet-ids'].split(','))
}
}).promise();
},
awsDelay, awsRetries,
error => {
return error &&
error.code === 'InvalidParameterValueException' &&
error.message === 'The role defined for the function cannot be assumed by Lambda.';
},
() => logger.logStage('waiting for IAM role propagation'),
Promise
);
},
markAliases = function (lambdaData) {
logger.logStage('creating version alias');
return markAlias(lambdaData.FunctionName, lambda, '$LATEST', 'latest')
.then(() => {
if (options.version) {
return markAlias(lambdaData.FunctionName, lambda, lambdaData.Version, options.version);
}
})
.then(() =>lambdaData);
},
createWebApi = function (lambdaMetadata, packageDir) {
let apiModule, apiConfig, apiModulePath;
const alias = options.version || 'latest';
logger.logStage('creating REST API');
try {
apiModulePath = path.join(packageDir, options['api-module']);
apiModule = require(path.resolve(apiModulePath));
apiConfig = apiModule && apiModule.apiConfig && apiModule.apiConfig();
} catch (e) {
console.error(e.stack || e);
return Promise.reject(`cannot load api config from ${apiModulePath}`);
}
if (!apiConfig) {
return Promise.reject(`No apiConfig defined on module '${options['api-module']}'. Are you missing a module.exports?`);
}
return apiGatewayPromise.createRestApiPromise({
name: lambdaMetadata.FunctionName
})
.then((result) => {
lambdaMetadata.api = {
id: result.id,
module: options['api-module'],
url: apiGWUrl(result.id, options.region, alias)
};
return rebuildWebApi(lambdaMetadata.FunctionName, alias, result.id, apiConfig, options.region, logger, options['cache-api-config']);
})
.then(() => {
if (apiModule.postDeploy) {
Promise.map = sequentialPromiseMap;
return apiModule.postDeploy(
options,
{
name: lambdaMetadata.FunctionName,
alias: alias,
apiId: lambdaMetadata.api.id,
apiUrl: lambdaMetadata.api.url,
region: options.region
},
{
apiGatewayPromise: apiGatewayPromise,
aws: aws,
Promise: Promise
}
);
}
})
.then(postDeployResult => {
if (postDeployResult) {
lambdaMetadata.api.deploy = postDeployResult;
}
return lambdaMetadata;
});
},
deployProxyApi = function (lambdaMetadata) {
const apiConfig = {
version: 3,
corsHandlers: true,
routes: {
'{proxy+}': { ANY: {}},
'': { ANY: {}}
}
},
alias = options.version || 'latest';
logger.logStage('creating REST API');
return apiGatewayPromise.createRestApiPromise({
name: lambdaMetadata.FunctionName
})
.then(result => {
lambdaMetadata.api = {
id: result.id,
url: apiGWUrl(result.id, options.region, alias)
};
return rebuildWebApi(lambdaMetadata.FunctionName, alias, result.id, apiConfig, options.region, logger, options['cache-api-config']);
})
.then(() => lambdaMetadata);
},
saveConfig = function (lambdaMetaData) {
const config = {
lambda: {
role: roleMetadata.Role.RoleName,
name: lambdaMetaData.FunctionName,
region: options.region
}
};
logger.logStage('saving configuration');
if (lambdaMetaData.api) {
config.api = { id: lambdaMetaData.api.id, module: lambdaMetaData.api.module };
}
return fs.writeFileAsync(
configFile,
JSON.stringify(config, null, 2),
'utf8'
)
.then(() => lambdaMetaData);
},
formatResult = function (lambdaMetaData) {
const config = {
lambda: {
role: roleMetadata.Role.RoleName,
name: lambdaMetaData.FunctionName,
region: options.region
}
};
if (lambdaMetaData.api) {
config.api = lambdaMetaData.api;
}
if (s3Key) {
config.s3key = s3Key;
}
return config;
},
isRoleArn = function (string) {
return /^arn:aws:iam:/.test(string);
},
loadRole = function (functionName) {
logger.logStage('initialising IAM role');
if (options.role) {
if (isRoleArn(options.role)) {
return Promise.resolve({
Role: {
RoleName: options.role,
Arn: options.role
}
});
}
return iam.getRole({RoleName: options.role}).promise();
} else {
return fs.readFileAsync(templateFile('lambda-exector-policy.json'), 'utf8')
.then(lambdaRolePolicy => {
return iam.createRole({
RoleName: functionName + '-executor',
AssumeRolePolicyDocument: lambdaRolePolicy
}).promise();
});
}
},
addExtraPolicies = function () {
return Promise.all(policyFiles().map(fileName => {
const policyName = path.basename(fileName).replace(/[^A-z0-9]/g, '-');
return addPolicy(policyName, roleMetadata.Role.RoleName, fileName);
}));
},
vpcPolicy = function () {
return JSON.stringify({
'Version': '2012-10-17',
'Statement': [{
'Sid': 'VPCAccessExecutionPermission',
'Effect': 'Allow',
'Action': [
'logs:CreateLogGroup',
'logs:CreateLogStream',
'logs:PutLogEvents',
'ec2:CreateNetworkInterface',
'ec2:DeleteNetworkInterface',
'ec2:DescribeNetworkInterfaces'
],
'Resource': '*'
}]
});
},
recursivePolicy = function (functionName) {
return JSON.stringify({
'Version': '2012-10-17',
'Statement': [{
'Sid': 'InvokePermission',
'Effect': 'Allow',
'Action': [
'lambda:InvokeFunction'
],
'Resource': 'arn:aws:lambda:' + options.region + ':*:function:' + functionName
}]
});
},
cleanup = function (result) {
if (!options.keep) {
fs.unlinkSync(packageArchive);
} else {
result.archive = packageArchive;
}
return result;
};
if (validationError()) {
return Promise.reject(validationError());
}
return initEnvVarsFromOptions(options)
.then(opts => customEnvVars = opts)
.then(getPackageInfo)
.then(packageInfo => {
functionName = packageInfo.name;
functionDesc = packageInfo.description;
})
.then(() => collectFiles(source, options['use-local-dependencies'], logger))
.then(dir => {
logger.logStage('validating package');
return validatePackage(dir, options.handler, options['api-module']);
})
.then(dir => {
packageFileDir = dir;
return cleanUpPackage(dir, options, logger);
})
.then(dir => {
logger.logStage('zipping package');
return zipdir(dir);
})
.then(zipFile => {
packageArchive = zipFile;
})
.then(() => loadRole(functionName))
.then((result) => {
roleMetadata = result;
})
.then(() => {
if (!options.role) {
return addPolicy('log-writer', roleMetadata.Role.RoleName);
}
})
.then(() => {
if (options.policies) {
return addExtraPolicies();
}
})
.then(() => {
if (options['security-group-ids']) {
return iam.putRolePolicy({
RoleName: roleMetadata.Role.RoleName,
PolicyName: 'vpc-access-execution',
PolicyDocument: vpcPolicy()
}).promise();
}
})
.then(() => {
if (options['allow-recursion']) {
return iam.putRolePolicy({
RoleName: roleMetadata.Role.RoleName,
PolicyName: 'recursive-execution',
PolicyDocument: recursivePolicy(functionName)
}).promise();
}
})
.then(() => lambdaCode(packageArchive, options['use-s3-bucket'], logger))
.then(functionCode => {
s3Key = functionCode.S3Key;
return createLambda(functionName, functionDesc, functionCode, roleMetadata.Role.Arn);
})
.then(markAliases)
.then(lambdaMetadata => {
if (options['api-module']) {
return createWebApi(lambdaMetadata, packageFileDir);
} else if (options['deploy-proxy-api']) {
return deployProxyApi(lambdaMetadata);
} else {
return lambdaMetadata;
}
})
.then(saveConfig)
.then(formatResult)
.then(cleanup);
};
module.exports.doc = {
description: 'Create the initial lambda function and related security role.',
priority: 1,
args: [
{
argument: 'region',
description: 'AWS region where to create the lambda',
example: 'us-east-1'
},
{
argument: 'handler',
optional: true,
description: 'Main function for Lambda to execute, as module.function',
example: 'if it is in the main.js file and exported as router, this would be main.router'
},
{
argument: 'api-module',
optional: true,
description: 'The main module to use when creating Web APIs. \n' +
'If you provide this parameter, do not set the handler option.\n' +
'This should be a module created using the Claudia API Builder.',
example: 'if the api is defined in web.js, this would be web'
},
{
argument: 'deploy-proxy-api',
optional: true,
description: 'If specified, a proxy API will be created for the Lambda \n' +
' function on API Gateway, and forward all requests to function. \n' +
' This is an alternative way to create web APIs to --api-module.'
},
{
argument: 'name',
optional: true,
description: 'lambda function name',
example: 'awesome-microservice',
'default': 'the project name from package.json'
},
{
argument: 'version',
optional: true,
description: 'A version alias to automatically assign to the new function',
example: 'development'
},
{
argument: 'source',
optional: true,
description: 'Directory with project files',
'default': 'current directory'
},
{
argument: 'config',
optional: true,
description: 'Config file where the creation result will be saved',
'default': 'claudia.json'
},
{
argument: 'policies',
optional: true,
description: 'A directory or file pattern for additional IAM policies\n' +
'which will automatically be included into the security role for the function',
example: 'policies/*.json'
},
{
argument: 'allow-recursion',
optional: true,
description: 'Set up IAM permissions so a function can call itself recursively'
},
{
argument: 'role',
optional: true,
description: 'The name or ARN of an existing role to assign to the function. \n' +
'If not supplied, Claudia will create a new role. Supply an ARN to create a function without any IAM access.',
example: 'arn:aws:iam::123456789012:role/FileConverter'
},
{
argument: 'runtime',
optional: true,
description: 'Node.js runtime to use. For supported values, see\n http://docs.aws.amazon.com/lambda/latest/dg/API_CreateFunction.html',
default: 'node4.3'
},
{
argument: 'description',
optional: true,
description: 'Textual description of the lambda function',
default: 'the project description from package.json'
},
{
argument: 'memory',
optional: true,
description: 'The amount of memory, in MB, your Lambda function is given.\nThe value must be a multiple of 64 MB.',
default: 128
},
{
argument: 'timeout',
optional: true,
description: 'The function execution time, in seconds, at which AWS Lambda should terminate the function',
default: 3
},
{
argument: 'no-optional-dependencies',
optional: true,
description: 'Do not upload optional dependencies to Lambda.'
},
{
argument: 'use-local-dependencies',
optional: true,
description: 'Do not install dependencies, use local node_modules directory instead'
},
{
argument: 'cache-api-config',
optional: true,
example: 'claudiaConfigCache',
description: 'Name of the stage variable for storing the current API configuration signature.\n' +
'If set, it will also be used to check if the previously deployed configuration can be re-used and speed up deployment'
},
{
argument: 'keep',
optional: true,
description: 'keep the produced package archive on disk for troubleshooting purposes.\n' +
'If not set, the temporary files will be removed after the Lambda function is successfully created'
},
{
argument: 'use-s3-bucket',
optional: true,
example: 'claudia-uploads',
description: 'The name of a S3 bucket that Claudia will use to upload the function code before installing in Lambda.\n' +
'You can use this to upload large functions over slower connections more reliably, and to leave a binary artifact\n' +
'after uploads for auditing purposes. If not set, the archive will be uploaded directly to Lambda'
},
{
argument: 'aws-delay',
optional: true,
example: '3000',
description: 'number of milliseconds betweeen retrying AWS operations if they fail',
default: '5000'
},
{
argument: 'aws-retries',
optional: true,
example: '15',
description: 'number of times to retry AWS operations if they fail',
default: '15'
},
{
argument: 'security-group-ids',
optional: true,
example: 'sg-1234abcd',
description: 'A comma-delimited list of AWS VPC Security Group IDs, which the function will be able to access.\n' +
'Note: these security groups need to be part of the same VPC as the subnets provided with --subnet-ids.'
},
{
argument: 'subnet-ids',
optional: true,
example: 'subnet-1234abcd,subnet-abcd4567',
description: 'A comma-delimited list of AWS VPC Subnet IDs, which this function should be able to access.\n' +
'At least one subnet is required if you are using VPC access.\n' +
'Note: these subnets need to be part of the same VPC as the security groups provided with --security-group-ids.'
},
{
argument: 'set-env',
optional: true,
example: 'S3BUCKET=testbucket,SNSQUEUE=testqueue',
description: 'comma-separated list of VAR=VALUE environment variables to set'
},
{
argument: 'set-env-from-json',
optional: true,
example: 'production-env.json',
description: 'file path to a JSON file containing environment variables to set'
},
{
argument: 'env-kms-key-arn',
optional: true,
description: 'KMS Key ARN to encrypt/decrypt environment variables'
}
]
};
|
angular.module("mocks.chromeApps.services.adapters.html5.fileReaderFactory", [])
.factory("chromeApps.services.adapters.html5.fileReaderFactory", function ($q) {
var factorySpy = jasmine.createSpy("chromeApps.services.html5.fileReaderFactory");
var fileReaderMock = jasmine.createSpyObj("fileReader",
["abort",
"readAsText"])
factorySpy.andReturn(fileReaderMock);
return factorySpy;
}); |
import { Shutdownable } from "./../lib/shutdownable.js";
/*
*
* ComposeWindowStub not attached to any window
*
**/
export const ComposeWindowStub = (function (params) {
this.ad = params.ad;
this.params = params;
this.shutdown_chain = [];
});
ComposeWindowStub.canManageWindow = function (window) {
return false;
};
Object.assign(
ComposeWindowStub.prototype,
Shutdownable);
Object.assign(ComposeWindowStub.prototype, {
shutdown_chain: [],
name: "ComposeWindowStub",
logger: null,
setListeners: function () {},
getCurrentLang: async function () {},
recipients: async function (_recipientType) {
return [];
},
changeLabel: async function (str) {},
changeLanguage: async function(){},
canSpellCheck: async function(){}
});
|
(function () {
"use strict";
angular.module('ctu').controller('WebRtcController', WebRtcController);
function WebRtcController(skylink) {
var me = this;
me.joinRoom = function (roomName) {
skylink.joinRoom(roomName, {
'audio': true,
'video': {
'resolution': {
'width': 640,
'height': 320
}
}
});
};
// var skylink = new Skylink();
skylink.on('peerJoined', function (peerId, peerInfo, isSelf) {
if (isSelf) return; // We already have a video element for our video and don't need to create a new one.
var vid = document.createElement('video');
vid.autoplay = true;
vid.muted = true; // Added to avoid feedback when testing locally
vid.id = peerId;
document.body.appendChild(vid);
});
skylink.on('incomingStream', function (peerId, stream, isSelf) {
if (isSelf) return;
var vid = document.getElementById(peerId);
attachMediaStream(vid, stream);
});
skylink.on('peerLeft', function (peerId, peerInfo, isSelf) {
var vid = document.getElementById(peerId);
document.body.removeChild(vid);
});
skylink.on('mediaAccessSuccess', function (stream) {
var vid = document.getElementById('myvideo');
attachMediaStream(vid, stream);
});
skylink.init({
apiKey: '1901cbc8-db47-4508-8bcd-c837c0ee5e79', // Get your own key at developer.temasys.com.sg
defaultRoom: getRoomId()
});
function joinRoom() {
skylink.joinRoom('room', {
'audio': true,
'video': {
'resolution': {
'width': 640,
'height': 320
}
}
});
}
function webcam(event) {
event.target.style.visibility = 'hidden';
}
function start() {
skylink.shareScreen();
}
/* Helper functions */
function getRoomId() {
var roomId = document.cookie.match(/roomId=([a-z0-9-]{36})/);
if (roomId) {
return roomId[1];
}
else {
roomId = skylink.generateUUID();
var date = new Date();
date.setTime(date.getTime() + (30 * 24 * 60 * 60 * 1000));
document.cookie = 'roomId=' + roomId + '; expires=' + date.toGMTString() + '; path=/';
return roomId;
}
};
}
} ()); |
/*
*
* Dashboard
*
*/
import React, { PropTypes } from 'react';
import { withRouter } from 'react-router-dom';
import styled from 'styled-components';
import AppLayout from '../../components/AppLayout';
import Button from '../../components/Button';
import CardProfile from '../../components/CardProfile';
import CardRaces from '../../components/CardRaces';
import ActiveRaces from '../ActiveRaces';
import Logo from '../../components/Logo';
import Profile from '../Profile';
import EventRaces from '../EventsRaces';
import { Tabs, Tab } from 'react-bootstrap';
export class Dashboard extends React.Component { // eslint-disable-line react/prefer-stateless-function
render() {
return (
<AppLayout>
{/* Profole submit run goes here*/}
<Profile />
<Tabs defaultActiveKey={2}>
<Tab eventKey={1} title="Event Races">
{/*<CardRaces onClick={(id) => this.props.history.push(`/races/${id}`)} />*/}
<EventRaces />
</Tab>
<Tab eventKey={2} title="Active Races">
<ActiveRaces />
</Tab>
<Tab eventKey={3} title="Past Races">
Past Races
</Tab>
</Tabs>
</AppLayout>
);
}
}
export default withRouter(Dashboard); |
/**
* Enum with http methods
* @type {{GET: string, PUT: string, POST: string, HEAD: string, DELETE: string, PATCH: string}}
*/
const HttpMethods = {
GET : 'get',
PUT : 'put',
POST : 'post',
HEAD : 'head',
DELETE : 'delete',
PATCH : 'patch'
};
export default HttpMethods; |
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
var _react = require('react');
var _propTypes = require('prop-types');
var _propTypes2 = _interopRequireDefault(_propTypes);
var _felaDom = require('fela-dom');
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
var Provider = function (_Component) {
_inherits(Provider, _Component);
function Provider() {
_classCallCheck(this, Provider);
return _possibleConstructorReturn(this, (Provider.__proto__ || Object.getPrototypeOf(Provider)).apply(this, arguments));
}
_createClass(Provider, [{
key: 'getChildContext',
value: function getChildContext() {
return { renderer: this.props.renderer };
}
}, {
key: 'componentDidMount',
value: function componentDidMount() {
if (!this.props.renderer.isNativeRenderer) {
(0, _felaDom.render)(this.props.renderer, this.props.mountNode);
}
}
}, {
key: 'render',
value: function render() {
return _react.Children.only(this.props.children);
}
}]);
return Provider;
}(_react.Component);
Provider.childContextTypes = { renderer: _propTypes2.default.object };
Provider.propTypes = {
renderer: _propTypes2.default.object.isRequired
};
exports.default = Provider; |
import React from 'react';
import PropTypes from 'prop-types';
import autobind from 'core-decorators/es/autobind';
import { graphql } from 'react-apollo';
import S3Explorer from '../../../../../../lib/react/components/S3Explorer';
import { _listObjectsFromS3 } from '../../../../graphql/upload';
import { getProtectedSetting } from '../../../../graphql/setting';
import LoadingSpinner from '../../../components/LoadingSpinner';
import ViewError from '../../components/ViewError';
import RefreshBar from '../../components/RefreshBar';
import AssetUpload from './AssetUpload';
import ObjectPreview from './ObjectPreview';
import '../../scss/views/_s3explorer-view.scss';
const QueryS3ObjectsParams = 'Name Prefix KeyCount Contents{Key LastModified Size} CommonPrefixes{Prefix}';
@graphql(_listObjectsFromS3(QueryS3ObjectsParams), { name: 'QueryS3Objects' })
@autobind
class S3ExplorerView extends React.Component {
static propTypes = {
shouldRefresh: PropTypes.bool.isRequired
}
state = {
previewObject: null
}
navigateTo(Prefix) {
return (e) => {
this.props.QueryS3Objects.refetch({ Prefix });
}
}
openPreview(Key) {
return (e) => {
this.setState({ previewObject: Key });
}
}
closePreview() {
this.setState({ previewObject: null });
}
render() {
const { loading, error, _listObjectsFromS3 } = this.props.QueryS3Objects;
let content, help;
if (loading) {
if (this.objects) {
content = (
<S3Explorer root={'uploads/'} objects={this.objects} navigateTo={this.navigateTo} open={this.openPreview} loading/>
);
}
else {
content = <LoadingSpinner/>;
}
}
else {
if (error) {
content = (
<ViewError error={error}/>
);
}
else {
this.objects = _listObjectsFromS3;
content = (
<S3Explorer root={'uploads/'} objects={_listObjectsFromS3}
navigateTo={this.navigateTo} open={this.openPreview}/>
);
}
}
if (!error) {
help = (
<div className='pt-callout pt-icon-info-sign' style={{marginBottom:'0.5rem'}}>
<ul style={{margin:'0',padding:'0 0 0 1rem'}}>
<li>
User responses are uploaded to the <code>responses</code> directory.
</li>
<li>
Public assets are uploaded to the <code>assets</code> directory.
</li>
<li>
To use a custom image in a challenge description,
upload a <b>public asset</b> and click on it to get the Markdown markup to insert the image.
</li>
</ul>
</div>
);
}
return (
<div id='dashboard-s3explorer' className='dashboard-tab'>
<h4>AWS S3 uploads explorer</h4>
<RefreshBar query={this.props.QueryS3Objects} shouldRefresh={this.props.shouldRefresh}/>
{help}
{error ? null : <AssetUpload refetchAssets={this.props.QueryS3Objects.refetch}/>}
{error ? null : <ObjectPreview objectKey={this.state.previewObject} close={this.closePreview} refetchObjects={this.props.QueryS3Objects.refetch}/>}
{content}
</div>
);
}
}
export default S3ExplorerView;
|
'use strict';
var TableEditButtonDirective = function () {
return {
template: '<md-button class="md-table-button md-raised md-fab md-mini " ng-click="clientScope.editClick(this)" aria-label="{{ \'actions.edit\' | translate }}"><md-icon md-font-icon="fa-pencil" class="fa"></md-icon></md-button>',
};
};
module.exports = TableEditButtonDirective; |
(function (angular, ModalEffects) {
'use strict';
angular.module('cherry.global')
.controller('navController', ['$scope', '$location', 'breadcrumbService',
function ($scope, $location, breadcrumbService) {
var getLocation = function () {
var path = $location.path().split('/');
return path.filter(function (e) { return e; })[0];
};
$scope.slideoutShowing = false;
$scope.menuShowing = false;
$scope.notificationsShowing = false;
$scope.breadcrumbs = breadcrumbService.breadcrumbs;
$scope.toggleMenu = function (force) {
$scope.menuShowing = force || !$scope.menuShowing;
};
$scope.toggleNotifications = function (force) {
$scope.notificationsShowing = force || !$scope.notificationsShowing;
};
$scope.toggleSlideout = function (force) {
// TODO: get data for nav menu
$scope.slideoutShowing = force || !$scope.slideoutShowing;
};
$scope.$on('$routeChangeSuccess', function (e) {
breadcrumbService.add(getLocation());
new ModalEffects();
});
}]);
})(angular, window.ModalEffects); |
///<reference path="../../../typings/tsd.d.ts" />
(function () {
'use strict';
angular.module('app').run(run);
run.$inject = ['$rootScope', 'NavigationServices', 'GlobalServices'];
function run($rootScope, NavigationServices, GlobalServices) {
$rootScope.$on('$routeChangeStart', function (event, next, current) {
NavigationServices.closeSideBar();
});
}
})();
//# sourceMappingURL=application-run.js.map |
// Shortcuts ---------------------
$(document).keydown(function(e)
{
// Esc (Close) ----------
if(e.keyCode == 27) {
if(scut_close) {
WForm_close();
};
}
// Ctrl+Intro (Save) ----
// if(e.keyCode == 13) {
// if(e.ctrlKey) {
// WForm_save();
// $(".WForm").submit();
// }
// }
});
//--------------------------------
$(document).ready(function()
{
// Search -----------------------------------
$(".FormSearch select, .FormSearch input:checkbox, .FormSearch input:radio").change(function() {
$(".FormSearch").submit();
});
// Focus in the first
// $('input').eq(0).focus();
// Submit -----------------------------------
$(".WForm").submit(function( event )
{
var scut_id_object = $(this).attr("scut_id_object");
// action: ROW_ID ---
var formEdit = document.getElementById('form_edit_'+scut_id_object);
var param_row_id = '';
if(formEdit.ROW_ID.value) {
param_row_id = '/'+formEdit.ROW_ID.value;
}
formEdit.action = formEdit.ACTION.value+formEdit.EVENT.value+param_row_id+'/';
// alert("scut_id_object: "+scut_id_object+"; action: "+formEdit.action);
});
// Enter ------------------------------------
// $(".WForm_bfAccept").click(function()
// {
// WForm_enter();
// });
// Save -------------------------------------
$(".WForm_btUpdate").click(function()
{
var scut_id_object = $(this).attr("scut_id_object");
WForm_save(scut_id_object);
});
// Save and new -----------------------------
$(".WForm_btInsert").click(function()
{
var scut_id_object = $(this).attr("scut_id_object");
WForm_insert(scut_id_object);
});
// Delete -----------------------------------
$(".WForm_btDelete").click(function()
{
var scut_id_object = $(this).attr("scut_id_object");
$("#form_edit_"+scut_id_object+" #OPER").val(CRUD_OPER_DELETE);
// action
var formEdit = document.getElementById('form_edit_'+scut_id_object);
formEdit.action = formEdit.action+formEdit.EVENT.value+'/'+formEdit.ROW_ID.value+'/?OPER='+formEdit.OPER.value;
var res = confirm("¿Estás seguro?");
if(res == true) {
formEdit.submit();
} else {
return false;
}
});
// Close ------------------------------------
$(".WForm_btClose").click(function()
{
WForm_close();
});
//-------------------------------------------
});
//-------------------------------------------
// function WForm_enter()
// {
// $(".WForm").submit();
// }
//-------------------------------------------
function WForm_insert(scut_id_object)
{
$("#form_edit_"+scut_id_object+" #EVENT").val(CRUD_EDIT_NEW);
// $(".WForm").submit();
}
//-------------------------------------------
function WForm_save(scut_id_object)
{
$("#form_edit_"+scut_id_object+" #EVENT").val(CRUD_EDIT_UPDATE);
// $(".WForm").submit();
}
//-------------------------------------------
function WForm_close()
{
window.location.href = '/'+main_secc+'/';
// var res = confirm("¿Seguro?");
// if(res == true) {
// window.location.href = '/'+main_secc+'/';
// } else {
// return false;
// }
}
//-------------------------------------------
|
import '../../components/list-all-shifts/list-all-shifts.js';
import './admin-shifts.html';
|
import React from 'react'
import {DragDropContext, Draggable, Droppable} from 'react-beautiful-dnd'
import update from 'immutability-helper';
//import bookings from '../bookings'
import {manageWholeEventCheck} from '../permission.js'
import Immutable from "immutable";
import {
Row,
Col,
Button,
Card,
CardBody,
CardTitle,
Input,
Table,
CardColumn,
CardDeck
} from 'reactstrap';
import FontAwesomeIcon from '@fortawesome/react-fontawesome'
import faTimes from '@fortawesome/fontawesome-free-solid/faTimes'
import faPlus from '@fortawesome/fontawesome-free-solid/faPlus'
//import W from '../../../shared/woodcraft.js'
class Villages extends React.Component {
constructor(props) {
super(props);
this.state = {newVillageName: ''};
this.onDragEnd = this.onDragEnd.bind(this);
this.updateVillageName = this.updateVillageName.bind(this);
this.addVillage = this.addVillage.bind(this);
};
static panelClass(total) {
if (total < 80) return "panel panel-success";
if (total < 100) return "panel panel-warning";
return "panel panel-danger";
};
updateVillageName(e) {
this.setState(update(this.state, {newVillageName: {$set: e.target.value}}));
e.preventDefault()
}
addVillage(e) {
this.props.addVillage({
name: this.state.newVillageName,
eventId: this.props.Event.get("id")
});
e.preventDefault();
this.setState(update(this.state, {newVillageName: {$set: ''}}));
}
deleteVillage(id) {
return e => {
if (confirm("Are you sure you want to delete this village?")) {
this.props.deleteVillage(id);
}
e.preventDefault();
}
}
onDragEnd(result) {
if (result.destination === null) return;
const bookingId = parseInt(/b([\d]+)/.exec(result.draggableId)[1]);
const villageId = result.destination.droppableId === "empty" ? null : parseInt(/v([\d]+)/.exec(result.destination.droppableId)[1]);
this.props.assignVillage(bookingId, villageId);
}
render() {
const event = this.props.Event.toJS();
const bookings = this.props.bookings;
const participants = bookings.reduce((r, b) => [...r, ...b.participants], []);
//const participants = this.props.Bookings.reduce((r, b) => r.concat(b.get("participants")), Immutable.List()).toJS();
const villages = (event.villages || []).map(v => {
v.participants = bookings.reduce((a, b) =>
b.villageId === v.id ? a + participants.filter(p => p.bookingId === b.id).length : a
, 0);
v.bookings = bookings.filter(b => b.villageId === v.id).map(b => {
return {...b, size: participants.filter(p => p.bookingId === b.id).length}
}).sort((a, b) => b.size - a.size);
return v;
});
const unassignedBookings = bookings.filter(b => b.villageId === null).map(b => {
return {...b, size: participants.filter(p => p.bookingId === b.id).length}
}).sort((a, b) => b.size - a.size);
const unassignedBoxes = unassignedBookings.map(b =>
<Draggable key={b.id} draggableId={'b' + b.id}>
{(provided, snapshot) => {
const style = {
...provided.draggableStyle,
cursor: 'pointer'
};
return (
<div ref={provided.innerRef}
style={style}
{...provided.dragHandleProps}>
<Card className="mb-3">
<CardBody>
<CardTitle>{(event.bigCampMode ? b.district : b.userName) + " (" + b.size + ")"}</CardTitle>
<p>{b.campWith}</p>
</CardBody>
</Card>
</div>)
}}
</Draggable>);
const villageBoxes = villages.map(v => {
const bookings = v.bookings.map(b =>
<Draggable key={b.id} draggableId={'b' + b.id}>
{(provided, snapshot) => {
const style = {
...provided.draggableStyle,
cursor: 'pointer'
};
return (
<div ref={provided.innerRef}
style={style}
{...provided.dragHandleProps}>
{(event.bigCampMode ? b.district : b.userName) + ' (' + b.size + ')'}
</div>)
}}
</Draggable>
);
return <Droppable key={v.id} droppableId={'v' + v.id}>
{(provided, snapshot) => (
<Card>
<CardBody>
<Button outline color="warning" onClick={this.deleteVillage(v.id)}
className="float-right"
aria-label="Close"><span aria-hidden="true"><FontAwesomeIcon
icon={faTimes}/></span>
</Button>
<CardTitle>{v.name}</CardTitle>
<div ref={provided.innerRef} style={{minHeight: "20px"}}>
{bookings}
{provided.placeholder}
</div>
<p>
<b>Total: {v.participants}</b>
</p>
</CardBody>
</Card>
)}
</Droppable>;
});
villageBoxes.push(<Card key="new">
<CardBody>
<CardTitle>Add Village</CardTitle>
<Input type="text"
placeholder="Name"
value={this.state.newVillageName}
onChange={this.updateVillageName}
/>
<Button className="mt-2"
disabled={this.state.newVillageName === ''}
color="success"
onClick={this.addVillage}>
<span aria-hidden="true"><FontAwesomeIcon
icon={faPlus}/></span> Add
</Button>
</CardBody>
</Card>
);
const villageCardDecks = villageBoxes.reduce((a, c) => {
a[a.length - 1].length > 2 ? a.push([c]) : a[a.length - 1].push(c)
return a
}, [[]])
.map((a, i) => <CardDeck className="mb-3" key={i}>{a}</CardDeck>);
return (<DragDropContext onDragEnd={this.onDragEnd}>
<Row>
<Col>
<h4>Drag and drop to configure villages</h4>
</Col>
</Row>
<Row>
<Col sm={3}>
<h5>Unassigned:</h5>
<Droppable droppableId="empty">
{(provided, snapshot) => (
<div ref={provided.innerRef} className="unassignedVillages">
{unassignedBoxes}
{provided.placeholder}
</div>
)}
</Droppable>
</Col>
<Col sm={9}>
{villageCardDecks}
</Col>
</Row>
</DragDropContext>);
}
}
export default manageWholeEventCheck(Villages); |
var publicUrl = '<enter public url here>';
var localUrl = '127.0.0.1';
var url = process.env.NODE_ENV === 'development' ? localUrl : publicUrl;
module.exports = {
socketUrl: 'http://' + url + ':8080'
};
|
// Generated by CoffeeScript 1.7.1
var __hasProp = {}.hasOwnProperty,
__extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
Extm.FormView = (function(_super) {
__extends(FormView, _super);
function FormView() {
return FormView.__super__.constructor.apply(this, arguments);
}
FormView.prototype.tagName = 'form';
FormView.prototype.className = 'extm-form-view';
FormView.prototype.onShow = function() {
return this.$el.validate();
};
return FormView;
})(Marionette.ItemView);
|
'use strict'
var Type
/**
* Parse and represent an object field. See example in Type.js
* @class
* @param {string} name
* @param {string|Object|Array<string>|Array<Object>} type
*/
function Field(name, type) {
/** @member {boolean} */
this.optional = false
if (name[name.length - 1] === '?') {
this.optional = true
name = name.substr(0, name.length - 1)
}
/** @member {string} */
this.name = name
/** @member {boolean} */
this.array = Array.isArray(type)
if (this.array) {
if (type.length !== 1) {
throw new TypeError('Invalid array type, it must have exactly one element')
}
type = type[0]
}
/** @member {Type} */
this.type = new Type(type)
}
module.exports = Field
Type = require('./Type') |
"use strict";
const fs = require('fs');
/**
* Web socket server for delivering styles
*/
const io = require('socket.io')();
const webSocketPort = process.env.WEB_SOCKET_PORT || 4001;
const webSocketAddress = `http://localhost:${webSocketPort}`
io.on('connection', function(socket) {
console.log(`Client connected :: ${socket.request.headers['user-agent']}`);
});
io.listen(webSocketPort);
console.log(`Web socket server started in ${webSocketAddress}/`);
/**
Chokidar setup for watching CSS changes and emitting changes to socket
*/
const chokidar = require('chokidar');
const watchPath = __dirname + '/frontend/dist/styles/main.dist.css';
const watchOptions = {
ignored: /[\/\\]\./
};
chokidar
.watch(watchPath, watchOptions)
.on('change', (path) => {
if (fs.readFileSync(path, 'utf-8')) {
io.emit('change');
}
});
/**
* A development server for the rest of the app
*/
const express = require('express');
const morgan = require('morgan');
const compression = require('compression');
const server = express();
server.use(morgan('dev'));
server.use(compression());
/**
* Setup static file serving before any other routes
*/
const buildDir = __dirname + '/frontend/dist';
server.use('/assets', express.static(buildDir + '/assets'));
server.use('/scripts', express.static(buildDir + '/scripts'));
server.use('/styles', express.static(buildDir + '/styles'));
/**
* Serves the same index.html for all routes. Allows
* using URLs without hashes. This is a naive approach so
* it might not maybe good for production use.
*/
server.get('*', function rootRoute(req, res) {
const cheerio = require('cheerio');
const file = fs.readFileSync(buildDir + '/index.html', 'utf-8');
const $ = cheerio.load(file);
$('body').append(`
<script type="text/javascript" src="${webSocketAddress}/socket.io/socket.io.js"></script>
<script type="text/javascript">
(function() {
var socket = io.connect('${webSocketAddress}');
var linkEl = document.getElementsByTagName('link')[0];
var initialHref = linkEl.href;
socket.on('change', function () {
linkEl.href = initialHref + '?' + Math.random();
console.info("Styles updated :: ", new Date());
});
}())
</script>
`);
res.send($.html());
});
const port = process.env.PORT || 4000;
server.listen(port, function() {
console.log(`Web server started in http://localhost:${port}/`);
});
|
import Vue from 'vue'
import VueRouter from 'vue-router'
Vue.use(VueRouter)
import auth from './auth'
import App from './components/App.vue'
import About from './components/About.vue'
import Dashboard from './components/Dashboard.vue'
import Login from './components/Login.vue'
function requireAuth (to, from, next) {
if (!auth.loggedIn()) {
next({
path: '/login',
query: { redirect: to.fullPath }
})
} else {
next()
}
}
const router = new VueRouter({
mode: 'history',
base: __dirname,
routes: [
{ path: '/about', component: About },
{ path: '/dashboard', component: Dashboard, beforeEnter: requireAuth },
{ path: '/login', component: Login },
{ path: '/logout',
beforeEnter (to, from, next) {
auth.logout()
next('/')
}
}
]
})
/* eslint-disable no-new */
new Vue({
el: '#app',
router,
// replace the content of <div id="app"></div> with App
render: h => h(App)
})
|
/**
* React Starter Kit (https://www.reactstarterkit.com/)
*
* Copyright © 2014-present Kriasoft, LLC. All rights reserved.
*
* This source code is licensed under the MIT license found in the
* LICENSE.txt file in the root directory of this source tree.
*/
import React, { PropTypes } from 'react';
import { analytics } from '../config';
class Html extends React.Component {
static propTypes = {
title: PropTypes.string.isRequired,
description: PropTypes.string.isRequired,
styles: PropTypes.arrayOf(PropTypes.shape({
id: PropTypes.string.isRequired,
cssText: PropTypes.string.isRequired,
}).isRequired),
scripts: PropTypes.arrayOf(PropTypes.string.isRequired),
children: PropTypes.string.isRequired,
};
static defaultProps = {
styles: [],
scripts: [],
};
render() {
const { title, description, styles, scripts, children } = this.props;
return (
<html className="no-js" lang="en">
<head>
<meta charSet="utf-8" />
<meta httpEquiv="x-ua-compatible" content="ie=edge" />
<title>{title}</title>
<meta name="description" content={description} />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link rel="apple-touch-icon" href="apple-touch-icon.png" />
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/latest/css/bootstrap.min.css" />
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/latest/css/bootstrap-theme.min.css" />
{styles.map(style =>
<style
key={style.id}
id={style.id}
// eslint-disable-next-line react/no-danger
dangerouslySetInnerHTML={{ __html: style.cssText }}
/>,
)}
</head>
<body>
<div
id="app"
// eslint-disable-next-line react/no-danger
dangerouslySetInnerHTML={{ __html: children }}
/>
{scripts.map(script => <script key={script} src={script} />)}
</body>
</html>
);
}
}
export default Html;
|
(function() {
'use strict';
var validEmail = "testing@vintagesoftware.com",
invalidEmail = "testingAtvintagesoftware.com",
validPostalCode = "63701",
invalidPostalCode = "ZK63701",
validPhoneNumber = "888-653-8468",
invalidPhoneNumber = "aaa-123-8909",
validPassword = "Password123",
invalidPassword = "password";
var results = 'Valid Email ' + validEmail + ' ' + validationService.isValidEmail(validEmail) + '<br />' +
'Invalid Email ' + invalidEmail + ' ' + validationService.isValidEmail(invalidEmail) + '<br />' +
'Valid Postal Code ' + validPostalCode + ' ' + validationService.isValidPostalCode(validPostalCode) + '<br />' +
'Invalid Postal Code ' + invalidPostalCode + ' ' + validationService.isValidPostalCode(invalidPostalCode) + '<br />' +
'Valid Phone Number ' + validPhoneNumber + ' ' + validationService.isValidPhoneNumber(validPhoneNumber) + '<br />' +
'Invalid Phone Number ' + invalidPhoneNumber + ' ' + validationService.isValidPhoneNumber(invalidPhoneNumber) + '<br />' +
'Valid Password ' + validPassword + ' ' + validationService.isValidPassword(validPassword) + '<br />' +
'Invalid Password ' + invalidPassword + ' ' + validationService.isValidPassword(invalidPassword);
document.getElementById('Results').innerHTML = results;
}()); |
git://github.com/mikefowler/crossfade.js.git
|
module.exports = {
options: {
force: true,
},
build: [ '<%= build %>' ]
};
|
Package.describe({
summary: "ElMar library package",
version: '0.1.0',
name: "elmar-lib"
});
Package.onUse(function (api) {
api.use([
'underscore',
], ['client', 'server']);
// api.add_files([
// 'lib/server/watermark.js'
// ], ['server']);
api.add_files([
'lib/lib.js',
'lib/medialibrary.js',
'lib/validation.js',
'lib/users.js',
'lib/base.js',
], ['client', 'server']);
api.add_files([
'lib/client/sortAction.js',
'lib/client/shuffle.js'
], ['client']);
api.export([
'getSetting',
'getSiteUrl',
'trimWords',
'capitalize',
'capitalizeFirst',
'randomStr',
'appendToFileName',
'replaceAll',
'getIndexOf',
'SortAction',
'MediaLibrary',
'Validation',
'isAdmin',
'isAdminById',
'SettingsSchemaAddOns',
'RandomShuffle',
'isTouchDevice'
]);
});
|
/* jslint node: true */
/* global describe, it, before, beforeEach, after, afterEach */
'use strict';
var M = require('./map');
var boolEqual = function(src, atr)
{
var valL = M.$content(M.$mapEVAL(src));
var valR = M.$content(M.$mapEVAL(atr));
return [(valL === valR)];
};
module.exports = boolEqual; |
var queued = 0;
var checked = 0;
var invalid = 0;
var warning = 0;
var redirected = 0;
var passed = 0;
chrome.extension.onMessage.addListener(
function doStuff(request, sender) {
if (request.action == "initial") {
var rpBox;
var blacklist = request.options.blacklist;
blacklist = blacklist.split("\n");
var cacheType = request.options.cache;
var checkType = request.options.checkType;
var optURL = request.options.optionsURL;
// Inject Styles and Elements for feedback report
createDisplay(optURL, cacheType, checkType);
// Gather links
var pageLinks = document.getElementsByTagName('a');
log(pageLinks);
var totalvalid = pageLinks.length;
for (var i = 0; i < pageLinks.length; i++) {
var link = pageLinks[i];
var isValidLink = false;
isValidLink = isLinkValid(link, request, blacklist);
if (isValidLink === true) {
queued += 1;
link.classList.add("CMY_Link");
checkURL(link, request.options);
} else {
totalvalid -= 1;
}
}
rbAmt.innerHTML = "Links: " + totalvalid;
// When close element is clicked, hide UI
document.getElementById("CMY_RB_Close").onclick = function() { removeDOMElement("CMY_ReportBox"); };
document.getElementById("CMY_RB_Export").onclick = function() {
var output = "";
var badLinks = document.getElementsByClassName("CMY_Invalid");
// Export csv string so it is accessible via excel
if (badLinks.length > 0) {
output += "URL,OuterHTML\n";
for (i = 0; i < badLinks.length; i++) {
var outerHTML;
output += "\"";
output += badLinks[i].href;
output += "\",";
output += "\"";
outerHTML = badLinks[i].outerHTML.replace(/"/g, '""');
output += outerHTML;
output += "\"";
output += "\n";
}
output = output.rtrim(',');
} else {
output = "No links to export";
}
var exportText = document.createElement("textarea");
document.body.appendChild(exportText);
exportText.value = output;
exportText.select();
document.execCommand("copy");
document.body.removeChild(exportText);
console.log(output);
};
// Remove the event listener in the event this is run again without reloading
chrome.extension.onMessage.removeListener(doStuff);
}
return true;
});
// Send links to get checked via XHR
function checkURL(link, options) {
// For empty href or no attribute href elements
var checkElement = create("a", {
href: link.href
});
chrome.extension.sendMessage({ "action": "check", "url": checkElement.href },
function(response) {
// Assess Warnings
var warnings = [];
warnings = getTrailingHashWarning(options, link, warnings);
warnings = getParseDOMWarning(options, link.href, response, warnings);
// Pass in the outerHTML, the href attributes defaults to the current page if left empty
warnings = getEmptyLinkWarning(options, link.outerHTML, warnings);
warnings = getNoHrefLinkWarning(options, link, warnings);
updateDisplay(link, warnings, response.status);
});
} |
'use strict'
var redis = require('redis')
var client = redis.createClient()
module.exports = function(req, res){
client.hgetall(req.params.twuser, function(err, user){
if (user === null){
res.send(404, 'User not found')
}
else{
res.render('changeuser', {accountname: user.username, photo: user.photo});
}
})
};
|
//
// Copyright (c) Autodesk, Inc. All rights reserved
//
// Permission to use, copy, modify, and distribute this software in
// object code form for any purpose and without fee is hereby granted,
// provided that the above copyright notice appears in all copies and
// that both that copyright notice and the limited warranty and
// restricted rights notice below appear in all supporting
// documentation.
//
// AUTODESK PROVIDES THIS PROGRAM "AS IS" AND WITH ALL FAULTS.
// AUTODESK SPECIFICALLY DISCLAIMS ANY IMPLIED WARRANTY OF
// MERCHANTABILITY OR FITNESS FOR A PARTICULAR USE. AUTODESK, INC.
// DOES NOT WARRANT THAT THE OPERATION OF THE PROGRAM WILL BE
// UNINTERRUPTED OR ERROR FREE.
//
// Forge Extractor
// by Cyrille Fauvel - Autodesk Developer Network (ADN)
//
var version ='3.3' ; // Set it in config.js
// config.BaseEndPoint
var viewer =[
'viewer3D.min.js',
'style.min.css',
'three.min.js',
'lmvworker.min.js',
'wgs.min.js',
] ;
// extensions
var extensions =[
// From viewer3d #57374
'extensions/FirstPerson/FirstPerson.min.js',
/* Autodesk.Viewing.Wireframes */ 'extensions/Wireframes/Wireframes.min.js',
/* Autodesk.RaaS*/ 'extensions/RaaS/RaaS.min.js',
/* Autodesk.Viewing.MarkupsCore */ 'extensions/Markups/Markups.min.js',
/* Autodesk.Viewing.MarkupsGui */ 'extensions/Markups/MarkupsGui.min.js',
'extensions/Markups/MarkupsGui.css',
/* Autodesk.Billboard */ 'extensions/Billboard/Billboard.min.js',
/* Autodesk.BillboardGui */ 'extensions/Billboard/Billboard.min.js',
/* Autodesk.Viewing.Comments */ 'extensions/Comments/Comments.min.js',
/* Autodesk.InViewerSearch */ 'extensions/InViewerSearch/InViewerSearch.min.js',
'extensions/InViewerSearch/InViewerSearch.min.css',
/* Autodesk.Viewing.WebVR */ 'extensions/WebVR/WebVR.min.js',
'extensions/WebVR/WebVR.min.css',
/* Autodesk.Viewing.MemoryManager */ 'extensions/MemoryManager/MemoryManager.min.js',
'extensions/MemoryManager/MemoryManagerUI.min.css',
/* Autodesk.Beeline */ 'extensions/Beeline/Beeline.js', // no min
/* Autodesk.FirstPerson */ 'extensions/FirstPerson/FirstPerson.min.js',
/* Autodesk.BimWalk */ 'extensions/BimWalk/BimWalk.min.js',
/* Autodesk.Debug */ 'extensions/Debug/Debug.min.js',
'extensions/Debug/Debug.min.css',
/* Autodesk.InitialVisibility */ 'extensions/InitialVisibility/InitialVisibility.min.js',
// These are already included in viewer3D
// Autodesk.Viewing.Extensions.CAM360
// Autodesk.Viewing.Extensions.Fusion360
// Autodesk.Viewing.Extensions.Fusion360Sim
// Autodesk.Viewing.Extensions.FusionOrbit
// Autodesk.Viewing.Extensions.Collaboration
// Autodesk.Viewing.Extensions.DefaultTools
// Autodesk.Viewing.Extensions.GamepadModule
// Autodesk.Viewing.Extensions.Hyperlink
// Autodesk.Viewing.Extensions.Measure
// Autodesk.Viewing.Extensions.Section
// Autodesk.Viewing.Extensions.ZoomWindow
] ;
// res/environments/
var environments =[
'CoolLight_irr.logluv.dds',
'CoolLight_mipdrop.logluv.dds',
'DarkSky_irr.logluv.dds',
'DarkSky_mipdrop.logluv.dds',
'GreyRoom_irr.logluv.dds',
'GreyRoom_mipdrop.logluv.dds',
'GridLight_irr.logluv.dds',
'GridLight_mipdrop.logluv.dds',
'IDViz_irr.logluv.dds',
'IDViz_mipdrop.logluv.dds',
'InfinityPool_irr.logluv.dds',
'InfinityPool_mipdrop.logluv.dds',
'PhotoBooth_irr.logluv.dds',
'PhotoBooth_mipdrop.logluv.dds',
'Plaza_irr.logluv.dds',
'Plaza_mipdrop.logluv.dds',
'Reflection_irr.logluv.dds',
'Reflection_mipdrop.logluv.dds',
'RimHighlights_irr.logluv.dds',
'RimHighlights_mipdrop.logluv.dds',
'SharpHighlights_irr.logluv.dds',
'SharpHighlights_mipdrop.logluv.dds',
'SnowField_irr.logluv.dds',
'SnowField_mipdrop.logluv.dds',
'SoftLight_irr.logluv.dds',
'SoftLight_mipdrop.logluv.dds',
'TranquilityBlue_irr.logluv.dds',
'TranquilityBlue_mipdrop.logluv.dds',
'WarmLight_irr.logluv.dds',
'WarmLight_mipdrop.logluv.dds',
'boardwalk_irr.logluv.dds',
'boardwalk_mipdrop.logluv.dds',
'crossroads_irr.logluv.dds',
'crossroads_mipdrop.logluv.dds',
'field_irr.logluv.dds',
'field_mipdrop.logluv.dds',
'glacier_irr.logluv.dds',
'glacier_mipdrop.logluv.dds',
'riverbank_irr.logluv.dds',
'riverbank_mipdrop.logluv.dds',
'seaport_irr.logluv.dds',
'seaport_mipdrop.logluv.dds'
] ;
environments =environments.map (function (elt) { return ('res/environments/' + elt) ; }) ;
// res/textures/
var textures =[
'VCarrows.png',
'VCarrowsS0.png',
'VCarrowsS1.png',
'VCcontext.png',
'VCcontextS.png',
'VCedge1.png',
'VChome.png',
'VChomeS.png',
'cardinalPoint.png',
'centerMarker_X.png',
'radial-fade-grid.png'
] ;
textures =textures.map (function (elt) { return ('res/textures/' + elt) ; }) ;
// res/locales
var locales =[ 'cs', 'de', 'en', 'es', 'fr', 'it', 'ja', 'ko', 'pl', 'pt-BR', 'ru', 'tr', 'zh-HANS', 'zh-HANT' ] ;
// res/locales/[locales]/
var localesJson =[
'allstrings.json',
//'VCcross.dds',
//'VCcross.png',
'VCcrossRGBA8small.dds'
] ;
locales =locales.reduce (
function (prev, elt, index, arr) {
return (prev.concat (
localesJson.map (function (elt2) {
return ('res/locales/' + elt + '/' + elt2) ;
})
)) ;
},
[]
) ;
//-
module.exports =viewer
.concat (extensions)
.concat (environments)
.concat (textures)
.concat (locales) ;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.