1019 lines
No EOL
28 KiB
JavaScript
1019 lines
No EOL
28 KiB
JavaScript
webpackJsonp([3],{
|
|
|
|
/***/ 265:
|
|
/***/ (function(module, exports) {
|
|
|
|
//fgnass.github.com/spin.js#v1.2.5
|
|
/**
|
|
* Copyright (c) 2011 Felix Gnass [fgnass at neteye dot de]
|
|
* Licensed under the MIT license
|
|
*/
|
|
|
|
var prefixes = ['webkit', 'Moz', 'ms', 'O']; /* Vendor prefixes */
|
|
var animations = {}; /* Animation rules keyed by their name */
|
|
var useCssAnimations;
|
|
|
|
/**
|
|
* Utility function to create elements. If no tag name is given,
|
|
* a DIV is created. Optionally properties can be passed.
|
|
*/
|
|
function createEl(tag, prop) {
|
|
var el = document.createElement(tag || 'div');
|
|
var n;
|
|
|
|
for(n in prop) {
|
|
el[n] = prop[n];
|
|
}
|
|
return el;
|
|
}
|
|
|
|
/**
|
|
* Appends children and returns the parent.
|
|
*/
|
|
function ins(parent /* child1, child2, ...*/) {
|
|
for (var i=1, n=arguments.length; i<n; i++) {
|
|
parent.appendChild(arguments[i]);
|
|
}
|
|
return parent;
|
|
}
|
|
|
|
/**
|
|
* Insert a new stylesheet to hold the @keyframe or VML rules.
|
|
*/
|
|
var sheet = function() {
|
|
var el = createEl('style');
|
|
ins(document.getElementsByTagName('head')[0], el);
|
|
return el.sheet || el.styleSheet;
|
|
}();
|
|
|
|
/**
|
|
* Creates an opacity keyframe animation rule and returns its name.
|
|
* Since most mobile Webkits have timing issues with animation-delay,
|
|
* we create separate rules for each line/segment.
|
|
*/
|
|
function addAnimation(alpha, trail, i, lines) {
|
|
var name = ['opacity', trail, ~~(alpha*100), i, lines].join('-');
|
|
var start = 0.01 + i/lines*100;
|
|
var z = Math.max(1-(1-alpha)/trail*(100-start) , alpha);
|
|
var prefix = useCssAnimations.substring(0, useCssAnimations.indexOf('Animation')).toLowerCase();
|
|
var pre = prefix && '-'+prefix+'-' || '';
|
|
|
|
if (!animations[name]) {
|
|
sheet.insertRule(
|
|
'@' + pre + 'keyframes ' + name + '{' +
|
|
'0%{opacity:'+z+'}' +
|
|
start + '%{opacity:'+ alpha + '}' +
|
|
(start+0.01) + '%{opacity:1}' +
|
|
(start+trail)%100 + '%{opacity:'+ alpha + '}' +
|
|
'100%{opacity:'+ z + '}' +
|
|
'}', 0);
|
|
animations[name] = 1;
|
|
}
|
|
return name;
|
|
}
|
|
|
|
/**
|
|
* Tries various vendor prefixes and returns the first supported property.
|
|
**/
|
|
function vendor(el, prop) {
|
|
var s = el.style;
|
|
var pp;
|
|
var i;
|
|
|
|
if(s[prop] !== undefined) return prop;
|
|
prop = prop.charAt(0).toUpperCase() + prop.slice(1);
|
|
for(i=0; i<prefixes.length; i++) {
|
|
pp = prefixes[i]+prop;
|
|
if(s[pp] !== undefined) return pp;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets multiple style properties at once.
|
|
*/
|
|
function css(el, prop) {
|
|
for (var n in prop) {
|
|
el.style[vendor(el, n)||n] = prop[n];
|
|
}
|
|
return el;
|
|
}
|
|
|
|
/**
|
|
* Fills in default values.
|
|
*/
|
|
function merge(obj) {
|
|
for (var i=1; i < arguments.length; i++) {
|
|
var def = arguments[i];
|
|
for (var n in def) {
|
|
if (obj[n] === undefined) obj[n] = def[n];
|
|
}
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
/**
|
|
* Returns the absolute page-offset of the given element.
|
|
*/
|
|
function pos(el) {
|
|
var o = {x:el.offsetLeft, y:el.offsetTop};
|
|
while((el = el.offsetParent)) {
|
|
o.x+=el.offsetLeft;
|
|
o.y+=el.offsetTop;
|
|
}
|
|
return o;
|
|
}
|
|
|
|
var defaults = {
|
|
lines: 12, // The number of lines to draw
|
|
length: 7, // The length of each line
|
|
width: 5, // The line thickness
|
|
radius: 10, // The radius of the inner circle
|
|
rotate: 0, // rotation offset
|
|
color: '#000', // #rgb or #rrggbb
|
|
speed: 1, // Rounds per second
|
|
trail: 100, // Afterglow percentage
|
|
opacity: 1/4, // Opacity of the lines
|
|
fps: 20, // Frames per second when using setTimeout()
|
|
zIndex: 2e9, // Use a high z-index by default
|
|
className: 'spinner', // CSS class to assign to the element
|
|
top: 'auto', // center vertically
|
|
left: 'auto' // center horizontally
|
|
};
|
|
|
|
/** The constructor */
|
|
var Spinner = function Spinner(o) {
|
|
if (!this.spin) return new Spinner(o);
|
|
this.opts = merge(o || {}, Spinner.defaults, defaults);
|
|
};
|
|
|
|
Spinner.defaults = {};
|
|
merge(Spinner.prototype, {
|
|
spin: function(target) {
|
|
this.stop();
|
|
var self = this;
|
|
var o = self.opts;
|
|
var el = self.el = css(createEl(0, {className: o.className}), {position: 'relative', zIndex: o.zIndex});
|
|
var mid = o.radius+o.length+o.width;
|
|
var ep; // element position
|
|
var tp; // target position
|
|
|
|
if (target) {
|
|
target.insertBefore(el, target.firstChild||null);
|
|
tp = pos(target);
|
|
ep = pos(el);
|
|
css(el, {
|
|
left: (o.left == 'auto' ? tp.x-ep.x + (target.offsetWidth >> 1) : o.left+mid) + 'px',
|
|
top: (o.top == 'auto' ? tp.y-ep.y + (target.offsetHeight >> 1) : o.top+mid) + 'px'
|
|
});
|
|
}
|
|
|
|
el.setAttribute('aria-role', 'progressbar');
|
|
self.lines(el, self.opts);
|
|
|
|
if (!useCssAnimations) {
|
|
// No CSS animation support, use setTimeout() instead
|
|
var i = 0;
|
|
var fps = o.fps;
|
|
var f = fps/o.speed;
|
|
var ostep = (1-o.opacity)/(f*o.trail / 100);
|
|
var astep = f/o.lines;
|
|
|
|
!function anim() {
|
|
i++;
|
|
for (var s=o.lines; s; s--) {
|
|
var alpha = Math.max(1-(i+s*astep)%f * ostep, o.opacity);
|
|
self.opacity(el, o.lines-s, alpha, o);
|
|
}
|
|
self.timeout = self.el && setTimeout(anim, ~~(1000/fps));
|
|
}();
|
|
}
|
|
return self;
|
|
},
|
|
stop: function() {
|
|
var el = this.el;
|
|
if (el) {
|
|
clearTimeout(this.timeout);
|
|
if (el.parentNode) el.parentNode.removeChild(el);
|
|
this.el = undefined;
|
|
}
|
|
return this;
|
|
},
|
|
lines: function(el, o) {
|
|
var i = 0;
|
|
var seg;
|
|
|
|
function fill(color, shadow) {
|
|
return css(createEl(), {
|
|
position: 'absolute',
|
|
width: (o.length+o.width) + 'px',
|
|
height: o.width + 'px',
|
|
background: color,
|
|
boxShadow: shadow,
|
|
transformOrigin: 'left',
|
|
transform: 'rotate(' + ~~(360/o.lines*i+o.rotate) + 'deg) translate(' + o.radius+'px' +',0)',
|
|
borderRadius: (o.width>>1) + 'px'
|
|
});
|
|
}
|
|
for (; i < o.lines; i++) {
|
|
seg = css(createEl(), {
|
|
position: 'absolute',
|
|
top: 1+~(o.width/2) + 'px',
|
|
transform: o.hwaccel ? 'translate3d(0,0,0)' : '',
|
|
opacity: o.opacity,
|
|
animation: useCssAnimations && addAnimation(o.opacity, o.trail, i, o.lines) + ' ' + 1/o.speed + 's linear infinite'
|
|
});
|
|
if (o.shadow) ins(seg, css(fill('#000', '0 0 4px ' + '#000'), {top: 2+'px'}));
|
|
ins(el, ins(seg, fill(o.color, '0 0 1px rgba(0,0,0,.1)')));
|
|
}
|
|
return el;
|
|
},
|
|
opacity: function(el, i, val) {
|
|
if (i < el.childNodes.length) el.childNodes[i].style.opacity = val;
|
|
}
|
|
});
|
|
|
|
/////////////////////////////////////////////////////////////////////////
|
|
// VML rendering for IE
|
|
/////////////////////////////////////////////////////////////////////////
|
|
|
|
/**
|
|
* Check and init VML support
|
|
*/
|
|
!function() {
|
|
|
|
function vml(tag, attr) {
|
|
return createEl('<' + tag + ' xmlns="urn:schemas-microsoft.com:vml" class="spin-vml">', attr);
|
|
}
|
|
|
|
var s = css(createEl('group'), {behavior: 'url(#default#VML)'});
|
|
|
|
if (!vendor(s, 'transform') && s.adj) {
|
|
|
|
// VML support detected. Insert CSS rule ...
|
|
sheet.addRule('.spin-vml', 'behavior:url(#default#VML)');
|
|
|
|
Spinner.prototype.lines = function(el, o) {
|
|
var r = o.length+o.width;
|
|
var s = 2*r;
|
|
|
|
function grp() {
|
|
return css(vml('group', {coordsize: s +' '+s, coordorigin: -r +' '+-r}), {width: s, height: s});
|
|
}
|
|
|
|
var margin = -(o.width+o.length)*2+'px';
|
|
var g = css(grp(), {position: 'absolute', top: margin, left: margin});
|
|
|
|
var i;
|
|
|
|
function seg(i, dx, filter) {
|
|
ins(g,
|
|
ins(css(grp(), {rotation: 360 / o.lines * i + 'deg', left: ~~dx}),
|
|
ins(css(vml('roundrect', {arcsize: 1}), {
|
|
width: r,
|
|
height: o.width,
|
|
left: o.radius,
|
|
top: -o.width>>1,
|
|
filter: filter
|
|
}),
|
|
vml('fill', {color: o.color, opacity: o.opacity}),
|
|
vml('stroke', {opacity: 0}) // transparent stroke to fix color bleeding upon opacity change
|
|
)
|
|
)
|
|
);
|
|
}
|
|
|
|
if (o.shadow) {
|
|
for (i = 1; i <= o.lines; i++) {
|
|
seg(i, -2, 'progid:DXImageTransform.Microsoft.Blur(pixelradius=2,makeshadow=1,shadowopacity=.3)');
|
|
}
|
|
}
|
|
for (i = 1; i <= o.lines; i++) seg(i);
|
|
return ins(el, g);
|
|
};
|
|
Spinner.prototype.opacity = function(el, i, val, o) {
|
|
var c = el.firstChild;
|
|
o = o.shadow && o.lines || 0;
|
|
if (c && i+o < c.childNodes.length) {
|
|
c = c.childNodes[i+o]; c = c && c.firstChild; c = c && c.firstChild;
|
|
if (c) c.opacity = val;
|
|
}
|
|
};
|
|
}
|
|
else {
|
|
useCssAnimations = vendor(s, 'animation');
|
|
}
|
|
}();
|
|
|
|
module.exports = Spinner;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 520:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
/* WEBPACK VAR INJECTION */(function(ko) {
|
|
|
|
var _jquery = __webpack_require__(6);
|
|
|
|
var _jquery2 = _interopRequireDefault(_jquery);
|
|
|
|
__webpack_require__(521);
|
|
|
|
__webpack_require__(265);
|
|
|
|
__webpack_require__(522);
|
|
|
|
var _sprintf = __webpack_require__(130);
|
|
|
|
var _sprintf2 = _interopRequireDefault(_sprintf);
|
|
|
|
__webpack_require__(523);
|
|
|
|
var _astro = __webpack_require__(525);
|
|
|
|
var astro = _interopRequireWildcard(_astro);
|
|
|
|
var _params = __webpack_require__(78);
|
|
|
|
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
// This is a small helper to handle the spinner consistently
|
|
var spinner = {
|
|
spinner_content: (0, _jquery2.default)('#form_result_content'),
|
|
activate: function activate() {
|
|
// Get the form result_content, fade it in, and put a spinner
|
|
spinner.spinner_content.css({ width: '100%', height: '10em', overflow: 'visible' }).fadeIn(400).spin();
|
|
|
|
(0, _jquery2.default)('.spinner', spinner.spinner_content).css({ position: 'relative' });
|
|
},
|
|
clean_spinner: function clean_spinner(after) {
|
|
spinner.spinner_content.spin(false).css({ height: 'auto' });
|
|
}
|
|
};
|
|
|
|
// This view handles all the results of a query
|
|
function ResultView(holder) {
|
|
var self = this;
|
|
|
|
self.result_error = ko.observable(false);
|
|
self.result_success = ko.observable(false);
|
|
self.result_fail = ko.observable(false);
|
|
self.results = ko.observableArray([]);
|
|
self.query_text = ko.observable();
|
|
self.fail_message = ko.observable();
|
|
self.backpane = function () {
|
|
// Reset all toggles to default value, this clean up the DOM at the same time.
|
|
self.result_error(false);
|
|
self.result_fail(false);
|
|
self.result_success(false);
|
|
// Hand control back to hints view.
|
|
holder.back_to_hints();
|
|
};
|
|
|
|
return self;
|
|
}
|
|
|
|
// This view handles all the naming hints and submit the named query
|
|
function HintView(holder) {
|
|
var self = this;
|
|
|
|
self.galname = ko.observable('');
|
|
self.search_in_progress = ko.observable(false);
|
|
self.more_results = ko.observable(false);
|
|
self.hints = ko.observableArray();
|
|
self.hint_click = function (hint) {
|
|
self.galname(hint);
|
|
};
|
|
|
|
// Run a complete search with name
|
|
self.run_search = function (name) {
|
|
// Build the query.
|
|
var query = 'name=' + encodeURIComponent(name);
|
|
var url = '/flow_query/get_flow_galaxy?' + query;
|
|
holder.results.query_text(name);
|
|
|
|
holder.setup_resume('name', name);
|
|
|
|
holder.go_search(url);
|
|
};
|
|
|
|
self.submit_request = function () {
|
|
// Indicate we are not searching for hints anymore.
|
|
self.search_in_progress(false);
|
|
self.more_results(false);
|
|
self.run_search(self.galname());
|
|
};
|
|
|
|
self.request_id = 0;
|
|
|
|
self.galname.subscribe(function (txt) {
|
|
var url = '/flow_query/hint_byname?name=' + encodeURIComponent(txt);
|
|
|
|
self.search_in_progress(true);
|
|
|
|
self.request_id++;
|
|
|
|
var this_request = self.request_id;
|
|
|
|
_jquery2.default.ajax({ url: url }).done(function (data) {
|
|
if (this_request < self.request_id) return;
|
|
self.search_in_progress(false);
|
|
self.hints(data.hints);
|
|
self.more_results(data.more_results);
|
|
}).fail(function () {
|
|
self.search_in_progress(false);
|
|
});
|
|
});
|
|
|
|
return self;
|
|
}
|
|
|
|
function ManualView(holder) {
|
|
var self = this;
|
|
|
|
self.search_longitude = ko.observable();
|
|
self.search_latitude = ko.observable();
|
|
self.search_z = ko.observable();
|
|
self.ztype = ko.observable();
|
|
self.syscoords = ko.observable();
|
|
|
|
self.run_search = function (pos_string) {
|
|
var opts = pos_string.split(',');
|
|
|
|
self.search_longitude(opts[0]);
|
|
self.search_latitude(opts[1]);
|
|
self.search_z(opts[2]);
|
|
self.ztype(opts[3]);
|
|
self.syscoords(opts[4]);
|
|
|
|
self._go();
|
|
};
|
|
|
|
self._go = function () {
|
|
// Build the query.
|
|
var query = ['longitude=' + encodeURIComponent(self.search_longitude()), 'latitude=' + encodeURIComponent(self.search_latitude()), 'redshift=' + encodeURIComponent(self.search_z()), 'redshift_unit=' + self.ztype(), 'syscoords=' + self.syscoords()].join('&');
|
|
var url = '/flow_query/get_flow_by_position?' + query;
|
|
|
|
// Run the query
|
|
holder.go_search(url);
|
|
};
|
|
|
|
self.submit_manual = function () {
|
|
holder.setup_resume('position', [self.search_longitude(), self.search_latitude(), self.search_z(), self.ztype(), self.syscoords()].join(','));
|
|
|
|
self._go();
|
|
};
|
|
return self;
|
|
}
|
|
|
|
function processBindings() {
|
|
var holder = {};
|
|
var do_search = false;
|
|
|
|
holder.search_topic = ko.observable();
|
|
holder.show_search_pane = ko.observable(true);
|
|
holder.results = new ResultView(holder);
|
|
holder.hints = new HintView(holder);
|
|
holder.manual = new ManualView(holder);
|
|
|
|
holder.setup_data_handler = function (url) {
|
|
return new Promise(function (resolve, reject) {
|
|
var req = _jquery2.default.ajax(url);
|
|
req.fail(function (xhr, status, error) {
|
|
holder.results.fail_message(status);
|
|
holder.results.result_fail(true);
|
|
reject();
|
|
});
|
|
|
|
req.done(function (data) {
|
|
if (data.code != 1) {
|
|
// Mark that we are ok showing the table.
|
|
holder.results.result_error(true);
|
|
reject();
|
|
} else {
|
|
data.results.forEach(function (element) {
|
|
element.hms = astro.hms(element.ra);
|
|
element.dms = astro.dms(element.dec);
|
|
element.vcmb = (0, _sprintf2.default)('%(vcmb).0f', { vcmb: element.vcmb });
|
|
element.distance = (0, _sprintf2.default)('%(dist).1f', {
|
|
dist: element.distance[0]
|
|
});
|
|
element.distance_error = (0, _sprintf2.default)('%(dist).1f', {
|
|
dist: element.distance_error[0]
|
|
});
|
|
element.vel_error = false;
|
|
if (!('mainName' in element)) element.mainName = '';
|
|
if (!('query' in element)) element.query = '';
|
|
});
|
|
holder.results.results(data.results);
|
|
|
|
// We stop the spinner.
|
|
holder.results.result_success(true);
|
|
resolve();
|
|
}
|
|
});
|
|
});
|
|
};
|
|
|
|
holder.go_search = function (url) {
|
|
// Now redimension the form_box and fade it out to accept the spinner
|
|
return new Promise(function (resolve, reject) {
|
|
spinner.activate();
|
|
var r = (0, _jquery2.default)('#form_box');
|
|
|
|
holder.form_height = r.height();
|
|
|
|
r.animate({ height: '10em' }, { queue: false }).fadeOut(400, function () {
|
|
resolve();
|
|
});
|
|
return holder.setup_data_handler(url).then(function () {
|
|
spinner.clean_spinner();
|
|
});
|
|
});
|
|
};
|
|
|
|
holder.back_to_hints = function () {
|
|
var r = (0, _jquery2.default)('#form_box');
|
|
var h = holder.form_height;
|
|
|
|
r.animate({ height: h }, { queue: false }).fadeIn();
|
|
};
|
|
|
|
var valid_keys = { name: holder.hints, position: holder.manual };
|
|
|
|
holder.setup_resume = function (key, value) {
|
|
for (var k in valid_keys) {
|
|
if (k in _params.queryString) delete _params.queryString[k];
|
|
}
|
|
_params.queryString[key] = value;
|
|
(0, _params.addNewState)();
|
|
};
|
|
|
|
if ('name' in _params.queryString || 'position' in _params.queryString) {
|
|
holder.show_search_pane(false);
|
|
do_search = true;
|
|
} else {
|
|
(0, _jquery2.default)('#form_box').show();
|
|
}
|
|
|
|
ko.applyBindings(holder, document.getElementById('form_box'));
|
|
ko.applyBindings(holder, document.getElementById('nota2'));
|
|
ko.applyBindings(holder.results, document.getElementById('form_result'));
|
|
|
|
if (do_search) {
|
|
for (var k in valid_keys) {
|
|
if (k in _params.queryString) {
|
|
valid_keys[k].run_search(_params.queryString[k]);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
(0, _jquery2.default)(document).ready(processBindings);
|
|
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(71)))
|
|
|
|
/***/ }),
|
|
|
|
/***/ 521:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(6)], __WEBPACK_AMD_DEFINE_RESULT__ = (function($) {
|
|
$.fn.animateToAutoHeight = function() {
|
|
var curHeight = this.height(),
|
|
height = this.wrap(
|
|
"<div style='position:relative;overflow:hidden'></div>"
|
|
)
|
|
.css({ right: '-100000px', position: 'absolute', height: 'auto' })
|
|
.show()
|
|
.height(),
|
|
duration = 200,
|
|
easing = 'swing',
|
|
callback = $.noop,
|
|
parameters = { height: height },
|
|
options;
|
|
|
|
this.hide()
|
|
.unwrap()
|
|
.css({ height: curHeight, right: 'initial', position: 'initial' });
|
|
|
|
if (arguments.length >= 1) {
|
|
options = arguments[0];
|
|
} else {
|
|
options = {};
|
|
}
|
|
/*
|
|
for (var i in arguments) {
|
|
switch (typeof arguments[i]) {
|
|
case 'object':
|
|
parameters = arguments[i];
|
|
parameters.height = height;
|
|
break;
|
|
case 'string':
|
|
if (arguments[i] == 'slow' || arguments[i] == 'fast') duration = arguments[i];
|
|
else easing = arguments[i];
|
|
break;
|
|
case 'number': duration = arguments[i]; break;
|
|
case 'function': callback = arguments[i]; break;
|
|
}
|
|
}
|
|
*/
|
|
|
|
var new_opt = $.extend({}, options);
|
|
new_opt.complete = function() {
|
|
$(this).css('height', 'auto');
|
|
if ('complete' in options) {
|
|
complete.options.call(this);
|
|
}
|
|
};
|
|
this.animate(parameters, options);
|
|
/*
|
|
this.animate(parameters, duration, easing, function() {
|
|
$(this).css('height', 'auto');
|
|
callback.call(this, arguments);
|
|
});
|
|
*/
|
|
return this;
|
|
};
|
|
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 522:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/**
|
|
* Copyright (c) 2011-2014 Felix Gnass
|
|
* Licensed under the MIT license
|
|
*/
|
|
|
|
/*
|
|
|
|
Basic Usage:
|
|
============
|
|
|
|
$('#el').spin(); // Creates a default Spinner using the text color of #el.
|
|
$('#el').spin({ ... }); // Creates a Spinner using the provided options.
|
|
|
|
$('#el').spin(false); // Stops and removes the spinner.
|
|
|
|
Using Presets:
|
|
==============
|
|
|
|
$('#el').spin('small'); // Creates a 'small' Spinner using the text color of #el.
|
|
$('#el').spin('large', '#fff'); // Creates a 'large' white Spinner.
|
|
|
|
Adding a custom preset:
|
|
=======================
|
|
|
|
$.fn.spin.presets.flower = {
|
|
lines: 9
|
|
length: 10
|
|
width: 20
|
|
radius: 0
|
|
}
|
|
|
|
$('#el').spin('flower', 'red');
|
|
|
|
*/
|
|
|
|
(function(factory) {
|
|
if (true) {
|
|
// CommonJS
|
|
factory(__webpack_require__(6), __webpack_require__(265));
|
|
} else if (typeof define == 'function' && define.amd) {
|
|
// AMD, register as anonymous module
|
|
define(['jquery', 'spin'], factory);
|
|
} else {
|
|
// Browser globals
|
|
if (!window.Spinner) throw new Error('Spin.js not present');
|
|
factory(window.jQuery, window.Spinner);
|
|
}
|
|
})(function($, Spinner) {
|
|
$.fn.spin = function(opts, color) {
|
|
return this.each(function() {
|
|
var $this = $(this),
|
|
data = $this.data();
|
|
|
|
if (data.spinner) {
|
|
data.spinner.stop();
|
|
delete data.spinner;
|
|
}
|
|
if (opts !== false) {
|
|
opts = $.extend(
|
|
{ color: color || $this.css('color') },
|
|
$.fn.spin.presets[opts] || opts
|
|
);
|
|
data.spinner = new Spinner(opts).spin(this);
|
|
}
|
|
});
|
|
};
|
|
|
|
$.fn.spin.presets = {
|
|
tiny: { lines: 8, length: 2, width: 2, radius: 3 },
|
|
small: { lines: 8, length: 4, width: 3, radius: 5 },
|
|
large: { lines: 10, length: 8, width: 4, radius: 8 },
|
|
};
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 523:
|
|
/***/ (function(module, __webpack_exports__, __webpack_require__) {
|
|
|
|
"use strict";
|
|
Object.defineProperty(__webpack_exports__, "__esModule", { value: true });
|
|
/* WEBPACK VAR INJECTION */(function(ko, $) {/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery_rotate__ = __webpack_require__(524);
|
|
/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0_jquery_rotate___default = __webpack_require__.n(__WEBPACK_IMPORTED_MODULE_0_jquery_rotate__);
|
|
|
|
|
|
ko.bindingHandlers.rotate = {
|
|
init: function(element, valueAccessor) {
|
|
var value = ko.unwrap(valueAccessor());
|
|
if (value !== null) $(element).rotate(value);
|
|
},
|
|
update: function(element, valueAccessor) {
|
|
var value = ko.unwrap(valueAccessor());
|
|
if (value !== null) $(element).rotate(value);
|
|
},
|
|
};
|
|
|
|
ko.bindingHandlers.fadeVisible = {
|
|
init: function(element, valueAccessor) {
|
|
// Start visible/invisible according to initial value
|
|
var shouldDisplay = ko.unwrap(valueAccessor());
|
|
$(element).toggle(shouldDisplay);
|
|
},
|
|
update: function(element, valueAccessor) {
|
|
// On update, fade in/out
|
|
var shouldDisplay = ko.unwrap(valueAccessor());
|
|
console.log('Should display: ' + shouldDisplay);
|
|
shouldDisplay ? $(element).fadeIn() : $(element).fadeOut();
|
|
},
|
|
};
|
|
|
|
ko.bindingHandlers.activateButton = {
|
|
init: function(element, valueAccessor) {
|
|
// Start visible/invisible according to initial value
|
|
var shouldActivate = ko.unwrap(valueAccessor());
|
|
var value = ko.unwrap(shouldActivate);
|
|
$(element)
|
|
.toggleClass('disabled', !value)
|
|
.attr('disabled', !value);
|
|
},
|
|
update: function(element, valueAccessor) {
|
|
// On update, fade in/out
|
|
var shouldActivate = ko.unwrap(valueAccessor());
|
|
var value = ko.unwrap(shouldActivate);
|
|
$(element)
|
|
.toggleClass('disabled', !value)
|
|
.attr('disabled', !value);
|
|
},
|
|
};
|
|
|
|
/* Usage: <div id="myPartialDiv" data-bind="asyncHtml: { source: getHtml, params: [123] }">Loading...</div> */
|
|
ko.bindingHandlers.asyncHtml = {
|
|
init: function(element, valueAccessor) {
|
|
var value = ko.utils.unwrapObservable(valueAccessor());
|
|
var parameters = value.params.concat([
|
|
function(data) {
|
|
$(element).html(data);
|
|
},
|
|
]);
|
|
value.source.apply(null, parameters);
|
|
},
|
|
};
|
|
|
|
ko.bindingHandlers.foreachGroups = {
|
|
init: function(element, valueAccessor) {
|
|
var groupedItems,
|
|
options = valueAccessor();
|
|
|
|
//create our own computed that transforms the flat array into rows/columns
|
|
groupedItems = ko.computed({
|
|
read: function() {
|
|
var index,
|
|
length,
|
|
group,
|
|
result = [],
|
|
count = +ko.utils.unwrapObservable(options.count) || 1,
|
|
items = ko.utils.unwrapObservable(options.data);
|
|
|
|
//create an array of arrays (rows/columns)
|
|
for (index = 0, length = items.length; index < length; index++) {
|
|
if (index % count === 0) {
|
|
group = [];
|
|
result.push(group);
|
|
}
|
|
|
|
group.push(items[index]);
|
|
}
|
|
|
|
return result;
|
|
},
|
|
disposeWhenNodeIsRemoved: element,
|
|
});
|
|
|
|
//use the normal foreach binding with our new computed
|
|
ko.applyBindingsToNode(element, { foreach: groupedItems });
|
|
|
|
//make sure that the children of this element are not bound
|
|
return { controlsDescendantBindings: true };
|
|
},
|
|
};
|
|
|
|
ko.extenders.trackChange = function(target, track) {
|
|
if (track) {
|
|
target.isDirty = ko.observable(false);
|
|
target.originalValue = target();
|
|
target.subscribe(function(newValue) {
|
|
// use != not !== so numbers will equate naturally
|
|
target.isDirty(newValue != target.originalValue);
|
|
});
|
|
}
|
|
return target;
|
|
};
|
|
|
|
ko.bindingHandlers.bsChecked = {
|
|
init: function(
|
|
element,
|
|
valueAccessor,
|
|
allBindingsAccessor,
|
|
viewModel,
|
|
bindingContext
|
|
) {
|
|
var value = valueAccessor();
|
|
var newValueAccessor = function() {
|
|
return {
|
|
change: function() {
|
|
value(element.value);
|
|
},
|
|
};
|
|
};
|
|
ko.bindingHandlers.event.init(
|
|
element,
|
|
newValueAccessor,
|
|
allBindingsAccessor,
|
|
viewModel,
|
|
bindingContext
|
|
);
|
|
},
|
|
update: function(
|
|
element,
|
|
valueAccessor,
|
|
allBindingsAccessor,
|
|
viewModel,
|
|
bindingContext
|
|
) {
|
|
if ($(element).val() == ko.unwrap(valueAccessor())) {
|
|
setTimeout(function() {
|
|
$(element)
|
|
.closest('.btn')
|
|
.button('toggle');
|
|
}, 1);
|
|
}
|
|
},
|
|
};
|
|
|
|
ko.extenders.maxlength = function(target, maxlength) {
|
|
var view = ko.dependentObservable({
|
|
read: target,
|
|
write: function(value) {
|
|
if (value.length <= maxlength) {
|
|
target(value);
|
|
} else {
|
|
view.notifySubscribers(target());
|
|
}
|
|
},
|
|
});
|
|
target.view = view;
|
|
target.maxlength = maxlength;
|
|
return target;
|
|
};
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(71), __webpack_require__(6)))
|
|
|
|
/***/ }),
|
|
|
|
/***/ 524:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/**
|
|
* jquery-rotate v0.1.0
|
|
* Very lightweight jquery rotate plugin using CSS 3 Transformation
|
|
* https://github.com/schickling/jquery-rotate
|
|
*/
|
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(6)], __WEBPACK_AMD_DEFINE_RESULT__ = (function($) {
|
|
$.fn.extend({
|
|
rotate: function(deg) {
|
|
// cache dom element
|
|
var $this = $(this);
|
|
|
|
// make deg random if not set
|
|
if (deg === null) {
|
|
deg = Math.floor(Math.random() * 359);
|
|
}
|
|
|
|
// rotate dom element
|
|
$this.css({
|
|
'-webkit-transform': 'rotate(' + deg + 'deg)',
|
|
'-moz-transform': 'rotate(' + deg + 'deg)',
|
|
'-ms-transform': 'rotate(' + deg + 'deg)',
|
|
'-o-transform': 'rotate(' + deg + 'deg)',
|
|
transform: 'rotate(' + deg + 'deg)',
|
|
});
|
|
|
|
// make chainable
|
|
return $this;
|
|
},
|
|
});
|
|
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 525:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() {
|
|
return {
|
|
hms: function(deg) {
|
|
var t,
|
|
r = Math.floor(12 * deg / 180),
|
|
ret = '';
|
|
ret = r + 'h';
|
|
|
|
deg = (12 * deg / 180 - r) * 60;
|
|
t = Math.floor(deg);
|
|
ret += t + 'm';
|
|
|
|
deg = (deg - t) * 60;
|
|
ret += Math.floor(deg) + 's';
|
|
return ret;
|
|
},
|
|
|
|
dms: function(deg) {
|
|
var t,
|
|
r = Math.floor(deg),
|
|
ret = '';
|
|
ret = r + 'd';
|
|
|
|
deg = (deg - r) * 60;
|
|
t = Math.floor(deg);
|
|
ret += t + 'm';
|
|
|
|
deg = (deg - t) * 60;
|
|
ret += Math.floor(deg) + 's';
|
|
return ret;
|
|
},
|
|
};
|
|
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ 78:
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
"use strict";
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;
|
|
|
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(6)], __WEBPACK_AMD_DEFINE_RESULT__ = (function ($) {
|
|
var self = this;
|
|
|
|
self.queryString = function (paramsArray) {
|
|
var params = {};
|
|
|
|
for (var i = 0; i < paramsArray.length; ++i) {
|
|
var param = paramsArray[i].split('=', 2);
|
|
|
|
if (param.length !== 2) continue;
|
|
|
|
params[param[0]] = decodeURIComponent(param[1].replace(/\+/g, ' '));
|
|
}
|
|
|
|
return params;
|
|
}(window.location.search.substr(1).split('&'));
|
|
|
|
self.addNewState = function () {
|
|
console.log(self.queryString);
|
|
history.pushState({}, '', '?' + $.param(self.queryString));
|
|
};
|
|
|
|
return self;
|
|
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
|
|
/***/ })
|
|
|
|
},[520]);
|
|
//# sourceMappingURL=galaxy_query.bundle.js.map
|