code
stringlengths 2
1.05M
|
|---|
var util = require('util');
var Duplex = require('stream').Duplex;
var cheerio = require('cheerio');
function ParseSingleRoute(options) {
if (!(this instanceof ParseSingleRoute)) {
return new ParseSingleRoute(options)
}
Duplex.call(this, options);
this.buffer = [];
this.writeFlag = false;
this.on('finish', function () {
this.buffer = parseSingleRoute(this.buffer);
this.writeFlag = true;
this.write(this.buffer);
this.buffer = [];
})
}
util.inherits(ParseSingleRoute, Duplex);
ParseSingleRoute.prototype._read = function readBytes(n) {};
ParseSingleRoute.prototype._write = function (chunk, enc, cb) {
if (this.writeFlag === true) {
this.push(chunk);
this.buffer = [];
this.writeFlag = false;
} else {
this.buffer = Buffer.concat([new Buffer(this.buffer), new Buffer(chunk)]);
}
cb();
};
function parseSingleRoute(data) {
var routes = {};
var bus_nubmer;
data = cheerio.load(data);
bus_nubmer = data('span.busicon').text().slice(1);
data('.StopPointList').each(function () {
var bus_stops = [];
data(this).children('a').each(function () {
bus_stops.push(data(this).text())
});
var route = {
tags: {
from: bus_stops[0],
name: 'Автобус № ' + bus_nubmer + ': ' + bus_stops[0] + ' — ' + bus_stops[bus_stops.length - 1],
ref: bus_nubmer,
route: 'bus',
to: bus_stops[bus_stops.length - 1]
},
bus_stops: {
bus_stops_count: bus_stops.length,
members: bus_stops
}
};
Number(route.bus_stops.bus_stops_count) ? routes[route.tags.name] = route : '';
});
return JSON.stringify(routes);
}
module.exports = ParseSingleRoute;
|
/**
* @copyright Wynncraft 2013, 2014
* @author Chris Ireland <ireland63@gmail.com>
*/
$(document).ready(function() {
// Json Fetch
$.getJSON(
'http://api.wynncraft.com/public_api.php?action=onlinePlayers',
function(data) {
$.each(data, function(key, obj) {
var server = key;
$.each(obj, function(key, obj) {
var player = obj;
// Check if player defined
if (player.length !== 0 &&
server !== "request") {
$('<img/>', {
id: player,
src: 'http://api.wynncraft.com/avatar/' +
player +
'/64.png',
"data-toggle": 'tooltip',
"data-original-title": player +
' online on server ' +
server,
"data-placement": "top"
}).appendTo('#online');
}
});
});
// Set tooltips
$('[data-toggle=tooltip]').tooltip();
});
});
|
process.on('message', function (m) {
process.send(m);
process.disconnect();
process.exit(0);
});
|
/*
* Copyright 2011 The Closure Compiler Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @fileoverview Externs for jQuery 1.6
*
* Note that some functions use different return types depending on the number
* of parameters passed in. In these cases, you may need to annotate the type
* of the result in your code, so the JSCompiler understands which type you're
* expecting. For example:
* <code>var elt = /** @type {Element} * / (foo.get(0));</code>
*
* @see http://api.jquery.com/
* @externs
*/
/** @typedef {(Window|Document|Element|Array.<Element>|string|jQuery)} */
var jQuerySelector;
/**
* @constructor
* @param {(jQuerySelector|Element|Array.<Element>|Object|jQuery|string|
* function())=} arg1
* @param {(Element|jQuery|Document|
* Object.<string, (string|function(jQuery.event=))>)=} arg2
* @return {jQuery}
*/
function jQuery(arg1, arg2) {};
/**
* @constructor
* @extends {jQuery}
* @param {(jQuerySelector|Element|Array.<Element>|Object|jQuery|string|
* function())} arg1
* @param {(Element|jQuery|Document|
* Object.<string, (string|function(jQuery.event=))>)=} arg2
* @return {jQuery}
*/
function $(arg1, arg2) {}
/**
* @param {(jQuerySelector|Array.<Element>|string)} arg1
* @param {Element=} context
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.add = function(arg1, context) {};
/**
* @param {(string|function(number,String))} arg1
* @return {jQuery}
*/
jQuery.prototype.addClass = function(arg1) {};
/**
* @param {(string|Element|jQuery|function(number))} arg1
* @param {(string|Element|Array.<Element>|jQuery)=} content
* @return {jQuery}
*/
jQuery.prototype.after = function(arg1, content) {};
/**
* @param {(string|Object.<string,*>)} arg1
* @param {Object.<string,*>=} settings
* @return {jQuery.jqXHR}
*/
jQuery.ajax = function(arg1, settings) {};
/**
* @param {(string|Object.<string,*>)} arg1
* @param {Object.<string,*>=} settings
* @return {jQuery.jqXHR}
*/
$.ajax = function(arg1, settings) {};
/**
* @param {function(jQuery.event,XMLHttpRequest,Object.<string, *>)} handler
* @return {jQuery}
*/
jQuery.prototype.ajaxComplete = function(handler) {};
/**
* @param {function(jQuery.event,jQuery.jqXHR,Object.<string, *>,*)} handler
* @return {jQuery}
*/
jQuery.prototype.ajaxError = function(handler) {};
/**
* @param {(string|
* function(Object.<string,*>,Object.<string, *>,jQuery.jqXHR))} dataTypes
* @param {function(Object.<string,*>,Object.<string, *>,jQuery.jqXHR)=} handler
* @return {undefined}
*/
jQuery.ajaxPrefilter = function(dataTypes, handler) {};
/**
* @param {(string|
* function(Object.<string,*>,Object.<string, *>,jQuery.jqXHR))} dataTypes
* @param {function(Object.<string,*>,Object.<string, *>,jQuery.jqXHR)=} handler
* @return {undefined}
*/
$.ajaxPrefilter = function(dataTypes, handler) {};
/**
* @param {function(jQuery.event,jQuery.jqXHR,Object.<string, *>)} handler
* @return {jQuery}
*/
jQuery.prototype.ajaxSend = function(handler) {};
/** @param {Object.<string,*>} options */
jQuery.ajaxSetup = function(options) {};
/** @param {Object.<string,*>} options */
$.ajaxSetup = function(options) {};
/**
* @param {function()} handler
* @return {jQuery}
*/
jQuery.prototype.ajaxStart = function(handler) {};
/**
* @param {function()} handler
* @return {jQuery}
*/
jQuery.prototype.ajaxStop = function(handler) {};
/**
* @param {function(jQuery.event,XMLHttpRequest,Object.<string, *>)} handler
* @return {jQuery}
*/
jQuery.prototype.ajaxSuccess = function(handler) {};
/**
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.andSelf = function() {};
/**
* @param {Object.<string,*>} properties
* @param {(string|number|function()|Object.<string,*>)=} arg2
* @param {(string|function())=} easing
* @param {function()=} complete
* @return {jQuery}
*/
jQuery.prototype.animate = function(properties, arg2, easing, complete) {};
/**
* @param {(string|Element|jQuery|function(number,string))} arg1
* @param {(string|Element|Array.<Element>|jQuery)=} content
* @return {jQuery}
*/
jQuery.prototype.append = function(arg1, content) {};
/**
* @param {(jQuerySelector|Element|jQuery)} target
* @return {jQuery}
*/
jQuery.prototype.appendTo = function(target) {};
/**
* @param {(string|Object.<string,*>)} arg1
* @param {(string|number|function(number,string))=} arg2
* @return {(string|jQuery)}
*/
jQuery.prototype.attr = function(arg1, arg2) {};
/**
* @param {(string|Element|jQuery|function())} arg1
* @param {(string|Element|Array.<Element>|jQuery)=} content
* @return {jQuery}
*/
jQuery.prototype.before = function(arg1, content) {};
/**
* @param {(string|Object.<string, function(jQuery.event=)>)} arg1
* @param {(Object.<string, *>|function(jQuery.event)|boolean)=} eventData
* @param {(function(jQuery.event)|boolean)=} arg3
* @return {jQuery}
*/
jQuery.prototype.bind = function(arg1, eventData, arg3) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.blur = function(arg1, handler) {};
/** @type {boolean} */
jQuery.boxModel;
/** @type {boolean} */
$.boxModel;
/** @type {Object.<string,*>} */
jQuery.browser;
/** @type {Object.<string,*>} */
$.browser;
/**
* @type {boolean}
* @const
*/
jQuery.browser.mozilla;
/**
* @type {boolean}
* @const
*/
$.browser.mozilla;
/**
* @type {boolean}
* @const
*/
jQuery.browser.msie;
/**
* @type {boolean}
* @const
*/
$.browser.msie;
/**
* @type {boolean}
* @const
*/
jQuery.browser.opera;
/**
* @type {boolean}
* @const
*/
$.browser.opera;
/**
* @type {boolean}
* @const
* @deprecated
*/
jQuery.browser.safari;
/**
* @type {boolean}
* @const
* @deprecated
*/
$.browser.safari;
/** @type {string} */
jQuery.browser.version;
/** @type {string} */
$.browser.version;
/**
* @type {boolean}
* @const
*/
jQuery.browser.webkit;
/**
* @type {boolean}
* @const
*/
$.browser.webkit;
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.change = function(arg1, handler) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.children = function(selector) {};
/**
* @param {string=} queueName
* @return {jQuery}
*/
jQuery.prototype.clearQueue = function(queueName) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.click = function(arg1, handler) {};
/**
* @param {boolean=} withDataAndEvents
* @param {boolean=} deepWithDataAndEvents
* @return {jQuery}
*/
jQuery.prototype.clone = function(withDataAndEvents, deepWithDataAndEvents) {};
/**
* @param {(jQuerySelector|jQuery|Element|string|Array.<string>)} arg1
* @param {Element=} context
* @return {(jQuery|Array.<Element>)}
* @nosideeffects
*/
jQuery.prototype.closest = function(arg1, context) {};
/**
* @param {Element} container
* @param {Element} contained
* @return {boolean}
*/
jQuery.contains = function(container, contained) {};
/**
* @param {Element} container
* @param {Element} contained
* @return {boolean}
*/
$.contains = function(container, contained) {};
/**
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.contents = function() {};
/** @type {Element} */
jQuery.prototype.context;
/**
* @param {(string|Object.<string,*>)} arg1
* @param {(string|number|function(number,*))=} arg2
* @return {(string|jQuery)}
*/
jQuery.prototype.css = function(arg1, arg2) {};
/** @type {Object.<string, *>} */
jQuery.cssHooks;
/** @type {Object.<string, *>} */
$.cssHooks;
/**
* @param {Element} elem
* @param {string=} key
* @param {*=} value
* @return {*}
*/
jQuery.data = function(elem, key, value) {};
/**
* @param {(string|Object.<string, *>)=} arg1
* @param {*=} value
* @return {*}
*/
jQuery.prototype.data = function(arg1, value) {};
/**
* @param {Element} elem
* @param {string=} key
* @param {*=} value
* @return {*}
*/
$.data = function(elem, key, value) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.dblclick = function(arg1, handler) {};
/**
* @constructor
* @param {function()=} opt_fn
* @see http://api.jquery.com/category/deferred-object/
*/
jQuery.deferred = function(opt_fn) {};
/**
* @constructor
* @extends {jQuery.deferred}
* @param {function()=} opt_fn
* @return {jQuery.Deferred}
*/
jQuery.Deferred = function(opt_fn) {};
/**
* @constructor
* @extends {jQuery.deferred}
* @param {function()=} opt_fn
* @see http://api.jquery.com/category/deferred-object/
*/
$.deferred = function(opt_fn) {};
/**
* @constructor
* @extends {jQuery.deferred}
* @param {function()=} opt_fn
* @return {jQuery.Deferred}
*/
$.Deferred = function(opt_fn) {};
/**
* @param {function()} alwaysCallbacks
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.always = function(alwaysCallbacks) {};
/**
* @param {function()} doneCallbacks
* @param {function()=} doneCallbacks2
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.done = function(doneCallbacks, doneCallbacks2) {};
/**
* @param {function()} failCallbacks
* @param {function()=} failCallbacks2
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.fail = function(failCallbacks, failCallbacks2) {};
/**
* @return {boolean}
* @nosideeffects
*/
jQuery.deferred.prototype.isRejected = function() {};
/**
* @return {boolean}
* @nosideeffects
*/
jQuery.deferred.prototype.isResolved = function() {};
/**
* @param {function()=} doneFilter
* @param {function()=} failFilter
* @return {jQuery.Promise}
*/
jQuery.deferred.prototype.pipe = function(doneFilter, failFilter) {};
/**
* @param {Object=} target
* @return {jQuery.Promise}
*/
jQuery.deferred.prototype.promise = function(target) {};
/**
* @param {...*} var_args
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.reject = function(var_args) {};
/**
* @param {Object} context
* @param {Array.<*>=} args
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.rejectWith = function(context, args) {};
/**
* @param {...*} var_args
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.resolve = function(var_args) {};
/**
* @param {Object} context
* @param {Array.<*>=} args
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.resolveWith = function(context, args) {};
/**
* @param {function()} doneCallbacks
* @param {function()} failCallbacks
* @return {jQuery.deferred}
*/
jQuery.deferred.prototype.then = function(doneCallbacks, failCallbacks) {};
/**
* @param {number} duration
* @param {string=} queueName
* @return {jQuery}
*/
jQuery.prototype.delay = function(duration, queueName) {};
/**
* @param {string} selector
* @param {(string|Object.<string,*>)} arg2
* @param {(function()|Object.<string, *>)=} arg3
* @param {function()=} handler
* @return {jQuery}
*/
jQuery.prototype.delegate = function(selector, arg2, arg3, handler) {};
/**
* @param {Element} elem
* @param {string=} queueName
* @return {jQuery}
*/
jQuery.dequeue = function(elem, queueName) {};
/**
* @param {string=} queueName
* @return {jQuery}
*/
jQuery.prototype.dequeue = function(queueName) {};
/**
* @param {Element} elem
* @param {string=} queueName
* @return {jQuery}
*/
$.dequeue = function(elem, queueName) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
*/
jQuery.prototype.detach = function(selector) {};
/**
* @param {(string|Object.<string,*>)=} arg1
* @param {string=} handler
* @return {jQuery}
*/
jQuery.prototype.die = function(arg1, handler) {};
/**
* @param {Object} collection
* @param {function(number,*)} callback
* @return {Object}
*/
jQuery.each = function(collection, callback) {};
/**
* @param {function(number,Element)} fnc
* @return {jQuery}
*/
jQuery.prototype.each = function(fnc) {};
/**
* @param {Object} collection
* @param {function(number,*)} callback
* @return {Object}
*/
$.each = function(collection, callback) {};
/** @return {jQuery} */
jQuery.prototype.empty = function() {};
/**
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.end = function() {};
/**
* @param {number} arg1
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.eq = function(arg1) {};
/** @param {string} message */
jQuery.error = function(message) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.error = function(arg1, handler) {};
/** @param {string} message */
$.error = function(message) {};
/**
* @constructor
* @param {string} eventType
*/
jQuery.event = function(eventType) {};
/**
* @constructor
* @extends {jQuery.event}
* @param {string} eventType
* @return {jQuery.Event}
*/
jQuery.Event = function(eventType) {};
/**
* @constructor
* @extends {jQuery.event}
* @param {string} eventType
*/
$.event = function(eventType) {};
/**
* @constructor
* @extends {jQuery.event}
* @param {string} eventType
* @return {$.Event}
*/
$.Event = function(eventType) {};
/** @type {Element} */
jQuery.event.prototype.currentTarget;
/** @type {*} */
jQuery.event.prototype.data;
/**
* @return {boolean}
* @nosideeffects
*/
jQuery.event.prototype.isDefaultPrevented = function() {};
/**
* @return {boolean}
* @nosideeffects
*/
jQuery.event.prototype.isImmediatePropagationStopped = function() {};
/**
* @return {boolean}
* @nosideeffects
*/
jQuery.event.prototype.isPropagationStopped = function() {};
/** @type {string} */
jQuery.event.prototype.namespace;
/** @type {Event} */
jQuery.event.prototype.originalEvent;
/** @type {number} */
jQuery.event.prototype.pageX;
/** @type {number} */
jQuery.event.prototype.pageY;
/** @return {undefined} */
jQuery.event.prototype.preventDefault = function() {};
/** @type {Object.<string, *>} */
jQuery.event.prototype.props;
/** @type {Element} */
jQuery.event.prototype.relatedTarget;
/** @type {*} */
jQuery.event.prototype.result;
/** @return {undefined} */
jQuery.event.prototype.stopImmediatePropagation = function() {};
/** @return {undefined} */
jQuery.event.prototype.stopPropagation = function() {};
/** @type {Element} */
jQuery.event.prototype.target;
/** @type {number} */
jQuery.event.prototype.timeStamp;
/** @type {string} */
jQuery.event.prototype.type;
/** @type {number} */
jQuery.event.prototype.which;
/**
* @param {(Object|boolean)} arg1
* @param {...*} var_args
* @return {Object}
*/
jQuery.extend = function(arg1, var_args) {};
/**
* @param {(Object|boolean)} arg1
* @param {...*} var_args
* @return {Object}
*/
jQuery.prototype.extend = function(arg1, var_args) {};
/**
* @param {(Object|boolean)} arg1
* @param {...*} var_args
* @return {Object}
*/
$.extend = function(arg1, var_args) {};
/**
* @param {(string|number|function())=} duration
* @param {(function()|string)=} arg2
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.fadeIn = function(duration, arg2, callback) {};
/**
* @param {(string|number|function())=} duration
* @param {(function()|string)=} arg2
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.fadeOut = function(duration, arg2, callback) {};
/**
* @param {(string|number)} duration
* @param {number} opacity
* @param {(function()|string)=} arg3
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.fadeTo = function(duration, opacity, arg3, callback) {};
/**
* @param {(string|number|function())=} duration
* @param {(string|function())=} easing
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.fadeToggle = function(duration, easing, callback) {};
/**
* @param {(jQuerySelector|function(number)|Element|jQuery)} arg1
* @return {jQuery}
*/
jQuery.prototype.filter = function(arg1) {};
/**
* @param {(jQuerySelector|jQuery|Element)} arg1
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.find = function(arg1) {};
/**
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.first = function() {};
/** @see http://docs.jquery.com/Plugins/Authoring */
jQuery.fn;
/** @see http://docs.jquery.com/Plugins/Authoring */
$.fn;
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.focus = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.focusin = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.focusout = function(arg1, handler) {};
/** @const */
jQuery.fx = {};
/** @const */
$.fx = {};
/** @type {number} */
jQuery.fx.interval;
/** @type {number} */
$.fx.interval;
/** @type {boolean} */
jQuery.fx.off;
/** @type {boolean} */
$.fx.off;
/**
* @param {string} url
* @param {(Object.<string,*>|string|
* function(string,string,jQuery.jqXHR))=} data
* @param {(function(string,string,jQuery.jqXHR)|string)=} success
* @param {string=} dataType
* @return {jQuery.jqXHR}
*/
jQuery.get = function(url, data, success, dataType) {};
/**
* @param {number=} index
* @return {(Element|Array.<Element>)}
*/
jQuery.prototype.get = function(index) {};
/**
* @param {string} url
* @param {(Object.<string,*>|string|
* function(string,string,jQuery.jqXHR))=} data
* @param {(function(string,string,jQuery.jqXHR)|string)=} success
* @param {string=} dataType
* @return {jQuery.jqXHR}
*/
$.get = function(url, data, success, dataType) {};
/**
* @param {string} url
* @param {(Object.<string,*>|function(string,string,jQuery.jqXHR))=} data
* @param {function(string,string,jQuery.jqXHR)=} success
* @return {jQuery.jqXHR}
*/
jQuery.getJSON = function(url, data, success) {};
/**
* @param {string} url
* @param {(Object.<string,*>|function(string,string,jQuery.jqXHR))=} data
* @param {function(string,string,jQuery.jqXHR)=} success
* @return {jQuery.jqXHR}
*/
$.getJSON = function(url, data, success) {};
/**
* @param {string} url
* @param {function(string,string)=} success
* @return {XMLHttpRequest}
*/
jQuery.getScript = function(url, success) {};
/**
* @param {string} url
* @param {function(string,string)=} success
* @return {XMLHttpRequest}
*/
$.getScript = function(url, success) {};
/** @param {string} code */
jQuery.globalEval = function(code) {};
/** @param {string} code */
$.globalEval = function(code) {};
/**
* @param {Array.<*>} arr
* @param {function(*,number)} fnc
* @param {boolean=} invert
* @return {Array.<*>}
*/
jQuery.grep = function(arr, fnc, invert) {};
/**
* @param {Array.<*>} arr
* @param {function(*,number)} fnc
* @param {boolean=} invert
* @return {Array.<*>}
*/
$.grep = function(arr, fnc, invert) {};
/**
* @param {(string|Element)} arg1
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.has = function(arg1) {};
/**
* @param {string} className
* @return {boolean}
* @nosideeffects
*/
jQuery.prototype.hasClass = function(className) {};
/**
* @param {Element} elem
* @return {boolean}
* @nosideeffects
*/
jQuery.hasData = function(elem) {};
/**
* @param {Element} elem
* @return {boolean}
* @nosideeffects
*/
$.hasData = function(elem) {};
/**
* @param {(string|number|function(number,number))=} arg1
* @return {(number|jQuery)}
*/
jQuery.prototype.height = function(arg1) {};
/**
* @param {(string|number|function())=} duration
* @param {(function()|string)=} arg2
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.hide = function(duration, arg2, callback) {};
/**
* @param {boolean} hold
* @return {boolean}
*/
jQuery.holdReady = function(hold) {};
/**
* @param {boolean} hold
* @return {boolean}
*/
$.holdReady = function(hold) {};
/**
* @param {function(jQuery.event)} arg1
* @param {function(jQuery.event)=} handlerOut
* @return {jQuery}
*/
jQuery.prototype.hover = function(arg1, handlerOut) {};
/**
* @param {(string|function(number,string))=} arg1
* @return {(string|jQuery)}
*/
jQuery.prototype.html = function(arg1) {};
/**
* @param {*} value
* @param {Array.<*>} arr
* @return {number}
* @nosideeffects
*/
jQuery.inArray = function(value, arr) {};
/**
* @param {*} value
* @param {Array.<*>} arr
* @return {number}
* @nosideeffects
*/
$.inArray = function(value, arr) {};
/**
* @param {(jQuerySelector|Element|jQuery)=} arg1
* @return {number}
*/
jQuery.prototype.index = function(arg1) {};
/** @return {number} */
jQuery.prototype.innerHeight = function() {};
/** @return {number} */
jQuery.prototype.innerWidth = function() {};
/**
* @param {(jQuerySelector|Element|jQuery)} target
* @return {jQuery}
*/
jQuery.prototype.insertAfter = function(target) {};
/**
* @param {(jQuerySelector|Element|jQuery)} target
* @return {jQuery}
*/
jQuery.prototype.insertBefore = function(target) {};
/**
* @param {(jQuerySelector|function(number)|jQuery|Element)} arg1
* @return {boolean}
*/
jQuery.prototype.is = function(arg1) {};
/**
* @param {*} obj
* @return {boolean}
* @nosideeffects
*/
jQuery.isArray = function(obj) {};
/**
* @param {*} obj
* @return {boolean}
* @nosideeffects
*/
$.isArray = function(obj) {};
/**
* @param {Object} obj
* @return {boolean}
* @nosideeffects
*/
jQuery.isEmptyObject = function(obj) {};
/**
* @param {Object} obj
* @return {boolean}
* @nosideeffects
*/
$.isEmptyObject = function(obj) {};
/**
* @param {*} obj
* @return {boolean}
* @nosideeffects
*/
jQuery.isFunction = function(obj) {};
/**
* @param {*} obj
* @return {boolean}
* @nosideeffects
*/
$.isFunction = function(obj) {};
/**
* @param {Object} obj
* @return {boolean}
* @nosideeffects
*/
jQuery.isPlainObject = function(obj) {};
/**
* @param {Object} obj
* @return {boolean}
* @nosideeffects
*/
$.isPlainObject = function(obj) {};
/**
* @param {*} obj
* @return {boolean}
* @nosideeffects
*/
jQuery.isWindow = function(obj) {};
/**
* @param {*} obj
* @return {boolean}
* @nosideeffects
*/
$.isWindow = function(obj) {};
/**
* @param {Element} node
* @return {boolean}
* @nosideeffects
*/
jQuery.isXMLDoc = function(node) {};
/**
* @param {Element} node
* @return {boolean}
* @nosideeffects
*/
$.isXMLDoc = function(node) {};
/** @type {string} */
jQuery.prototype.jquery;
/**
* @constructor
* @extends {XMLHttpRequest}
* @implements {jQuery.Promise}
* @private
* @see http://api.jquery.com/jQuery.ajax/#jqXHR
*/
jQuery.jqXHR = function () {};
/**
* @param {function()} callback
* @return {jQuery.jqXHR}
*/
jQuery.jqXHR.prototype.complete = function (callback) {};
/**
* @override
* @param {function()} doneCallbacks
* @return {jQuery.Promise}
*/
jQuery.jqXHR.prototype.done = function(doneCallbacks) {};
/**
* @param {function()} callback
* @return {jQuery.jqXHR}
*/
jQuery.jqXHR.prototype.error = function (callback) {};
/**
* @override
* @param {function()} failCallbacks
* @return {jQuery.Promise}
*/
jQuery.jqXHR.prototype.fail = function(failCallbacks) {};
/**
* @override
* @return {boolean}
* @nosideeffects
*/
jQuery.jqXHR.prototype.isRejected = function() {};
/**
* @override
* @return {boolean}
* @nosideeffects
*/
jQuery.jqXHR.prototype.isResolved = function() {};
/**
* @override
* @deprecated
*/
jQuery.jqXHR.prototype.onreadystatechange = function (callback) {};
/**
* @param {function()} callback
* @return {jQuery.jqXHR}
*/
jQuery.jqXHR.prototype.success = function (callback) {};
/**
* @override
* @param {function()} doneCallbacks
* @param {function()} failCallbacks
* @return {jQuery.Promise}
*/
jQuery.jqXHR.prototype.then = function(doneCallbacks, failCallbacks) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.keydown = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.keypress = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.keyup = function(arg1, handler) {};
/**
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.last = function() {};
/** @type {number} */
jQuery.prototype.length;
/**
* @param {(string|Object.<string, function(jQuery.event=)>)} arg1
* @param {(function()|Object.<string, *>)=} arg2
* @param {function()=} handler
* @return {jQuery}
*/
jQuery.prototype.live = function(arg1, arg2, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>|string)} arg1
* @param {(function(jQuery.event)|Object.<string,*>|string)=} arg2
* @param {function(string,string,XMLHttpRequest)=} complete
* @return {jQuery}
*/
jQuery.prototype.load = function(arg1, arg2, complete) {};
/**
* @param {*} obj
* @return {Array.<*>}
*/
jQuery.makeArray = function(obj) {};
/**
* @param {*} obj
* @return {Array.<*>}
*/
$.makeArray = function(obj) {};
/**
* @param {(Array.<*>|Object.<string, *>)} arg1
* @param {(function(*,number)|function(*,(string|number)))} callback
* @return {Array.<*>}
*/
jQuery.map = function(arg1, callback) {};
/**
* @param {function(number,Element)} callback
* @return {jQuery}
*/
jQuery.prototype.map = function(callback) {};
/**
* @param {(Array.<*>|Object.<string, *>)} arg1
* @param {(function(*,number)|function(*,(string|number)))} callback
* @return {Array.<*>}
*/
$.map = function(arg1, callback) {};
/**
* @param {Array.<*>} first
* @param {Array.<*>} second
* @return {Array.<*>}
*/
jQuery.merge = function(first, second) {};
/**
* @param {Array.<*>} first
* @param {Array.<*>} second
* @return {Array.<*>}
*/
$.merge = function(first, second) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.mousedown = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.mouseenter = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.mouseleave = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.mousemove = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.mouseout = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.mouseover = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.mouseup = function(arg1, handler) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.next = function(selector) {};
/**
* @param {string=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.nextAll = function(selector) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.nextUntil = function(selector) {};
/**
* @param {boolean=} removeAll
* @return {Object}
*/
jQuery.noConflict = function(removeAll) {};
/**
* @param {boolean=} removeAll
* @return {Object}
*/
$.noConflict = function(removeAll) {};
/**
* @return {function()}
* @nosideeffects
*/
jQuery.noop = function() {};
/**
* @return {function()}
* @nosideeffects
*/
$.noop = function() {};
/**
* @param {(jQuerySelector|Array.<Element>|function(number))} arg1
* @return {jQuery}
*/
jQuery.prototype.not = function(arg1) {};
/**
* @return {number}
* @nosideeffects
*/
jQuery.now = function() {};
/**
* @return {number}
* @nosideeffects
*/
$.now = function() {};
/**
* @param {({left:number,top:number}|
* function(number,{top:number,left:number}))=} arg1
* @return {({left:number,top:number}|jQuery)}
*/
jQuery.prototype.offset = function(arg1) {};
/**
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.offsetParent = function() {};
/**
* @param {string} eventType
* @param {(Object.<string, *>|function(jQuery.event))} eventData
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.one = function(eventType, eventData, handler) {};
/**
* @param {boolean=} includeMargin
* @return {number}
*/
jQuery.prototype.outerHeight = function(includeMargin) {};
/**
* @param {boolean=} includeMargin
* @return {number}
*/
jQuery.prototype.outerWidth = function(includeMargin) {};
/**
* @param {(Object.<string, *>|Array.<Object.<string, *>>)} obj
* @param {boolean=} traditional
* @return {string}
*/
jQuery.param = function(obj, traditional) {};
/**
* @param {(Object.<string, *>|Array.<Object.<string, *>>)} obj
* @param {boolean=} traditional
* @return {string}
*/
$.param = function(obj, traditional) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.parent = function(selector) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.parents = function(selector) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.parentsUntil = function(selector) {};
/**
* @param {string} json
* @return {Object.<string, *>}
*/
jQuery.parseJSON = function(json) {};
/**
* @param {string} json
* @return {Object.<string, *>}
*/
$.parseJSON = function(json) {};
/**
* @param {string} data
* @return {Document}
*/
jQuery.parseXML = function(data) {};
/**
* @param {string} data
* @return {Document}
*/
$.parseXML = function(data) {};
/** @return {{left:number,top:number}} */
jQuery.prototype.position = function() {};
/**
* @param {string} url
* @param {(Object.<string,*>|string|
* function(string,string,jQuery.jqXHR))=} data
* @param {(function(string,string,jQuery.jqXHR)|string)=} success
* @param {string=} dataType
* @return {jQuery.jqXHR}
*/
jQuery.post = function(url, data, success, dataType) {};
/**
* @param {string} url
* @param {(Object.<string,*>|string|
* function(string,string,jQuery.jqXHR))=} data
* @param {(function(string,string,jQuery.jqXHR)|string)=} success
* @param {string=} dataType
* @return {jQuery.jqXHR}
*/
$.post = function(url, data, success, dataType) {};
/**
* @param {(string|Element|jQuery|function(number,string))} arg1
* @param {(string|Element|jQuery)=} content
* @return {jQuery}
*/
jQuery.prototype.prepend = function(arg1, content) {};
/**
* @param {(jQuerySelector|Element|jQuery)} target
* @return {jQuery}
*/
jQuery.prototype.prependTo = function(target) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.prev = function(selector) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.prevAll = function(selector) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.prevUntil = function(selector) {};
/**
* @param {(string|Object)=} type
* @param {Object=} target
* @return {jQuery.Promise}
*/
jQuery.prototype.promise = function(type, target) {};
/**
* @interface
* @private
* @see http://api.jquery.com/Types/#Promise
*/
jQuery.Promise = function () {};
/**
* @param {function()} doneCallbacks
* @return {jQuery.Promise}
*/
jQuery.Promise.prototype.done = function(doneCallbacks) {};
/**
* @param {function()} failCallbacks
* @return {jQuery.Promise}
*/
jQuery.Promise.prototype.fail = function(failCallbacks) {};
/**
* @return {boolean}
* @nosideeffects
*/
jQuery.Promise.prototype.isRejected = function() {};
/**
* @return {boolean}
* @nosideeffects
*/
jQuery.Promise.prototype.isResolved = function() {};
/**
* @param {function()} doneCallbacks
* @param {function()} failCallbacks
* @return {jQuery.Promise}
*/
jQuery.Promise.prototype.then = function(doneCallbacks, failCallbacks) {};
/**
* @param {(string|Object.<string,*>)} arg1
* @param {(string|number|boolean|function(number,String))=} arg2
* @return {(string|jQuery)}
*/
jQuery.prototype.prop = function(arg1, arg2) {};
/**
* @param {(function()|Object)} arg1
* @param {(Object|string)} arg2
* @return {function()}
*/
jQuery.proxy = function(arg1, arg2) {};
/**
* @param {(function()|Object)} arg1
* @param {(Object|string)} arg2
* @return {function()}
*/
$.proxy = function(arg1, arg2) {};
/**
* @param {Array.<Element>} elements
* @param {string=} name
* @param {Array.<*>=} args
* @return {jQuery}
*/
jQuery.prototype.pushStack = function(elements, name, args) {};
/**
* @param {(string|Array.<function()>|function(function()))=} queueName
* @param {(Array.<function()>|function(function()))=} arg2
* @return {(Array.<Element>|jQuery)}
*/
jQuery.prototype.queue = function(queueName, arg2) {};
/**
* @param {Element} elem
* @param {string=} queueName
* @param {(Array.<function()>|function())=} arg3
* @return {(Array.<Element>|jQuery)}
*/
jQuery.queue = function(elem, queueName, arg3) {};
/**
* @param {Element} elem
* @param {string=} queueName
* @param {(Array.<function()>|function())=} arg3
* @return {(Array.<Element>|jQuery)}
*/
$.queue = function(elem, queueName, arg3) {};
/**
* @param {function()} handler
* @return {jQuery}
*/
jQuery.prototype.ready = function(handler) {};
/**
* @param {string=} selector
* @return {jQuery}
*/
jQuery.prototype.remove = function(selector) {};
/**
* @param {string} attributeName
* @return {jQuery}
*/
jQuery.prototype.removeAttr = function(attributeName) {};
/**
* @param {(string|function(number,string))=} arg1
* @return {jQuery}
*/
jQuery.prototype.removeClass = function(arg1) {};
/**
* @param {string=} name
* @return {jQuery}
*/
jQuery.prototype.removeData = function(name) {};
/**
* @param {Element} elem
* @param {string=} name
* @return {jQuery}
*/
jQuery.removeData = function(elem, name) {};
/**
* @param {Element} elem
* @param {string=} name
* @return {jQuery}
*/
$.removeData = function(elem, name) {};
/**
* @param {string} propertyName
* @param {(string|number|boolean)} value
* @return {jQuery}
*/
jQuery.prototype.removeProp = function(propertyName, value) {};
/**
* @param {jQuerySelector} target
* @return {jQuery}
*/
jQuery.prototype.replaceAll = function(target) {};
/**
* @param {(string|Element|jQuery|function())} arg1
* @return {jQuery}
*/
jQuery.prototype.replaceWith = function(arg1) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.resize = function(arg1, handler) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.scroll = function(arg1, handler) {};
/**
* @param {number=} value
* @return {(number|jQuery)}
*/
jQuery.prototype.scrollLeft = function(value) {};
/**
* @param {number=} value
* @return {(number|jQuery)}
*/
jQuery.prototype.scrollTop = function(value) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.select = function(arg1, handler) {};
/** @type {string} */
jQuery.prototype.selector;
/** @return {string} */
jQuery.prototype.serialize = function() {};
/** @return {Array.<Object.<string, *>>} */
jQuery.prototype.serializeArray = function() {};
/**
* @param {(string|number|function())=} duration
* @param {(function()|string)=} arg2
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.show = function(duration, arg2, callback) {};
/**
* @param {jQuerySelector=} selector
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.siblings = function(selector) {};
/** @return {number} */
jQuery.prototype.size = function() {};
/**
* @param {number} start
* @param {number=} end
* @return {jQuery}
* @nosideeffects
*/
jQuery.prototype.slice = function(start, end) {};
/**
* @param {(string|number|function())=} duration
* @param {(function()|string)=} arg2
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.slideDown = function(duration, arg2, callback) {};
/**
* @param {(string|number|function())=} duration
* @param {(function()|string)=} arg2
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.slideToggle = function(duration, arg2, callback) {};
/**
* @param {(string|number|function())=} duration
* @param {(function()|string)=} arg2
* @param {function()=} callback
* @return {jQuery}
*/
jQuery.prototype.slideUp = function(duration, arg2, callback) {};
/**
* @param {boolean=} clearQueue
* @param {boolean=} jumpToEnd
* @return {jQuery}
*/
jQuery.prototype.stop = function(clearQueue, jumpToEnd) {};
/**
* @return {jQuery}
* @nosideeffects
*/
jQuery.sub = function() {};
/**
* @return {jQuery}
* @nosideeffects
*/
$.sub = function() {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)=} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.submit = function(arg1, handler) {};
/** @type {Object.<string, *>} */
jQuery.support;
/** @type {Object.<string, *>} */
$.support;
/** @type {boolean} */
jQuery.support.boxModel;
/** @type {boolean} */
$.support.boxModel;
/** @type {boolean} */
jQuery.support.changeBubbles;
/** @type {boolean} */
$.support.changeBubbles;
/** @type {boolean} */
jQuery.support.cssFloat;
/** @type {boolean} */
$.support.cssFloat;
/** @type {boolean} */
jQuery.support.hrefNormalized;
/** @type {boolean} */
$.support.hrefNormalized;
/** @type {boolean} */
jQuery.support.htmlSerialize;
/** @type {boolean} */
$.support.htmlSerialize;
/** @type {boolean} */
jQuery.support.leadingWhitespace;
/** @type {boolean} */
$.support.leadingWhitespace;
/** @type {boolean} */
jQuery.support.noCloneEvent;
/** @type {boolean} */
$.support.noCloneEvent;
/** @type {boolean} */
jQuery.support.opacity;
/** @type {boolean} */
$.support.opacity;
/** @type {boolean} */
jQuery.support.scriptEval;
/** @type {boolean} */
$.support.scriptEval;
/** @type {boolean} */
jQuery.support.style;
/** @type {boolean} */
$.support.style;
/** @type {boolean} */
jQuery.support.submitBubbles;
/** @type {boolean} */
$.support.submitBubbles;
/** @type {boolean} */
jQuery.support.tbody;
/** @type {boolean} */
$.support.tbody;
/**
* @param {(string|function(number,string))=} arg1
* @return {(string|jQuery)}
*/
jQuery.prototype.text = function(arg1) {};
/** @return {Array.<Element>} */
jQuery.prototype.toArray = function() {};
/**
* @param {(function(jQuery.event)|string|number|function()|boolean)=} arg1
* @param {(function(jQuery.event)|function()|string)=} arg2
* @param {(function(jQuery.event)|function())=} arg3
* @return {jQuery}
*/
jQuery.prototype.toggle = function(arg1, arg2, arg3) {};
/**
* @param {(string|function(number,string))} arg1
* @param {boolean=} flag
* @return {jQuery}
*/
jQuery.prototype.toggleClass = function(arg1, flag) {};
/**
* @param {(string|jQuery.event)} arg1
* @param {Array.<*>=} extraParameters
* @return {jQuery}
*/
jQuery.prototype.trigger = function(arg1, extraParameters) {};
/**
* @param {string} eventType
* @param {Array.<*>} extraParameters
* @return {*}
*/
jQuery.prototype.triggerHandler = function(eventType, extraParameters) {};
/**
* @param {string} str
* @return {string}
* @nosideeffects
*/
jQuery.trim = function(str) {};
/**
* @param {string} str
* @return {string}
* @nosideeffects
*/
$.trim = function(str) {};
/**
* @param {*} obj
* @return {string}
* @nosideeffects
*/
jQuery.type = function(obj) {};
/**
* @param {*} obj
* @return {string}
* @nosideeffects
*/
$.type = function(obj) {};
/**
* @param {(string|function(jQuery.event)|jQuery.event)=} arg1
* @param {(function(jQuery.event)|boolean)=} arg2
* @return {jQuery}
*/
jQuery.prototype.unbind = function(arg1, arg2) {};
/**
* @param {string=} arg1
* @param {(string|Object.<string,*>)=} arg2
* @param {function()=} handler
* @return {jQuery}
*/
jQuery.prototype.undelegate = function(arg1, arg2, handler) {};
/**
* @param {Array.<Element>} arr
* @return {Array.<Element>}
*/
jQuery.unique = function(arr) {};
/**
* @param {Array.<Element>} arr
* @return {Array.<Element>}
*/
$.unique = function(arr) {};
/**
* @param {(function(jQuery.event)|Object.<string, *>)} arg1
* @param {function(jQuery.event)=} handler
* @return {jQuery}
*/
jQuery.prototype.unload = function(arg1, handler) {};
/** @return {jQuery} */
jQuery.prototype.unwrap = function() {};
/**
* @param {(string|function(number,*))=} arg1
* @return {(string|Array.<string>|jQuery)}
*/
jQuery.prototype.val = function(arg1) {};
/**
* @param {jQuery.deferred} deferreds
* @return {jQuery.Promise}
*/
jQuery.when = function(deferreds) {};
/**
* @param {jQuery.deferred} deferreds
* @return {jQuery.Promise}
*/
$.when = function(deferreds) {};
/**
* @param {(string|number|function(number,number))=} arg1
* @return {(number|jQuery)}
*/
jQuery.prototype.width = function(arg1) {};
/**
* @param {(string|jQuerySelector|Element|jQuery|function(number))} arg1
* @return {jQuery}
*/
jQuery.prototype.wrap = function(arg1) {};
/**
* @param {(string|jQuerySelector|Element|jQuery)} wrappingElement
* @return {jQuery}
*/
jQuery.prototype.wrapAll = function(wrappingElement) {};
/**
* @param {(string|function())} arg1
* @return {jQuery}
*/
jQuery.prototype.wrapInner = function(arg1) {}; |
const http = require('http');
const {expect} = require('chai');
const bts = require('../../');
const makeRequest = require('../make-request');
describe('Parent-chain test', function () {
const app = bts('./tests/app-folders/Parent');
const server = http.createServer(app);
beforeEach(function () {
server.listen(8181, '127.0.0.1');
});
afterEach(function () {
server.close();
});
it('should pass', function (done) {
makeRequest('GET', '/a/b1', (body) => {
expect(body).to.equal('prebpost');
done();
});
});
it('should pass', function (done) {
makeRequest('GET', '/a/b/c1', (body) => {
expect(body).to.equal('prepre1cpost1post');
done();
});
});
it('should pass', function (done) {
makeRequest('GET', '/a/b/c/d1', (body) => {
expect(body).to.equal('prepre1pre2dpost2post1post');
done();
});
});
});
|
/**
* DocuSign REST API
* The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign.
*
* OpenAPI spec version: v2.1
* Contact: devcenter@docusign.com
*
* NOTE: This class is auto generated. Do not edit the class manually and submit a new issue instead.
*
*/
(function(root, factory) {
if (typeof define === 'function' && define.amd) {
// AMD. Register as an anonymous module.
define(['ApiClient'], factory);
} else if (typeof module === 'object' && module.exports) {
// CommonJS-like environments that support module.exports, like Node.
module.exports = factory(require('../ApiClient'));
} else {
// Browser globals (root is window)
if (!root.Docusign) {
root.Docusign = {};
}
root.Docusign.Comment = factory(root.Docusign.ApiClient);
}
}(this, function(ApiClient) {
'use strict';
/**
* The Comment model module.
* @module model/Comment
*/
/**
* Constructs a new <code>Comment</code>.
* @alias module:model/Comment
* @class
*/
var exports = function() {
var _this = this;
};
/**
* Constructs a <code>Comment</code> from a plain JavaScript object, optionally creating a new instance.
* Copies all relevant properties from <code>data</code> to <code>obj</code> if supplied or a new instance if not.
* @param {Object} data The plain JavaScript object bearing properties of interest.
* @param {module:model/Comment} obj Optional instance to populate.
* @return {module:model/Comment} The populated <code>Comment</code> instance.
*/
exports.constructFromObject = function(data, obj) {
if (data) {
obj = obj || new exports();
if (data.hasOwnProperty('envelopeId')) {
obj['envelopeId'] = ApiClient.convertToType(data['envelopeId'], 'String');
}
if (data.hasOwnProperty('hmac')) {
obj['hmac'] = ApiClient.convertToType(data['hmac'], 'String');
}
if (data.hasOwnProperty('id')) {
obj['id'] = ApiClient.convertToType(data['id'], 'String');
}
if (data.hasOwnProperty('mentions')) {
obj['mentions'] = ApiClient.convertToType(data['mentions'], ['String']);
}
if (data.hasOwnProperty('read')) {
obj['read'] = ApiClient.convertToType(data['read'], 'Boolean');
}
if (data.hasOwnProperty('sentByEmail')) {
obj['sentByEmail'] = ApiClient.convertToType(data['sentByEmail'], 'String');
}
if (data.hasOwnProperty('sentByFullName')) {
obj['sentByFullName'] = ApiClient.convertToType(data['sentByFullName'], 'String');
}
if (data.hasOwnProperty('sentByImageId')) {
obj['sentByImageId'] = ApiClient.convertToType(data['sentByImageId'], 'String');
}
if (data.hasOwnProperty('sentByInitials')) {
obj['sentByInitials'] = ApiClient.convertToType(data['sentByInitials'], 'String');
}
if (data.hasOwnProperty('sentByRecipientId')) {
obj['sentByRecipientId'] = ApiClient.convertToType(data['sentByRecipientId'], 'String');
}
if (data.hasOwnProperty('sentByUserId')) {
obj['sentByUserId'] = ApiClient.convertToType(data['sentByUserId'], 'String');
}
if (data.hasOwnProperty('signingGroupId')) {
obj['signingGroupId'] = ApiClient.convertToType(data['signingGroupId'], 'String');
}
if (data.hasOwnProperty('signingGroupName')) {
obj['signingGroupName'] = ApiClient.convertToType(data['signingGroupName'], 'String');
}
if (data.hasOwnProperty('subject')) {
obj['subject'] = ApiClient.convertToType(data['subject'], 'String');
}
if (data.hasOwnProperty('tabId')) {
obj['tabId'] = ApiClient.convertToType(data['tabId'], 'String');
}
if (data.hasOwnProperty('text')) {
obj['text'] = ApiClient.convertToType(data['text'], 'String');
}
if (data.hasOwnProperty('threadId')) {
obj['threadId'] = ApiClient.convertToType(data['threadId'], 'String');
}
if (data.hasOwnProperty('threadOriginatorId')) {
obj['threadOriginatorId'] = ApiClient.convertToType(data['threadOriginatorId'], 'String');
}
if (data.hasOwnProperty('timestamp')) {
obj['timestamp'] = ApiClient.convertToType(data['timestamp'], 'String');
}
if (data.hasOwnProperty('timeStampFormatted')) {
obj['timeStampFormatted'] = ApiClient.convertToType(data['timeStampFormatted'], 'String');
}
if (data.hasOwnProperty('visibleTo')) {
obj['visibleTo'] = ApiClient.convertToType(data['visibleTo'], ['String']);
}
}
return obj;
}
/**
* The envelope ID of the envelope status that failed to post.
* @member {String} envelopeId
*/
exports.prototype['envelopeId'] = undefined;
/**
*
* @member {String} hmac
*/
exports.prototype['hmac'] = undefined;
/**
*
* @member {String} id
*/
exports.prototype['id'] = undefined;
/**
*
* @member {Array.<String>} mentions
*/
exports.prototype['mentions'] = undefined;
/**
*
* @member {Boolean} read
*/
exports.prototype['read'] = undefined;
/**
*
* @member {String} sentByEmail
*/
exports.prototype['sentByEmail'] = undefined;
/**
*
* @member {String} sentByFullName
*/
exports.prototype['sentByFullName'] = undefined;
/**
*
* @member {String} sentByImageId
*/
exports.prototype['sentByImageId'] = undefined;
/**
*
* @member {String} sentByInitials
*/
exports.prototype['sentByInitials'] = undefined;
/**
*
* @member {String} sentByRecipientId
*/
exports.prototype['sentByRecipientId'] = undefined;
/**
*
* @member {String} sentByUserId
*/
exports.prototype['sentByUserId'] = undefined;
/**
* When set to **true** and the feature is enabled in the sender's account, the signing recipient is required to draw signatures and initials at each signature/initial tab ( instead of adopting a signature/initial style or only drawing a signature/initial once).
* @member {String} signingGroupId
*/
exports.prototype['signingGroupId'] = undefined;
/**
* The display name for the signing group. Maximum Length: 100 characters.
* @member {String} signingGroupName
*/
exports.prototype['signingGroupName'] = undefined;
/**
*
* @member {String} subject
*/
exports.prototype['subject'] = undefined;
/**
* The unique identifier for the tab. The tabid can be retrieved with the [ML:GET call].
* @member {String} tabId
*/
exports.prototype['tabId'] = undefined;
/**
*
* @member {String} text
*/
exports.prototype['text'] = undefined;
/**
*
* @member {String} threadId
*/
exports.prototype['threadId'] = undefined;
/**
*
* @member {String} threadOriginatorId
*/
exports.prototype['threadOriginatorId'] = undefined;
/**
*
* @member {String} timestamp
*/
exports.prototype['timestamp'] = undefined;
/**
*
* @member {String} timeStampFormatted
*/
exports.prototype['timeStampFormatted'] = undefined;
/**
*
* @member {Array.<String>} visibleTo
*/
exports.prototype['visibleTo'] = undefined;
return exports;
}));
|
define([
'jquery',
'underscore',
'backbone',
'text!demos/demo10/templates/HotlineControlsView.html'
], function ($, _, Backbone, templateHtml) {
var ElevationChartView = Backbone.View.extend({
events: {
'input .paletteColor': 'updatePalette',
'input #outlineColor': 'updateOutlineColor',
'input .styleControl': 'updateStyle'
},
initialize: function (args) {
this.dispatcher = args.dispatcher;
this.rangeMultiplier = args.rangeMultiplier
},
updatePalette: function () {
var color1 = $('#paletteColor1').val();
var color2 = $('#paletteColor2').val();
var color3 = $('#paletteColor3').val();
var style = {
'palette': {
0.0: color1,
0.5: color2,
1.0: color3
}
};
$('#palette1').html(color1);
$('#palette2').html(color2);
$('#palette3').html(color3);
this.dispatcher.trigger(this.dispatcher.Events.CHANGE_STYLE, {
type: this.dispatcher.Events.CHANGE_STYLE,
style: style
});
},
updateOutlineColor: function () {
var color = $('#outlineColor').val();
$('#outlineHex').html(color);
this.dispatcher.trigger(this.dispatcher.Events.CHANGE_STYLE, {
type: this.dispatcher.Events.CHANGE_STYLE,
style: {'outlineColor': color}
});
},
updateStyle: function (event) {
var style = {};
style[event.target.id] = parseInt(event.target.value, 10);
if (event.target.id == 'min' || event.target.id == 'max') {
var elem = $('#' + event.target.id + 'Value');
if ($('.pace').hasClass('YouAreHere')) {
elem.html(this.fromMpsToPace(event.target.value / this.rangeMultiplier));
} else {
elem.html(event.target.value);
}
}
this.dispatcher.trigger(this.dispatcher.Events.CHANGE_STYLE, {
type: this.dispatcher.Events.CHANGE_STYLE,
style: style
});
},
fromMpsToPace: function (metersPerSecond) {
var minutesPerMile = 26.8224 / Number(metersPerSecond);
minutes = Math.floor(minutesPerMile);
if (minutes < 10) {
minutes = "0" + minutes;
}
seconds = Math.floor((minutesPerMile - minutes) * 60);
if (seconds < 10) {
seconds = "0" + seconds;
}
return minutes + ":" + seconds;
},
destroy: function () {
// Remove view from DOM
this.remove();
}
});
return ElevationChartView;
});
|
"use strict"
const process = require(`process`)
const fs = require(`fs`)
const createVerge3ChrConverter = require(`../converter/createVerge3ChrConverter`)// TODO looks unneccesary?
const asset = require(`../asset`)
const chrFilename = process.argv[2]
const chrData = asset.fromDisk(chrFilename, asset.v3chr)
const targetFilename = chrFilename + `.json`
console.log("DUMPING...")
delete chrData.frames
const replaceAll = (myString, search, replacement) => {
return myString.replace(new RegExp(search, 'g'), replacement);
};
const deepCopy = (val) => {
return JSON.parse(JSON.stringify(val));
};
const isNumber = (str) => {
return !isNaN(parseInt(str, 10));
};
const animStringData = (animString) => {
var str = replaceAll(animString, ' ', '');
var ret = [];
var tmp = [];
var code = '';
var num = '';
var chr = '';
for (var i = 0; i<str.length; i++ ) {
chr = str[i];
if( isNumber(chr) ) {
if( !code ) {
console.warn('recieved a number without a code loaded in, was: ', chr);
continue;
} else {
num = num + chr;
}
} else {
if( num || i !== 0 ) { // time to save out
ret.push({
code: code,
value: parseInt(num)
});
}
code = chr;
num = '';
}
}
if(num) {
ret.push({
code: code,
value: parseInt(num)
});
}
return ret;
};
const animConvert = (animString) => {
var ret = [];
ret[1] = "Looping";
var parsed = animStringData(animString); // holder
var anim = [];
for (var i = 0; i<parsed.length; i+=2 ) {
if( parsed[i].code === 'F' && parsed[i+1].code === 'W' ) {
anim.push([parsed[i].value, parsed[i+1].value]);
} else {
console.error( "DETECTED UNHANDLED ANIMSTRING PAIR: ",parsed[i].code, parsed[i+1].code );
throw "blowup";
}
}
ret[0] = anim;
return ret;
};
chrData._V3_LEGACY = {};
chrData._V3_LEGACY.signature = deepCopy(chrData.signature);
chrData._V3_LEGACY.version = deepCopy(chrData.version);
chrData._V3_LEGACY.bitsPerPixel = deepCopy(chrData.bitsPerPixel);
chrData._V3_LEGACY.flags = deepCopy(chrData.flags);
chrData._V3_LEGACY.transparentColor = deepCopy(chrData.transparentColor);
chrData._V3_LEGACY.formatName = deepCopy(chrData.formatName);
chrData._V3_LEGACY.customScriptsIgnored = deepCopy(chrData.customScriptsIgnored);
chrData._V3_LEGACY.compression = deepCopy(chrData.compression);
delete chrData.signature
delete chrData.version
delete chrData.bitsPerPixel
delete chrData.flags
delete chrData.transparentColor
delete chrData.formatName
delete chrData.customScriptsIgnored
delete chrData.compression
var newAnim = {};
chrData.dims = [chrData.frameWidth, chrData.frameHeight];
delete chrData.frameWidth
delete chrData.frameHeight
chrData.hitbox = [chrData.hotSpotX, chrData.hotSpotY, chrData.hotSpotWidth, chrData.hotSpotHeight];
delete chrData.hotSpotX
delete chrData.hotSpotY
delete chrData.hotSpotWidth
delete chrData.hotSpotHeight
chrData.frames = chrData.frameCount
delete chrData.frameCount
var newAnim = {};
// rudimentary tests
// newAnim["no space"] = animConvert("F69W100F42W400");
// newAnim["yes space"] = animConvert("F0 W100 F2 W50 F1 W200");
newAnim["Idle Down"] = [ [ [chrData.downIdleFrameIndex, 10000] ], "Looping" ]; // TODO needs "STATIC" in format
newAnim["Idle Up"] = [ [ [chrData.upIdleFrameIndex, 10000] ], "Looping" ]; // TODO needs "STATIC" in format
newAnim["Idle Left"] = [ [ [chrData.leftIdleFrameIndex, 10000] ], "Looping" ]; // TODO needs "STATIC" in format
newAnim["Idle Right"] = [ [ [chrData.rightIdleFrameIndex, 10000] ], "Looping" ]; // TODO needs "STATIC" in format
newAnim["Walk Down"] = animConvert(chrData.animations[0].animationString)
newAnim["Walk Up"] = animConvert(chrData.animations[1].animationString)
newAnim["Walk Right"] = animConvert(chrData.animations[2].animationString)
newAnim["Walk Left"] = animConvert(chrData.animations[3].animationString)
// TODO ignoring UL/DL/UR/DR (chrData.animations indexes [4,7])
chrData.animations = newAnim;
delete chrData.downIdleFrameIndex
delete chrData.upIdleFrameIndex
delete chrData.leftIdleFrameIndex
delete chrData.rightIdleFrameIndex
chrData.image = replaceAll( chrFilename + '.png', `XNAVERGE/Examples/Sully/SullyContent/`, '');
chrData.inner_pad = 0;
chrData.outer_pad = 0;
chrData.per_row = 5;
console.log(JSON.stringify(chrData, null, 2))
fs.writeFileSync(targetFilename, JSON.stringify(chrData))
console.log(`converted`, chrFilename, `to`, targetFilename)
|
/**
* The Jazzcat client is a library for loading JavaScript from the Jazzcat
* webservice. Jazzcat provides a JSONP HTTP endpoint for fetching multiple HTTP
* resources with a single HTTP request. This is handy if you'd to request a
* number of JavaScript files in a single request.
*
* The client is designed to work with Capturing in a "drop in" manner and as such is
* optimized for loading collections of scripts on a page through Jazzcat,
* rather than fetching specific scripts.
*
* The client cannot rely on the browser's cache to store Jazzcat responses. Imagine
* page one with external scripts a and b and page two with script a. Visitng
* page one and then page two results in a cache miss because each set of scripts
* generate different requests to Jazzcat.
*
* To work around this, the client implements a cache over localStorage for caching
* the results of requests to Jazzcat.
*
* Scripts that should use the client must be passed to `Jazzcat.optimizeScripts`
* during the capturing phase. During execution, uncached scripts are loaded
* into the cache using a bootloader request to Jazzcat. Scripts are then
* executed directly from the cache.
*/
(function (root, factory) {
if (typeof define === 'function' && define.amd) {
// AMD. Register as an anonymous module.
define(["mobifyjs/utils"], factory);
} else if (typeof exports === 'object') {
// Node. Does not work with strict CommonJS, but
// only CommonJS-like environments that support module.exports,
// like Node.
var Utils = require('../mobifyjs-utils/utils.js');
module.exports = factory(Utils);
} else {
// Browser globals (root is window)
root.Jazzcat = factory(root.Utils);
}
}(this, function (Utils) {
/**
* An HTTP 1.1 compliant localStorage backed cache.
*/
var httpCache = {
cache: {},
options: {},
utils: {}
};
var localStorageKey = 'Mobify-Jazzcat-Cache-v1.0';
/**
* Reset the cache, optionally to `val`. Useful for testing.
*/
httpCache.reset = function(val) {
httpCache.cache = val || {};
};
/**
* Returns value of `key` if it is in the cache and marks it as used now if
* `touch` is true.
*/
httpCache.get = function(key, touch) {
// Ignore anchors.
var resource = httpCache.cache[key.split('#')[0]];
if (resource && touch) {
resource.lastUsed = Date.now();
}
return resource;
};
/**
* Set `key` to `val` in the cache.
*/
httpCache.set = function(key, val) {
httpCache.cache[key] = val;
};
/**
* Load the cache into memory, skipping stale resources.
*/
httpCache.load = function(options) {
var data = localStorage.getItem(localStorageKey);
var key;
var staleOptions;
if (options && options.overrideTime !== undefined) {
staleOptions = {overrideTime: options.overrideTime};
}
if (!data) {
return;
}
try {
data = JSON.parse(data);
} catch(err) {
return;
}
for (key in data) {
if (data.hasOwnProperty(key) && !httpCache.utils.isStale(data[key], staleOptions)) {
httpCache.set(key, data[key]);
}
}
};
/**
* Save the in-memory cache to localStorage. If the localStorage is full,
* use LRU to drop resources until it will fit on disk, or give up after 10
* attempts.
*/
// save mutex to prevent multiple concurrent saves and saving before `load`
// event for document
var canSave = true;
httpCache.save = function(callback) {
var attempts = 10;
var resources;
var key;
// prevent multiple saves before onload
if (!canSave) {
return callback && callback("Save currently in progress");
}
canSave = false;
// Serialize the cache for storage. If the serialized data won't fit,
// evict an item and try again. Use `setTimeout` to ensure the UI stays
// responsive even if a number of resources are evicted.
(function persist() {
var store = function() {
var resource;
var serialized;
// End of time.
var lruTime = 9007199254740991;
var lruKey;
resources = resources || Utils.clone(httpCache.cache);
try {
serialized = JSON.stringify(resources);
} catch(e) {
canSave = true;
return callback && callback(e);
}
try {
localStorage.setItem(localStorageKey, serialized);
// The serialized data won't fit. Remove the least recently used
// resource and try again.
} catch(e) {
if (!--attempts) {
canSave = true;
return callback && callback(e);
}
// Find the least recently used resource.
for (var key in resources) {
if (!resources.hasOwnProperty(key)) continue;
resource = resources[key];
if (resource.lastUsed) {
if (resource.lastUsed <= lruTime) {
lruKey = key;
lruTime = resource.lastUsed;
}
// If a resource has not been used, it's the LRU.
} else {
lruKey = key;
lruTime = 0;
break;
}
}
delete resources[lruKey];
return persist();
}
canSave = true;
callback && callback();
};
if (Utils.domIsReady()) {
store();
}
else {
setTimeout(persist, 15);
}
})();
};
// Regular expressions for cache-control directives.
// See http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9
var ccDirectives = /^\s*(public|private|no-cache|no-store)\s*$/;
var ccMaxAge = /^\s*(max-age)\s*=\s*(\d+)\s*$/;
/**
* Returns a parsed HTTP 1.1 Cache-Control directive from a string `directives`.
*/
httpCache.utils.ccParse = function(directives) {
var obj = {};
var match;
directives.split(',').forEach(function(directive) {
if (match = ccDirectives.exec(directive)) {
obj[match[1]] = true;
} else if (match = ccMaxAge.exec(directive)) {
obj[match[1]] = parseInt(match[2], 10);
}
});
return obj;
};
/**
* Returns `false` if a response is "fresh" by HTTP/1.1 caching rules or
* less than ten minutes old. Treats invalid headers as stale.
*/
httpCache.utils.isStale = function(resource, options) {
var ONE_DAY_IN_MS = 24 * 60 * 60 * 1000;
var headers = resource.headers || {};
var cacheControl = headers['cache-control'];
var now = Date.now();
var date = Date.parse(headers['date']);
var expires;
var lastModified = headers['last-modified'];
var age;
var modifiedAge;
var overrideTime;
// Fresh if less than 10 minutes old
if (date && (now < date + 600 * 1000)) {
return false;
}
// If a cache override parameter is present, see if the age of the
// response is less than the override, cacheOverrideTime is in minutes,
// turn it off by setting it to false
if (options && (overrideTime = options.overrideTime) && date) {
return (now > (date + (overrideTime * 60 * 1000)));
}
// If `max-age` and `date` are present, and no other cache
// directives exist, then we are stale if we are older.
if (cacheControl && date) {
cacheControl = httpCache.utils.ccParse(cacheControl);
if ((cacheControl['max-age']) &&
(!cacheControl['no-store']) &&
(!cacheControl['no-cache'])) {
// Convert the max-age directive to ms.
return now > (date + (cacheControl['max-age'] * 1000));
} else {
// there was no max-age or this was marked no-store or
// no-cache, and so is stale
return true;
}
}
// If `expires` is present, we are stale if we are older.
if (headers.expires && (expires = Date.parse(headers.expires))) {
return now > expires;
}
// Fresh if less than 10% of difference between date and
// last-modified old, up to a day
if (lastModified && (lastModified = Date.parse(lastModified)) && date) {
modifiedAge = date - lastModified;
age = now - date;
// If the age is less than 10% of the time between the last
// modification and the response, and the age is less than a
// day, then it is not stale
if ((age < 0.1 * modifiedAge) && (age < ONE_DAY_IN_MS)) {
return false;
}
}
// Otherwise, we are stale.
return true;
};
var Jazzcat = window.Jazzcat = {
httpCache: httpCache,
// Cache a reference to `document.write` in case it is reassigned.
write: document.write
};
// No support for Firefox <= 11, Opera 11/12, browsers without
// window.JSON, and browsers without localstorage.
// All other unsupported browsers filtered by mobify.js tag.
Jazzcat.isIncompatibleBrowser = function(userAgent) {
var match = /(firefox)[\/\s](\d+)|(opera[\s\S]*version[\/\s](11|12))/i.exec(userAgent || navigator.userAgent);
// match[1] == Firefox <= 11, // match[3] == Opera 11|12
// These browsers have problems with document.write after a document.write
if ((match && match[1] && +match[2] < 12) || (match && match[3])
|| (!Utils.supportsLocalStorage())
|| (!window.JSON)) {
return true;
}
return false;
};
/**
* Alter the array of scripts, `scripts`, into calls that use the Jazzcat
* service. Roughly:
*
* Before:
*
* <script src="http://code.jquery.com/jquery.js"></script>
* <script>$(function() { alert("helo joe"); })</script>
*
* After:
*
* <script>Jazzcat.httpCache.load();<\/script>
* <script src="//jazzcat.mobify.com/jsonp/Jazzcat.load/http%3A%2F%2Fcode.jquery.com%2Fjquery.js"></script>
* <script>Jazzcat.exec("http://code.jquery.com/jquery.js")</script>
* <script>$(function() { alert("helo joe"); })</script>
*
*
* Takes an option argument, `options`, an object whose properties define
* options that alter jazzcat's javascript loading, caching and execution
* behaviour. Right now the options default to `Jazzcat.defaults` which
* can be overridden. More details on options:
*
* - `cacheOverrideTime` : An integer value greater than 10 that will
* override the freshness implied by the HTTP
* caching headers set on the reource.
* - `responseType` : This value defaults to `jsonp`, which will
* make a request for a jsonp response which
* loads scripts into the httpCache object.
* Can also specify `js`, which will send back
* a plain JavaScript response, which does not
* use localStorage to manage script caching.
* (warning - `js` responses are currently
* experimental and may have issues with cache
* headers).
* - `concat`: A boolean that specifies whether or not script
* requests should be concatenated (split between
* head and body).
*/
// `loaded` indicates if we have loaded the cached and inserted the loader
// into the document
Jazzcat.cacheLoaderInserted = false;
Jazzcat.optimizeScripts = function(scripts, options) {
options = options || {};
if (options && options.cacheOverrideTime !== undefined) {
Utils.extend(httpCache.options,
{overrideTime: options.cacheOverrideTime});
}
scripts = Array.prototype.slice.call(scripts);
// Fastfail if there are no scripts or if required features are missing.
if (!scripts.length || Jazzcat.isIncompatibleBrowser()) {
return scripts;
}
options = Utils.extend({}, Jazzcat.defaults, options || {});
var concat = options.concat;
// A Boolean to control whether the loader is inlined into the document,
// or only added to the returned scripts array
var inlineLoader = ((options.inlineLoader !== undefined) ?
options.inlineLoader: true);
// helper method for inserting the loader script
// before the first uncached script in the "uncached" array
var insertLoaderInContainingElement = function(script, urls) {
if (script) {
var loader = Jazzcat.getLoaderScript(urls, options);
// insert the loader directly before the script
script.parentNode.insertBefore(loader, script);
}
};
// helper for appending loader script into an array before the
// referenced script
var appendLoaderForScriptsToArray = function(array, urls) {
var loader = Jazzcat.getLoaderScript(urls, options);
array.push(loader);
};
var url;
var toConcat = {
'head': {
firstScript: undefined,
urls: [],
scripts: []
},
'body': {
firstScript: undefined,
urls: [],
scripts: []
}
};
// an array to accumulate resulting scripts in and later return
var resultScripts = [];
for (var i=0, len=scripts.length; i<len; i++) {
var script = scripts[i];
// Skip script if it has been optimized already, or if you have a "skip-optimize" class
if (script.hasAttribute('mobify-optimized') ||
script.hasAttribute('skip-optimize') ||
/mobify/i.test(script.className)){
continue;
}
// skip if modifying inline, append to results otherwise
url = script.getAttribute(options.attribute);
if (!url) {
if (inlineLoader) {
continue;
} else {
resultScripts.push(script);
continue;
}
}
url = Utils.absolutify(url);
if (!Utils.httpUrl(url)) {
continue;
}
// TODO: Check for async/defer
// Load what we have in http cache, and insert loader into document
// or result array
if (!Jazzcat.cacheLoaderInserted) {
httpCache.load(httpCache.options);
var httpLoaderScript = Jazzcat.getHttpCacheLoaderScript(options);
if (inlineLoader) {
script.parentNode.insertBefore(httpLoaderScript, script);
} else {
resultScripts.push(httpLoaderScript);
}
// ensure this doesn't happen again for this page load
Jazzcat.cacheLoaderInserted = true;
}
var parent;
if (inlineLoader) {
parent = (script.parentNode.nodeName === "HEAD" ? "head" : "body");
} else {
// If we're not going to use the inline loader, we'll do
// something terrible and put everything into the head bucket
parent = 'head';
}
// if: the script is not in the cache, add a loader
// else: queue for concatenation
if (!httpCache.get(url)) {
if (!concat) {
if (inlineLoader) {
insertLoaderInContainingElement(script, [url]);
} else {
appendLoaderForScriptsToArray(resultScripts, [url]);
}
} else {
toConcat[parent].urls.push(url);
// Remember details of first uncached script
if (toConcat[parent].firstScript === undefined) {
toConcat[parent].firstScript = script;
var firstUncachedScriptIndex = resultScripts.length;
}
}
}
script.type = 'text/mobify-script';
// Rewriting script to grab contents from our in-memory cache
// ex. <script>Jazzcat.exec("http://code.jquery.com/jquery.js")</script>
if (script.hasAttribute('onload')){
var onload = script.getAttribute('onload');
script.innerHTML = options.execCallback + "('" + url + "', '" + onload.replace(/'/g, '\\\'') + "');";
script.removeAttribute('onload');
} else {
script.innerHTML = options.execCallback + "('" + url + "');";
}
// Remove the src attribute
script.removeAttribute(options.attribute);
// Enqueue the script to be returned
if (!inlineLoader) {
resultScripts.push(script);
}
}
// insert the loaders for uncached head and body scripts if
// using concatenation
if (concat) {
if (inlineLoader) {
insertLoaderInContainingElement(toConcat['head'].firstScript,
toConcat['head'].urls);
insertLoaderInContainingElement(toConcat['body'].firstScript,
toConcat['body'].urls);
} else {
// splice in loader for uncached scripts if there are any
if (firstUncachedScriptIndex) {
var loader = Jazzcat.getLoaderScript(toConcat['head'].urls, options);
resultScripts.splice(firstUncachedScriptIndex, 0, loader);
}
}
}
// If the loader was inlined, return the original set of scripts
if (inlineLoader) {
return scripts;
}
// Otherwise return the generated list
return resultScripts;
};
/**
* Private helper that returns a script node that when run, loads the
* httpCache from localStorage.
*/
Jazzcat.getHttpCacheLoaderScript = function(options) {
var loadFromCacheScript = document.createElement('script');
loadFromCacheScript.type = 'text/mobify-script';
loadFromCacheScript.innerHTML = (httpCache.options.overrideTime ?
options.cacheLoadCallback + "(" + JSON.stringify(httpCache.options) + ");" :
options.cacheLoadCallback + "();" );
return loadFromCacheScript;
};
/**
* Returns an array of scripts suitable for loading Jazzcat's localStorage
* cache and loading any uncached scripts through the jazzcat service. Takes
* a list of URLs to load via the service (possibly empty), the name of the
* jsonp callback used in loading the service's response and a boolean of
* whether we expect the cache to have been loaded from localStorage by this
* point.
*/
Jazzcat.getLoaderScript = function(urls, options) {
var loadScript;
if (urls && urls.length) {
loadScript = document.createElement('script');
// Set the script to "optimized"
loadScript.setAttribute('mobify-optimized', '');
loadScript.setAttribute(options.attribute, Jazzcat.getURL(urls, options));
}
return loadScript;
};
/**
* Returns a URL suitable for loading `urls` from Jazzcat, calling the
* function `jsonpCallback` on complete. `urls` are sorted to generate
* consistent URLs.
*/
Jazzcat.getURL = function(urls, options) {
var options = Utils.extend({}, Jazzcat.defaults, options || {});
return options.base +
(options.projectName ? '/project-' + options.projectName : '') +
(options.cacheBreaker ? '/cb' + options.cacheBreaker : '') +
'/' + options.responseType +
(options.responseType === 'jsonp' ? '/' + options.loadCallback : '') +
'/' + encodeURIComponent(JSON.stringify(urls.slice().sort()));
};
var scriptSplitRe = /(<\/scr)(ipt\s*>)/ig;
/**
* Execute the script at `url` using `document.write`. If the scripts
* can't be retrieved from the cache, load it using an external script.
*/
Jazzcat.exec = function(url, onload) {
var resource = httpCache.get(url, true);
var out;
var onloadAttrAndVal = '';
if (onload) {
onload = ';' + onload + ';';
onloadAttrAndVal = ' onload="' + onload + '"';
} else {
onload = '';
}
if (!resource) {
out = 'src="' + url + '"' + onloadAttrAndVal + '>';
} else {
out = 'data-orig-src="' + url + '"';
// Explanation below uses [] to stand for <>.
// Inline scripts appear to work faster than data URIs on many OSes
// (e.g. Android 2.3.x, iOS 5, likely most of early 2013 device market)
//
// However, it is not safe to directly convert a remote script into an
// inline one. If there is a closing script tag inside the script,
// the script element will be closed prematurely.
//
// To guard against this, we need to prevent script element spillage.
// This is done by replacing [/script] with [/scr\ipt] inside script
// content. This transformation renders closing [/script] inert.
//
// The transformation is safe. There are three ways for a valid JS file
// to end up with a [/script] character sequence:
// * Inside a comment - safe to alter
// * Inside a string - replacing 'i' with '\i' changes nothing, as
// backslash in front of characters that need no escaping is ignored.
// * Inside a regular expression starting with '/script' - '\i' has no
// meaning inside regular expressions, either, so it is treated just
// like 'i' when expression is matched.
//
// Talk to Roman if you want to know more about this.
out += '>' + resource.body.replace(scriptSplitRe, '$1\\$2') + onload;
}
// `document.write` is used to ensure scripts are executed in order,
// as opposed to "as fast as possible"
// http://hsivonen.iki.fi/script-execution/
// http://wiki.whatwg.org/wiki/Dynamic_Script_Execution_Order
// This call seems to do nothing in Opera 11/12
Jazzcat.write.call(document, '<script ' + out +'<\/script>');
};
/**
* Load the cache and populate it with the results of the Jazzcat
* response `resources`.
*/
Jazzcat.load = function(resources) {
var resource;
var i = 0;
var save = false;
// All the resources are already in the cache.
if (!resources) {
return;
}
while (resource = resources[i++]) {
// filter out error statuses and status codes
if (resource.status == 'ready' && resource.statusCode >= 200 &&
resource.statusCode < 300) {
save = true;
httpCache.set(encodeURI(resource.url), resource);
}
}
if (save) {
httpCache.save();
}
};
Jazzcat.defaults = {
selector: 'script',
attribute: 'x-src',
base: '//jazzcat.mobify.com',
responseType: 'jsonp',
execCallback: 'Jazzcat.exec',
loadCallback: 'Jazzcat.load',
cacheLoadCallback: 'Jazzcat.httpCache.load',
inlineLoader: 'true',
concat: false,
projectName: '',
};
return Jazzcat;
}));
|
/* global describe, it, afterEach */
import { expect } from 'chai'
import path from 'path'
import { hockeyShotchart } from './../src/index.js'
import { readJSON } from './utils.js'
const base = 'fixtures'
const input = readJSON(
path.join(__dirname, base, 'hockey-shotchart-payload.json'))
describe('hockey', () => {
it('hed should handle no data or filters', () =>
expect(hockeyShotchart.hed({}))
.to.deep.equal(''))
it('hed should handle no filters', () =>
expect(hockeyShotchart.hed({ rows: input.rows }))
.to.deep.equal(''))
it('hed should handle team filter', () =>
expect(hockeyShotchart.hed({
rows: input.rows,
filters: {
teamA: {
key: 'teamNickname',
value: 'Bruins',
},
},
})).to.deep.equal('Bruins, 2015-16'))
it('hed should handle player filter', () =>
expect(hockeyShotchart.hed({
rows: input.rows,
filters: {
playerA: {
key: 'player',
value: 'Torey Krug',
},
},
})).to.deep.equal('Torey Krug, 2015-16'))
it('subhed should handle no data or filters', () =>
expect(hockeyShotchart.subhed({}))
.to.deep.equal(''))
it('subhed should handle team or player', () =>
expect(hockeyShotchart.subhed({
rows: input.rows,
filters: {
teamA: {
key: 'teamNickname',
value: 'Bruins',
},
},
})).to.deep.equal('All shots through Oct. 8'))
it('subhed should handle home/away', () =>
expect(hockeyShotchart.subhed({
rows: input.rows,
filters: {
homeA: {
key: 'home',
value: false,
},
},
})).to.deep.equal('All shots on the road through Oct. 8'))
it('subhed should handle power play', () =>
expect(hockeyShotchart.subhed({
rows: input.rows,
filters: {
powerPlayA: {
key: 'powerPlay',
value: true,
},
},
})).to.deep.equal('All shots on a power play through Oct. 8'))
it('subhed should handle opponent', () =>
expect(hockeyShotchart.subhed({
rows: input.rows,
filters: {
opponentA: {
key: 'opponentNickname',
value: 'Jets',
},
},
})).to.deep.equal('All shots against the Jets through Oct. 8'))
it('subhed should period', () =>
expect(hockeyShotchart.subhed({
rows: input.rows,
filters: {
periodA: {
key: 'period',
value: '1',
},
},
})).to.deep.equal('All shots in the 1st period through Oct. 8'))
})
|
var bender = require('../../');
module.exports = function () {
var ret = {};
Object.keys(bender.argv).forEach(function (key) {
if (key !== '_' && key !== '$0') {
ret[key] = bender.argv[key];
}
});
return ret;
};
|
var gm = require('gm');
var ExifImage = require('exif').ExifImage;
var async = require('async');
exports.getColorProfile = function getExifColorProfile(image, cb) {
async.parallel({
hasEmbeddedICCProfile: function (cb) {
hasEmbeddedICCProfile(image, function (err, data) {
cb (err, data);
});
},
getExifData: function (cb) {
getExifData(image, function (err, data) {
return cb (err, data);
});
}
}, function (err, data) {
if (data.hasEmbeddedICCProfile && !data.getExifData.isAdobe) {
cb(null, 'embedded');
} else if(data.getExifData.isAdobe && data.getExifData.ColorSpace === 65535) {
cb(null, 'AdobeRGB1998');
} else if (data.getExifData.InteropIndex === 'R98') {
cb(null, 'sRGB');
} else if (data.getExifData.InteropIndex === 'R03') {
cb(null, 'AdobeRGB1998');
} else {
cb(null, 'unknown');
}
});
};
function hasEmbeddedICCProfile(image, cb) {
gm(image)
.setFormat('icc')
.toBuffer(function(err, buffer){
cb(null, buffer !== null);
});
};
/**
* TEMPORARY SOLUTION TO https://github.com/gomfunkel/node-exif/pull/30
*/
ExifImage.prototype.processImage = function (data, callback) {
var self = this;
var offset = 0;
if (data[offset++] == 0xFF && data[offset++] == 0xD8) {
self.imageType = 'JPEG';
} else {
callback(new Error('The given image is not a JPEG and thus unsupported right now.'));
return;
}
try {
while (offset < data.length) {
if (data[offset++] != 0xFF) {
callback(false, self.exifData);
return;
}
if (data[offset++] == 0xE1) {
var exifData = self.extractExifData(data, offset + 2, data.getShort(offset, true) - 2);
callback(false, exifData);
return;
} else {
offset += data.getShort(offset, true);
}
}
} catch (error) {
return callback(error); // FIXED, waiting for merge on official repository
}
callback(new Error('No Exif segment found in the given image.'));
};
/**
* END TEMPORARY SOLUTION TO https://github.com/gomfunkel/node-exif/pull/30
*/
function getExifData(image, cb) {
try {
new ExifImage({ image : image }, function (error, exifData) {
if (error)
cb('Error: ' + error.message, {InteropIndex: null, isAdobe: false, ColorSpace: null});
else {
var isAdobe = exifData.image.Software.match(/adobe/gi) !== null;
cb(null, {InteropIndex: exifData.interoperability.InteropIndex,
isAdobe: isAdobe,
ColorSpace: exifData.exif.ColorSpace});
}
});
} catch (error) {
cb('Error: ' + error.message, null);
}
};
|
var game = new function() {
var participants = [];
var currentAnswers = [];
var startTimeMs = -1;
var currentQuestionIndex = 0;
var questions = [];
var currentCount = -1;
var countdownInterval = null;
var questionTimeout = null;
this.startGame = function() {
chromequiz.sendGameStarting();
countdownInterval = null;
currentAnswers = [];
startTimeMs = -1;
currentQuestionIndex = 0;
questions = seedQuestions();
startCountdown();
}
var startCountdown = function() {
currentCount = 5;
if(countdownInterval != null) {
window.clearTimeout(countdownInterval);
}
tickCountdown();
}
var tickCountdown = function() {
countdownInterval = window.setTimeout(function() {
// UPDATE GUI
$('#gamearea').empty();
$('#gamearea').append('Next question in ' + currentCount-- + ' seconds');
if(currentCount > 0) {
tickCountdown();
} else {
game.displayQuestion(questions[currentQuestionIndex++]);
}
}, 1000);
}
this.addAnswer = function(participantName, answerLetter) {
var ms = new Date().getTime();
currentAnswers.push({"name":participantName,"answer":answerLetter, "time": ms-startTimeMs});
if(currentAnswers.length == participants.length) {
if(questionTimeout != null) {
window.clearTimeout(questionTimeout);
}
game.displayAnswer(questions[currentQuestionIndex-1]);
}
}
/**
* Registers a sender ID as a new participant
* @param castId
*/
this.addParticipant = function(castId) {
var participant= {"castId":castId, "name":"Unknown","score":0};
participants.push(participant);
game.updateParticipantList();
if(participants.length == 1) {
participants[0].isMaster = true;
chromequiz.sendIsMasterEvent(castId);
}
}
/**
* Associates a human-readable name to a castId.
* @param castId
* @param name
*/
this.addParticipantName = function(castId, name) {
var index = -1;
for(var a=0;a < participants.length;a++) {
var existingParticipant = participants[a];
if(existingParticipant.castId == castId) {
existingParticipant.name = name;
break;
}
}
}
this.removeParticipant = function(name) {
var index = -1;
for(var a=0;a < participants.length;a++) {
var existingParticipant = participants[a];
if(existingParticipant.name == name) {
index = a;
break;
}
}
if(index > -1) {
participants.splice(index, 1);
}
}
this.updateParticipantList = function() {
$('#participants').empty().append('<ul>');
for(var a=0;a < participants.length;a++) {
$('#participants').append('<li>' + participants[a].name + ' ' + participants[a].score + '</li>');
}
$('#participants').append('</ul>');
}
this.displayQuestion = function(question) {
currentAnswers = [];
startTimeMs = new Date().getTime();
$('#gamearea').empty();
$('#gamearea').append('<center>');
$('#gamearea').append('<br/><h1>' + question.q + '</h1><br/>');
for(var a=0;a < question.options.length;a++) {
$('#gamearea').append('<h2>' + question.options[a].letter + ': ' + question.options[a].text + '</h2>');
}
$('#gamearea').append('</center>');
chromequiz.sendQuestion(question);
// Start the timer
questionTimeout = setTimeout(function() {
game.displayAnswer(questions[currentQuestionIndex-1]);
}, 10000);
}
this.displayAnswer = function(question) {
$('#gamearea').empty();
$('#gamearea').append('<center>');
$('#gamearea').append('<br/><h1>The correct answer is: ' + question.a + '</h1><br/>');
var correctOptionIndex = (question.a == 'A' ? 0 : (question.a == 'B' ? 1 : 2));
$('#gamearea').append('<br/><h2>'+question.options[correctOptionIndex] + '</h2><br/>');
for(var a=0;a < participants.length;a++) {
$('#gamearea').append(participants[a].name);
var didAnswer = false;
for(var b=0;b < currentAnswers.length;b++) {
var answ = currentAnswers[b];
if(answ.name == participants[a].name) {
didAnswer = true;
$('#gamearea').append(' answered: ' + answ.answer);
}
}
if(!didAnswer) {
$('#gamearea').append(' failed to answer');
}
}
$('#gamearea').append('</center>');
game.updateScoring(question.a);
if(currentQuestionIndex == questions-1) {
game.finishGame();
} else {
setTimeout(function() {
startCountdown();
}, 10000);
}
}
this.finishGame = function() {
chromequiz.sendGameEnded();
}
this.updateScoring = function(correctAnswerLetter) {
for(var a=0;a < participants.length;a++) {
for(var b=0;b < currentAnswers.length;b++) {
var answ = currentAnswers[b];
if(answ.name == participants[a].name) {
if(correctAnswerLetter == answ.answer) {
participants[a].score = participants[a].score + 1;
}
}
}
if(!didAnswer) {
$('#gamearea').append(' failed to answer');
}
}
}
var questions = [
{"q":"What's the name of the world's longest river?","a":"C","options":
[
{"letter":"A","answer":"The Nile"},
{"letter":"B","answer":"The Mississippi"},
{"letter":"C","answer":"The Amazon"}
]
},
{"q":"What's the name of the capital of Mongolia?","a":"A","options":
[
{"letter":"A","answer":"Ulan Bator"},
{"letter":"B","answer":"Tbilisi"},
{"letter":"C","answer":"Astana"}
]
},
{"q":"Some question 1?","a":"B","options":
[
{"letter":"A","answer":"The A1"},
{"letter":"B","answer":"The B1"},
{"letter":"C","answer":"The C1"}
]
},
{"q":"Some question 2","a":"C","options":
[
{"letter":"A","answer":"The A2"},
{"letter":"B","answer":"The B2"},
{"letter":"C","answer":"The C2"}
]
},
{"q":"What's the name of that large iron thing in Paris","a":"C","options":
[
{"letter":"A","answer":"The Golden Gate bridge"},
{"letter":"B","answer":"The Louvre"},
{"letter":"C","answer":"The Eiffel Tower"}
]
}
];
var seedQuestions = function() {
return shuffleArray(questions);
}
var shuffleArray = function(array) {
for (var i = array.length - 1; i > 0; i--) {
var j = Math.floor(Math.random() * (i + 1));
var temp = array[i];
array[i] = array[j];
array[j] = temp;
}
return array;
}
} |
'use strict';
var crypto = require('crypto');
function encryptPassword(password, salt){
return crypto.createHmac('sha1', salt).update(password).digest('hex');
};
module.exports = {
up: function (queryInterface, Sequelize) {
return queryInterface.bulkInsert('Users', [
{ username: 'admin',
password: encryptPassword('1234', 'aaaa'),
salt: 'aaaa',
isAdmin: true,
createdAt: new Date(),
updatedAt: new Date() },
{ username: 'pepe',
password: encryptPassword('5678', 'bbbb'),
salt: 'bbbb',
createdAt: new Date(),
updatedAt: new Date() }
]);
},
down: function (queryInterface, Sequelize) {
return queryInterface.bulkDelete('Users', null, {});
}
};
|
import React from 'react';
import PropTypes from 'prop-types';
import classNames from 'classnames';
class ButtonToolbar extends React.Component {
render() {
const {
className,
...attributes
} = this.props;
const classes = classNames(
className,
'btn-toolbar'
);
return (
<div {...attributes} className={classes} >
{this.props.children}
</div>
);
}
}
ButtonToolbar.propTypes = {
'aria-label': PropTypes.string,
className: PropTypes.string,
children: PropTypes.node,
role: PropTypes.string
};
ButtonToolbar.defaultProps = {
role: 'toolbar'
};
export default ButtonToolbar; |
/* eslint-env browser */
"use strict";
// http://paulirish.com/2011/requestanimationframe-for-smart-animating/
// http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
// MIT license
// requestAnimationFrame polyfill by Erik Möller. fixes from Paul Irish and Tino Zijdel
(function() {
var lastTime = 0,
vendors = [ "ms", "moz", "webkit", "o" ];
for (var x = 0; x < vendors.length && !window.requestAnimationFrame; ++x) {
window.requestAnimationFrame = window[vendors[x] + "RequestAnimationFrame"];
window.cancelAnimationFrame = window[vendors[x] + "CancelAnimationFrame"] ||
window[vendors[x] + "CancelRequestAnimationFrame"];
}
if (!window.requestAnimationFrame) {
window.requestAnimationFrame = function(callback) {
var currTime, timeToCall, id;
currTime = new Date().getTime();
timeToCall = Math.max(0, 16 - (currTime - lastTime));
id = window.setTimeout(function() {
callback(currTime + timeToCall);
}, timeToCall);
lastTime = currTime + timeToCall;
return id;
};
}
if (!window.cancelAnimationFrame) {
window.cancelAnimationFrame = function(id) {
clearTimeout(id);
};
}
}());
|
import * as t from '../types/todo_types';
import { resolvePageAction } from './page_resolver';
import { todoStore } from '../stores/todo_store'
export default function(action, next) {
// do the specific action first, this way
// you can easily override the base action
const store = action.store;
switch(action.type) {
case t.TODO_DONE:
action.store.done(action.store, action.payload)
break;
case t.TODO_VALIDATE:
// do something special with this one
// TODO
return next(null, action);
}
resolvePageAction(action)
return next(null, action);
} |
Gavia.Record.fn.delete = function (keyName) {
var request,
deferred = new Gavia.Deferred(),
key = (function () {
if (this.store.keyPath)
return this[this.store.keyPath];
if (typeof keyName === 'function')
return keyName();
if (keyName)
return this[keyName];
}).apply(this);
if (!key) {
deferred.reject('key does not setting.');
return deferred.promise();
}
request = indexedDB.open(this.db.name, this.db.version);
request.onsuccess = function (event) {
var db = event.target.result,
store = db.transaction([this.store.name], 'readwrite').objectStore(this.store.name);
store.delete(key);
store.transaction.oncomplete = function () {
deferred.resolve(key);
db.close();
};
store.transaction.onerror = function (event) {
deferred.reject(key);
db.close();
};
}.bind(this);
request.onerror = function (event) {
var db = event.target.result;
deferred.reject();
db.close();
};
return deferred.promise();
}; |
import sinon from 'sinon'
import lolex from 'lolex'
import {
makeMutators,
start,
stop,
} from './endless-job'
test('machines/endless-job/makeMutators', () => {
const state = {
frame: null,
jobs: [],
isStopped: true,
};
const mutators = makeMutators({}, state);
mutators.registerJob({ job: 'foobar' });
expect(state.jobs).toEqual(['foobar']);
mutators.startMachine();
expect(state.isStopped).toBe(false);
mutators.stopMachine();
expect(state).toEqual(
{ frame: null, jobs: [], isStopped: true }
);
});
test('machines/endless-job/start', () => {
const clock = lolex.createClock();
const state = {
isStopped: false,
jobs: [],
requestAnimationFrame: callback => clock.setTimeout(callback, 10),
};
const mutators = makeMutators({}, state);
const expectedCallCount = 5;
let callCount = 0;
const job = () => {
if (callCount === expectedCallCount) {
state.isStopped = true;
} else {
callCount++;
}
}
state.jobs.push(job);
start(state, mutators)();
clock.runAll();
expect(callCount).toBe(expectedCallCount);
});
test('machines/endless-job/stop', () => {
const clock = lolex.createClock();
const cancelAnimationFrame = sinon.spy();
const state = {
frame: 'hello',
cancelAnimationFrame,
};
const mutators = makeMutators({}, state);
stop(state, mutators)();
expect(cancelAnimationFrame.firstCall.args[0]).toBe('hello');
});
|
import {
UVMapping,
CubeReflectionMapping,
CubeRefractionMapping,
EquirectangularReflectionMapping,
EquirectangularRefractionMapping,
SphericalReflectionMapping,
CubeUVReflectionMapping,
CubeUVRefractionMapping,
RepeatWrapping,
ClampToEdgeWrapping,
MirroredRepeatWrapping,
NearestFilter,
NearestMipmapNearestFilter,
NearestMipmapLinearFilter,
LinearFilter,
LinearMipmapNearestFilter,
LinearMipmapLinearFilter
} from '../constants.js';
import { Color } from '../math/Color.js';
import { Object3D } from '../core/Object3D.js';
import { Group } from '../objects/Group.js';
import { Sprite } from '../objects/Sprite.js';
import { Points } from '../objects/Points.js';
import { Line } from '../objects/Line.js';
import { LineLoop } from '../objects/LineLoop.js';
import { LineSegments } from '../objects/LineSegments.js';
import { LOD } from '../objects/LOD.js';
import { Mesh } from '../objects/Mesh.js';
import { SkinnedMesh } from '../objects/SkinnedMesh.js';
import { Shape } from '../extras/core/Shape.js';
import { Fog } from '../scenes/Fog.js';
import { FogExp2 } from '../scenes/FogExp2.js';
import { HemisphereLight } from '../lights/HemisphereLight.js';
import { SpotLight } from '../lights/SpotLight.js';
import { PointLight } from '../lights/PointLight.js';
import { DirectionalLight } from '../lights/DirectionalLight.js';
import { AmbientLight } from '../lights/AmbientLight.js';
import { RectAreaLight } from '../lights/RectAreaLight.js';
import { OrthographicCamera } from '../cameras/OrthographicCamera.js';
import { PerspectiveCamera } from '../cameras/PerspectiveCamera.js';
import { Scene } from '../scenes/Scene.js';
import { CubeTexture } from '../textures/CubeTexture.js';
import { Texture } from '../textures/Texture.js';
import { ImageLoader } from './ImageLoader.js';
import { LoadingManager } from './LoadingManager.js';
import { AnimationClip } from '../animation/AnimationClip.js';
import { MaterialLoader } from './MaterialLoader.js';
import { LoaderUtils } from './LoaderUtils.js';
import { BufferGeometryLoader } from './BufferGeometryLoader.js';
import { Loader } from './Loader.js';
import { FileLoader } from './FileLoader.js';
import * as Geometries from '../geometries/Geometries.js';
import * as Curves from '../extras/curves/Curves.js';
/**
* @author mrdoob / http://mrdoob.com/
*/
function ObjectLoader( manager ) {
Loader.call( this, manager );
}
ObjectLoader.prototype = Object.assign( Object.create( Loader.prototype ), {
constructor: ObjectLoader,
load: function ( url, onLoad, onProgress, onError ) {
var scope = this;
var path = ( this.path === '' ) ? LoaderUtils.extractUrlBase( url ) : this.path;
this.resourcePath = this.resourcePath || path;
var loader = new FileLoader( scope.manager );
loader.setPath( this.path );
loader.load( url, function ( text ) {
var json = null;
try {
json = JSON.parse( text );
} catch ( error ) {
if ( onError !== undefined ) onError( error );
console.error( 'THREE:ObjectLoader: Can\'t parse ' + url + '.', error.message );
return;
}
var metadata = json.metadata;
if ( metadata === undefined || metadata.type === undefined || metadata.type.toLowerCase() === 'geometry' ) {
console.error( 'THREE.ObjectLoader: Can\'t load ' + url );
return;
}
scope.parse( json, onLoad );
}, onProgress, onError );
},
parse: function ( json, onLoad ) {
var shapes = this.parseShape( json.shapes );
var geometries = this.parseGeometries( json.geometries, shapes );
var images = this.parseImages( json.images, function () {
if ( onLoad !== undefined ) onLoad( object );
} );
var textures = this.parseTextures( json.textures, images );
var materials = this.parseMaterials( json.materials, textures );
var object = this.parseObject( json.object, geometries, materials );
if ( json.animations ) {
object.animations = this.parseAnimations( json.animations );
}
if ( json.images === undefined || json.images.length === 0 ) {
if ( onLoad !== undefined ) onLoad( object );
}
return object;
},
parseShape: function ( json ) {
var shapes = {};
if ( json !== undefined ) {
for ( var i = 0, l = json.length; i < l; i ++ ) {
var shape = new Shape().fromJSON( json[ i ] );
shapes[ shape.uuid ] = shape;
}
}
return shapes;
},
parseGeometries: function ( json, shapes ) {
var geometries = {};
if ( json !== undefined ) {
var bufferGeometryLoader = new BufferGeometryLoader();
for ( var i = 0, l = json.length; i < l; i ++ ) {
var geometry;
var data = json[ i ];
switch ( data.type ) {
case 'PlaneGeometry':
case 'PlaneBufferGeometry':
geometry = new Geometries[ data.type ](
data.width,
data.height,
data.widthSegments,
data.heightSegments
);
break;
case 'BoxGeometry':
case 'BoxBufferGeometry':
case 'CubeGeometry': // backwards compatible
geometry = new Geometries[ data.type ](
data.width,
data.height,
data.depth,
data.widthSegments,
data.heightSegments,
data.depthSegments
);
break;
case 'CircleGeometry':
case 'CircleBufferGeometry':
geometry = new Geometries[ data.type ](
data.radius,
data.segments,
data.thetaStart,
data.thetaLength
);
break;
case 'CylinderGeometry':
case 'CylinderBufferGeometry':
geometry = new Geometries[ data.type ](
data.radiusTop,
data.radiusBottom,
data.height,
data.radialSegments,
data.heightSegments,
data.openEnded,
data.thetaStart,
data.thetaLength
);
break;
case 'ConeGeometry':
case 'ConeBufferGeometry':
geometry = new Geometries[ data.type ](
data.radius,
data.height,
data.radialSegments,
data.heightSegments,
data.openEnded,
data.thetaStart,
data.thetaLength
);
break;
case 'SphereGeometry':
case 'SphereBufferGeometry':
geometry = new Geometries[ data.type ](
data.radius,
data.widthSegments,
data.heightSegments,
data.phiStart,
data.phiLength,
data.thetaStart,
data.thetaLength
);
break;
case 'DodecahedronGeometry':
case 'DodecahedronBufferGeometry':
case 'IcosahedronGeometry':
case 'IcosahedronBufferGeometry':
case 'OctahedronGeometry':
case 'OctahedronBufferGeometry':
case 'TetrahedronGeometry':
case 'TetrahedronBufferGeometry':
geometry = new Geometries[ data.type ](
data.radius,
data.detail
);
break;
case 'RingGeometry':
case 'RingBufferGeometry':
geometry = new Geometries[ data.type ](
data.innerRadius,
data.outerRadius,
data.thetaSegments,
data.phiSegments,
data.thetaStart,
data.thetaLength
);
break;
case 'TorusGeometry':
case 'TorusBufferGeometry':
geometry = new Geometries[ data.type ](
data.radius,
data.tube,
data.radialSegments,
data.tubularSegments,
data.arc
);
break;
case 'TorusKnotGeometry':
case 'TorusKnotBufferGeometry':
geometry = new Geometries[ data.type ](
data.radius,
data.tube,
data.tubularSegments,
data.radialSegments,
data.p,
data.q
);
break;
case 'TubeGeometry':
case 'TubeBufferGeometry':
// This only works for built-in curves (e.g. CatmullRomCurve3).
// User defined curves or instances of CurvePath will not be deserialized.
geometry = new Geometries[ data.type ](
new Curves[ data.path.type ]().fromJSON( data.path ),
data.tubularSegments,
data.radius,
data.radialSegments,
data.closed
);
break;
case 'LatheGeometry':
case 'LatheBufferGeometry':
geometry = new Geometries[ data.type ](
data.points,
data.segments,
data.phiStart,
data.phiLength
);
break;
case 'PolyhedronGeometry':
case 'PolyhedronBufferGeometry':
geometry = new Geometries[ data.type ](
data.vertices,
data.indices,
data.radius,
data.details
);
break;
case 'ShapeGeometry':
case 'ShapeBufferGeometry':
var geometryShapes = [];
for ( var j = 0, jl = data.shapes.length; j < jl; j ++ ) {
var shape = shapes[ data.shapes[ j ] ];
geometryShapes.push( shape );
}
geometry = new Geometries[ data.type ](
geometryShapes,
data.curveSegments
);
break;
case 'ExtrudeGeometry':
case 'ExtrudeBufferGeometry':
var geometryShapes = [];
for ( var j = 0, jl = data.shapes.length; j < jl; j ++ ) {
var shape = shapes[ data.shapes[ j ] ];
geometryShapes.push( shape );
}
var extrudePath = data.options.extrudePath;
if ( extrudePath !== undefined ) {
data.options.extrudePath = new Curves[ extrudePath.type ]().fromJSON( extrudePath );
}
geometry = new Geometries[ data.type ](
geometryShapes,
data.options
);
break;
case 'BufferGeometry':
case 'InstancedBufferGeometry':
geometry = bufferGeometryLoader.parse( data );
break;
case 'Geometry':
if ( 'THREE' in window && 'LegacyJSONLoader' in THREE ) {
var geometryLoader = new THREE.LegacyJSONLoader();
geometry = geometryLoader.parse( data, this.resourcePath ).geometry;
} else {
console.error( 'THREE.ObjectLoader: You have to import LegacyJSONLoader in order load geometry data of type "Geometry".' );
}
break;
default:
console.warn( 'THREE.ObjectLoader: Unsupported geometry type "' + data.type + '"' );
continue;
}
geometry.uuid = data.uuid;
if ( data.name !== undefined ) geometry.name = data.name;
if ( geometry.isBufferGeometry === true && data.userData !== undefined ) geometry.userData = data.userData;
geometries[ data.uuid ] = geometry;
}
}
return geometries;
},
parseMaterials: function ( json, textures ) {
var cache = {}; // MultiMaterial
var materials = {};
if ( json !== undefined ) {
var loader = new MaterialLoader();
loader.setTextures( textures );
for ( var i = 0, l = json.length; i < l; i ++ ) {
var data = json[ i ];
if ( data.type === 'MultiMaterial' ) {
// Deprecated
var array = [];
for ( var j = 0; j < data.materials.length; j ++ ) {
var material = data.materials[ j ];
if ( cache[ material.uuid ] === undefined ) {
cache[ material.uuid ] = loader.parse( material );
}
array.push( cache[ material.uuid ] );
}
materials[ data.uuid ] = array;
} else {
if ( cache[ data.uuid ] === undefined ) {
cache[ data.uuid ] = loader.parse( data );
}
materials[ data.uuid ] = cache[ data.uuid ];
}
}
}
return materials;
},
parseAnimations: function ( json ) {
var animations = [];
for ( var i = 0; i < json.length; i ++ ) {
var data = json[ i ];
var clip = AnimationClip.parse( data );
if ( data.uuid !== undefined ) clip.uuid = data.uuid;
animations.push( clip );
}
return animations;
},
parseImages: function ( json, onLoad ) {
var scope = this;
var images = {};
function loadImage( url ) {
scope.manager.itemStart( url );
return loader.load( url, function () {
scope.manager.itemEnd( url );
}, undefined, function () {
scope.manager.itemError( url );
scope.manager.itemEnd( url );
} );
}
if ( json !== undefined && json.length > 0 ) {
var manager = new LoadingManager( onLoad );
var loader = new ImageLoader( manager );
loader.setCrossOrigin( this.crossOrigin );
for ( var i = 0, il = json.length; i < il; i ++ ) {
var image = json[ i ];
var url = image.url;
if ( Array.isArray( url ) ) {
// load array of images e.g CubeTexture
images[ image.uuid ] = [];
for ( var j = 0, jl = url.length; j < jl; j ++ ) {
var currentUrl = url[ j ];
var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( currentUrl ) ? currentUrl : scope.resourcePath + currentUrl;
images[ image.uuid ].push( loadImage( path ) );
}
} else {
// load single image
var path = /^(\/\/)|([a-z]+:(\/\/)?)/i.test( image.url ) ? image.url : scope.resourcePath + image.url;
images[ image.uuid ] = loadImage( path );
}
}
}
return images;
},
parseTextures: function ( json, images ) {
function parseConstant( value, type ) {
if ( typeof value === 'number' ) return value;
console.warn( 'THREE.ObjectLoader.parseTexture: Constant should be in numeric form.', value );
return type[ value ];
}
var textures = {};
if ( json !== undefined ) {
for ( var i = 0, l = json.length; i < l; i ++ ) {
var data = json[ i ];
if ( data.image === undefined ) {
console.warn( 'THREE.ObjectLoader: No "image" specified for', data.uuid );
}
if ( images[ data.image ] === undefined ) {
console.warn( 'THREE.ObjectLoader: Undefined image', data.image );
}
var texture;
if ( Array.isArray( images[ data.image ] ) ) {
texture = new CubeTexture( images[ data.image ] );
} else {
texture = new Texture( images[ data.image ] );
}
texture.needsUpdate = true;
texture.uuid = data.uuid;
if ( data.name !== undefined ) texture.name = data.name;
if ( data.mapping !== undefined ) texture.mapping = parseConstant( data.mapping, TEXTURE_MAPPING );
if ( data.offset !== undefined ) texture.offset.fromArray( data.offset );
if ( data.repeat !== undefined ) texture.repeat.fromArray( data.repeat );
if ( data.center !== undefined ) texture.center.fromArray( data.center );
if ( data.rotation !== undefined ) texture.rotation = data.rotation;
if ( data.wrap !== undefined ) {
texture.wrapS = parseConstant( data.wrap[ 0 ], TEXTURE_WRAPPING );
texture.wrapT = parseConstant( data.wrap[ 1 ], TEXTURE_WRAPPING );
}
if ( data.format !== undefined ) texture.format = data.format;
if ( data.type !== undefined ) texture.type = data.type;
if ( data.encoding !== undefined ) texture.encoding = data.encoding;
if ( data.minFilter !== undefined ) texture.minFilter = parseConstant( data.minFilter, TEXTURE_FILTER );
if ( data.magFilter !== undefined ) texture.magFilter = parseConstant( data.magFilter, TEXTURE_FILTER );
if ( data.anisotropy !== undefined ) texture.anisotropy = data.anisotropy;
if ( data.flipY !== undefined ) texture.flipY = data.flipY;
if ( data.premultiplyAlpha !== undefined ) texture.premultiplyAlpha = data.premultiplyAlpha;
if ( data.unpackAlignment !== undefined ) texture.unpackAlignment = data.unpackAlignment;
textures[ data.uuid ] = texture;
}
}
return textures;
},
parseObject: function ( data, geometries, materials ) {
var object;
function getGeometry( name ) {
if ( geometries[ name ] === undefined ) {
console.warn( 'THREE.ObjectLoader: Undefined geometry', name );
}
return geometries[ name ];
}
function getMaterial( name ) {
if ( name === undefined ) return undefined;
if ( Array.isArray( name ) ) {
var array = [];
for ( var i = 0, l = name.length; i < l; i ++ ) {
var uuid = name[ i ];
if ( materials[ uuid ] === undefined ) {
console.warn( 'THREE.ObjectLoader: Undefined material', uuid );
}
array.push( materials[ uuid ] );
}
return array;
}
if ( materials[ name ] === undefined ) {
console.warn( 'THREE.ObjectLoader: Undefined material', name );
}
return materials[ name ];
}
switch ( data.type ) {
case 'Scene':
object = new Scene();
if ( data.background !== undefined ) {
if ( Number.isInteger( data.background ) ) {
object.background = new Color( data.background );
}
}
if ( data.fog !== undefined ) {
if ( data.fog.type === 'Fog' ) {
object.fog = new Fog( data.fog.color, data.fog.near, data.fog.far );
} else if ( data.fog.type === 'FogExp2' ) {
object.fog = new FogExp2( data.fog.color, data.fog.density );
}
}
break;
case 'PerspectiveCamera':
object = new PerspectiveCamera( data.fov, data.aspect, data.near, data.far );
if ( data.focus !== undefined ) object.focus = data.focus;
if ( data.zoom !== undefined ) object.zoom = data.zoom;
if ( data.filmGauge !== undefined ) object.filmGauge = data.filmGauge;
if ( data.filmOffset !== undefined ) object.filmOffset = data.filmOffset;
if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
break;
case 'OrthographicCamera':
object = new OrthographicCamera( data.left, data.right, data.top, data.bottom, data.near, data.far );
if ( data.zoom !== undefined ) object.zoom = data.zoom;
if ( data.view !== undefined ) object.view = Object.assign( {}, data.view );
break;
case 'AmbientLight':
object = new AmbientLight( data.color, data.intensity );
break;
case 'DirectionalLight':
object = new DirectionalLight( data.color, data.intensity );
break;
case 'PointLight':
object = new PointLight( data.color, data.intensity, data.distance, data.decay );
break;
case 'RectAreaLight':
object = new RectAreaLight( data.color, data.intensity, data.width, data.height );
break;
case 'SpotLight':
object = new SpotLight( data.color, data.intensity, data.distance, data.angle, data.penumbra, data.decay );
break;
case 'HemisphereLight':
object = new HemisphereLight( data.color, data.groundColor, data.intensity );
break;
case 'SkinnedMesh':
console.warn( 'THREE.ObjectLoader.parseObject() does not support SkinnedMesh yet.' );
case 'Mesh':
var geometry = getGeometry( data.geometry );
var material = getMaterial( data.material );
if ( geometry.bones && geometry.bones.length > 0 ) {
object = new SkinnedMesh( geometry, material );
} else {
object = new Mesh( geometry, material );
}
if ( data.drawMode !== undefined ) object.setDrawMode( data.drawMode );
break;
case 'LOD':
object = new LOD();
break;
case 'Line':
object = new Line( getGeometry( data.geometry ), getMaterial( data.material ), data.mode );
break;
case 'LineLoop':
object = new LineLoop( getGeometry( data.geometry ), getMaterial( data.material ) );
break;
case 'LineSegments':
object = new LineSegments( getGeometry( data.geometry ), getMaterial( data.material ) );
break;
case 'PointCloud':
case 'Points':
object = new Points( getGeometry( data.geometry ), getMaterial( data.material ) );
break;
case 'Sprite':
object = new Sprite( getMaterial( data.material ) );
break;
case 'Group':
object = new Group();
break;
default:
object = new Object3D();
}
object.uuid = data.uuid;
if ( data.name !== undefined ) object.name = data.name;
if ( data.matrix !== undefined ) {
object.matrix.fromArray( data.matrix );
if ( data.matrixAutoUpdate !== undefined ) object.matrixAutoUpdate = data.matrixAutoUpdate;
if ( object.matrixAutoUpdate ) object.matrix.decompose( object.position, object.quaternion, object.scale );
} else {
if ( data.position !== undefined ) object.position.fromArray( data.position );
if ( data.rotation !== undefined ) object.rotation.fromArray( data.rotation );
if ( data.quaternion !== undefined ) object.quaternion.fromArray( data.quaternion );
if ( data.scale !== undefined ) object.scale.fromArray( data.scale );
}
if ( data.castShadow !== undefined ) object.castShadow = data.castShadow;
if ( data.receiveShadow !== undefined ) object.receiveShadow = data.receiveShadow;
if ( data.shadow ) {
if ( data.shadow.bias !== undefined ) object.shadow.bias = data.shadow.bias;
if ( data.shadow.radius !== undefined ) object.shadow.radius = data.shadow.radius;
if ( data.shadow.mapSize !== undefined ) object.shadow.mapSize.fromArray( data.shadow.mapSize );
if ( data.shadow.camera !== undefined ) object.shadow.camera = this.parseObject( data.shadow.camera );
}
if ( data.visible !== undefined ) object.visible = data.visible;
if ( data.frustumCulled !== undefined ) object.frustumCulled = data.frustumCulled;
if ( data.renderOrder !== undefined ) object.renderOrder = data.renderOrder;
if ( data.userData !== undefined ) object.userData = data.userData;
if ( data.layers !== undefined ) object.layers.mask = data.layers;
if ( data.children !== undefined ) {
var children = data.children;
for ( var i = 0; i < children.length; i ++ ) {
object.add( this.parseObject( children[ i ], geometries, materials ) );
}
}
if ( data.type === 'LOD' ) {
var levels = data.levels;
for ( var l = 0; l < levels.length; l ++ ) {
var level = levels[ l ];
var child = object.getObjectByProperty( 'uuid', level.object );
if ( child !== undefined ) {
object.addLevel( child, level.distance );
}
}
}
return object;
}
} );
var TEXTURE_MAPPING = {
UVMapping: UVMapping,
CubeReflectionMapping: CubeReflectionMapping,
CubeRefractionMapping: CubeRefractionMapping,
EquirectangularReflectionMapping: EquirectangularReflectionMapping,
EquirectangularRefractionMapping: EquirectangularRefractionMapping,
SphericalReflectionMapping: SphericalReflectionMapping,
CubeUVReflectionMapping: CubeUVReflectionMapping,
CubeUVRefractionMapping: CubeUVRefractionMapping
};
var TEXTURE_WRAPPING = {
RepeatWrapping: RepeatWrapping,
ClampToEdgeWrapping: ClampToEdgeWrapping,
MirroredRepeatWrapping: MirroredRepeatWrapping
};
var TEXTURE_FILTER = {
NearestFilter: NearestFilter,
NearestMipmapNearestFilter: NearestMipmapNearestFilter,
NearestMipmapLinearFilter: NearestMipmapLinearFilter,
LinearFilter: LinearFilter,
LinearMipmapNearestFilter: LinearMipmapNearestFilter,
LinearMipmapLinearFilter: LinearMipmapLinearFilter
};
export { ObjectLoader };
|
import Modal from '../mixin/modal';
import {$, addClass, append, css, endsWith, hasClass, height, removeClass, trigger, unwrap, wrapAll} from 'uikit-util';
export default {
mixins: [Modal],
args: 'mode',
props: {
mode: String,
flip: Boolean,
overlay: Boolean
},
data: {
mode: 'slide',
flip: false,
overlay: false,
clsPage: 'uk-offcanvas-page',
clsContainer: 'uk-offcanvas-container',
selPanel: '.uk-offcanvas-bar',
clsFlip: 'uk-offcanvas-flip',
clsContainerAnimation: 'uk-offcanvas-container-animation',
clsSidebarAnimation: 'uk-offcanvas-bar-animation',
clsMode: 'uk-offcanvas',
clsOverlay: 'uk-offcanvas-overlay',
selClose: '.uk-offcanvas-close'
},
computed: {
clsFlip({flip, clsFlip}) {
return flip ? clsFlip : '';
},
clsOverlay({overlay, clsOverlay}) {
return overlay ? clsOverlay : '';
},
clsMode({mode, clsMode}) {
return `${clsMode}-${mode}`;
},
clsSidebarAnimation({mode, clsSidebarAnimation}) {
return mode === 'none' || mode === 'reveal' ? '' : clsSidebarAnimation;
},
clsContainerAnimation({mode, clsContainerAnimation}) {
return mode !== 'push' && mode !== 'reveal' ? '' : clsContainerAnimation;
},
transitionElement({mode}) {
return mode === 'reveal' ? this.panel.parentNode : this.panel;
}
},
events: [
{
name: 'click',
delegate() {
return 'a[href^="#"]';
},
handler({current}) {
if (current.hash && $(current.hash, document.body)) {
this.hide();
}
}
},
{
name: 'touchstart',
passive: true,
el() {
return this.panel;
},
handler({targetTouches}) {
if (targetTouches.length === 1) {
this.clientY = targetTouches[0].clientY;
}
}
},
{
name: 'touchmove',
self: true,
passive: false,
filter() {
return this.overlay;
},
handler(e) {
e.cancelable && e.preventDefault();
}
},
{
name: 'touchmove',
passive: false,
el() {
return this.panel;
},
handler(e) {
if (e.targetTouches.length !== 1) {
return;
}
const clientY = event.targetTouches[0].clientY - this.clientY;
const {scrollTop, scrollHeight, clientHeight} = this.panel;
if (clientHeight >= scrollHeight
|| scrollTop === 0 && clientY > 0
|| scrollHeight - scrollTop <= clientHeight && clientY < 0
) {
e.cancelable && e.preventDefault();
}
}
},
{
name: 'show',
self: true,
handler() {
if (this.mode === 'reveal' && !hasClass(this.panel.parentNode, this.clsMode)) {
wrapAll(this.panel, '<div>');
addClass(this.panel.parentNode, this.clsMode);
}
css(document.documentElement, 'overflowY', this.overlay ? 'hidden' : '');
addClass(document.body, this.clsContainer, this.clsFlip);
css(this.$el, 'display', 'block');
addClass(this.$el, this.clsOverlay);
addClass(this.panel, this.clsSidebarAnimation, this.mode !== 'reveal' ? this.clsMode : '');
height(document.body); // force reflow
addClass(document.body, this.clsContainerAnimation);
this.clsContainerAnimation && suppressUserScale();
}
},
{
name: 'hide',
self: true,
handler() {
removeClass(document.body, this.clsContainerAnimation);
const active = this.getActive();
if (this.mode === 'none' || active && active !== this && active !== this.prev) {
trigger(this.panel, 'transitionend');
}
}
},
{
name: 'hidden',
self: true,
handler() {
this.clsContainerAnimation && resumeUserScale();
if (this.mode === 'reveal') {
unwrap(this.panel);
}
removeClass(this.panel, this.clsSidebarAnimation, this.clsMode);
removeClass(this.$el, this.clsOverlay);
css(this.$el, 'display', '');
removeClass(document.body, this.clsContainer, this.clsFlip);
css(document.documentElement, 'overflowY', '');
}
},
{
name: 'swipeLeft swipeRight',
handler(e) {
if (this.isToggled() && endsWith(e.type, 'Left') ^ this.flip) {
this.hide();
}
}
}
]
};
// Chrome in responsive mode zooms page upon opening offcanvas
function suppressUserScale() {
getViewport().content += ',user-scalable=0';
}
function resumeUserScale() {
const viewport = getViewport();
viewport.content = viewport.content.replace(/,user-scalable=0$/, '');
}
function getViewport() {
return $('meta[name="viewport"]', document.head) || append(document.head, '<meta name="viewport">');
}
|
module.exports = {
isGPSEnabled: function (successCallback, errorCallback) {
console.log('run isGPSEnabled')
cordova.exec(successCallback, errorCallback, "GPSCheck", "isGPSEnabled", []);
},
isNetworkEnabled: function (successCallback, errorCallback) {
console.log('run isNetworkEnabled')
cordova.exec(successCallback, errorCallback, "GPSCheck", "isNetworkEnabled", []);
},
isBothEnabled: function (successCallback, errorCallback) {
console.log('run isNetworkEnabled')
cordova.exec(function(networkRes){
cordova.exec(function(gpsresult){
successCallback([gpsresult,networkRes]);
}, errorCallback, "GPSCheck", "isGPSEnabled", []);
}, errorCallback, "GPSCheck", "isNetworkEnabled", []);
},
getLocation: function (successCallback, errorCallback) {
console.log('run getLocation')
cordova.exec(successCallback, errorCallback, "GPSCheck", "getLocation", []);
},
upload : function(args,success, error) {
cordova.exec(success, error, "GPSCheck", "upload", [args]);
}
}; |
import { postJSON } from 'src/js/tools'
import global from 'src/js/global'
export const LOAD_USER_LIST_SUCCESS = 'LOAD_USER_LIST_SUCCESS'
export const LOAD_MANAGERTREE_LIST_SUCCESS = 'LOAD_MANAGERTREE_LIST_SUCCESS'
export const USER_ERROR = 'USER_ERROR'
// 用户列表
export const getUserList = (params) => dispatch => {
return postJSON('/user/queryUser', params)
.then(json => {
if (json.code === global.successCode) {
dispatch({ type: LOAD_USER_LIST_SUCCESS, payload: json.userList.list })
}
return json
})
}
// 新增用户列表
export const addUserList = (params) => dispatch => {
//todo 设置loading
return postJSON('/user/addUser', params)
.then(json => json)
}
// 修改用户
export const modifyUser = (params) => dispatch => {
//todo 设置loading
return postJSON('/user/modifyUser', params)
.then(json => json)
}
// 删除用户列表
export const deleteUserList = (params) => dispatch => {
//todo 设置loading
return postJSON('/user/deleteUser', params)
.then(json => json)
}
//选择部门
export const getManagerTreeList = (params) => dispatch => {
//todo 设置loading
return postJSON('/user/getOrganizationList', params)
.then(json => {
if (json.code === global.successCode) {
dispatch({ type: LOAD_MANAGERTREE_LIST_SUCCESS, payload: json.organizationTreeList })
}
return json
})
}
//获取角色
export const getRoleList = (params) => dispatch => {
//todo 设置loading
return postJSON('/user/getRoleList', params)
.then(json => json)
}
// 修改密码
export const resetPassword = (params) => dispatch => {
return postJSON('/user/resetPassword', { ...params })
.then(json => {
if (json.code !== global.successCode) {
dispatch({ type: ERROR_OCCURED, error: json.message })
}
return json
})
}
// 锁定用户
export const lockUser = (params) => dispatch => {
return postJSON('/user/lockUser', params)
.then(json => json)
}
// 激活用户
export const activeUser = (params) => dispatch => {
return postJSON('/user/activeUser', params)
.then(json => json)
}
// 导出用户
export const exportUsers = (params) => dispatch => {
return postJSON('/user/exportUserExcel', params, {}, 'GET')
.then(json => json)
}
|
const PersistentObject = require('../src/persistent-cache-object');
const fs = require('fs');
const assert = require('assert');
const map = new PersistentObject('./map.db', null, {'disableInterval': true});
const myArgs = process.argv.slice(2);
const something = myArgs[0] ? myArgs[0] : Math.floor(Math.random() * 100);
map.lock(10000, () => {
map.reload();
map[something] = something;
map.flush();
map.unlock();
});
|
/*!
* Copyright (c) 2017 ~ present NAVER Corp.
* billboard.js project is licensed under the MIT license
*
* billboard.js, JavaScript chart library
* https://naver.github.io/billboard.js/
*
* @version 3.3.2
* @requires billboard.js
* @summary billboard.js plugin
*/
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define("bb", [], factory);
else if(typeof exports === 'object')
exports["bb"] = factory();
else
root["bb"] = root["bb"] || {}, root["bb"]["plugin"] = root["bb"]["plugin"] || {}, root["bb"]["plugin"]["bubblecompare"] = factory();
})(this, function() {
return /******/ (function() { // webpackBootstrap
/******/ var __webpack_modules__ = ([
/* 0 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
__webpack_require__(1);
__webpack_require__(86);
__webpack_require__(87);
__webpack_require__(88);
__webpack_require__(89);
__webpack_require__(90);
__webpack_require__(91);
__webpack_require__(92);
__webpack_require__(93);
__webpack_require__(94);
__webpack_require__(95);
__webpack_require__(96);
__webpack_require__(97);
__webpack_require__(98);
__webpack_require__(99);
__webpack_require__(100);
__webpack_require__(109);
__webpack_require__(111);
__webpack_require__(120);
__webpack_require__(121);
__webpack_require__(123);
__webpack_require__(125);
__webpack_require__(127);
__webpack_require__(129);
__webpack_require__(131);
__webpack_require__(132);
__webpack_require__(133);
__webpack_require__(134);
__webpack_require__(136);
__webpack_require__(137);
__webpack_require__(139);
__webpack_require__(143);
__webpack_require__(144);
__webpack_require__(145);
__webpack_require__(146);
__webpack_require__(150);
__webpack_require__(151);
__webpack_require__(153);
__webpack_require__(154);
__webpack_require__(155);
__webpack_require__(158);
__webpack_require__(159);
__webpack_require__(160);
__webpack_require__(161);
__webpack_require__(162);
__webpack_require__(167);
__webpack_require__(169);
__webpack_require__(170);
__webpack_require__(171);
__webpack_require__(172);
__webpack_require__(179);
__webpack_require__(181);
__webpack_require__(184);
__webpack_require__(185);
__webpack_require__(186);
__webpack_require__(187);
__webpack_require__(188);
__webpack_require__(189);
__webpack_require__(193);
__webpack_require__(194);
__webpack_require__(196);
__webpack_require__(197);
__webpack_require__(198);
__webpack_require__(200);
__webpack_require__(201);
__webpack_require__(202);
__webpack_require__(203);
__webpack_require__(204);
__webpack_require__(205);
__webpack_require__(212);
__webpack_require__(214);
__webpack_require__(215);
__webpack_require__(216);
__webpack_require__(218);
__webpack_require__(219);
__webpack_require__(221);
__webpack_require__(222);
__webpack_require__(224);
__webpack_require__(225);
__webpack_require__(226);
__webpack_require__(228);
__webpack_require__(229);
__webpack_require__(230);
__webpack_require__(231);
__webpack_require__(232);
__webpack_require__(233);
__webpack_require__(234);
__webpack_require__(235);
__webpack_require__(239);
__webpack_require__(240);
__webpack_require__(242);
__webpack_require__(244);
__webpack_require__(245);
__webpack_require__(246);
__webpack_require__(247);
__webpack_require__(248);
__webpack_require__(250);
__webpack_require__(252);
__webpack_require__(253);
__webpack_require__(254);
__webpack_require__(255);
__webpack_require__(257);
__webpack_require__(258);
__webpack_require__(260);
__webpack_require__(261);
__webpack_require__(262);
__webpack_require__(263);
__webpack_require__(265);
__webpack_require__(266);
__webpack_require__(267);
__webpack_require__(268);
__webpack_require__(269);
__webpack_require__(270);
__webpack_require__(271);
__webpack_require__(272);
__webpack_require__(274);
__webpack_require__(275);
__webpack_require__(276);
__webpack_require__(277);
__webpack_require__(278);
__webpack_require__(279);
__webpack_require__(280);
__webpack_require__(281);
__webpack_require__(282);
__webpack_require__(283);
__webpack_require__(285);
__webpack_require__(286);
__webpack_require__(287);
__webpack_require__(288);
__webpack_require__(302);
__webpack_require__(303);
__webpack_require__(304);
__webpack_require__(305);
__webpack_require__(306);
__webpack_require__(307);
__webpack_require__(308);
__webpack_require__(309);
__webpack_require__(311);
__webpack_require__(312);
__webpack_require__(313);
__webpack_require__(314);
__webpack_require__(315);
__webpack_require__(316);
__webpack_require__(317);
__webpack_require__(318);
__webpack_require__(319);
__webpack_require__(320);
__webpack_require__(326);
__webpack_require__(327);
__webpack_require__(329);
__webpack_require__(330);
__webpack_require__(331);
__webpack_require__(332);
__webpack_require__(333);
__webpack_require__(334);
__webpack_require__(335);
__webpack_require__(337);
__webpack_require__(340);
__webpack_require__(341);
__webpack_require__(342);
__webpack_require__(343);
__webpack_require__(347);
__webpack_require__(348);
__webpack_require__(350);
__webpack_require__(351);
__webpack_require__(352);
__webpack_require__(353);
__webpack_require__(355);
__webpack_require__(356);
__webpack_require__(357);
__webpack_require__(358);
__webpack_require__(359);
__webpack_require__(360);
__webpack_require__(362);
__webpack_require__(363);
__webpack_require__(364);
__webpack_require__(367);
__webpack_require__(368);
__webpack_require__(369);
__webpack_require__(370);
__webpack_require__(371);
__webpack_require__(372);
__webpack_require__(373);
__webpack_require__(374);
__webpack_require__(375);
__webpack_require__(376);
__webpack_require__(377);
__webpack_require__(378);
__webpack_require__(379);
__webpack_require__(385);
__webpack_require__(386);
__webpack_require__(387);
__webpack_require__(388);
__webpack_require__(389);
__webpack_require__(390);
__webpack_require__(391);
__webpack_require__(392);
__webpack_require__(393);
__webpack_require__(394);
__webpack_require__(395);
__webpack_require__(396);
__webpack_require__(397);
__webpack_require__(401);
__webpack_require__(402);
__webpack_require__(403);
__webpack_require__(404);
__webpack_require__(405);
__webpack_require__(406);
__webpack_require__(407);
__webpack_require__(408);
__webpack_require__(409);
__webpack_require__(410);
__webpack_require__(411);
__webpack_require__(412);
__webpack_require__(413);
__webpack_require__(414);
__webpack_require__(415);
__webpack_require__(416);
__webpack_require__(417);
__webpack_require__(418);
__webpack_require__(419);
__webpack_require__(420);
__webpack_require__(421);
__webpack_require__(422);
__webpack_require__(423);
__webpack_require__(425);
__webpack_require__(426);
__webpack_require__(428);
__webpack_require__(429);
__webpack_require__(432);
__webpack_require__(433);
__webpack_require__(436);
__webpack_require__(437);
__webpack_require__(438);
__webpack_require__(439);
__webpack_require__(440);
__webpack_require__(441);
__webpack_require__(442);
__webpack_require__(446);
__webpack_require__(445);
/* unused reexport */ __webpack_require__(79);
/***/ }),
/* 1 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var getBuiltIn = __webpack_require__(21);
var apply = __webpack_require__(64);
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var IS_PURE = __webpack_require__(33);
var DESCRIPTORS = __webpack_require__(5);
var NATIVE_SYMBOL = __webpack_require__(24);
var fails = __webpack_require__(6);
var hasOwn = __webpack_require__(36);
var isArray = __webpack_require__(65);
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var isPrototypeOf = __webpack_require__(22);
var isSymbol = __webpack_require__(20);
var anObject = __webpack_require__(44);
var toObject = __webpack_require__(37);
var toIndexedObject = __webpack_require__(11);
var toPropertyKey = __webpack_require__(16);
var $toString = __webpack_require__(66);
var createPropertyDescriptor = __webpack_require__(10);
var nativeObjectCreate = __webpack_require__(69);
var objectKeys = __webpack_require__(71);
var getOwnPropertyNamesModule = __webpack_require__(54);
var getOwnPropertyNamesExternal = __webpack_require__(73);
var getOwnPropertySymbolsModule = __webpack_require__(62);
var getOwnPropertyDescriptorModule = __webpack_require__(4);
var definePropertyModule = __webpack_require__(42);
var definePropertiesModule = __webpack_require__(70);
var propertyIsEnumerableModule = __webpack_require__(9);
var arraySlice = __webpack_require__(76);
var redefine = __webpack_require__(45);
var shared = __webpack_require__(32);
var sharedKey = __webpack_require__(49);
var hiddenKeys = __webpack_require__(50);
var uid = __webpack_require__(38);
var wellKnownSymbol = __webpack_require__(31);
var wrappedWellKnownSymbolModule = __webpack_require__(77);
var defineWellKnownSymbol = __webpack_require__(78);
var setToStringTag = __webpack_require__(80);
var InternalStateModule = __webpack_require__(47);
var $forEach = (__webpack_require__(81).forEach);
var HIDDEN = sharedKey('hidden');
var SYMBOL = 'Symbol';
var PROTOTYPE = 'prototype';
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(SYMBOL);
var ObjectPrototype = Object[PROTOTYPE];
var $Symbol = global.Symbol;
var SymbolPrototype = $Symbol && $Symbol[PROTOTYPE];
var TypeError = global.TypeError;
var QObject = global.QObject;
var $stringify = getBuiltIn('JSON', 'stringify');
var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
var nativeDefineProperty = definePropertyModule.f;
var nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;
var nativePropertyIsEnumerable = propertyIsEnumerableModule.f;
var push = uncurryThis([].push);
var AllSymbols = shared('symbols');
var ObjectPrototypeSymbols = shared('op-symbols');
var StringToSymbolRegistry = shared('string-to-symbol-registry');
var SymbolToStringRegistry = shared('symbol-to-string-registry');
var WellKnownSymbolsStore = shared('wks');
// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173
var USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687
var setSymbolDescriptor = DESCRIPTORS && fails(function () {
return nativeObjectCreate(nativeDefineProperty({}, 'a', {
get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; }
})).a != 7;
}) ? function (O, P, Attributes) {
var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);
if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];
nativeDefineProperty(O, P, Attributes);
if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {
nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);
}
} : nativeDefineProperty;
var wrap = function (tag, description) {
var symbol = AllSymbols[tag] = nativeObjectCreate(SymbolPrototype);
setInternalState(symbol, {
type: SYMBOL,
tag: tag,
description: description
});
if (!DESCRIPTORS) symbol.description = description;
return symbol;
};
var $defineProperty = function defineProperty(O, P, Attributes) {
if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);
anObject(O);
var key = toPropertyKey(P);
anObject(Attributes);
if (hasOwn(AllSymbols, key)) {
if (!Attributes.enumerable) {
if (!hasOwn(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {}));
O[HIDDEN][key] = true;
} else {
if (hasOwn(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;
Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });
} return setSymbolDescriptor(O, key, Attributes);
} return nativeDefineProperty(O, key, Attributes);
};
var $defineProperties = function defineProperties(O, Properties) {
anObject(O);
var properties = toIndexedObject(Properties);
var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));
$forEach(keys, function (key) {
if (!DESCRIPTORS || call($propertyIsEnumerable, properties, key)) $defineProperty(O, key, properties[key]);
});
return O;
};
var $create = function create(O, Properties) {
return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);
};
var $propertyIsEnumerable = function propertyIsEnumerable(V) {
var P = toPropertyKey(V);
var enumerable = call(nativePropertyIsEnumerable, this, P);
if (this === ObjectPrototype && hasOwn(AllSymbols, P) && !hasOwn(ObjectPrototypeSymbols, P)) return false;
return enumerable || !hasOwn(this, P) || !hasOwn(AllSymbols, P) || hasOwn(this, HIDDEN) && this[HIDDEN][P]
? enumerable : true;
};
var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {
var it = toIndexedObject(O);
var key = toPropertyKey(P);
if (it === ObjectPrototype && hasOwn(AllSymbols, key) && !hasOwn(ObjectPrototypeSymbols, key)) return;
var descriptor = nativeGetOwnPropertyDescriptor(it, key);
if (descriptor && hasOwn(AllSymbols, key) && !(hasOwn(it, HIDDEN) && it[HIDDEN][key])) {
descriptor.enumerable = true;
}
return descriptor;
};
var $getOwnPropertyNames = function getOwnPropertyNames(O) {
var names = nativeGetOwnPropertyNames(toIndexedObject(O));
var result = [];
$forEach(names, function (key) {
if (!hasOwn(AllSymbols, key) && !hasOwn(hiddenKeys, key)) push(result, key);
});
return result;
};
var $getOwnPropertySymbols = function getOwnPropertySymbols(O) {
var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;
var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));
var result = [];
$forEach(names, function (key) {
if (hasOwn(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || hasOwn(ObjectPrototype, key))) {
push(result, AllSymbols[key]);
}
});
return result;
};
// `Symbol` constructor
// https://tc39.es/ecma262/#sec-symbol-constructor
if (!NATIVE_SYMBOL) {
$Symbol = function Symbol() {
if (isPrototypeOf(SymbolPrototype, this)) throw TypeError('Symbol is not a constructor');
var description = !arguments.length || arguments[0] === undefined ? undefined : $toString(arguments[0]);
var tag = uid(description);
var setter = function (value) {
if (this === ObjectPrototype) call(setter, ObjectPrototypeSymbols, value);
if (hasOwn(this, HIDDEN) && hasOwn(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value));
};
if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });
return wrap(tag, description);
};
SymbolPrototype = $Symbol[PROTOTYPE];
redefine(SymbolPrototype, 'toString', function toString() {
return getInternalState(this).tag;
});
redefine($Symbol, 'withoutSetter', function (description) {
return wrap(uid(description), description);
});
propertyIsEnumerableModule.f = $propertyIsEnumerable;
definePropertyModule.f = $defineProperty;
definePropertiesModule.f = $defineProperties;
getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;
getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;
getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;
wrappedWellKnownSymbolModule.f = function (name) {
return wrap(wellKnownSymbol(name), name);
};
if (DESCRIPTORS) {
// https://github.com/tc39/proposal-Symbol-description
nativeDefineProperty(SymbolPrototype, 'description', {
configurable: true,
get: function description() {
return getInternalState(this).description;
}
});
if (!IS_PURE) {
redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });
}
}
}
$({ global: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, {
Symbol: $Symbol
});
$forEach(objectKeys(WellKnownSymbolsStore), function (name) {
defineWellKnownSymbol(name);
});
$({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, {
// `Symbol.for` method
// https://tc39.es/ecma262/#sec-symbol.for
'for': function (key) {
var string = $toString(key);
if (hasOwn(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];
var symbol = $Symbol(string);
StringToSymbolRegistry[string] = symbol;
SymbolToStringRegistry[symbol] = string;
return symbol;
},
// `Symbol.keyFor` method
// https://tc39.es/ecma262/#sec-symbol.keyfor
keyFor: function keyFor(sym) {
if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol');
if (hasOwn(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];
},
useSetter: function () { USE_SETTER = true; },
useSimple: function () { USE_SETTER = false; }
});
$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, {
// `Object.create` method
// https://tc39.es/ecma262/#sec-object.create
create: $create,
// `Object.defineProperty` method
// https://tc39.es/ecma262/#sec-object.defineproperty
defineProperty: $defineProperty,
// `Object.defineProperties` method
// https://tc39.es/ecma262/#sec-object.defineproperties
defineProperties: $defineProperties,
// `Object.getOwnPropertyDescriptor` method
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors
getOwnPropertyDescriptor: $getOwnPropertyDescriptor
});
$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, {
// `Object.getOwnPropertyNames` method
// https://tc39.es/ecma262/#sec-object.getownpropertynames
getOwnPropertyNames: $getOwnPropertyNames,
// `Object.getOwnPropertySymbols` method
// https://tc39.es/ecma262/#sec-object.getownpropertysymbols
getOwnPropertySymbols: $getOwnPropertySymbols
});
// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives
// https://bugs.chromium.org/p/v8/issues/detail?id=3443
$({ target: 'Object', stat: true, forced: fails(function () { getOwnPropertySymbolsModule.f(1); }) }, {
getOwnPropertySymbols: function getOwnPropertySymbols(it) {
return getOwnPropertySymbolsModule.f(toObject(it));
}
});
// `JSON.stringify` method behavior with symbols
// https://tc39.es/ecma262/#sec-json.stringify
if ($stringify) {
var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL || fails(function () {
var symbol = $Symbol();
// MS Edge converts symbol values to JSON as {}
return $stringify([symbol]) != '[null]'
// WebKit converts symbol values to JSON as null
|| $stringify({ a: symbol }) != '{}'
// V8 throws on boxed symbols
|| $stringify(Object(symbol)) != '{}';
});
$({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
stringify: function stringify(it, replacer, space) {
var args = arraySlice(arguments);
var $replacer = replacer;
if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined
if (!isArray(replacer)) replacer = function (key, value) {
if (isCallable($replacer)) value = call($replacer, this, key, value);
if (!isSymbol(value)) return value;
};
args[1] = replacer;
return apply($stringify, null, args);
}
});
}
// `Symbol.prototype[@@toPrimitive]` method
// https://tc39.es/ecma262/#sec-symbol.prototype-@@toprimitive
if (!SymbolPrototype[TO_PRIMITIVE]) {
var valueOf = SymbolPrototype.valueOf;
// eslint-disable-next-line no-unused-vars -- required for .length
redefine(SymbolPrototype, TO_PRIMITIVE, function (hint) {
// TODO: improve hint logic
return call(valueOf, this);
});
}
// `Symbol.prototype[@@toStringTag]` property
// https://tc39.es/ecma262/#sec-symbol.prototype-@@tostringtag
setToStringTag($Symbol, SYMBOL);
hiddenKeys[HIDDEN] = true;
/***/ }),
/* 2 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
var createNonEnumerableProperty = __webpack_require__(41);
var redefine = __webpack_require__(45);
var setGlobal = __webpack_require__(35);
var copyConstructorProperties = __webpack_require__(52);
var isForced = __webpack_require__(63);
/*
options.target - name of the target object
options.global - target is the global object
options.stat - export as static methods of target
options.proto - export as prototype methods of target
options.real - real prototype method for the `pure` version
options.forced - export even if the native feature is available
options.bind - bind methods to the target, required for the `pure` version
options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
options.unsafe - use the simple assignment of property instead of delete + defineProperty
options.sham - add a flag to not completely full polyfills
options.enumerable - export as enumerable property
options.noTargetGet - prevent calling a getter on target
options.name - the .name of the function if it does not match the key
*/
module.exports = function (options, source) {
var TARGET = options.target;
var GLOBAL = options.global;
var STATIC = options.stat;
var FORCED, target, key, targetProperty, sourceProperty, descriptor;
if (GLOBAL) {
target = global;
} else if (STATIC) {
target = global[TARGET] || setGlobal(TARGET, {});
} else {
target = (global[TARGET] || {}).prototype;
}
if (target) for (key in source) {
sourceProperty = source[key];
if (options.noTargetGet) {
descriptor = getOwnPropertyDescriptor(target, key);
targetProperty = descriptor && descriptor.value;
} else targetProperty = target[key];
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
// contained in target
if (!FORCED && targetProperty !== undefined) {
if (typeof sourceProperty == typeof targetProperty) continue;
copyConstructorProperties(sourceProperty, targetProperty);
}
// add a flag to not completely full polyfills
if (options.sham || (targetProperty && targetProperty.sham)) {
createNonEnumerableProperty(sourceProperty, 'sham', true);
}
// extend global
redefine(target, key, sourceProperty, options);
}
};
/***/ }),
/* 3 */
/***/ (function(module) {
var check = function (it) {
return it && it.Math == Math && it;
};
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
module.exports =
// eslint-disable-next-line es/no-global-this -- safe
check(typeof globalThis == 'object' && globalThis) ||
check(typeof window == 'object' && window) ||
// eslint-disable-next-line no-restricted-globals -- safe
check(typeof self == 'object' && self) ||
check(typeof global == 'object' && global) ||
// eslint-disable-next-line no-new-func -- fallback
(function () { return this; })() || Function('return this')();
/***/ }),
/* 4 */
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var call = __webpack_require__(7);
var propertyIsEnumerableModule = __webpack_require__(9);
var createPropertyDescriptor = __webpack_require__(10);
var toIndexedObject = __webpack_require__(11);
var toPropertyKey = __webpack_require__(16);
var hasOwn = __webpack_require__(36);
var IE8_DOM_DEFINE = __webpack_require__(39);
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
// `Object.getOwnPropertyDescriptor` method
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
O = toIndexedObject(O);
P = toPropertyKey(P);
if (IE8_DOM_DEFINE) try {
return $getOwnPropertyDescriptor(O, P);
} catch (error) { /* empty */ }
if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
};
/***/ }),
/* 5 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
// Detect IE8's incomplete defineProperty implementation
module.exports = !fails(function () {
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;
});
/***/ }),
/* 6 */
/***/ (function(module) {
module.exports = function (exec) {
try {
return !!exec();
} catch (error) {
return true;
}
};
/***/ }),
/* 7 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var NATIVE_BIND = __webpack_require__(8);
var call = Function.prototype.call;
module.exports = NATIVE_BIND ? call.bind(call) : function () {
return call.apply(call, arguments);
};
/***/ }),
/* 8 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
module.exports = !fails(function () {
var test = (function () { /* empty */ }).bind();
// eslint-disable-next-line no-prototype-builtins -- safe
return typeof test != 'function' || test.hasOwnProperty('prototype');
});
/***/ }),
/* 9 */
/***/ (function(__unused_webpack_module, exports) {
"use strict";
var $propertyIsEnumerable = {}.propertyIsEnumerable;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
// Nashorn ~ JDK8 bug
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
// `Object.prototype.propertyIsEnumerable` method implementation
// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
var descriptor = getOwnPropertyDescriptor(this, V);
return !!descriptor && descriptor.enumerable;
} : $propertyIsEnumerable;
/***/ }),
/* 10 */
/***/ (function(module) {
module.exports = function (bitmap, value) {
return {
enumerable: !(bitmap & 1),
configurable: !(bitmap & 2),
writable: !(bitmap & 4),
value: value
};
};
/***/ }),
/* 11 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// toObject with fallback for non-array-like ES3 strings
var IndexedObject = __webpack_require__(12);
var requireObjectCoercible = __webpack_require__(15);
module.exports = function (it) {
return IndexedObject(requireObjectCoercible(it));
};
/***/ }),
/* 12 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var classof = __webpack_require__(14);
var Object = global.Object;
var split = uncurryThis(''.split);
// fallback for non-array-like ES3 and non-enumerable old V8 strings
module.exports = fails(function () {
// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
// eslint-disable-next-line no-prototype-builtins -- safe
return !Object('z').propertyIsEnumerable(0);
}) ? function (it) {
return classof(it) == 'String' ? split(it, '') : Object(it);
} : Object;
/***/ }),
/* 13 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var NATIVE_BIND = __webpack_require__(8);
var FunctionPrototype = Function.prototype;
var bind = FunctionPrototype.bind;
var call = FunctionPrototype.call;
var uncurryThis = NATIVE_BIND && bind.bind(call, call);
module.exports = NATIVE_BIND ? function (fn) {
return fn && uncurryThis(fn);
} : function (fn) {
return fn && function () {
return call.apply(fn, arguments);
};
};
/***/ }),
/* 14 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var toString = uncurryThis({}.toString);
var stringSlice = uncurryThis(''.slice);
module.exports = function (it) {
return stringSlice(toString(it), 8, -1);
};
/***/ }),
/* 15 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var TypeError = global.TypeError;
// `RequireObjectCoercible` abstract operation
// https://tc39.es/ecma262/#sec-requireobjectcoercible
module.exports = function (it) {
if (it == undefined) throw TypeError("Can't call method on " + it);
return it;
};
/***/ }),
/* 16 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var toPrimitive = __webpack_require__(17);
var isSymbol = __webpack_require__(20);
// `ToPropertyKey` abstract operation
// https://tc39.es/ecma262/#sec-topropertykey
module.exports = function (argument) {
var key = toPrimitive(argument, 'string');
return isSymbol(key) ? key : key + '';
};
/***/ }),
/* 17 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var isObject = __webpack_require__(18);
var isSymbol = __webpack_require__(20);
var getMethod = __webpack_require__(27);
var ordinaryToPrimitive = __webpack_require__(30);
var wellKnownSymbol = __webpack_require__(31);
var TypeError = global.TypeError;
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
// `ToPrimitive` abstract operation
// https://tc39.es/ecma262/#sec-toprimitive
module.exports = function (input, pref) {
if (!isObject(input) || isSymbol(input)) return input;
var exoticToPrim = getMethod(input, TO_PRIMITIVE);
var result;
if (exoticToPrim) {
if (pref === undefined) pref = 'default';
result = call(exoticToPrim, input, pref);
if (!isObject(result) || isSymbol(result)) return result;
throw TypeError("Can't convert object to primitive value");
}
if (pref === undefined) pref = 'number';
return ordinaryToPrimitive(input, pref);
};
/***/ }),
/* 18 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var isCallable = __webpack_require__(19);
module.exports = function (it) {
return typeof it == 'object' ? it !== null : isCallable(it);
};
/***/ }),
/* 19 */
/***/ (function(module) {
// `IsCallable` abstract operation
// https://tc39.es/ecma262/#sec-iscallable
module.exports = function (argument) {
return typeof argument == 'function';
};
/***/ }),
/* 20 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var getBuiltIn = __webpack_require__(21);
var isCallable = __webpack_require__(19);
var isPrototypeOf = __webpack_require__(22);
var USE_SYMBOL_AS_UID = __webpack_require__(23);
var Object = global.Object;
module.exports = USE_SYMBOL_AS_UID ? function (it) {
return typeof it == 'symbol';
} : function (it) {
var $Symbol = getBuiltIn('Symbol');
return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, Object(it));
};
/***/ }),
/* 21 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isCallable = __webpack_require__(19);
var aFunction = function (argument) {
return isCallable(argument) ? argument : undefined;
};
module.exports = function (namespace, method) {
return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];
};
/***/ }),
/* 22 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
module.exports = uncurryThis({}.isPrototypeOf);
/***/ }),
/* 23 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
/* eslint-disable es/no-symbol -- required for testing */
var NATIVE_SYMBOL = __webpack_require__(24);
module.exports = NATIVE_SYMBOL
&& !Symbol.sham
&& typeof Symbol.iterator == 'symbol';
/***/ }),
/* 24 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
/* eslint-disable es/no-symbol -- required for testing */
var V8_VERSION = __webpack_require__(25);
var fails = __webpack_require__(6);
// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
var symbol = Symbol();
// Chrome 38 Symbol has incorrect toString conversion
// `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
return !String(symbol) || !(Object(symbol) instanceof Symbol) ||
// Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
!Symbol.sham && V8_VERSION && V8_VERSION < 41;
});
/***/ }),
/* 25 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var userAgent = __webpack_require__(26);
var process = global.process;
var Deno = global.Deno;
var versions = process && process.versions || Deno && Deno.version;
var v8 = versions && versions.v8;
var match, version;
if (v8) {
match = v8.split('.');
// in old Chrome, versions of V8 isn't V8 = Chrome / 10
// but their correct versions are not interesting for us
version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
}
// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
// so check `userAgent` even if `.v8` exists, but 0
if (!version && userAgent) {
match = userAgent.match(/Edge\/(\d+)/);
if (!match || match[1] >= 74) {
match = userAgent.match(/Chrome\/(\d+)/);
if (match) version = +match[1];
}
}
module.exports = version;
/***/ }),
/* 26 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var getBuiltIn = __webpack_require__(21);
module.exports = getBuiltIn('navigator', 'userAgent') || '';
/***/ }),
/* 27 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var aCallable = __webpack_require__(28);
// `GetMethod` abstract operation
// https://tc39.es/ecma262/#sec-getmethod
module.exports = function (V, P) {
var func = V[P];
return func == null ? undefined : aCallable(func);
};
/***/ }),
/* 28 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isCallable = __webpack_require__(19);
var tryToString = __webpack_require__(29);
var TypeError = global.TypeError;
// `Assert: IsCallable(argument) is true`
module.exports = function (argument) {
if (isCallable(argument)) return argument;
throw TypeError(tryToString(argument) + ' is not a function');
};
/***/ }),
/* 29 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var String = global.String;
module.exports = function (argument) {
try {
return String(argument);
} catch (error) {
return 'Object';
}
};
/***/ }),
/* 30 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var TypeError = global.TypeError;
// `OrdinaryToPrimitive` abstract operation
// https://tc39.es/ecma262/#sec-ordinarytoprimitive
module.exports = function (input, pref) {
var fn, val;
if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
throw TypeError("Can't convert object to primitive value");
};
/***/ }),
/* 31 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var shared = __webpack_require__(32);
var hasOwn = __webpack_require__(36);
var uid = __webpack_require__(38);
var NATIVE_SYMBOL = __webpack_require__(24);
var USE_SYMBOL_AS_UID = __webpack_require__(23);
var WellKnownSymbolsStore = shared('wks');
var Symbol = global.Symbol;
var symbolFor = Symbol && Symbol['for'];
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
module.exports = function (name) {
if (!hasOwn(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
var description = 'Symbol.' + name;
if (NATIVE_SYMBOL && hasOwn(Symbol, name)) {
WellKnownSymbolsStore[name] = Symbol[name];
} else if (USE_SYMBOL_AS_UID && symbolFor) {
WellKnownSymbolsStore[name] = symbolFor(description);
} else {
WellKnownSymbolsStore[name] = createWellKnownSymbol(description);
}
} return WellKnownSymbolsStore[name];
};
/***/ }),
/* 32 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var IS_PURE = __webpack_require__(33);
var store = __webpack_require__(34);
(module.exports = function (key, value) {
return store[key] || (store[key] = value !== undefined ? value : {});
})('versions', []).push({
version: '3.21.0',
mode: IS_PURE ? 'pure' : 'global',
copyright: '© 2014-2022 Denis Pushkarev (zloirock.ru)',
license: 'https://github.com/zloirock/core-js/blob/v3.21.0/LICENSE',
source: 'https://github.com/zloirock/core-js'
});
/***/ }),
/* 33 */
/***/ (function(module) {
module.exports = false;
/***/ }),
/* 34 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var setGlobal = __webpack_require__(35);
var SHARED = '__core-js_shared__';
var store = global[SHARED] || setGlobal(SHARED, {});
module.exports = store;
/***/ }),
/* 35 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
// eslint-disable-next-line es/no-object-defineproperty -- safe
var defineProperty = Object.defineProperty;
module.exports = function (key, value) {
try {
defineProperty(global, key, { value: value, configurable: true, writable: true });
} catch (error) {
global[key] = value;
} return value;
};
/***/ }),
/* 36 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var toObject = __webpack_require__(37);
var hasOwnProperty = uncurryThis({}.hasOwnProperty);
// `HasOwnProperty` abstract operation
// https://tc39.es/ecma262/#sec-hasownproperty
module.exports = Object.hasOwn || function hasOwn(it, key) {
return hasOwnProperty(toObject(it), key);
};
/***/ }),
/* 37 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var requireObjectCoercible = __webpack_require__(15);
var Object = global.Object;
// `ToObject` abstract operation
// https://tc39.es/ecma262/#sec-toobject
module.exports = function (argument) {
return Object(requireObjectCoercible(argument));
};
/***/ }),
/* 38 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var id = 0;
var postfix = Math.random();
var toString = uncurryThis(1.0.toString);
module.exports = function (key) {
return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
};
/***/ }),
/* 39 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var fails = __webpack_require__(6);
var createElement = __webpack_require__(40);
// Thanks to IE8 for its funny defineProperty
module.exports = !DESCRIPTORS && !fails(function () {
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
return Object.defineProperty(createElement('div'), 'a', {
get: function () { return 7; }
}).a != 7;
});
/***/ }),
/* 40 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isObject = __webpack_require__(18);
var document = global.document;
// typeof document.createElement is 'object' in old IE
var EXISTS = isObject(document) && isObject(document.createElement);
module.exports = function (it) {
return EXISTS ? document.createElement(it) : {};
};
/***/ }),
/* 41 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var definePropertyModule = __webpack_require__(42);
var createPropertyDescriptor = __webpack_require__(10);
module.exports = DESCRIPTORS ? function (object, key, value) {
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
} : function (object, key, value) {
object[key] = value;
return object;
};
/***/ }),
/* 42 */
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
var global = __webpack_require__(3);
var DESCRIPTORS = __webpack_require__(5);
var IE8_DOM_DEFINE = __webpack_require__(39);
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(43);
var anObject = __webpack_require__(44);
var toPropertyKey = __webpack_require__(16);
var TypeError = global.TypeError;
// eslint-disable-next-line es/no-object-defineproperty -- safe
var $defineProperty = Object.defineProperty;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
var ENUMERABLE = 'enumerable';
var CONFIGURABLE = 'configurable';
var WRITABLE = 'writable';
// `Object.defineProperty` method
// https://tc39.es/ecma262/#sec-object.defineproperty
exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
anObject(O);
P = toPropertyKey(P);
anObject(Attributes);
if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
var current = $getOwnPropertyDescriptor(O, P);
if (current && current[WRITABLE]) {
O[P] = Attributes.value;
Attributes = {
configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
writable: false
};
}
} return $defineProperty(O, P, Attributes);
} : $defineProperty : function defineProperty(O, P, Attributes) {
anObject(O);
P = toPropertyKey(P);
anObject(Attributes);
if (IE8_DOM_DEFINE) try {
return $defineProperty(O, P, Attributes);
} catch (error) { /* empty */ }
if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
if ('value' in Attributes) O[P] = Attributes.value;
return O;
};
/***/ }),
/* 43 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var fails = __webpack_require__(6);
// V8 ~ Chrome 36-
// https://bugs.chromium.org/p/v8/issues/detail?id=3334
module.exports = DESCRIPTORS && fails(function () {
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
return Object.defineProperty(function () { /* empty */ }, 'prototype', {
value: 42,
writable: false
}).prototype != 42;
});
/***/ }),
/* 44 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isObject = __webpack_require__(18);
var String = global.String;
var TypeError = global.TypeError;
// `Assert: Type(argument) is Object`
module.exports = function (argument) {
if (isObject(argument)) return argument;
throw TypeError(String(argument) + ' is not an object');
};
/***/ }),
/* 45 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isCallable = __webpack_require__(19);
var hasOwn = __webpack_require__(36);
var createNonEnumerableProperty = __webpack_require__(41);
var setGlobal = __webpack_require__(35);
var inspectSource = __webpack_require__(46);
var InternalStateModule = __webpack_require__(47);
var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(51).CONFIGURABLE);
var getInternalState = InternalStateModule.get;
var enforceInternalState = InternalStateModule.enforce;
var TEMPLATE = String(String).split('String');
(module.exports = function (O, key, value, options) {
var unsafe = options ? !!options.unsafe : false;
var simple = options ? !!options.enumerable : false;
var noTargetGet = options ? !!options.noTargetGet : false;
var name = options && options.name !== undefined ? options.name : key;
var state;
if (isCallable(value)) {
if (String(name).slice(0, 7) === 'Symbol(') {
name = '[' + String(name).replace(/^Symbol\(([^)]*)\)/, '$1') + ']';
}
if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
createNonEnumerableProperty(value, 'name', name);
}
state = enforceInternalState(value);
if (!state.source) {
state.source = TEMPLATE.join(typeof name == 'string' ? name : '');
}
}
if (O === global) {
if (simple) O[key] = value;
else setGlobal(key, value);
return;
} else if (!unsafe) {
delete O[key];
} else if (!noTargetGet && O[key]) {
simple = true;
}
if (simple) O[key] = value;
else createNonEnumerableProperty(O, key, value);
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
})(Function.prototype, 'toString', function toString() {
return isCallable(this) && getInternalState(this).source || inspectSource(this);
});
/***/ }),
/* 46 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var isCallable = __webpack_require__(19);
var store = __webpack_require__(34);
var functionToString = uncurryThis(Function.toString);
// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
if (!isCallable(store.inspectSource)) {
store.inspectSource = function (it) {
return functionToString(it);
};
}
module.exports = store.inspectSource;
/***/ }),
/* 47 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var NATIVE_WEAK_MAP = __webpack_require__(48);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var isObject = __webpack_require__(18);
var createNonEnumerableProperty = __webpack_require__(41);
var hasOwn = __webpack_require__(36);
var shared = __webpack_require__(34);
var sharedKey = __webpack_require__(49);
var hiddenKeys = __webpack_require__(50);
var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
var TypeError = global.TypeError;
var WeakMap = global.WeakMap;
var set, get, has;
var enforce = function (it) {
return has(it) ? get(it) : set(it, {});
};
var getterFor = function (TYPE) {
return function (it) {
var state;
if (!isObject(it) || (state = get(it)).type !== TYPE) {
throw TypeError('Incompatible receiver, ' + TYPE + ' required');
} return state;
};
};
if (NATIVE_WEAK_MAP || shared.state) {
var store = shared.state || (shared.state = new WeakMap());
var wmget = uncurryThis(store.get);
var wmhas = uncurryThis(store.has);
var wmset = uncurryThis(store.set);
set = function (it, metadata) {
if (wmhas(store, it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
wmset(store, it, metadata);
return metadata;
};
get = function (it) {
return wmget(store, it) || {};
};
has = function (it) {
return wmhas(store, it);
};
} else {
var STATE = sharedKey('state');
hiddenKeys[STATE] = true;
set = function (it, metadata) {
if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
metadata.facade = it;
createNonEnumerableProperty(it, STATE, metadata);
return metadata;
};
get = function (it) {
return hasOwn(it, STATE) ? it[STATE] : {};
};
has = function (it) {
return hasOwn(it, STATE);
};
}
module.exports = {
set: set,
get: get,
has: has,
enforce: enforce,
getterFor: getterFor
};
/***/ }),
/* 48 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isCallable = __webpack_require__(19);
var inspectSource = __webpack_require__(46);
var WeakMap = global.WeakMap;
module.exports = isCallable(WeakMap) && /native code/.test(inspectSource(WeakMap));
/***/ }),
/* 49 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var shared = __webpack_require__(32);
var uid = __webpack_require__(38);
var keys = shared('keys');
module.exports = function (key) {
return keys[key] || (keys[key] = uid(key));
};
/***/ }),
/* 50 */
/***/ (function(module) {
module.exports = {};
/***/ }),
/* 51 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var hasOwn = __webpack_require__(36);
var FunctionPrototype = Function.prototype;
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
var EXISTS = hasOwn(FunctionPrototype, 'name');
// additional protection from minified / mangled / dropped function names
var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';
var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
module.exports = {
EXISTS: EXISTS,
PROPER: PROPER,
CONFIGURABLE: CONFIGURABLE
};
/***/ }),
/* 52 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var hasOwn = __webpack_require__(36);
var ownKeys = __webpack_require__(53);
var getOwnPropertyDescriptorModule = __webpack_require__(4);
var definePropertyModule = __webpack_require__(42);
module.exports = function (target, source, exceptions) {
var keys = ownKeys(source);
var defineProperty = definePropertyModule.f;
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
defineProperty(target, key, getOwnPropertyDescriptor(source, key));
}
}
};
/***/ }),
/* 53 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var getBuiltIn = __webpack_require__(21);
var uncurryThis = __webpack_require__(13);
var getOwnPropertyNamesModule = __webpack_require__(54);
var getOwnPropertySymbolsModule = __webpack_require__(62);
var anObject = __webpack_require__(44);
var concat = uncurryThis([].concat);
// all object keys, includes non-enumerable and symbols
module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
var keys = getOwnPropertyNamesModule.f(anObject(it));
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
};
/***/ }),
/* 54 */
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
var internalObjectKeys = __webpack_require__(55);
var enumBugKeys = __webpack_require__(61);
var hiddenKeys = enumBugKeys.concat('length', 'prototype');
// `Object.getOwnPropertyNames` method
// https://tc39.es/ecma262/#sec-object.getownpropertynames
// eslint-disable-next-line es/no-object-getownpropertynames -- safe
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
return internalObjectKeys(O, hiddenKeys);
};
/***/ }),
/* 55 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var hasOwn = __webpack_require__(36);
var toIndexedObject = __webpack_require__(11);
var indexOf = (__webpack_require__(56).indexOf);
var hiddenKeys = __webpack_require__(50);
var push = uncurryThis([].push);
module.exports = function (object, names) {
var O = toIndexedObject(object);
var i = 0;
var result = [];
var key;
for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
// Don't enum bug & hidden keys
while (names.length > i) if (hasOwn(O, key = names[i++])) {
~indexOf(result, key) || push(result, key);
}
return result;
};
/***/ }),
/* 56 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var toIndexedObject = __webpack_require__(11);
var toAbsoluteIndex = __webpack_require__(57);
var lengthOfArrayLike = __webpack_require__(59);
// `Array.prototype.{ indexOf, includes }` methods implementation
var createMethod = function (IS_INCLUDES) {
return function ($this, el, fromIndex) {
var O = toIndexedObject($this);
var length = lengthOfArrayLike(O);
var index = toAbsoluteIndex(fromIndex, length);
var value;
// Array#includes uses SameValueZero equality algorithm
// eslint-disable-next-line no-self-compare -- NaN check
if (IS_INCLUDES && el != el) while (length > index) {
value = O[index++];
// eslint-disable-next-line no-self-compare -- NaN check
if (value != value) return true;
// Array#indexOf ignores holes, Array#includes - not
} else for (;length > index; index++) {
if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
} return !IS_INCLUDES && -1;
};
};
module.exports = {
// `Array.prototype.includes` method
// https://tc39.es/ecma262/#sec-array.prototype.includes
includes: createMethod(true),
// `Array.prototype.indexOf` method
// https://tc39.es/ecma262/#sec-array.prototype.indexof
indexOf: createMethod(false)
};
/***/ }),
/* 57 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var toIntegerOrInfinity = __webpack_require__(58);
var max = Math.max;
var min = Math.min;
// Helper for a popular repeating case of the spec:
// Let integer be ? ToInteger(index).
// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
module.exports = function (index, length) {
var integer = toIntegerOrInfinity(index);
return integer < 0 ? max(integer + length, 0) : min(integer, length);
};
/***/ }),
/* 58 */
/***/ (function(module) {
var ceil = Math.ceil;
var floor = Math.floor;
// `ToIntegerOrInfinity` abstract operation
// https://tc39.es/ecma262/#sec-tointegerorinfinity
module.exports = function (argument) {
var number = +argument;
// eslint-disable-next-line no-self-compare -- safe
return number !== number || number === 0 ? 0 : (number > 0 ? floor : ceil)(number);
};
/***/ }),
/* 59 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var toLength = __webpack_require__(60);
// `LengthOfArrayLike` abstract operation
// https://tc39.es/ecma262/#sec-lengthofarraylike
module.exports = function (obj) {
return toLength(obj.length);
};
/***/ }),
/* 60 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var toIntegerOrInfinity = __webpack_require__(58);
var min = Math.min;
// `ToLength` abstract operation
// https://tc39.es/ecma262/#sec-tolength
module.exports = function (argument) {
return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
};
/***/ }),
/* 61 */
/***/ (function(module) {
// IE8- don't enum bug keys
module.exports = [
'constructor',
'hasOwnProperty',
'isPrototypeOf',
'propertyIsEnumerable',
'toLocaleString',
'toString',
'valueOf'
];
/***/ }),
/* 62 */
/***/ (function(__unused_webpack_module, exports) {
// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
exports.f = Object.getOwnPropertySymbols;
/***/ }),
/* 63 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var isCallable = __webpack_require__(19);
var replacement = /#|\.prototype\./;
var isForced = function (feature, detection) {
var value = data[normalize(feature)];
return value == POLYFILL ? true
: value == NATIVE ? false
: isCallable(detection) ? fails(detection)
: !!detection;
};
var normalize = isForced.normalize = function (string) {
return String(string).replace(replacement, '.').toLowerCase();
};
var data = isForced.data = {};
var NATIVE = isForced.NATIVE = 'N';
var POLYFILL = isForced.POLYFILL = 'P';
module.exports = isForced;
/***/ }),
/* 64 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var NATIVE_BIND = __webpack_require__(8);
var FunctionPrototype = Function.prototype;
var apply = FunctionPrototype.apply;
var call = FunctionPrototype.call;
// eslint-disable-next-line es/no-reflect -- safe
module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
return call.apply(apply, arguments);
});
/***/ }),
/* 65 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var classof = __webpack_require__(14);
// `IsArray` abstract operation
// https://tc39.es/ecma262/#sec-isarray
// eslint-disable-next-line es/no-array-isarray -- safe
module.exports = Array.isArray || function isArray(argument) {
return classof(argument) == 'Array';
};
/***/ }),
/* 66 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var classof = __webpack_require__(67);
var String = global.String;
module.exports = function (argument) {
if (classof(argument) === 'Symbol') throw TypeError('Cannot convert a Symbol value to a string');
return String(argument);
};
/***/ }),
/* 67 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var TO_STRING_TAG_SUPPORT = __webpack_require__(68);
var isCallable = __webpack_require__(19);
var classofRaw = __webpack_require__(14);
var wellKnownSymbol = __webpack_require__(31);
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var Object = global.Object;
// ES3 wrong here
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
// fallback for IE11 Script Access Denied error
var tryGet = function (it, key) {
try {
return it[key];
} catch (error) { /* empty */ }
};
// getting tag from ES6+ `Object.prototype.toString`
module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
var O, tag, result;
return it === undefined ? 'Undefined' : it === null ? 'Null'
// @@toStringTag case
: typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag
// builtinTag case
: CORRECT_ARGUMENTS ? classofRaw(O)
// ES3 arguments fallback
: (result = classofRaw(O)) == 'Object' && isCallable(O.callee) ? 'Arguments' : result;
};
/***/ }),
/* 68 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var wellKnownSymbol = __webpack_require__(31);
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var test = {};
test[TO_STRING_TAG] = 'z';
module.exports = String(test) === '[object z]';
/***/ }),
/* 69 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
/* global ActiveXObject -- old IE, WSH */
var anObject = __webpack_require__(44);
var definePropertiesModule = __webpack_require__(70);
var enumBugKeys = __webpack_require__(61);
var hiddenKeys = __webpack_require__(50);
var html = __webpack_require__(72);
var documentCreateElement = __webpack_require__(40);
var sharedKey = __webpack_require__(49);
var GT = '>';
var LT = '<';
var PROTOTYPE = 'prototype';
var SCRIPT = 'script';
var IE_PROTO = sharedKey('IE_PROTO');
var EmptyConstructor = function () { /* empty */ };
var scriptTag = function (content) {
return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
};
// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
var NullProtoObjectViaActiveX = function (activeXDocument) {
activeXDocument.write(scriptTag(''));
activeXDocument.close();
var temp = activeXDocument.parentWindow.Object;
activeXDocument = null; // avoid memory leak
return temp;
};
// Create object with fake `null` prototype: use iframe Object with cleared prototype
var NullProtoObjectViaIFrame = function () {
// Thrash, waste and sodomy: IE GC bug
var iframe = documentCreateElement('iframe');
var JS = 'java' + SCRIPT + ':';
var iframeDocument;
iframe.style.display = 'none';
html.appendChild(iframe);
// https://github.com/zloirock/core-js/issues/475
iframe.src = String(JS);
iframeDocument = iframe.contentWindow.document;
iframeDocument.open();
iframeDocument.write(scriptTag('document.F=Object'));
iframeDocument.close();
return iframeDocument.F;
};
// Check for document.domain and active x support
// No need to use active x approach when document.domain is not set
// see https://github.com/es-shims/es5-shim/issues/150
// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
// avoid IE GC bug
var activeXDocument;
var NullProtoObject = function () {
try {
activeXDocument = new ActiveXObject('htmlfile');
} catch (error) { /* ignore */ }
NullProtoObject = typeof document != 'undefined'
? document.domain && activeXDocument
? NullProtoObjectViaActiveX(activeXDocument) // old IE
: NullProtoObjectViaIFrame()
: NullProtoObjectViaActiveX(activeXDocument); // WSH
var length = enumBugKeys.length;
while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
return NullProtoObject();
};
hiddenKeys[IE_PROTO] = true;
// `Object.create` method
// https://tc39.es/ecma262/#sec-object.create
module.exports = Object.create || function create(O, Properties) {
var result;
if (O !== null) {
EmptyConstructor[PROTOTYPE] = anObject(O);
result = new EmptyConstructor();
EmptyConstructor[PROTOTYPE] = null;
// add "__proto__" for Object.getPrototypeOf polyfill
result[IE_PROTO] = O;
} else result = NullProtoObject();
return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
};
/***/ }),
/* 70 */
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(43);
var definePropertyModule = __webpack_require__(42);
var anObject = __webpack_require__(44);
var toIndexedObject = __webpack_require__(11);
var objectKeys = __webpack_require__(71);
// `Object.defineProperties` method
// https://tc39.es/ecma262/#sec-object.defineproperties
// eslint-disable-next-line es/no-object-defineproperties -- safe
exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
anObject(O);
var props = toIndexedObject(Properties);
var keys = objectKeys(Properties);
var length = keys.length;
var index = 0;
var key;
while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
return O;
};
/***/ }),
/* 71 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var internalObjectKeys = __webpack_require__(55);
var enumBugKeys = __webpack_require__(61);
// `Object.keys` method
// https://tc39.es/ecma262/#sec-object.keys
// eslint-disable-next-line es/no-object-keys -- safe
module.exports = Object.keys || function keys(O) {
return internalObjectKeys(O, enumBugKeys);
};
/***/ }),
/* 72 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var getBuiltIn = __webpack_require__(21);
module.exports = getBuiltIn('document', 'documentElement');
/***/ }),
/* 73 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
/* eslint-disable es/no-object-getownpropertynames -- safe */
var classof = __webpack_require__(14);
var toIndexedObject = __webpack_require__(11);
var $getOwnPropertyNames = (__webpack_require__(54).f);
var arraySlice = __webpack_require__(74);
var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames
? Object.getOwnPropertyNames(window) : [];
var getWindowNames = function (it) {
try {
return $getOwnPropertyNames(it);
} catch (error) {
return arraySlice(windowNames);
}
};
// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window
module.exports.f = function getOwnPropertyNames(it) {
return windowNames && classof(it) == 'Window'
? getWindowNames(it)
: $getOwnPropertyNames(toIndexedObject(it));
};
/***/ }),
/* 74 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var toAbsoluteIndex = __webpack_require__(57);
var lengthOfArrayLike = __webpack_require__(59);
var createProperty = __webpack_require__(75);
var Array = global.Array;
var max = Math.max;
module.exports = function (O, start, end) {
var length = lengthOfArrayLike(O);
var k = toAbsoluteIndex(start, length);
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
var result = Array(max(fin - k, 0));
for (var n = 0; k < fin; k++, n++) createProperty(result, n, O[k]);
result.length = n;
return result;
};
/***/ }),
/* 75 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var toPropertyKey = __webpack_require__(16);
var definePropertyModule = __webpack_require__(42);
var createPropertyDescriptor = __webpack_require__(10);
module.exports = function (object, key, value) {
var propertyKey = toPropertyKey(key);
if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
else object[propertyKey] = value;
};
/***/ }),
/* 76 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
module.exports = uncurryThis([].slice);
/***/ }),
/* 77 */
/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
var wellKnownSymbol = __webpack_require__(31);
exports.f = wellKnownSymbol;
/***/ }),
/* 78 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var path = __webpack_require__(79);
var hasOwn = __webpack_require__(36);
var wrappedWellKnownSymbolModule = __webpack_require__(77);
var defineProperty = (__webpack_require__(42).f);
module.exports = function (NAME) {
var Symbol = path.Symbol || (path.Symbol = {});
if (!hasOwn(Symbol, NAME)) defineProperty(Symbol, NAME, {
value: wrappedWellKnownSymbolModule.f(NAME)
});
};
/***/ }),
/* 79 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
module.exports = global;
/***/ }),
/* 80 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var defineProperty = (__webpack_require__(42).f);
var hasOwn = __webpack_require__(36);
var wellKnownSymbol = __webpack_require__(31);
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
module.exports = function (target, TAG, STATIC) {
if (target && !STATIC) target = target.prototype;
if (target && !hasOwn(target, TO_STRING_TAG)) {
defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });
}
};
/***/ }),
/* 81 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var bind = __webpack_require__(82);
var uncurryThis = __webpack_require__(13);
var IndexedObject = __webpack_require__(12);
var toObject = __webpack_require__(37);
var lengthOfArrayLike = __webpack_require__(59);
var arraySpeciesCreate = __webpack_require__(83);
var push = uncurryThis([].push);
// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation
var createMethod = function (TYPE) {
var IS_MAP = TYPE == 1;
var IS_FILTER = TYPE == 2;
var IS_SOME = TYPE == 3;
var IS_EVERY = TYPE == 4;
var IS_FIND_INDEX = TYPE == 6;
var IS_FILTER_REJECT = TYPE == 7;
var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
return function ($this, callbackfn, that, specificCreate) {
var O = toObject($this);
var self = IndexedObject(O);
var boundFunction = bind(callbackfn, that);
var length = lengthOfArrayLike(self);
var index = 0;
var create = specificCreate || arraySpeciesCreate;
var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;
var value, result;
for (;length > index; index++) if (NO_HOLES || index in self) {
value = self[index];
result = boundFunction(value, index, O);
if (TYPE) {
if (IS_MAP) target[index] = result; // map
else if (result) switch (TYPE) {
case 3: return true; // some
case 5: return value; // find
case 6: return index; // findIndex
case 2: push(target, value); // filter
} else switch (TYPE) {
case 4: return false; // every
case 7: push(target, value); // filterReject
}
}
}
return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;
};
};
module.exports = {
// `Array.prototype.forEach` method
// https://tc39.es/ecma262/#sec-array.prototype.foreach
forEach: createMethod(0),
// `Array.prototype.map` method
// https://tc39.es/ecma262/#sec-array.prototype.map
map: createMethod(1),
// `Array.prototype.filter` method
// https://tc39.es/ecma262/#sec-array.prototype.filter
filter: createMethod(2),
// `Array.prototype.some` method
// https://tc39.es/ecma262/#sec-array.prototype.some
some: createMethod(3),
// `Array.prototype.every` method
// https://tc39.es/ecma262/#sec-array.prototype.every
every: createMethod(4),
// `Array.prototype.find` method
// https://tc39.es/ecma262/#sec-array.prototype.find
find: createMethod(5),
// `Array.prototype.findIndex` method
// https://tc39.es/ecma262/#sec-array.prototype.findIndex
findIndex: createMethod(6),
// `Array.prototype.filterReject` method
// https://github.com/tc39/proposal-array-filtering
filterReject: createMethod(7)
};
/***/ }),
/* 82 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var aCallable = __webpack_require__(28);
var NATIVE_BIND = __webpack_require__(8);
var bind = uncurryThis(uncurryThis.bind);
// optional / simple context binding
module.exports = function (fn, that) {
aCallable(fn);
return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
return fn.apply(that, arguments);
};
};
/***/ }),
/* 83 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var arraySpeciesConstructor = __webpack_require__(84);
// `ArraySpeciesCreate` abstract operation
// https://tc39.es/ecma262/#sec-arrayspeciescreate
module.exports = function (originalArray, length) {
return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);
};
/***/ }),
/* 84 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isArray = __webpack_require__(65);
var isConstructor = __webpack_require__(85);
var isObject = __webpack_require__(18);
var wellKnownSymbol = __webpack_require__(31);
var SPECIES = wellKnownSymbol('species');
var Array = global.Array;
// a part of `ArraySpeciesCreate` abstract operation
// https://tc39.es/ecma262/#sec-arrayspeciescreate
module.exports = function (originalArray) {
var C;
if (isArray(originalArray)) {
C = originalArray.constructor;
// cross-realm fallback
if (isConstructor(C) && (C === Array || isArray(C.prototype))) C = undefined;
else if (isObject(C)) {
C = C[SPECIES];
if (C === null) C = undefined;
}
} return C === undefined ? Array : C;
};
/***/ }),
/* 85 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var isCallable = __webpack_require__(19);
var classof = __webpack_require__(67);
var getBuiltIn = __webpack_require__(21);
var inspectSource = __webpack_require__(46);
var noop = function () { /* empty */ };
var empty = [];
var construct = getBuiltIn('Reflect', 'construct');
var constructorRegExp = /^\s*(?:class|function)\b/;
var exec = uncurryThis(constructorRegExp.exec);
var INCORRECT_TO_STRING = !constructorRegExp.exec(noop);
var isConstructorModern = function isConstructor(argument) {
if (!isCallable(argument)) return false;
try {
construct(noop, empty, argument);
return true;
} catch (error) {
return false;
}
};
var isConstructorLegacy = function isConstructor(argument) {
if (!isCallable(argument)) return false;
switch (classof(argument)) {
case 'AsyncFunction':
case 'GeneratorFunction':
case 'AsyncGeneratorFunction': return false;
}
try {
// we can't check .prototype since constructors produced by .bind haven't it
// `Function#toString` throws on some built-it function in some legacy engines
// (for example, `DOMQuad` and similar in FF41-)
return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));
} catch (error) {
return true;
}
};
isConstructorLegacy.sham = true;
// `IsConstructor` abstract operation
// https://tc39.es/ecma262/#sec-isconstructor
module.exports = !construct || fails(function () {
var called;
return isConstructorModern(isConstructorModern.call)
|| !isConstructorModern(Object)
|| !isConstructorModern(function () { called = true; })
|| called;
}) ? isConstructorLegacy : isConstructorModern;
/***/ }),
/* 86 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
// `Symbol.prototype.description` getter
// https://tc39.es/ecma262/#sec-symbol.prototype.description
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var hasOwn = __webpack_require__(36);
var isCallable = __webpack_require__(19);
var isPrototypeOf = __webpack_require__(22);
var toString = __webpack_require__(66);
var defineProperty = (__webpack_require__(42).f);
var copyConstructorProperties = __webpack_require__(52);
var NativeSymbol = global.Symbol;
var SymbolPrototype = NativeSymbol && NativeSymbol.prototype;
if (DESCRIPTORS && isCallable(NativeSymbol) && (!('description' in SymbolPrototype) ||
// Safari 12 bug
NativeSymbol().description !== undefined
)) {
var EmptyStringDescriptionStore = {};
// wrap Symbol constructor for correct work with undefined description
var SymbolWrapper = function Symbol() {
var description = arguments.length < 1 || arguments[0] === undefined ? undefined : toString(arguments[0]);
var result = isPrototypeOf(SymbolPrototype, this)
? new NativeSymbol(description)
// in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'
: description === undefined ? NativeSymbol() : NativeSymbol(description);
if (description === '') EmptyStringDescriptionStore[result] = true;
return result;
};
copyConstructorProperties(SymbolWrapper, NativeSymbol);
SymbolWrapper.prototype = SymbolPrototype;
SymbolPrototype.constructor = SymbolWrapper;
var NATIVE_SYMBOL = String(NativeSymbol('test')) == 'Symbol(test)';
var symbolToString = uncurryThis(SymbolPrototype.toString);
var symbolValueOf = uncurryThis(SymbolPrototype.valueOf);
var regexp = /^Symbol\((.*)\)[^)]+$/;
var replace = uncurryThis(''.replace);
var stringSlice = uncurryThis(''.slice);
defineProperty(SymbolPrototype, 'description', {
configurable: true,
get: function description() {
var symbol = symbolValueOf(this);
var string = symbolToString(symbol);
if (hasOwn(EmptyStringDescriptionStore, symbol)) return '';
var desc = NATIVE_SYMBOL ? stringSlice(string, 7, -1) : replace(string, regexp, '$1');
return desc === '' ? undefined : desc;
}
});
$({ global: true, forced: true }, {
Symbol: SymbolWrapper
});
}
/***/ }),
/* 87 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.asyncIterator` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.asynciterator
defineWellKnownSymbol('asyncIterator');
/***/ }),
/* 88 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.hasInstance` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.hasinstance
defineWellKnownSymbol('hasInstance');
/***/ }),
/* 89 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.isConcatSpreadable` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.isconcatspreadable
defineWellKnownSymbol('isConcatSpreadable');
/***/ }),
/* 90 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.iterator` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.iterator
defineWellKnownSymbol('iterator');
/***/ }),
/* 91 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.match` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.match
defineWellKnownSymbol('match');
/***/ }),
/* 92 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.matchAll` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.matchall
defineWellKnownSymbol('matchAll');
/***/ }),
/* 93 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.replace` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.replace
defineWellKnownSymbol('replace');
/***/ }),
/* 94 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.search` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.search
defineWellKnownSymbol('search');
/***/ }),
/* 95 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.species` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.species
defineWellKnownSymbol('species');
/***/ }),
/* 96 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.split` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.split
defineWellKnownSymbol('split');
/***/ }),
/* 97 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.toPrimitive` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.toprimitive
defineWellKnownSymbol('toPrimitive');
/***/ }),
/* 98 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.toStringTag` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.tostringtag
defineWellKnownSymbol('toStringTag');
/***/ }),
/* 99 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var defineWellKnownSymbol = __webpack_require__(78);
// `Symbol.unscopables` well-known symbol
// https://tc39.es/ecma262/#sec-symbol.unscopables
defineWellKnownSymbol('unscopables');
/***/ }),
/* 100 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
/* eslint-disable no-unused-vars -- required for functions `.length` */
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var apply = __webpack_require__(64);
var wrapErrorConstructorWithCause = __webpack_require__(101);
var WEB_ASSEMBLY = 'WebAssembly';
var WebAssembly = global[WEB_ASSEMBLY];
var FORCED = Error('e', { cause: 7 }).cause !== 7;
var exportGlobalErrorCauseWrapper = function (ERROR_NAME, wrapper) {
var O = {};
O[ERROR_NAME] = wrapErrorConstructorWithCause(ERROR_NAME, wrapper, FORCED);
$({ global: true, forced: FORCED }, O);
};
var exportWebAssemblyErrorCauseWrapper = function (ERROR_NAME, wrapper) {
if (WebAssembly && WebAssembly[ERROR_NAME]) {
var O = {};
O[ERROR_NAME] = wrapErrorConstructorWithCause(WEB_ASSEMBLY + '.' + ERROR_NAME, wrapper, FORCED);
$({ target: WEB_ASSEMBLY, stat: true, forced: FORCED }, O);
}
};
// https://github.com/tc39/proposal-error-cause
exportGlobalErrorCauseWrapper('Error', function (init) {
return function Error(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('EvalError', function (init) {
return function EvalError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('RangeError', function (init) {
return function RangeError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('ReferenceError', function (init) {
return function ReferenceError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('SyntaxError', function (init) {
return function SyntaxError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('TypeError', function (init) {
return function TypeError(message) { return apply(init, this, arguments); };
});
exportGlobalErrorCauseWrapper('URIError', function (init) {
return function URIError(message) { return apply(init, this, arguments); };
});
exportWebAssemblyErrorCauseWrapper('CompileError', function (init) {
return function CompileError(message) { return apply(init, this, arguments); };
});
exportWebAssemblyErrorCauseWrapper('LinkError', function (init) {
return function LinkError(message) { return apply(init, this, arguments); };
});
exportWebAssemblyErrorCauseWrapper('RuntimeError', function (init) {
return function RuntimeError(message) { return apply(init, this, arguments); };
});
/***/ }),
/* 101 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var getBuiltIn = __webpack_require__(21);
var hasOwn = __webpack_require__(36);
var createNonEnumerableProperty = __webpack_require__(41);
var isPrototypeOf = __webpack_require__(22);
var setPrototypeOf = __webpack_require__(102);
var copyConstructorProperties = __webpack_require__(52);
var inheritIfRequired = __webpack_require__(104);
var normalizeStringArgument = __webpack_require__(105);
var installErrorCause = __webpack_require__(106);
var clearErrorStack = __webpack_require__(107);
var ERROR_STACK_INSTALLABLE = __webpack_require__(108);
var IS_PURE = __webpack_require__(33);
module.exports = function (FULL_NAME, wrapper, FORCED, IS_AGGREGATE_ERROR) {
var OPTIONS_POSITION = IS_AGGREGATE_ERROR ? 2 : 1;
var path = FULL_NAME.split('.');
var ERROR_NAME = path[path.length - 1];
var OriginalError = getBuiltIn.apply(null, path);
if (!OriginalError) return;
var OriginalErrorPrototype = OriginalError.prototype;
// V8 9.3- bug https://bugs.chromium.org/p/v8/issues/detail?id=12006
if (!IS_PURE && hasOwn(OriginalErrorPrototype, 'cause')) delete OriginalErrorPrototype.cause;
if (!FORCED) return OriginalError;
var BaseError = getBuiltIn('Error');
var WrappedError = wrapper(function (a, b) {
var message = normalizeStringArgument(IS_AGGREGATE_ERROR ? b : a, undefined);
var result = IS_AGGREGATE_ERROR ? new OriginalError(a) : new OriginalError();
if (message !== undefined) createNonEnumerableProperty(result, 'message', message);
if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(result, 'stack', clearErrorStack(result.stack, 2));
if (this && isPrototypeOf(OriginalErrorPrototype, this)) inheritIfRequired(result, this, WrappedError);
if (arguments.length > OPTIONS_POSITION) installErrorCause(result, arguments[OPTIONS_POSITION]);
return result;
});
WrappedError.prototype = OriginalErrorPrototype;
if (ERROR_NAME !== 'Error') {
if (setPrototypeOf) setPrototypeOf(WrappedError, BaseError);
else copyConstructorProperties(WrappedError, BaseError, { name: true });
}
copyConstructorProperties(WrappedError, OriginalError);
if (!IS_PURE) try {
// Safari 13- bug: WebAssembly errors does not have a proper `.name`
if (OriginalErrorPrototype.name !== ERROR_NAME) {
createNonEnumerableProperty(OriginalErrorPrototype, 'name', ERROR_NAME);
}
OriginalErrorPrototype.constructor = WrappedError;
} catch (error) { /* empty */ }
return WrappedError;
};
/***/ }),
/* 102 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
/* eslint-disable no-proto -- safe */
var uncurryThis = __webpack_require__(13);
var anObject = __webpack_require__(44);
var aPossiblePrototype = __webpack_require__(103);
// `Object.setPrototypeOf` method
// https://tc39.es/ecma262/#sec-object.setprototypeof
// Works with __proto__ only. Old v8 can't work with null proto objects.
// eslint-disable-next-line es/no-object-setprototypeof -- safe
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
var CORRECT_SETTER = false;
var test = {};
var setter;
try {
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
setter = uncurryThis(Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set);
setter(test, []);
CORRECT_SETTER = test instanceof Array;
} catch (error) { /* empty */ }
return function setPrototypeOf(O, proto) {
anObject(O);
aPossiblePrototype(proto);
if (CORRECT_SETTER) setter(O, proto);
else O.__proto__ = proto;
return O;
};
}() : undefined);
/***/ }),
/* 103 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isCallable = __webpack_require__(19);
var String = global.String;
var TypeError = global.TypeError;
module.exports = function (argument) {
if (typeof argument == 'object' || isCallable(argument)) return argument;
throw TypeError("Can't set " + String(argument) + ' as a prototype');
};
/***/ }),
/* 104 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var setPrototypeOf = __webpack_require__(102);
// makes subclassing work correct for wrapped built-ins
module.exports = function ($this, dummy, Wrapper) {
var NewTarget, NewTargetPrototype;
if (
// it can work only with native `setPrototypeOf`
setPrototypeOf &&
// we haven't completely correct pre-ES6 way for getting `new.target`, so use this
isCallable(NewTarget = dummy.constructor) &&
NewTarget !== Wrapper &&
isObject(NewTargetPrototype = NewTarget.prototype) &&
NewTargetPrototype !== Wrapper.prototype
) setPrototypeOf($this, NewTargetPrototype);
return $this;
};
/***/ }),
/* 105 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var toString = __webpack_require__(66);
module.exports = function (argument, $default) {
return argument === undefined ? arguments.length < 2 ? '' : $default : toString(argument);
};
/***/ }),
/* 106 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var isObject = __webpack_require__(18);
var createNonEnumerableProperty = __webpack_require__(41);
// `InstallErrorCause` abstract operation
// https://tc39.es/proposal-error-cause/#sec-errorobjects-install-error-cause
module.exports = function (O, options) {
if (isObject(options) && 'cause' in options) {
createNonEnumerableProperty(O, 'cause', options.cause);
}
};
/***/ }),
/* 107 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var replace = uncurryThis(''.replace);
var TEST = (function (arg) { return String(Error(arg).stack); })('zxcasd');
var V8_OR_CHAKRA_STACK_ENTRY = /\n\s*at [^:]*:[^\n]*/;
var IS_V8_OR_CHAKRA_STACK = V8_OR_CHAKRA_STACK_ENTRY.test(TEST);
module.exports = function (stack, dropEntries) {
if (IS_V8_OR_CHAKRA_STACK && typeof stack == 'string') {
while (dropEntries--) stack = replace(stack, V8_OR_CHAKRA_STACK_ENTRY, '');
} return stack;
};
/***/ }),
/* 108 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var createPropertyDescriptor = __webpack_require__(10);
module.exports = !fails(function () {
var error = Error('a');
if (!('stack' in error)) return true;
// eslint-disable-next-line es/no-object-defineproperty -- safe
Object.defineProperty(error, 'stack', createPropertyDescriptor(1, 7));
return error.stack !== 7;
});
/***/ }),
/* 109 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var redefine = __webpack_require__(45);
var errorToString = __webpack_require__(110);
var ErrorPrototype = Error.prototype;
// `Error.prototype.toString` method fix
// https://tc39.es/ecma262/#sec-error.prototype.tostring
if (ErrorPrototype.toString !== errorToString) {
redefine(ErrorPrototype, 'toString', errorToString);
}
/***/ }),
/* 110 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var DESCRIPTORS = __webpack_require__(5);
var fails = __webpack_require__(6);
var anObject = __webpack_require__(44);
var create = __webpack_require__(69);
var normalizeStringArgument = __webpack_require__(105);
var nativeErrorToString = Error.prototype.toString;
var INCORRECT_TO_STRING = fails(function () {
if (DESCRIPTORS) {
// Chrome 32- incorrectly call accessor
// eslint-disable-next-line es/no-object-defineproperty -- safe
var object = create(Object.defineProperty({}, 'name', { get: function () {
return this === object;
} }));
if (nativeErrorToString.call(object) !== 'true') return true;
}
// FF10- does not properly handle non-strings
return nativeErrorToString.call({ message: 1, name: 2 }) !== '2: 1'
// IE8 does not properly handle defaults
|| nativeErrorToString.call({}) !== 'Error';
});
module.exports = INCORRECT_TO_STRING ? function toString() {
var O = anObject(this);
var name = normalizeStringArgument(O.name, 'Error');
var message = normalizeStringArgument(O.message);
return !name ? message : !message ? name : name + ': ' + message;
} : nativeErrorToString;
/***/ }),
/* 111 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var isPrototypeOf = __webpack_require__(22);
var getPrototypeOf = __webpack_require__(112);
var setPrototypeOf = __webpack_require__(102);
var copyConstructorProperties = __webpack_require__(52);
var create = __webpack_require__(69);
var createNonEnumerableProperty = __webpack_require__(41);
var createPropertyDescriptor = __webpack_require__(10);
var clearErrorStack = __webpack_require__(107);
var installErrorCause = __webpack_require__(106);
var iterate = __webpack_require__(114);
var normalizeStringArgument = __webpack_require__(105);
var wellKnownSymbol = __webpack_require__(31);
var ERROR_STACK_INSTALLABLE = __webpack_require__(108);
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var Error = global.Error;
var push = [].push;
var $AggregateError = function AggregateError(errors, message /* , options */) {
var options = arguments.length > 2 ? arguments[2] : undefined;
var isInstance = isPrototypeOf(AggregateErrorPrototype, this);
var that;
if (setPrototypeOf) {
that = setPrototypeOf(new Error(), isInstance ? getPrototypeOf(this) : AggregateErrorPrototype);
} else {
that = isInstance ? this : create(AggregateErrorPrototype);
createNonEnumerableProperty(that, TO_STRING_TAG, 'Error');
}
if (message !== undefined) createNonEnumerableProperty(that, 'message', normalizeStringArgument(message));
if (ERROR_STACK_INSTALLABLE) createNonEnumerableProperty(that, 'stack', clearErrorStack(that.stack, 1));
installErrorCause(that, options);
var errorsArray = [];
iterate(errors, push, { that: errorsArray });
createNonEnumerableProperty(that, 'errors', errorsArray);
return that;
};
if (setPrototypeOf) setPrototypeOf($AggregateError, Error);
else copyConstructorProperties($AggregateError, Error, { name: true });
var AggregateErrorPrototype = $AggregateError.prototype = create(Error.prototype, {
constructor: createPropertyDescriptor(1, $AggregateError),
message: createPropertyDescriptor(1, ''),
name: createPropertyDescriptor(1, 'AggregateError')
});
// `AggregateError` constructor
// https://tc39.es/ecma262/#sec-aggregate-error-constructor
$({ global: true }, {
AggregateError: $AggregateError
});
/***/ }),
/* 112 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var hasOwn = __webpack_require__(36);
var isCallable = __webpack_require__(19);
var toObject = __webpack_require__(37);
var sharedKey = __webpack_require__(49);
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(113);
var IE_PROTO = sharedKey('IE_PROTO');
var Object = global.Object;
var ObjectPrototype = Object.prototype;
// `Object.getPrototypeOf` method
// https://tc39.es/ecma262/#sec-object.getprototypeof
module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
var object = toObject(O);
if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
var constructor = object.constructor;
if (isCallable(constructor) && object instanceof constructor) {
return constructor.prototype;
} return object instanceof Object ? ObjectPrototype : null;
};
/***/ }),
/* 113 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
module.exports = !fails(function () {
function F() { /* empty */ }
F.prototype.constructor = null;
// eslint-disable-next-line es/no-object-getprototypeof -- required for testing
return Object.getPrototypeOf(new F()) !== F.prototype;
});
/***/ }),
/* 114 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var bind = __webpack_require__(82);
var call = __webpack_require__(7);
var anObject = __webpack_require__(44);
var tryToString = __webpack_require__(29);
var isArrayIteratorMethod = __webpack_require__(115);
var lengthOfArrayLike = __webpack_require__(59);
var isPrototypeOf = __webpack_require__(22);
var getIterator = __webpack_require__(117);
var getIteratorMethod = __webpack_require__(118);
var iteratorClose = __webpack_require__(119);
var TypeError = global.TypeError;
var Result = function (stopped, result) {
this.stopped = stopped;
this.result = result;
};
var ResultPrototype = Result.prototype;
module.exports = function (iterable, unboundFunction, options) {
var that = options && options.that;
var AS_ENTRIES = !!(options && options.AS_ENTRIES);
var IS_ITERATOR = !!(options && options.IS_ITERATOR);
var INTERRUPTED = !!(options && options.INTERRUPTED);
var fn = bind(unboundFunction, that);
var iterator, iterFn, index, length, result, next, step;
var stop = function (condition) {
if (iterator) iteratorClose(iterator, 'normal', condition);
return new Result(true, condition);
};
var callFn = function (value) {
if (AS_ENTRIES) {
anObject(value);
return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
} return INTERRUPTED ? fn(value, stop) : fn(value);
};
if (IS_ITERATOR) {
iterator = iterable;
} else {
iterFn = getIteratorMethod(iterable);
if (!iterFn) throw TypeError(tryToString(iterable) + ' is not iterable');
// optimisation for array iterators
if (isArrayIteratorMethod(iterFn)) {
for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
result = callFn(iterable[index]);
if (result && isPrototypeOf(ResultPrototype, result)) return result;
} return new Result(false);
}
iterator = getIterator(iterable, iterFn);
}
next = iterator.next;
while (!(step = call(next, iterator)).done) {
try {
result = callFn(step.value);
} catch (error) {
iteratorClose(iterator, 'throw', error);
}
if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
} return new Result(false);
};
/***/ }),
/* 115 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var wellKnownSymbol = __webpack_require__(31);
var Iterators = __webpack_require__(116);
var ITERATOR = wellKnownSymbol('iterator');
var ArrayPrototype = Array.prototype;
// check on default Array iterator
module.exports = function (it) {
return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
};
/***/ }),
/* 116 */
/***/ (function(module) {
module.exports = {};
/***/ }),
/* 117 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var aCallable = __webpack_require__(28);
var anObject = __webpack_require__(44);
var tryToString = __webpack_require__(29);
var getIteratorMethod = __webpack_require__(118);
var TypeError = global.TypeError;
module.exports = function (argument, usingIterator) {
var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
throw TypeError(tryToString(argument) + ' is not iterable');
};
/***/ }),
/* 118 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var classof = __webpack_require__(67);
var getMethod = __webpack_require__(27);
var Iterators = __webpack_require__(116);
var wellKnownSymbol = __webpack_require__(31);
var ITERATOR = wellKnownSymbol('iterator');
module.exports = function (it) {
if (it != undefined) return getMethod(it, ITERATOR)
|| getMethod(it, '@@iterator')
|| Iterators[classof(it)];
};
/***/ }),
/* 119 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var call = __webpack_require__(7);
var anObject = __webpack_require__(44);
var getMethod = __webpack_require__(27);
module.exports = function (iterator, kind, value) {
var innerResult, innerError;
anObject(iterator);
try {
innerResult = getMethod(iterator, 'return');
if (!innerResult) {
if (kind === 'throw') throw value;
return value;
}
innerResult = call(innerResult, iterator);
} catch (error) {
innerError = true;
innerResult = error;
}
if (kind === 'throw') throw value;
if (innerError) throw innerResult;
anObject(innerResult);
return value;
};
/***/ }),
/* 120 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var getBuiltIn = __webpack_require__(21);
var apply = __webpack_require__(64);
var fails = __webpack_require__(6);
var wrapErrorConstructorWithCause = __webpack_require__(101);
var AGGREGATE_ERROR = 'AggregateError';
var $AggregateError = getBuiltIn(AGGREGATE_ERROR);
var FORCED = !fails(function () {
return $AggregateError([1]).errors[0] !== 1;
}) && fails(function () {
return $AggregateError([1], AGGREGATE_ERROR, { cause: 7 }).cause !== 7;
});
// https://github.com/tc39/proposal-error-cause
$({ global: true, forced: FORCED }, {
AggregateError: wrapErrorConstructorWithCause(AGGREGATE_ERROR, function (init) {
// eslint-disable-next-line no-unused-vars -- required for functions `.length`
return function AggregateError(errors, message) { return apply(init, this, arguments); };
}, FORCED, true)
});
/***/ }),
/* 121 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var toObject = __webpack_require__(37);
var lengthOfArrayLike = __webpack_require__(59);
var toIntegerOrInfinity = __webpack_require__(58);
var addToUnscopables = __webpack_require__(122);
// `Array.prototype.at` method
// https://github.com/tc39/proposal-relative-indexing-method
$({ target: 'Array', proto: true }, {
at: function at(index) {
var O = toObject(this);
var len = lengthOfArrayLike(O);
var relativeIndex = toIntegerOrInfinity(index);
var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
return (k < 0 || k >= len) ? undefined : O[k];
}
});
addToUnscopables('at');
/***/ }),
/* 122 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var wellKnownSymbol = __webpack_require__(31);
var create = __webpack_require__(69);
var definePropertyModule = __webpack_require__(42);
var UNSCOPABLES = wellKnownSymbol('unscopables');
var ArrayPrototype = Array.prototype;
// Array.prototype[@@unscopables]
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
if (ArrayPrototype[UNSCOPABLES] == undefined) {
definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
configurable: true,
value: create(null)
});
}
// add a key to Array.prototype[@@unscopables]
module.exports = function (key) {
ArrayPrototype[UNSCOPABLES][key] = true;
};
/***/ }),
/* 123 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var fails = __webpack_require__(6);
var isArray = __webpack_require__(65);
var isObject = __webpack_require__(18);
var toObject = __webpack_require__(37);
var lengthOfArrayLike = __webpack_require__(59);
var createProperty = __webpack_require__(75);
var arraySpeciesCreate = __webpack_require__(83);
var arrayMethodHasSpeciesSupport = __webpack_require__(124);
var wellKnownSymbol = __webpack_require__(31);
var V8_VERSION = __webpack_require__(25);
var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
var MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded';
var TypeError = global.TypeError;
// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
// https://github.com/zloirock/core-js/issues/679
var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {
var array = [];
array[IS_CONCAT_SPREADABLE] = false;
return array.concat()[0] !== array;
});
var SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');
var isConcatSpreadable = function (O) {
if (!isObject(O)) return false;
var spreadable = O[IS_CONCAT_SPREADABLE];
return spreadable !== undefined ? !!spreadable : isArray(O);
};
var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;
// `Array.prototype.concat` method
// https://tc39.es/ecma262/#sec-array.prototype.concat
// with adding support of @@isConcatSpreadable and @@species
$({ target: 'Array', proto: true, forced: FORCED }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
concat: function concat(arg) {
var O = toObject(this);
var A = arraySpeciesCreate(O, 0);
var n = 0;
var i, k, length, len, E;
for (i = -1, length = arguments.length; i < length; i++) {
E = i === -1 ? O : arguments[i];
if (isConcatSpreadable(E)) {
len = lengthOfArrayLike(E);
if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);
} else {
if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);
createProperty(A, n++, E);
}
}
A.length = n;
return A;
}
});
/***/ }),
/* 124 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var wellKnownSymbol = __webpack_require__(31);
var V8_VERSION = __webpack_require__(25);
var SPECIES = wellKnownSymbol('species');
module.exports = function (METHOD_NAME) {
// We can't use this feature detection in V8 since it causes
// deoptimization and serious performance degradation
// https://github.com/zloirock/core-js/issues/677
return V8_VERSION >= 51 || !fails(function () {
var array = [];
var constructor = array.constructor = {};
constructor[SPECIES] = function () {
return { foo: 1 };
};
return array[METHOD_NAME](Boolean).foo !== 1;
});
};
/***/ }),
/* 125 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var copyWithin = __webpack_require__(126);
var addToUnscopables = __webpack_require__(122);
// `Array.prototype.copyWithin` method
// https://tc39.es/ecma262/#sec-array.prototype.copywithin
$({ target: 'Array', proto: true }, {
copyWithin: copyWithin
});
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('copyWithin');
/***/ }),
/* 126 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var toObject = __webpack_require__(37);
var toAbsoluteIndex = __webpack_require__(57);
var lengthOfArrayLike = __webpack_require__(59);
var min = Math.min;
// `Array.prototype.copyWithin` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.copywithin
// eslint-disable-next-line es/no-array-prototype-copywithin -- safe
module.exports = [].copyWithin || function copyWithin(target /* = 0 */, start /* = 0, end = @length */) {
var O = toObject(this);
var len = lengthOfArrayLike(O);
var to = toAbsoluteIndex(target, len);
var from = toAbsoluteIndex(start, len);
var end = arguments.length > 2 ? arguments[2] : undefined;
var count = min((end === undefined ? len : toAbsoluteIndex(end, len)) - from, len - to);
var inc = 1;
if (from < to && to < from + count) {
inc = -1;
from += count - 1;
to += count - 1;
}
while (count-- > 0) {
if (from in O) O[to] = O[from];
else delete O[to];
to += inc;
from += inc;
} return O;
};
/***/ }),
/* 127 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $every = (__webpack_require__(81).every);
var arrayMethodIsStrict = __webpack_require__(128);
var STRICT_METHOD = arrayMethodIsStrict('every');
// `Array.prototype.every` method
// https://tc39.es/ecma262/#sec-array.prototype.every
$({ target: 'Array', proto: true, forced: !STRICT_METHOD }, {
every: function every(callbackfn /* , thisArg */) {
return $every(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 128 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var fails = __webpack_require__(6);
module.exports = function (METHOD_NAME, argument) {
var method = [][METHOD_NAME];
return !!method && fails(function () {
// eslint-disable-next-line no-useless-call,no-throw-literal -- required for testing
method.call(null, argument || function () { throw 1; }, 1);
});
};
/***/ }),
/* 129 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fill = __webpack_require__(130);
var addToUnscopables = __webpack_require__(122);
// `Array.prototype.fill` method
// https://tc39.es/ecma262/#sec-array.prototype.fill
$({ target: 'Array', proto: true }, {
fill: fill
});
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('fill');
/***/ }),
/* 130 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var toObject = __webpack_require__(37);
var toAbsoluteIndex = __webpack_require__(57);
var lengthOfArrayLike = __webpack_require__(59);
// `Array.prototype.fill` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.fill
module.exports = function fill(value /* , start = 0, end = @length */) {
var O = toObject(this);
var length = lengthOfArrayLike(O);
var argumentsLength = arguments.length;
var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);
var end = argumentsLength > 2 ? arguments[2] : undefined;
var endPos = end === undefined ? length : toAbsoluteIndex(end, length);
while (endPos > index) O[index++] = value;
return O;
};
/***/ }),
/* 131 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $filter = (__webpack_require__(81).filter);
var arrayMethodHasSpeciesSupport = __webpack_require__(124);
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');
// `Array.prototype.filter` method
// https://tc39.es/ecma262/#sec-array.prototype.filter
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
filter: function filter(callbackfn /* , thisArg */) {
return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 132 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $find = (__webpack_require__(81).find);
var addToUnscopables = __webpack_require__(122);
var FIND = 'find';
var SKIPS_HOLES = true;
// Shouldn't skip holes
if (FIND in []) Array(1)[FIND](function () { SKIPS_HOLES = false; });
// `Array.prototype.find` method
// https://tc39.es/ecma262/#sec-array.prototype.find
$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
find: function find(callbackfn /* , that = undefined */) {
return $find(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables(FIND);
/***/ }),
/* 133 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $findIndex = (__webpack_require__(81).findIndex);
var addToUnscopables = __webpack_require__(122);
var FIND_INDEX = 'findIndex';
var SKIPS_HOLES = true;
// Shouldn't skip holes
if (FIND_INDEX in []) Array(1)[FIND_INDEX](function () { SKIPS_HOLES = false; });
// `Array.prototype.findIndex` method
// https://tc39.es/ecma262/#sec-array.prototype.findindex
$({ target: 'Array', proto: true, forced: SKIPS_HOLES }, {
findIndex: function findIndex(callbackfn /* , that = undefined */) {
return $findIndex(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables(FIND_INDEX);
/***/ }),
/* 134 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var flattenIntoArray = __webpack_require__(135);
var toObject = __webpack_require__(37);
var lengthOfArrayLike = __webpack_require__(59);
var toIntegerOrInfinity = __webpack_require__(58);
var arraySpeciesCreate = __webpack_require__(83);
// `Array.prototype.flat` method
// https://tc39.es/ecma262/#sec-array.prototype.flat
$({ target: 'Array', proto: true }, {
flat: function flat(/* depthArg = 1 */) {
var depthArg = arguments.length ? arguments[0] : undefined;
var O = toObject(this);
var sourceLen = lengthOfArrayLike(O);
var A = arraySpeciesCreate(O, 0);
A.length = flattenIntoArray(A, O, O, sourceLen, 0, depthArg === undefined ? 1 : toIntegerOrInfinity(depthArg));
return A;
}
});
/***/ }),
/* 135 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var isArray = __webpack_require__(65);
var lengthOfArrayLike = __webpack_require__(59);
var bind = __webpack_require__(82);
var TypeError = global.TypeError;
// `FlattenIntoArray` abstract operation
// https://tc39.github.io/proposal-flatMap/#sec-FlattenIntoArray
var flattenIntoArray = function (target, original, source, sourceLen, start, depth, mapper, thisArg) {
var targetIndex = start;
var sourceIndex = 0;
var mapFn = mapper ? bind(mapper, thisArg) : false;
var element, elementLen;
while (sourceIndex < sourceLen) {
if (sourceIndex in source) {
element = mapFn ? mapFn(source[sourceIndex], sourceIndex, original) : source[sourceIndex];
if (depth > 0 && isArray(element)) {
elementLen = lengthOfArrayLike(element);
targetIndex = flattenIntoArray(target, original, element, elementLen, targetIndex, depth - 1) - 1;
} else {
if (targetIndex >= 0x1FFFFFFFFFFFFF) throw TypeError('Exceed the acceptable array length');
target[targetIndex] = element;
}
targetIndex++;
}
sourceIndex++;
}
return targetIndex;
};
module.exports = flattenIntoArray;
/***/ }),
/* 136 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var flattenIntoArray = __webpack_require__(135);
var aCallable = __webpack_require__(28);
var toObject = __webpack_require__(37);
var lengthOfArrayLike = __webpack_require__(59);
var arraySpeciesCreate = __webpack_require__(83);
// `Array.prototype.flatMap` method
// https://tc39.es/ecma262/#sec-array.prototype.flatmap
$({ target: 'Array', proto: true }, {
flatMap: function flatMap(callbackfn /* , thisArg */) {
var O = toObject(this);
var sourceLen = lengthOfArrayLike(O);
var A;
aCallable(callbackfn);
A = arraySpeciesCreate(O, 0);
A.length = flattenIntoArray(A, O, O, sourceLen, 0, 1, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
return A;
}
});
/***/ }),
/* 137 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var forEach = __webpack_require__(138);
// `Array.prototype.forEach` method
// https://tc39.es/ecma262/#sec-array.prototype.foreach
// eslint-disable-next-line es/no-array-prototype-foreach -- safe
$({ target: 'Array', proto: true, forced: [].forEach != forEach }, {
forEach: forEach
});
/***/ }),
/* 138 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $forEach = (__webpack_require__(81).forEach);
var arrayMethodIsStrict = __webpack_require__(128);
var STRICT_METHOD = arrayMethodIsStrict('forEach');
// `Array.prototype.forEach` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.foreach
module.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {
return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
// eslint-disable-next-line es/no-array-prototype-foreach -- safe
} : [].forEach;
/***/ }),
/* 139 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var from = __webpack_require__(140);
var checkCorrectnessOfIteration = __webpack_require__(142);
var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
// eslint-disable-next-line es/no-array-from -- required for testing
Array.from(iterable);
});
// `Array.from` method
// https://tc39.es/ecma262/#sec-array.from
$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
from: from
});
/***/ }),
/* 140 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var bind = __webpack_require__(82);
var call = __webpack_require__(7);
var toObject = __webpack_require__(37);
var callWithSafeIterationClosing = __webpack_require__(141);
var isArrayIteratorMethod = __webpack_require__(115);
var isConstructor = __webpack_require__(85);
var lengthOfArrayLike = __webpack_require__(59);
var createProperty = __webpack_require__(75);
var getIterator = __webpack_require__(117);
var getIteratorMethod = __webpack_require__(118);
var Array = global.Array;
// `Array.from` method implementation
// https://tc39.es/ecma262/#sec-array.from
module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
var O = toObject(arrayLike);
var IS_CONSTRUCTOR = isConstructor(this);
var argumentsLength = arguments.length;
var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
var mapping = mapfn !== undefined;
if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);
var iteratorMethod = getIteratorMethod(O);
var index = 0;
var length, result, step, iterator, next, value;
// if the target is not iterable or it's an array with the default iterator - use a simple case
if (iteratorMethod && !(this == Array && isArrayIteratorMethod(iteratorMethod))) {
iterator = getIterator(O, iteratorMethod);
next = iterator.next;
result = IS_CONSTRUCTOR ? new this() : [];
for (;!(step = call(next, iterator)).done; index++) {
value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;
createProperty(result, index, value);
}
} else {
length = lengthOfArrayLike(O);
result = IS_CONSTRUCTOR ? new this(length) : Array(length);
for (;length > index; index++) {
value = mapping ? mapfn(O[index], index) : O[index];
createProperty(result, index, value);
}
}
result.length = index;
return result;
};
/***/ }),
/* 141 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var anObject = __webpack_require__(44);
var iteratorClose = __webpack_require__(119);
// call something on iterator step with safe closing on error
module.exports = function (iterator, fn, value, ENTRIES) {
try {
return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
} catch (error) {
iteratorClose(iterator, 'throw', error);
}
};
/***/ }),
/* 142 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var wellKnownSymbol = __webpack_require__(31);
var ITERATOR = wellKnownSymbol('iterator');
var SAFE_CLOSING = false;
try {
var called = 0;
var iteratorWithReturn = {
next: function () {
return { done: !!called++ };
},
'return': function () {
SAFE_CLOSING = true;
}
};
iteratorWithReturn[ITERATOR] = function () {
return this;
};
// eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing
Array.from(iteratorWithReturn, function () { throw 2; });
} catch (error) { /* empty */ }
module.exports = function (exec, SKIP_CLOSING) {
if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
var ITERATION_SUPPORT = false;
try {
var object = {};
object[ITERATOR] = function () {
return {
next: function () {
return { done: ITERATION_SUPPORT = true };
}
};
};
exec(object);
} catch (error) { /* empty */ }
return ITERATION_SUPPORT;
};
/***/ }),
/* 143 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $includes = (__webpack_require__(56).includes);
var addToUnscopables = __webpack_require__(122);
// `Array.prototype.includes` method
// https://tc39.es/ecma262/#sec-array.prototype.includes
$({ target: 'Array', proto: true }, {
includes: function includes(el /* , fromIndex = 0 */) {
return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
}
});
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('includes');
/***/ }),
/* 144 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
/* eslint-disable es/no-array-prototype-indexof -- required for testing */
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var $IndexOf = (__webpack_require__(56).indexOf);
var arrayMethodIsStrict = __webpack_require__(128);
var un$IndexOf = uncurryThis([].indexOf);
var NEGATIVE_ZERO = !!un$IndexOf && 1 / un$IndexOf([1], 1, -0) < 0;
var STRICT_METHOD = arrayMethodIsStrict('indexOf');
// `Array.prototype.indexOf` method
// https://tc39.es/ecma262/#sec-array.prototype.indexof
$({ target: 'Array', proto: true, forced: NEGATIVE_ZERO || !STRICT_METHOD }, {
indexOf: function indexOf(searchElement /* , fromIndex = 0 */) {
var fromIndex = arguments.length > 1 ? arguments[1] : undefined;
return NEGATIVE_ZERO
// convert -0 to +0
? un$IndexOf(this, searchElement, fromIndex) || 0
: $IndexOf(this, searchElement, fromIndex);
}
});
/***/ }),
/* 145 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var isArray = __webpack_require__(65);
// `Array.isArray` method
// https://tc39.es/ecma262/#sec-array.isarray
$({ target: 'Array', stat: true }, {
isArray: isArray
});
/***/ }),
/* 146 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var toIndexedObject = __webpack_require__(11);
var addToUnscopables = __webpack_require__(122);
var Iterators = __webpack_require__(116);
var InternalStateModule = __webpack_require__(47);
var defineProperty = (__webpack_require__(42).f);
var defineIterator = __webpack_require__(147);
var IS_PURE = __webpack_require__(33);
var DESCRIPTORS = __webpack_require__(5);
var ARRAY_ITERATOR = 'Array Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
// `Array.prototype.entries` method
// https://tc39.es/ecma262/#sec-array.prototype.entries
// `Array.prototype.keys` method
// https://tc39.es/ecma262/#sec-array.prototype.keys
// `Array.prototype.values` method
// https://tc39.es/ecma262/#sec-array.prototype.values
// `Array.prototype[@@iterator]` method
// https://tc39.es/ecma262/#sec-array.prototype-@@iterator
// `CreateArrayIterator` internal method
// https://tc39.es/ecma262/#sec-createarrayiterator
module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
setInternalState(this, {
type: ARRAY_ITERATOR,
target: toIndexedObject(iterated), // target
index: 0, // next index
kind: kind // kind
});
// `%ArrayIteratorPrototype%.next` method
// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next
}, function () {
var state = getInternalState(this);
var target = state.target;
var kind = state.kind;
var index = state.index++;
if (!target || index >= target.length) {
state.target = undefined;
return { value: undefined, done: true };
}
if (kind == 'keys') return { value: index, done: false };
if (kind == 'values') return { value: target[index], done: false };
return { value: [index, target[index]], done: false };
}, 'values');
// argumentsList[@@iterator] is %ArrayProto_values%
// https://tc39.es/ecma262/#sec-createunmappedargumentsobject
// https://tc39.es/ecma262/#sec-createmappedargumentsobject
var values = Iterators.Arguments = Iterators.Array;
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('keys');
addToUnscopables('values');
addToUnscopables('entries');
// V8 ~ Chrome 45- bug
if (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {
defineProperty(values, 'name', { value: 'values' });
} catch (error) { /* empty */ }
/***/ }),
/* 147 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var call = __webpack_require__(7);
var IS_PURE = __webpack_require__(33);
var FunctionName = __webpack_require__(51);
var isCallable = __webpack_require__(19);
var createIteratorConstructor = __webpack_require__(148);
var getPrototypeOf = __webpack_require__(112);
var setPrototypeOf = __webpack_require__(102);
var setToStringTag = __webpack_require__(80);
var createNonEnumerableProperty = __webpack_require__(41);
var redefine = __webpack_require__(45);
var wellKnownSymbol = __webpack_require__(31);
var Iterators = __webpack_require__(116);
var IteratorsCore = __webpack_require__(149);
var PROPER_FUNCTION_NAME = FunctionName.PROPER;
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
var IteratorPrototype = IteratorsCore.IteratorPrototype;
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
var ITERATOR = wellKnownSymbol('iterator');
var KEYS = 'keys';
var VALUES = 'values';
var ENTRIES = 'entries';
var returnThis = function () { return this; };
module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
createIteratorConstructor(IteratorConstructor, NAME, next);
var getIterationMethod = function (KIND) {
if (KIND === DEFAULT && defaultIterator) return defaultIterator;
if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
switch (KIND) {
case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
} return function () { return new IteratorConstructor(this); };
};
var TO_STRING_TAG = NAME + ' Iterator';
var INCORRECT_VALUES_NAME = false;
var IterablePrototype = Iterable.prototype;
var nativeIterator = IterablePrototype[ITERATOR]
|| IterablePrototype['@@iterator']
|| DEFAULT && IterablePrototype[DEFAULT];
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
var CurrentIteratorPrototype, methods, KEY;
// fix native
if (anyNativeIterator) {
CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
if (setPrototypeOf) {
setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
} else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {
redefine(CurrentIteratorPrototype, ITERATOR, returnThis);
}
}
// Set @@toStringTag to native iterators
setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
}
}
// fix Array.prototype.{ values, @@iterator }.name in V8 / FF
if (PROPER_FUNCTION_NAME && DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {
createNonEnumerableProperty(IterablePrototype, 'name', VALUES);
} else {
INCORRECT_VALUES_NAME = true;
defaultIterator = function values() { return call(nativeIterator, this); };
}
}
// export additional methods
if (DEFAULT) {
methods = {
values: getIterationMethod(VALUES),
keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
entries: getIterationMethod(ENTRIES)
};
if (FORCED) for (KEY in methods) {
if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
redefine(IterablePrototype, KEY, methods[KEY]);
}
} else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
}
// define iterator
if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
redefine(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });
}
Iterators[NAME] = defaultIterator;
return methods;
};
/***/ }),
/* 148 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var IteratorPrototype = (__webpack_require__(149).IteratorPrototype);
var create = __webpack_require__(69);
var createPropertyDescriptor = __webpack_require__(10);
var setToStringTag = __webpack_require__(80);
var Iterators = __webpack_require__(116);
var returnThis = function () { return this; };
module.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {
var TO_STRING_TAG = NAME + ' Iterator';
IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });
setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
Iterators[TO_STRING_TAG] = returnThis;
return IteratorConstructor;
};
/***/ }),
/* 149 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var fails = __webpack_require__(6);
var isCallable = __webpack_require__(19);
var create = __webpack_require__(69);
var getPrototypeOf = __webpack_require__(112);
var redefine = __webpack_require__(45);
var wellKnownSymbol = __webpack_require__(31);
var IS_PURE = __webpack_require__(33);
var ITERATOR = wellKnownSymbol('iterator');
var BUGGY_SAFARI_ITERATORS = false;
// `%IteratorPrototype%` object
// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
/* eslint-disable es/no-array-prototype-keys -- safe */
if ([].keys) {
arrayIterator = [].keys();
// Safari 8 has buggy iterators w/o `next`
if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
else {
PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
}
}
var NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {
var test = {};
// FF44- legacy iterators case
return IteratorPrototype[ITERATOR].call(test) !== test;
});
if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
// `%IteratorPrototype%[@@iterator]()` method
// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
if (!isCallable(IteratorPrototype[ITERATOR])) {
redefine(IteratorPrototype, ITERATOR, function () {
return this;
});
}
module.exports = {
IteratorPrototype: IteratorPrototype,
BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
};
/***/ }),
/* 150 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var IndexedObject = __webpack_require__(12);
var toIndexedObject = __webpack_require__(11);
var arrayMethodIsStrict = __webpack_require__(128);
var un$Join = uncurryThis([].join);
var ES3_STRINGS = IndexedObject != Object;
var STRICT_METHOD = arrayMethodIsStrict('join', ',');
// `Array.prototype.join` method
// https://tc39.es/ecma262/#sec-array.prototype.join
$({ target: 'Array', proto: true, forced: ES3_STRINGS || !STRICT_METHOD }, {
join: function join(separator) {
return un$Join(toIndexedObject(this), separator === undefined ? ',' : separator);
}
});
/***/ }),
/* 151 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var lastIndexOf = __webpack_require__(152);
// `Array.prototype.lastIndexOf` method
// https://tc39.es/ecma262/#sec-array.prototype.lastindexof
// eslint-disable-next-line es/no-array-prototype-lastindexof -- required for testing
$({ target: 'Array', proto: true, forced: lastIndexOf !== [].lastIndexOf }, {
lastIndexOf: lastIndexOf
});
/***/ }),
/* 152 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
/* eslint-disable es/no-array-prototype-lastindexof -- safe */
var apply = __webpack_require__(64);
var toIndexedObject = __webpack_require__(11);
var toIntegerOrInfinity = __webpack_require__(58);
var lengthOfArrayLike = __webpack_require__(59);
var arrayMethodIsStrict = __webpack_require__(128);
var min = Math.min;
var $lastIndexOf = [].lastIndexOf;
var NEGATIVE_ZERO = !!$lastIndexOf && 1 / [1].lastIndexOf(1, -0) < 0;
var STRICT_METHOD = arrayMethodIsStrict('lastIndexOf');
var FORCED = NEGATIVE_ZERO || !STRICT_METHOD;
// `Array.prototype.lastIndexOf` method implementation
// https://tc39.es/ecma262/#sec-array.prototype.lastindexof
module.exports = FORCED ? function lastIndexOf(searchElement /* , fromIndex = @[*-1] */) {
// convert -0 to +0
if (NEGATIVE_ZERO) return apply($lastIndexOf, this, arguments) || 0;
var O = toIndexedObject(this);
var length = lengthOfArrayLike(O);
var index = length - 1;
if (arguments.length > 1) index = min(index, toIntegerOrInfinity(arguments[1]));
if (index < 0) index = length + index;
for (;index >= 0; index--) if (index in O && O[index] === searchElement) return index || 0;
return -1;
} : $lastIndexOf;
/***/ }),
/* 153 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $map = (__webpack_require__(81).map);
var arrayMethodHasSpeciesSupport = __webpack_require__(124);
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');
// `Array.prototype.map` method
// https://tc39.es/ecma262/#sec-array.prototype.map
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
map: function map(callbackfn /* , thisArg */) {
return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 154 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var fails = __webpack_require__(6);
var isConstructor = __webpack_require__(85);
var createProperty = __webpack_require__(75);
var Array = global.Array;
var ISNT_GENERIC = fails(function () {
function F() { /* empty */ }
return !(Array.of.call(F) instanceof F);
});
// `Array.of` method
// https://tc39.es/ecma262/#sec-array.of
// WebKit Array.of isn't generic
$({ target: 'Array', stat: true, forced: ISNT_GENERIC }, {
of: function of(/* ...args */) {
var index = 0;
var argumentsLength = arguments.length;
var result = new (isConstructor(this) ? this : Array)(argumentsLength);
while (argumentsLength > index) createProperty(result, index, arguments[index++]);
result.length = argumentsLength;
return result;
}
});
/***/ }),
/* 155 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $reduce = (__webpack_require__(156).left);
var arrayMethodIsStrict = __webpack_require__(128);
var CHROME_VERSION = __webpack_require__(25);
var IS_NODE = __webpack_require__(157);
var STRICT_METHOD = arrayMethodIsStrict('reduce');
// Chrome 80-82 has a critical bug
// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;
// `Array.prototype.reduce` method
// https://tc39.es/ecma262/#sec-array.prototype.reduce
$({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, {
reduce: function reduce(callbackfn /* , initialValue */) {
var length = arguments.length;
return $reduce(this, callbackfn, length, length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 156 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var aCallable = __webpack_require__(28);
var toObject = __webpack_require__(37);
var IndexedObject = __webpack_require__(12);
var lengthOfArrayLike = __webpack_require__(59);
var TypeError = global.TypeError;
// `Array.prototype.{ reduce, reduceRight }` methods implementation
var createMethod = function (IS_RIGHT) {
return function (that, callbackfn, argumentsLength, memo) {
aCallable(callbackfn);
var O = toObject(that);
var self = IndexedObject(O);
var length = lengthOfArrayLike(O);
var index = IS_RIGHT ? length - 1 : 0;
var i = IS_RIGHT ? -1 : 1;
if (argumentsLength < 2) while (true) {
if (index in self) {
memo = self[index];
index += i;
break;
}
index += i;
if (IS_RIGHT ? index < 0 : length <= index) {
throw TypeError('Reduce of empty array with no initial value');
}
}
for (;IS_RIGHT ? index >= 0 : length > index; index += i) if (index in self) {
memo = callbackfn(memo, self[index], index, O);
}
return memo;
};
};
module.exports = {
// `Array.prototype.reduce` method
// https://tc39.es/ecma262/#sec-array.prototype.reduce
left: createMethod(false),
// `Array.prototype.reduceRight` method
// https://tc39.es/ecma262/#sec-array.prototype.reduceright
right: createMethod(true)
};
/***/ }),
/* 157 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var classof = __webpack_require__(14);
var global = __webpack_require__(3);
module.exports = classof(global.process) == 'process';
/***/ }),
/* 158 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $reduceRight = (__webpack_require__(156).right);
var arrayMethodIsStrict = __webpack_require__(128);
var CHROME_VERSION = __webpack_require__(25);
var IS_NODE = __webpack_require__(157);
var STRICT_METHOD = arrayMethodIsStrict('reduceRight');
// Chrome 80-82 has a critical bug
// https://bugs.chromium.org/p/chromium/issues/detail?id=1049982
var CHROME_BUG = !IS_NODE && CHROME_VERSION > 79 && CHROME_VERSION < 83;
// `Array.prototype.reduceRight` method
// https://tc39.es/ecma262/#sec-array.prototype.reduceright
$({ target: 'Array', proto: true, forced: !STRICT_METHOD || CHROME_BUG }, {
reduceRight: function reduceRight(callbackfn /* , initialValue */) {
return $reduceRight(this, callbackfn, arguments.length, arguments.length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 159 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var isArray = __webpack_require__(65);
var un$Reverse = uncurryThis([].reverse);
var test = [1, 2];
// `Array.prototype.reverse` method
// https://tc39.es/ecma262/#sec-array.prototype.reverse
// fix for Safari 12.0 bug
// https://bugs.webkit.org/show_bug.cgi?id=188794
$({ target: 'Array', proto: true, forced: String(test) === String(test.reverse()) }, {
reverse: function reverse() {
// eslint-disable-next-line no-self-assign -- dirty hack
if (isArray(this)) this.length = this.length;
return un$Reverse(this);
}
});
/***/ }),
/* 160 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var isArray = __webpack_require__(65);
var isConstructor = __webpack_require__(85);
var isObject = __webpack_require__(18);
var toAbsoluteIndex = __webpack_require__(57);
var lengthOfArrayLike = __webpack_require__(59);
var toIndexedObject = __webpack_require__(11);
var createProperty = __webpack_require__(75);
var wellKnownSymbol = __webpack_require__(31);
var arrayMethodHasSpeciesSupport = __webpack_require__(124);
var un$Slice = __webpack_require__(76);
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');
var SPECIES = wellKnownSymbol('species');
var Array = global.Array;
var max = Math.max;
// `Array.prototype.slice` method
// https://tc39.es/ecma262/#sec-array.prototype.slice
// fallback for not array-like ES3 strings and DOM objects
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
slice: function slice(start, end) {
var O = toIndexedObject(this);
var length = lengthOfArrayLike(O);
var k = toAbsoluteIndex(start, length);
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
// inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible
var Constructor, result, n;
if (isArray(O)) {
Constructor = O.constructor;
// cross-realm fallback
if (isConstructor(Constructor) && (Constructor === Array || isArray(Constructor.prototype))) {
Constructor = undefined;
} else if (isObject(Constructor)) {
Constructor = Constructor[SPECIES];
if (Constructor === null) Constructor = undefined;
}
if (Constructor === Array || Constructor === undefined) {
return un$Slice(O, k, fin);
}
}
result = new (Constructor === undefined ? Array : Constructor)(max(fin - k, 0));
for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);
result.length = n;
return result;
}
});
/***/ }),
/* 161 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $some = (__webpack_require__(81).some);
var arrayMethodIsStrict = __webpack_require__(128);
var STRICT_METHOD = arrayMethodIsStrict('some');
// `Array.prototype.some` method
// https://tc39.es/ecma262/#sec-array.prototype.some
$({ target: 'Array', proto: true, forced: !STRICT_METHOD }, {
some: function some(callbackfn /* , thisArg */) {
return $some(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 162 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var aCallable = __webpack_require__(28);
var toObject = __webpack_require__(37);
var lengthOfArrayLike = __webpack_require__(59);
var toString = __webpack_require__(66);
var fails = __webpack_require__(6);
var internalSort = __webpack_require__(163);
var arrayMethodIsStrict = __webpack_require__(128);
var FF = __webpack_require__(164);
var IE_OR_EDGE = __webpack_require__(165);
var V8 = __webpack_require__(25);
var WEBKIT = __webpack_require__(166);
var test = [];
var un$Sort = uncurryThis(test.sort);
var push = uncurryThis(test.push);
// IE8-
var FAILS_ON_UNDEFINED = fails(function () {
test.sort(undefined);
});
// V8 bug
var FAILS_ON_NULL = fails(function () {
test.sort(null);
});
// Old WebKit
var STRICT_METHOD = arrayMethodIsStrict('sort');
var STABLE_SORT = !fails(function () {
// feature detection can be too slow, so check engines versions
if (V8) return V8 < 70;
if (FF && FF > 3) return;
if (IE_OR_EDGE) return true;
if (WEBKIT) return WEBKIT < 603;
var result = '';
var code, chr, value, index;
// generate an array with more 512 elements (Chakra and old V8 fails only in this case)
for (code = 65; code < 76; code++) {
chr = String.fromCharCode(code);
switch (code) {
case 66: case 69: case 70: case 72: value = 3; break;
case 68: case 71: value = 4; break;
default: value = 2;
}
for (index = 0; index < 47; index++) {
test.push({ k: chr + index, v: value });
}
}
test.sort(function (a, b) { return b.v - a.v; });
for (index = 0; index < test.length; index++) {
chr = test[index].k.charAt(0);
if (result.charAt(result.length - 1) !== chr) result += chr;
}
return result !== 'DGBEFHACIJK';
});
var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;
var getSortCompare = function (comparefn) {
return function (x, y) {
if (y === undefined) return -1;
if (x === undefined) return 1;
if (comparefn !== undefined) return +comparefn(x, y) || 0;
return toString(x) > toString(y) ? 1 : -1;
};
};
// `Array.prototype.sort` method
// https://tc39.es/ecma262/#sec-array.prototype.sort
$({ target: 'Array', proto: true, forced: FORCED }, {
sort: function sort(comparefn) {
if (comparefn !== undefined) aCallable(comparefn);
var array = toObject(this);
if (STABLE_SORT) return comparefn === undefined ? un$Sort(array) : un$Sort(array, comparefn);
var items = [];
var arrayLength = lengthOfArrayLike(array);
var itemsLength, index;
for (index = 0; index < arrayLength; index++) {
if (index in array) push(items, array[index]);
}
internalSort(items, getSortCompare(comparefn));
itemsLength = items.length;
index = 0;
while (index < itemsLength) array[index] = items[index++];
while (index < arrayLength) delete array[index++];
return array;
}
});
/***/ }),
/* 163 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var arraySlice = __webpack_require__(74);
var floor = Math.floor;
var mergeSort = function (array, comparefn) {
var length = array.length;
var middle = floor(length / 2);
return length < 8 ? insertionSort(array, comparefn) : merge(
array,
mergeSort(arraySlice(array, 0, middle), comparefn),
mergeSort(arraySlice(array, middle), comparefn),
comparefn
);
};
var insertionSort = function (array, comparefn) {
var length = array.length;
var i = 1;
var element, j;
while (i < length) {
j = i;
element = array[i];
while (j && comparefn(array[j - 1], element) > 0) {
array[j] = array[--j];
}
if (j !== i++) array[j] = element;
} return array;
};
var merge = function (array, left, right, comparefn) {
var llength = left.length;
var rlength = right.length;
var lindex = 0;
var rindex = 0;
while (lindex < llength || rindex < rlength) {
array[lindex + rindex] = (lindex < llength && rindex < rlength)
? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]
: lindex < llength ? left[lindex++] : right[rindex++];
} return array;
};
module.exports = mergeSort;
/***/ }),
/* 164 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var userAgent = __webpack_require__(26);
var firefox = userAgent.match(/firefox\/(\d+)/i);
module.exports = !!firefox && +firefox[1];
/***/ }),
/* 165 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var UA = __webpack_require__(26);
module.exports = /MSIE|Trident/.test(UA);
/***/ }),
/* 166 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var userAgent = __webpack_require__(26);
var webkit = userAgent.match(/AppleWebKit\/(\d+)\./);
module.exports = !!webkit && +webkit[1];
/***/ }),
/* 167 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var setSpecies = __webpack_require__(168);
// `Array[@@species]` getter
// https://tc39.es/ecma262/#sec-get-array-@@species
setSpecies('Array');
/***/ }),
/* 168 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var getBuiltIn = __webpack_require__(21);
var definePropertyModule = __webpack_require__(42);
var wellKnownSymbol = __webpack_require__(31);
var DESCRIPTORS = __webpack_require__(5);
var SPECIES = wellKnownSymbol('species');
module.exports = function (CONSTRUCTOR_NAME) {
var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
var defineProperty = definePropertyModule.f;
if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
defineProperty(Constructor, SPECIES, {
configurable: true,
get: function () { return this; }
});
}
};
/***/ }),
/* 169 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var toAbsoluteIndex = __webpack_require__(57);
var toIntegerOrInfinity = __webpack_require__(58);
var lengthOfArrayLike = __webpack_require__(59);
var toObject = __webpack_require__(37);
var arraySpeciesCreate = __webpack_require__(83);
var createProperty = __webpack_require__(75);
var arrayMethodHasSpeciesSupport = __webpack_require__(124);
var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('splice');
var TypeError = global.TypeError;
var max = Math.max;
var min = Math.min;
var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;
var MAXIMUM_ALLOWED_LENGTH_EXCEEDED = 'Maximum allowed length exceeded';
// `Array.prototype.splice` method
// https://tc39.es/ecma262/#sec-array.prototype.splice
// with adding support of @@species
$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {
splice: function splice(start, deleteCount /* , ...items */) {
var O = toObject(this);
var len = lengthOfArrayLike(O);
var actualStart = toAbsoluteIndex(start, len);
var argumentsLength = arguments.length;
var insertCount, actualDeleteCount, A, k, from, to;
if (argumentsLength === 0) {
insertCount = actualDeleteCount = 0;
} else if (argumentsLength === 1) {
insertCount = 0;
actualDeleteCount = len - actualStart;
} else {
insertCount = argumentsLength - 2;
actualDeleteCount = min(max(toIntegerOrInfinity(deleteCount), 0), len - actualStart);
}
if (len + insertCount - actualDeleteCount > MAX_SAFE_INTEGER) {
throw TypeError(MAXIMUM_ALLOWED_LENGTH_EXCEEDED);
}
A = arraySpeciesCreate(O, actualDeleteCount);
for (k = 0; k < actualDeleteCount; k++) {
from = actualStart + k;
if (from in O) createProperty(A, k, O[from]);
}
A.length = actualDeleteCount;
if (insertCount < actualDeleteCount) {
for (k = actualStart; k < len - actualDeleteCount; k++) {
from = k + actualDeleteCount;
to = k + insertCount;
if (from in O) O[to] = O[from];
else delete O[to];
}
for (k = len; k > len - actualDeleteCount + insertCount; k--) delete O[k - 1];
} else if (insertCount > actualDeleteCount) {
for (k = len - actualDeleteCount; k > actualStart; k--) {
from = k + actualDeleteCount - 1;
to = k + insertCount - 1;
if (from in O) O[to] = O[from];
else delete O[to];
}
}
for (k = 0; k < insertCount; k++) {
O[k + actualStart] = arguments[k + 2];
}
O.length = len - actualDeleteCount + insertCount;
return A;
}
});
/***/ }),
/* 170 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
// this method was added to unscopables after implementation
// in popular engines, so it's moved to a separate module
var addToUnscopables = __webpack_require__(122);
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('flat');
/***/ }),
/* 171 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
// this method was added to unscopables after implementation
// in popular engines, so it's moved to a separate module
var addToUnscopables = __webpack_require__(122);
// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
addToUnscopables('flatMap');
/***/ }),
/* 172 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var arrayBufferModule = __webpack_require__(173);
var setSpecies = __webpack_require__(168);
var ARRAY_BUFFER = 'ArrayBuffer';
var ArrayBuffer = arrayBufferModule[ARRAY_BUFFER];
var NativeArrayBuffer = global[ARRAY_BUFFER];
// `ArrayBuffer` constructor
// https://tc39.es/ecma262/#sec-arraybuffer-constructor
$({ global: true, forced: NativeArrayBuffer !== ArrayBuffer }, {
ArrayBuffer: ArrayBuffer
});
setSpecies(ARRAY_BUFFER);
/***/ }),
/* 173 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var DESCRIPTORS = __webpack_require__(5);
var NATIVE_ARRAY_BUFFER = __webpack_require__(174);
var FunctionName = __webpack_require__(51);
var createNonEnumerableProperty = __webpack_require__(41);
var redefineAll = __webpack_require__(175);
var fails = __webpack_require__(6);
var anInstance = __webpack_require__(176);
var toIntegerOrInfinity = __webpack_require__(58);
var toLength = __webpack_require__(60);
var toIndex = __webpack_require__(177);
var IEEE754 = __webpack_require__(178);
var getPrototypeOf = __webpack_require__(112);
var setPrototypeOf = __webpack_require__(102);
var getOwnPropertyNames = (__webpack_require__(54).f);
var defineProperty = (__webpack_require__(42).f);
var arrayFill = __webpack_require__(130);
var arraySlice = __webpack_require__(74);
var setToStringTag = __webpack_require__(80);
var InternalStateModule = __webpack_require__(47);
var PROPER_FUNCTION_NAME = FunctionName.PROPER;
var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;
var getInternalState = InternalStateModule.get;
var setInternalState = InternalStateModule.set;
var ARRAY_BUFFER = 'ArrayBuffer';
var DATA_VIEW = 'DataView';
var PROTOTYPE = 'prototype';
var WRONG_LENGTH = 'Wrong length';
var WRONG_INDEX = 'Wrong index';
var NativeArrayBuffer = global[ARRAY_BUFFER];
var $ArrayBuffer = NativeArrayBuffer;
var ArrayBufferPrototype = $ArrayBuffer && $ArrayBuffer[PROTOTYPE];
var $DataView = global[DATA_VIEW];
var DataViewPrototype = $DataView && $DataView[PROTOTYPE];
var ObjectPrototype = Object.prototype;
var Array = global.Array;
var RangeError = global.RangeError;
var fill = uncurryThis(arrayFill);
var reverse = uncurryThis([].reverse);
var packIEEE754 = IEEE754.pack;
var unpackIEEE754 = IEEE754.unpack;
var packInt8 = function (number) {
return [number & 0xFF];
};
var packInt16 = function (number) {
return [number & 0xFF, number >> 8 & 0xFF];
};
var packInt32 = function (number) {
return [number & 0xFF, number >> 8 & 0xFF, number >> 16 & 0xFF, number >> 24 & 0xFF];
};
var unpackInt32 = function (buffer) {
return buffer[3] << 24 | buffer[2] << 16 | buffer[1] << 8 | buffer[0];
};
var packFloat32 = function (number) {
return packIEEE754(number, 23, 4);
};
var packFloat64 = function (number) {
return packIEEE754(number, 52, 8);
};
var addGetter = function (Constructor, key) {
defineProperty(Constructor[PROTOTYPE], key, { get: function () { return getInternalState(this)[key]; } });
};
var get = function (view, count, index, isLittleEndian) {
var intIndex = toIndex(index);
var store = getInternalState(view);
if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX);
var bytes = getInternalState(store.buffer).bytes;
var start = intIndex + store.byteOffset;
var pack = arraySlice(bytes, start, start + count);
return isLittleEndian ? pack : reverse(pack);
};
var set = function (view, count, index, conversion, value, isLittleEndian) {
var intIndex = toIndex(index);
var store = getInternalState(view);
if (intIndex + count > store.byteLength) throw RangeError(WRONG_INDEX);
var bytes = getInternalState(store.buffer).bytes;
var start = intIndex + store.byteOffset;
var pack = conversion(+value);
for (var i = 0; i < count; i++) bytes[start + i] = pack[isLittleEndian ? i : count - i - 1];
};
if (!NATIVE_ARRAY_BUFFER) {
$ArrayBuffer = function ArrayBuffer(length) {
anInstance(this, ArrayBufferPrototype);
var byteLength = toIndex(length);
setInternalState(this, {
bytes: fill(Array(byteLength), 0),
byteLength: byteLength
});
if (!DESCRIPTORS) this.byteLength = byteLength;
};
ArrayBufferPrototype = $ArrayBuffer[PROTOTYPE];
$DataView = function DataView(buffer, byteOffset, byteLength) {
anInstance(this, DataViewPrototype);
anInstance(buffer, ArrayBufferPrototype);
var bufferLength = getInternalState(buffer).byteLength;
var offset = toIntegerOrInfinity(byteOffset);
if (offset < 0 || offset > bufferLength) throw RangeError('Wrong offset');
byteLength = byteLength === undefined ? bufferLength - offset : toLength(byteLength);
if (offset + byteLength > bufferLength) throw RangeError(WRONG_LENGTH);
setInternalState(this, {
buffer: buffer,
byteLength: byteLength,
byteOffset: offset
});
if (!DESCRIPTORS) {
this.buffer = buffer;
this.byteLength = byteLength;
this.byteOffset = offset;
}
};
DataViewPrototype = $DataView[PROTOTYPE];
if (DESCRIPTORS) {
addGetter($ArrayBuffer, 'byteLength');
addGetter($DataView, 'buffer');
addGetter($DataView, 'byteLength');
addGetter($DataView, 'byteOffset');
}
redefineAll(DataViewPrototype, {
getInt8: function getInt8(byteOffset) {
return get(this, 1, byteOffset)[0] << 24 >> 24;
},
getUint8: function getUint8(byteOffset) {
return get(this, 1, byteOffset)[0];
},
getInt16: function getInt16(byteOffset /* , littleEndian */) {
var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined);
return (bytes[1] << 8 | bytes[0]) << 16 >> 16;
},
getUint16: function getUint16(byteOffset /* , littleEndian */) {
var bytes = get(this, 2, byteOffset, arguments.length > 1 ? arguments[1] : undefined);
return bytes[1] << 8 | bytes[0];
},
getInt32: function getInt32(byteOffset /* , littleEndian */) {
return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined));
},
getUint32: function getUint32(byteOffset /* , littleEndian */) {
return unpackInt32(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined)) >>> 0;
},
getFloat32: function getFloat32(byteOffset /* , littleEndian */) {
return unpackIEEE754(get(this, 4, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 23);
},
getFloat64: function getFloat64(byteOffset /* , littleEndian */) {
return unpackIEEE754(get(this, 8, byteOffset, arguments.length > 1 ? arguments[1] : undefined), 52);
},
setInt8: function setInt8(byteOffset, value) {
set(this, 1, byteOffset, packInt8, value);
},
setUint8: function setUint8(byteOffset, value) {
set(this, 1, byteOffset, packInt8, value);
},
setInt16: function setInt16(byteOffset, value /* , littleEndian */) {
set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined);
},
setUint16: function setUint16(byteOffset, value /* , littleEndian */) {
set(this, 2, byteOffset, packInt16, value, arguments.length > 2 ? arguments[2] : undefined);
},
setInt32: function setInt32(byteOffset, value /* , littleEndian */) {
set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined);
},
setUint32: function setUint32(byteOffset, value /* , littleEndian */) {
set(this, 4, byteOffset, packInt32, value, arguments.length > 2 ? arguments[2] : undefined);
},
setFloat32: function setFloat32(byteOffset, value /* , littleEndian */) {
set(this, 4, byteOffset, packFloat32, value, arguments.length > 2 ? arguments[2] : undefined);
},
setFloat64: function setFloat64(byteOffset, value /* , littleEndian */) {
set(this, 8, byteOffset, packFloat64, value, arguments.length > 2 ? arguments[2] : undefined);
}
});
} else {
var INCORRECT_ARRAY_BUFFER_NAME = PROPER_FUNCTION_NAME && NativeArrayBuffer.name !== ARRAY_BUFFER;
/* eslint-disable no-new -- required for testing */
if (!fails(function () {
NativeArrayBuffer(1);
}) || !fails(function () {
new NativeArrayBuffer(-1);
}) || fails(function () {
new NativeArrayBuffer();
new NativeArrayBuffer(1.5);
new NativeArrayBuffer(NaN);
return INCORRECT_ARRAY_BUFFER_NAME && !CONFIGURABLE_FUNCTION_NAME;
})) {
/* eslint-enable no-new -- required for testing */
$ArrayBuffer = function ArrayBuffer(length) {
anInstance(this, ArrayBufferPrototype);
return new NativeArrayBuffer(toIndex(length));
};
$ArrayBuffer[PROTOTYPE] = ArrayBufferPrototype;
for (var keys = getOwnPropertyNames(NativeArrayBuffer), j = 0, key; keys.length > j;) {
if (!((key = keys[j++]) in $ArrayBuffer)) {
createNonEnumerableProperty($ArrayBuffer, key, NativeArrayBuffer[key]);
}
}
ArrayBufferPrototype.constructor = $ArrayBuffer;
} else if (INCORRECT_ARRAY_BUFFER_NAME && CONFIGURABLE_FUNCTION_NAME) {
createNonEnumerableProperty(NativeArrayBuffer, 'name', ARRAY_BUFFER);
}
// WebKit bug - the same parent prototype for typed arrays and data view
if (setPrototypeOf && getPrototypeOf(DataViewPrototype) !== ObjectPrototype) {
setPrototypeOf(DataViewPrototype, ObjectPrototype);
}
// iOS Safari 7.x bug
var testView = new $DataView(new $ArrayBuffer(2));
var $setInt8 = uncurryThis(DataViewPrototype.setInt8);
testView.setInt8(0, 2147483648);
testView.setInt8(1, 2147483649);
if (testView.getInt8(0) || !testView.getInt8(1)) redefineAll(DataViewPrototype, {
setInt8: function setInt8(byteOffset, value) {
$setInt8(this, byteOffset, value << 24 >> 24);
},
setUint8: function setUint8(byteOffset, value) {
$setInt8(this, byteOffset, value << 24 >> 24);
}
}, { unsafe: true });
}
setToStringTag($ArrayBuffer, ARRAY_BUFFER);
setToStringTag($DataView, DATA_VIEW);
module.exports = {
ArrayBuffer: $ArrayBuffer,
DataView: $DataView
};
/***/ }),
/* 174 */
/***/ (function(module) {
// eslint-disable-next-line es/no-typed-arrays -- safe
module.exports = typeof ArrayBuffer != 'undefined' && typeof DataView != 'undefined';
/***/ }),
/* 175 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var redefine = __webpack_require__(45);
module.exports = function (target, src, options) {
for (var key in src) redefine(target, key, src[key], options);
return target;
};
/***/ }),
/* 176 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isPrototypeOf = __webpack_require__(22);
var TypeError = global.TypeError;
module.exports = function (it, Prototype) {
if (isPrototypeOf(Prototype, it)) return it;
throw TypeError('Incorrect invocation');
};
/***/ }),
/* 177 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var toIntegerOrInfinity = __webpack_require__(58);
var toLength = __webpack_require__(60);
var RangeError = global.RangeError;
// `ToIndex` abstract operation
// https://tc39.es/ecma262/#sec-toindex
module.exports = function (it) {
if (it === undefined) return 0;
var number = toIntegerOrInfinity(it);
var length = toLength(number);
if (number !== length) throw RangeError('Wrong length or index');
return length;
};
/***/ }),
/* 178 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// IEEE754 conversions based on https://github.com/feross/ieee754
var global = __webpack_require__(3);
var Array = global.Array;
var abs = Math.abs;
var pow = Math.pow;
var floor = Math.floor;
var log = Math.log;
var LN2 = Math.LN2;
var pack = function (number, mantissaLength, bytes) {
var buffer = Array(bytes);
var exponentLength = bytes * 8 - mantissaLength - 1;
var eMax = (1 << exponentLength) - 1;
var eBias = eMax >> 1;
var rt = mantissaLength === 23 ? pow(2, -24) - pow(2, -77) : 0;
var sign = number < 0 || number === 0 && 1 / number < 0 ? 1 : 0;
var index = 0;
var exponent, mantissa, c;
number = abs(number);
// eslint-disable-next-line no-self-compare -- NaN check
if (number != number || number === Infinity) {
// eslint-disable-next-line no-self-compare -- NaN check
mantissa = number != number ? 1 : 0;
exponent = eMax;
} else {
exponent = floor(log(number) / LN2);
c = pow(2, -exponent);
if (number * c < 1) {
exponent--;
c *= 2;
}
if (exponent + eBias >= 1) {
number += rt / c;
} else {
number += rt * pow(2, 1 - eBias);
}
if (number * c >= 2) {
exponent++;
c /= 2;
}
if (exponent + eBias >= eMax) {
mantissa = 0;
exponent = eMax;
} else if (exponent + eBias >= 1) {
mantissa = (number * c - 1) * pow(2, mantissaLength);
exponent = exponent + eBias;
} else {
mantissa = number * pow(2, eBias - 1) * pow(2, mantissaLength);
exponent = 0;
}
}
while (mantissaLength >= 8) {
buffer[index++] = mantissa & 255;
mantissa /= 256;
mantissaLength -= 8;
}
exponent = exponent << mantissaLength | mantissa;
exponentLength += mantissaLength;
while (exponentLength > 0) {
buffer[index++] = exponent & 255;
exponent /= 256;
exponentLength -= 8;
}
buffer[--index] |= sign * 128;
return buffer;
};
var unpack = function (buffer, mantissaLength) {
var bytes = buffer.length;
var exponentLength = bytes * 8 - mantissaLength - 1;
var eMax = (1 << exponentLength) - 1;
var eBias = eMax >> 1;
var nBits = exponentLength - 7;
var index = bytes - 1;
var sign = buffer[index--];
var exponent = sign & 127;
var mantissa;
sign >>= 7;
while (nBits > 0) {
exponent = exponent * 256 + buffer[index--];
nBits -= 8;
}
mantissa = exponent & (1 << -nBits) - 1;
exponent >>= -nBits;
nBits += mantissaLength;
while (nBits > 0) {
mantissa = mantissa * 256 + buffer[index--];
nBits -= 8;
}
if (exponent === 0) {
exponent = 1 - eBias;
} else if (exponent === eMax) {
return mantissa ? NaN : sign ? -Infinity : Infinity;
} else {
mantissa = mantissa + pow(2, mantissaLength);
exponent = exponent - eBias;
} return (sign ? -1 : 1) * mantissa * pow(2, exponent - mantissaLength);
};
module.exports = {
pack: pack,
unpack: unpack
};
/***/ }),
/* 179 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var ArrayBufferViewCore = __webpack_require__(180);
var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS;
// `ArrayBuffer.isView` method
// https://tc39.es/ecma262/#sec-arraybuffer.isview
$({ target: 'ArrayBuffer', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {
isView: ArrayBufferViewCore.isView
});
/***/ }),
/* 180 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var NATIVE_ARRAY_BUFFER = __webpack_require__(174);
var DESCRIPTORS = __webpack_require__(5);
var global = __webpack_require__(3);
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var hasOwn = __webpack_require__(36);
var classof = __webpack_require__(67);
var tryToString = __webpack_require__(29);
var createNonEnumerableProperty = __webpack_require__(41);
var redefine = __webpack_require__(45);
var defineProperty = (__webpack_require__(42).f);
var isPrototypeOf = __webpack_require__(22);
var getPrototypeOf = __webpack_require__(112);
var setPrototypeOf = __webpack_require__(102);
var wellKnownSymbol = __webpack_require__(31);
var uid = __webpack_require__(38);
var Int8Array = global.Int8Array;
var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
var Uint8ClampedArray = global.Uint8ClampedArray;
var Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;
var TypedArray = Int8Array && getPrototypeOf(Int8Array);
var TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);
var ObjectPrototype = Object.prototype;
var TypeError = global.TypeError;
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');
var TYPED_ARRAY_CONSTRUCTOR = uid('TYPED_ARRAY_CONSTRUCTOR');
// Fixing native typed arrays in Opera Presto crashes the browser, see #595
var NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';
var TYPED_ARRAY_TAG_REQUIRED = false;
var NAME, Constructor, Prototype;
var TypedArrayConstructorsList = {
Int8Array: 1,
Uint8Array: 1,
Uint8ClampedArray: 1,
Int16Array: 2,
Uint16Array: 2,
Int32Array: 4,
Uint32Array: 4,
Float32Array: 4,
Float64Array: 8
};
var BigIntArrayConstructorsList = {
BigInt64Array: 8,
BigUint64Array: 8
};
var isView = function isView(it) {
if (!isObject(it)) return false;
var klass = classof(it);
return klass === 'DataView'
|| hasOwn(TypedArrayConstructorsList, klass)
|| hasOwn(BigIntArrayConstructorsList, klass);
};
var isTypedArray = function (it) {
if (!isObject(it)) return false;
var klass = classof(it);
return hasOwn(TypedArrayConstructorsList, klass)
|| hasOwn(BigIntArrayConstructorsList, klass);
};
var aTypedArray = function (it) {
if (isTypedArray(it)) return it;
throw TypeError('Target is not a typed array');
};
var aTypedArrayConstructor = function (C) {
if (isCallable(C) && (!setPrototypeOf || isPrototypeOf(TypedArray, C))) return C;
throw TypeError(tryToString(C) + ' is not a typed array constructor');
};
var exportTypedArrayMethod = function (KEY, property, forced, options) {
if (!DESCRIPTORS) return;
if (forced) for (var ARRAY in TypedArrayConstructorsList) {
var TypedArrayConstructor = global[ARRAY];
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor.prototype, KEY)) try {
delete TypedArrayConstructor.prototype[KEY];
} catch (error) {
// old WebKit bug - some methods are non-configurable
try {
TypedArrayConstructor.prototype[KEY] = property;
} catch (error2) { /* empty */ }
}
}
if (!TypedArrayPrototype[KEY] || forced) {
redefine(TypedArrayPrototype, KEY, forced ? property
: NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property, options);
}
};
var exportTypedArrayStaticMethod = function (KEY, property, forced) {
var ARRAY, TypedArrayConstructor;
if (!DESCRIPTORS) return;
if (setPrototypeOf) {
if (forced) for (ARRAY in TypedArrayConstructorsList) {
TypedArrayConstructor = global[ARRAY];
if (TypedArrayConstructor && hasOwn(TypedArrayConstructor, KEY)) try {
delete TypedArrayConstructor[KEY];
} catch (error) { /* empty */ }
}
if (!TypedArray[KEY] || forced) {
// V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable
try {
return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && TypedArray[KEY] || property);
} catch (error) { /* empty */ }
} else return;
}
for (ARRAY in TypedArrayConstructorsList) {
TypedArrayConstructor = global[ARRAY];
if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {
redefine(TypedArrayConstructor, KEY, property);
}
}
};
for (NAME in TypedArrayConstructorsList) {
Constructor = global[NAME];
Prototype = Constructor && Constructor.prototype;
if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);
else NATIVE_ARRAY_BUFFER_VIEWS = false;
}
for (NAME in BigIntArrayConstructorsList) {
Constructor = global[NAME];
Prototype = Constructor && Constructor.prototype;
if (Prototype) createNonEnumerableProperty(Prototype, TYPED_ARRAY_CONSTRUCTOR, Constructor);
}
// WebKit bug - typed arrays constructors prototype is Object.prototype
if (!NATIVE_ARRAY_BUFFER_VIEWS || !isCallable(TypedArray) || TypedArray === Function.prototype) {
// eslint-disable-next-line no-shadow -- safe
TypedArray = function TypedArray() {
throw TypeError('Incorrect invocation');
};
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);
}
}
if (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {
TypedArrayPrototype = TypedArray.prototype;
if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {
if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);
}
}
// WebKit bug - one more object in Uint8ClampedArray prototype chain
if (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {
setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);
}
if (DESCRIPTORS && !hasOwn(TypedArrayPrototype, TO_STRING_TAG)) {
TYPED_ARRAY_TAG_REQUIRED = true;
defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () {
return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;
} });
for (NAME in TypedArrayConstructorsList) if (global[NAME]) {
createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);
}
}
module.exports = {
NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,
TYPED_ARRAY_CONSTRUCTOR: TYPED_ARRAY_CONSTRUCTOR,
TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQUIRED && TYPED_ARRAY_TAG,
aTypedArray: aTypedArray,
aTypedArrayConstructor: aTypedArrayConstructor,
exportTypedArrayMethod: exportTypedArrayMethod,
exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,
isView: isView,
isTypedArray: isTypedArray,
TypedArray: TypedArray,
TypedArrayPrototype: TypedArrayPrototype
};
/***/ }),
/* 181 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var ArrayBufferModule = __webpack_require__(173);
var anObject = __webpack_require__(44);
var toAbsoluteIndex = __webpack_require__(57);
var toLength = __webpack_require__(60);
var speciesConstructor = __webpack_require__(182);
var ArrayBuffer = ArrayBufferModule.ArrayBuffer;
var DataView = ArrayBufferModule.DataView;
var DataViewPrototype = DataView.prototype;
var un$ArrayBufferSlice = uncurryThis(ArrayBuffer.prototype.slice);
var getUint8 = uncurryThis(DataViewPrototype.getUint8);
var setUint8 = uncurryThis(DataViewPrototype.setUint8);
var INCORRECT_SLICE = fails(function () {
return !new ArrayBuffer(2).slice(1, undefined).byteLength;
});
// `ArrayBuffer.prototype.slice` method
// https://tc39.es/ecma262/#sec-arraybuffer.prototype.slice
$({ target: 'ArrayBuffer', proto: true, unsafe: true, forced: INCORRECT_SLICE }, {
slice: function slice(start, end) {
if (un$ArrayBufferSlice && end === undefined) {
return un$ArrayBufferSlice(anObject(this), start); // FF fix
}
var length = anObject(this).byteLength;
var first = toAbsoluteIndex(start, length);
var fin = toAbsoluteIndex(end === undefined ? length : end, length);
var result = new (speciesConstructor(this, ArrayBuffer))(toLength(fin - first));
var viewSource = new DataView(this);
var viewTarget = new DataView(result);
var index = 0;
while (first < fin) {
setUint8(viewTarget, index++, getUint8(viewSource, first++));
} return result;
}
});
/***/ }),
/* 182 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var anObject = __webpack_require__(44);
var aConstructor = __webpack_require__(183);
var wellKnownSymbol = __webpack_require__(31);
var SPECIES = wellKnownSymbol('species');
// `SpeciesConstructor` abstract operation
// https://tc39.es/ecma262/#sec-speciesconstructor
module.exports = function (O, defaultConstructor) {
var C = anObject(O).constructor;
var S;
return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aConstructor(S);
};
/***/ }),
/* 183 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isConstructor = __webpack_require__(85);
var tryToString = __webpack_require__(29);
var TypeError = global.TypeError;
// `Assert: IsConstructor(argument) is true`
module.exports = function (argument) {
if (isConstructor(argument)) return argument;
throw TypeError(tryToString(argument) + ' is not a constructor');
};
/***/ }),
/* 184 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var ArrayBufferModule = __webpack_require__(173);
var NATIVE_ARRAY_BUFFER = __webpack_require__(174);
// `DataView` constructor
// https://tc39.es/ecma262/#sec-dataview-constructor
$({ global: true, forced: !NATIVE_ARRAY_BUFFER }, {
DataView: ArrayBufferModule.DataView
});
/***/ }),
/* 185 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var FORCED = fails(function () {
return new Date(16e11).getYear() !== 120;
});
var getFullYear = uncurryThis(Date.prototype.getFullYear);
// `Date.prototype.getYear` method
// https://tc39.es/ecma262/#sec-date.prototype.getyear
$({ target: 'Date', proto: true, forced: FORCED }, {
getYear: function getYear() {
return getFullYear(this) - 1900;
}
});
/***/ }),
/* 186 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var Date = global.Date;
var getTime = uncurryThis(Date.prototype.getTime);
// `Date.now` method
// https://tc39.es/ecma262/#sec-date.now
$({ target: 'Date', stat: true }, {
now: function now() {
return getTime(new Date());
}
});
/***/ }),
/* 187 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var toIntegerOrInfinity = __webpack_require__(58);
var DatePrototype = Date.prototype;
var getTime = uncurryThis(DatePrototype.getTime);
var setFullYear = uncurryThis(DatePrototype.setFullYear);
// `Date.prototype.setYear` method
// https://tc39.es/ecma262/#sec-date.prototype.setyear
$({ target: 'Date', proto: true }, {
setYear: function setYear(year) {
// validate
getTime(this);
var yi = toIntegerOrInfinity(year);
var yyyy = 0 <= yi && yi <= 99 ? yi + 1900 : yi;
return setFullYear(this, yyyy);
}
});
/***/ }),
/* 188 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// `Date.prototype.toGMTString` method
// https://tc39.es/ecma262/#sec-date.prototype.togmtstring
$({ target: 'Date', proto: true }, {
toGMTString: Date.prototype.toUTCString
});
/***/ }),
/* 189 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var toISOString = __webpack_require__(190);
// `Date.prototype.toISOString` method
// https://tc39.es/ecma262/#sec-date.prototype.toisostring
// PhantomJS / old WebKit has a broken implementations
$({ target: 'Date', proto: true, forced: Date.prototype.toISOString !== toISOString }, {
toISOString: toISOString
});
/***/ }),
/* 190 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var padStart = (__webpack_require__(191).start);
var RangeError = global.RangeError;
var abs = Math.abs;
var DatePrototype = Date.prototype;
var n$DateToISOString = DatePrototype.toISOString;
var getTime = uncurryThis(DatePrototype.getTime);
var getUTCDate = uncurryThis(DatePrototype.getUTCDate);
var getUTCFullYear = uncurryThis(DatePrototype.getUTCFullYear);
var getUTCHours = uncurryThis(DatePrototype.getUTCHours);
var getUTCMilliseconds = uncurryThis(DatePrototype.getUTCMilliseconds);
var getUTCMinutes = uncurryThis(DatePrototype.getUTCMinutes);
var getUTCMonth = uncurryThis(DatePrototype.getUTCMonth);
var getUTCSeconds = uncurryThis(DatePrototype.getUTCSeconds);
// `Date.prototype.toISOString` method implementation
// https://tc39.es/ecma262/#sec-date.prototype.toisostring
// PhantomJS / old WebKit fails here:
module.exports = (fails(function () {
return n$DateToISOString.call(new Date(-5e13 - 1)) != '0385-07-25T07:06:39.999Z';
}) || !fails(function () {
n$DateToISOString.call(new Date(NaN));
})) ? function toISOString() {
if (!isFinite(getTime(this))) throw RangeError('Invalid time value');
var date = this;
var year = getUTCFullYear(date);
var milliseconds = getUTCMilliseconds(date);
var sign = year < 0 ? '-' : year > 9999 ? '+' : '';
return sign + padStart(abs(year), sign ? 6 : 4, 0) +
'-' + padStart(getUTCMonth(date) + 1, 2, 0) +
'-' + padStart(getUTCDate(date), 2, 0) +
'T' + padStart(getUTCHours(date), 2, 0) +
':' + padStart(getUTCMinutes(date), 2, 0) +
':' + padStart(getUTCSeconds(date), 2, 0) +
'.' + padStart(milliseconds, 3, 0) +
'Z';
} : n$DateToISOString;
/***/ }),
/* 191 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// https://github.com/tc39/proposal-string-pad-start-end
var uncurryThis = __webpack_require__(13);
var toLength = __webpack_require__(60);
var toString = __webpack_require__(66);
var $repeat = __webpack_require__(192);
var requireObjectCoercible = __webpack_require__(15);
var repeat = uncurryThis($repeat);
var stringSlice = uncurryThis(''.slice);
var ceil = Math.ceil;
// `String.prototype.{ padStart, padEnd }` methods implementation
var createMethod = function (IS_END) {
return function ($this, maxLength, fillString) {
var S = toString(requireObjectCoercible($this));
var intMaxLength = toLength(maxLength);
var stringLength = S.length;
var fillStr = fillString === undefined ? ' ' : toString(fillString);
var fillLen, stringFiller;
if (intMaxLength <= stringLength || fillStr == '') return S;
fillLen = intMaxLength - stringLength;
stringFiller = repeat(fillStr, ceil(fillLen / fillStr.length));
if (stringFiller.length > fillLen) stringFiller = stringSlice(stringFiller, 0, fillLen);
return IS_END ? S + stringFiller : stringFiller + S;
};
};
module.exports = {
// `String.prototype.padStart` method
// https://tc39.es/ecma262/#sec-string.prototype.padstart
start: createMethod(false),
// `String.prototype.padEnd` method
// https://tc39.es/ecma262/#sec-string.prototype.padend
end: createMethod(true)
};
/***/ }),
/* 192 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var toIntegerOrInfinity = __webpack_require__(58);
var toString = __webpack_require__(66);
var requireObjectCoercible = __webpack_require__(15);
var RangeError = global.RangeError;
// `String.prototype.repeat` method implementation
// https://tc39.es/ecma262/#sec-string.prototype.repeat
module.exports = function repeat(count) {
var str = toString(requireObjectCoercible(this));
var result = '';
var n = toIntegerOrInfinity(count);
if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions');
for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str;
return result;
};
/***/ }),
/* 193 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
var toObject = __webpack_require__(37);
var toPrimitive = __webpack_require__(17);
var FORCED = fails(function () {
return new Date(NaN).toJSON() !== null
|| Date.prototype.toJSON.call({ toISOString: function () { return 1; } }) !== 1;
});
// `Date.prototype.toJSON` method
// https://tc39.es/ecma262/#sec-date.prototype.tojson
$({ target: 'Date', proto: true, forced: FORCED }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
toJSON: function toJSON(key) {
var O = toObject(this);
var pv = toPrimitive(O, 'number');
return typeof pv == 'number' && !isFinite(pv) ? null : O.toISOString();
}
});
/***/ }),
/* 194 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var hasOwn = __webpack_require__(36);
var redefine = __webpack_require__(45);
var dateToPrimitive = __webpack_require__(195);
var wellKnownSymbol = __webpack_require__(31);
var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
var DatePrototype = Date.prototype;
// `Date.prototype[@@toPrimitive]` method
// https://tc39.es/ecma262/#sec-date.prototype-@@toprimitive
if (!hasOwn(DatePrototype, TO_PRIMITIVE)) {
redefine(DatePrototype, TO_PRIMITIVE, dateToPrimitive);
}
/***/ }),
/* 195 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var anObject = __webpack_require__(44);
var ordinaryToPrimitive = __webpack_require__(30);
var TypeError = global.TypeError;
// `Date.prototype[@@toPrimitive](hint)` method implementation
// https://tc39.es/ecma262/#sec-date.prototype-@@toprimitive
module.exports = function (hint) {
anObject(this);
if (hint === 'string' || hint === 'default') hint = 'string';
else if (hint !== 'number') throw TypeError('Incorrect hint');
return ordinaryToPrimitive(this, hint);
};
/***/ }),
/* 196 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var redefine = __webpack_require__(45);
var DatePrototype = Date.prototype;
var INVALID_DATE = 'Invalid Date';
var TO_STRING = 'toString';
var un$DateToString = uncurryThis(DatePrototype[TO_STRING]);
var getTime = uncurryThis(DatePrototype.getTime);
// `Date.prototype.toString` method
// https://tc39.es/ecma262/#sec-date.prototype.tostring
if (String(new Date(NaN)) != INVALID_DATE) {
redefine(DatePrototype, TO_STRING, function toString() {
var value = getTime(this);
// eslint-disable-next-line no-self-compare -- NaN check
return value === value ? un$DateToString(this) : INVALID_DATE;
});
}
/***/ }),
/* 197 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var toString = __webpack_require__(66);
var charAt = uncurryThis(''.charAt);
var charCodeAt = uncurryThis(''.charCodeAt);
var exec = uncurryThis(/./.exec);
var numberToString = uncurryThis(1.0.toString);
var toUpperCase = uncurryThis(''.toUpperCase);
var raw = /[\w*+\-./@]/;
var hex = function (code, length) {
var result = numberToString(code, 16);
while (result.length < length) result = '0' + result;
return result;
};
// `escape` method
// https://tc39.es/ecma262/#sec-escape-string
$({ global: true }, {
escape: function escape(string) {
var str = toString(string);
var result = '';
var length = str.length;
var index = 0;
var chr, code;
while (index < length) {
chr = charAt(str, index++);
if (exec(raw, chr)) {
result += chr;
} else {
code = charCodeAt(chr, 0);
if (code < 256) {
result += '%' + hex(code, 2);
} else {
result += '%u' + toUpperCase(hex(code, 4));
}
}
} return result;
}
});
/***/ }),
/* 198 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var bind = __webpack_require__(199);
// `Function.prototype.bind` method
// https://tc39.es/ecma262/#sec-function.prototype.bind
$({ target: 'Function', proto: true, forced: Function.bind !== bind }, {
bind: bind
});
/***/ }),
/* 199 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var aCallable = __webpack_require__(28);
var isObject = __webpack_require__(18);
var hasOwn = __webpack_require__(36);
var arraySlice = __webpack_require__(76);
var NATIVE_BIND = __webpack_require__(8);
var Function = global.Function;
var concat = uncurryThis([].concat);
var join = uncurryThis([].join);
var factories = {};
var construct = function (C, argsLength, args) {
if (!hasOwn(factories, argsLength)) {
for (var list = [], i = 0; i < argsLength; i++) list[i] = 'a[' + i + ']';
factories[argsLength] = Function('C,a', 'return new C(' + join(list, ',') + ')');
} return factories[argsLength](C, args);
};
// `Function.prototype.bind` method implementation
// https://tc39.es/ecma262/#sec-function.prototype.bind
module.exports = NATIVE_BIND ? Function.bind : function bind(that /* , ...args */) {
var F = aCallable(this);
var Prototype = F.prototype;
var partArgs = arraySlice(arguments, 1);
var boundFunction = function bound(/* args... */) {
var args = concat(partArgs, arraySlice(arguments));
return this instanceof boundFunction ? construct(F, args.length, args) : F.apply(that, args);
};
if (isObject(Prototype)) boundFunction.prototype = Prototype;
return boundFunction;
};
/***/ }),
/* 200 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var definePropertyModule = __webpack_require__(42);
var getPrototypeOf = __webpack_require__(112);
var wellKnownSymbol = __webpack_require__(31);
var HAS_INSTANCE = wellKnownSymbol('hasInstance');
var FunctionPrototype = Function.prototype;
// `Function.prototype[@@hasInstance]` method
// https://tc39.es/ecma262/#sec-function.prototype-@@hasinstance
if (!(HAS_INSTANCE in FunctionPrototype)) {
definePropertyModule.f(FunctionPrototype, HAS_INSTANCE, { value: function (O) {
if (!isCallable(this) || !isObject(O)) return false;
var P = this.prototype;
if (!isObject(P)) return O instanceof this;
// for environment w/o native `@@hasInstance` logic enough `instanceof`, but add this:
while (O = getPrototypeOf(O)) if (P === O) return true;
return false;
} });
}
/***/ }),
/* 201 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var FUNCTION_NAME_EXISTS = (__webpack_require__(51).EXISTS);
var uncurryThis = __webpack_require__(13);
var defineProperty = (__webpack_require__(42).f);
var FunctionPrototype = Function.prototype;
var functionToString = uncurryThis(FunctionPrototype.toString);
var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/;
var regExpExec = uncurryThis(nameRE.exec);
var NAME = 'name';
// Function instances `.name` property
// https://tc39.es/ecma262/#sec-function-instances-name
if (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {
defineProperty(FunctionPrototype, NAME, {
configurable: true,
get: function () {
try {
return regExpExec(nameRE, functionToString(this))[1];
} catch (error) {
return '';
}
}
});
}
/***/ }),
/* 202 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
// `globalThis` object
// https://tc39.es/ecma262/#sec-globalthis
$({ global: true }, {
globalThis: global
});
/***/ }),
/* 203 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var getBuiltIn = __webpack_require__(21);
var apply = __webpack_require__(64);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var Array = global.Array;
var $stringify = getBuiltIn('JSON', 'stringify');
var exec = uncurryThis(/./.exec);
var charAt = uncurryThis(''.charAt);
var charCodeAt = uncurryThis(''.charCodeAt);
var replace = uncurryThis(''.replace);
var numberToString = uncurryThis(1.0.toString);
var tester = /[\uD800-\uDFFF]/g;
var low = /^[\uD800-\uDBFF]$/;
var hi = /^[\uDC00-\uDFFF]$/;
var fix = function (match, offset, string) {
var prev = charAt(string, offset - 1);
var next = charAt(string, offset + 1);
if ((exec(low, match) && !exec(hi, next)) || (exec(hi, match) && !exec(low, prev))) {
return '\\u' + numberToString(charCodeAt(match, 0), 16);
} return match;
};
var FORCED = fails(function () {
return $stringify('\uDF06\uD834') !== '"\\udf06\\ud834"'
|| $stringify('\uDEAD') !== '"\\udead"';
});
if ($stringify) {
// `JSON.stringify` method
// https://tc39.es/ecma262/#sec-json.stringify
// https://github.com/tc39/proposal-well-formed-stringify
$({ target: 'JSON', stat: true, forced: FORCED }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
stringify: function stringify(it, replacer, space) {
for (var i = 0, l = arguments.length, args = Array(l); i < l; i++) args[i] = arguments[i];
var result = apply($stringify, null, args);
return typeof result == 'string' ? replace(result, tester, fix) : result;
}
});
}
/***/ }),
/* 204 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var setToStringTag = __webpack_require__(80);
// JSON[@@toStringTag] property
// https://tc39.es/ecma262/#sec-json-@@tostringtag
setToStringTag(global.JSON, 'JSON', true);
/***/ }),
/* 205 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var collection = __webpack_require__(206);
var collectionStrong = __webpack_require__(211);
// `Map` constructor
// https://tc39.es/ecma262/#sec-map-objects
collection('Map', function (init) {
return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };
}, collectionStrong);
/***/ }),
/* 206 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var isForced = __webpack_require__(63);
var redefine = __webpack_require__(45);
var InternalMetadataModule = __webpack_require__(207);
var iterate = __webpack_require__(114);
var anInstance = __webpack_require__(176);
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var fails = __webpack_require__(6);
var checkCorrectnessOfIteration = __webpack_require__(142);
var setToStringTag = __webpack_require__(80);
var inheritIfRequired = __webpack_require__(104);
module.exports = function (CONSTRUCTOR_NAME, wrapper, common) {
var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;
var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;
var ADDER = IS_MAP ? 'set' : 'add';
var NativeConstructor = global[CONSTRUCTOR_NAME];
var NativePrototype = NativeConstructor && NativeConstructor.prototype;
var Constructor = NativeConstructor;
var exported = {};
var fixMethod = function (KEY) {
var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);
redefine(NativePrototype, KEY,
KEY == 'add' ? function add(value) {
uncurriedNativeMethod(this, value === 0 ? 0 : value);
return this;
} : KEY == 'delete' ? function (key) {
return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);
} : KEY == 'get' ? function get(key) {
return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);
} : KEY == 'has' ? function has(key) {
return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);
} : function set(key, value) {
uncurriedNativeMethod(this, key === 0 ? 0 : key, value);
return this;
}
);
};
var REPLACE = isForced(
CONSTRUCTOR_NAME,
!isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {
new NativeConstructor().entries().next();
}))
);
if (REPLACE) {
// create collection constructor
Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);
InternalMetadataModule.enable();
} else if (isForced(CONSTRUCTOR_NAME, true)) {
var instance = new Constructor();
// early implementations not supports chaining
var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
// V8 ~ Chromium 40- weak-collections throws on primitives, but should return false
var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });
// most early implementations doesn't supports iterables, most modern - not close it correctly
// eslint-disable-next-line no-new -- required for testing
var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });
// for early implementations -0 and +0 not the same
var BUGGY_ZERO = !IS_WEAK && fails(function () {
// V8 ~ Chromium 42- fails only with 5+ elements
var $instance = new NativeConstructor();
var index = 5;
while (index--) $instance[ADDER](index, index);
return !$instance.has(-0);
});
if (!ACCEPT_ITERABLES) {
Constructor = wrapper(function (dummy, iterable) {
anInstance(dummy, NativePrototype);
var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);
if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });
return that;
});
Constructor.prototype = NativePrototype;
NativePrototype.constructor = Constructor;
}
if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
fixMethod('delete');
fixMethod('has');
IS_MAP && fixMethod('get');
}
if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
// weak collections should not contains .clear method
if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;
}
exported[CONSTRUCTOR_NAME] = Constructor;
$({ global: true, forced: Constructor != NativeConstructor }, exported);
setToStringTag(Constructor, CONSTRUCTOR_NAME);
if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);
return Constructor;
};
/***/ }),
/* 207 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var hiddenKeys = __webpack_require__(50);
var isObject = __webpack_require__(18);
var hasOwn = __webpack_require__(36);
var defineProperty = (__webpack_require__(42).f);
var getOwnPropertyNamesModule = __webpack_require__(54);
var getOwnPropertyNamesExternalModule = __webpack_require__(73);
var isExtensible = __webpack_require__(208);
var uid = __webpack_require__(38);
var FREEZING = __webpack_require__(210);
var REQUIRED = false;
var METADATA = uid('meta');
var id = 0;
var setMetadata = function (it) {
defineProperty(it, METADATA, { value: {
objectID: 'O' + id++, // object ID
weakData: {} // weak collections IDs
} });
};
var fastKey = function (it, create) {
// return a primitive with prefix
if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
if (!hasOwn(it, METADATA)) {
// can't set metadata to uncaught frozen object
if (!isExtensible(it)) return 'F';
// not necessary to add metadata
if (!create) return 'E';
// add missing metadata
setMetadata(it);
// return object ID
} return it[METADATA].objectID;
};
var getWeakData = function (it, create) {
if (!hasOwn(it, METADATA)) {
// can't set metadata to uncaught frozen object
if (!isExtensible(it)) return true;
// not necessary to add metadata
if (!create) return false;
// add missing metadata
setMetadata(it);
// return the store of weak collections IDs
} return it[METADATA].weakData;
};
// add metadata on freeze-family methods calling
var onFreeze = function (it) {
if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);
return it;
};
var enable = function () {
meta.enable = function () { /* empty */ };
REQUIRED = true;
var getOwnPropertyNames = getOwnPropertyNamesModule.f;
var splice = uncurryThis([].splice);
var test = {};
test[METADATA] = 1;
// prevent exposing of metadata key
if (getOwnPropertyNames(test).length) {
getOwnPropertyNamesModule.f = function (it) {
var result = getOwnPropertyNames(it);
for (var i = 0, length = result.length; i < length; i++) {
if (result[i] === METADATA) {
splice(result, i, 1);
break;
}
} return result;
};
$({ target: 'Object', stat: true, forced: true }, {
getOwnPropertyNames: getOwnPropertyNamesExternalModule.f
});
}
};
var meta = module.exports = {
enable: enable,
fastKey: fastKey,
getWeakData: getWeakData,
onFreeze: onFreeze
};
hiddenKeys[METADATA] = true;
/***/ }),
/* 208 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var isObject = __webpack_require__(18);
var classof = __webpack_require__(14);
var ARRAY_BUFFER_NON_EXTENSIBLE = __webpack_require__(209);
// eslint-disable-next-line es/no-object-isextensible -- safe
var $isExtensible = Object.isExtensible;
var FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });
// `Object.isExtensible` method
// https://tc39.es/ecma262/#sec-object.isextensible
module.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {
if (!isObject(it)) return false;
if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) == 'ArrayBuffer') return false;
return $isExtensible ? $isExtensible(it) : true;
} : $isExtensible;
/***/ }),
/* 209 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it
var fails = __webpack_require__(6);
module.exports = fails(function () {
if (typeof ArrayBuffer == 'function') {
var buffer = new ArrayBuffer(8);
// eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe
if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });
}
});
/***/ }),
/* 210 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
module.exports = !fails(function () {
// eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing
return Object.isExtensible(Object.preventExtensions({}));
});
/***/ }),
/* 211 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var defineProperty = (__webpack_require__(42).f);
var create = __webpack_require__(69);
var redefineAll = __webpack_require__(175);
var bind = __webpack_require__(82);
var anInstance = __webpack_require__(176);
var iterate = __webpack_require__(114);
var defineIterator = __webpack_require__(147);
var setSpecies = __webpack_require__(168);
var DESCRIPTORS = __webpack_require__(5);
var fastKey = (__webpack_require__(207).fastKey);
var InternalStateModule = __webpack_require__(47);
var setInternalState = InternalStateModule.set;
var internalStateGetterFor = InternalStateModule.getterFor;
module.exports = {
getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
var Constructor = wrapper(function (that, iterable) {
anInstance(that, Prototype);
setInternalState(that, {
type: CONSTRUCTOR_NAME,
index: create(null),
first: undefined,
last: undefined,
size: 0
});
if (!DESCRIPTORS) that.size = 0;
if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });
});
var Prototype = Constructor.prototype;
var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
var define = function (that, key, value) {
var state = getInternalState(that);
var entry = getEntry(that, key);
var previous, index;
// change existing entry
if (entry) {
entry.value = value;
// create new entry
} else {
state.last = entry = {
index: index = fastKey(key, true),
key: key,
value: value,
previous: previous = state.last,
next: undefined,
removed: false
};
if (!state.first) state.first = entry;
if (previous) previous.next = entry;
if (DESCRIPTORS) state.size++;
else that.size++;
// add to index
if (index !== 'F') state.index[index] = entry;
} return that;
};
var getEntry = function (that, key) {
var state = getInternalState(that);
// fast case
var index = fastKey(key);
var entry;
if (index !== 'F') return state.index[index];
// frozen object case
for (entry = state.first; entry; entry = entry.next) {
if (entry.key == key) return entry;
}
};
redefineAll(Prototype, {
// `{ Map, Set }.prototype.clear()` methods
// https://tc39.es/ecma262/#sec-map.prototype.clear
// https://tc39.es/ecma262/#sec-set.prototype.clear
clear: function clear() {
var that = this;
var state = getInternalState(that);
var data = state.index;
var entry = state.first;
while (entry) {
entry.removed = true;
if (entry.previous) entry.previous = entry.previous.next = undefined;
delete data[entry.index];
entry = entry.next;
}
state.first = state.last = undefined;
if (DESCRIPTORS) state.size = 0;
else that.size = 0;
},
// `{ Map, Set }.prototype.delete(key)` methods
// https://tc39.es/ecma262/#sec-map.prototype.delete
// https://tc39.es/ecma262/#sec-set.prototype.delete
'delete': function (key) {
var that = this;
var state = getInternalState(that);
var entry = getEntry(that, key);
if (entry) {
var next = entry.next;
var prev = entry.previous;
delete state.index[entry.index];
entry.removed = true;
if (prev) prev.next = next;
if (next) next.previous = prev;
if (state.first == entry) state.first = next;
if (state.last == entry) state.last = prev;
if (DESCRIPTORS) state.size--;
else that.size--;
} return !!entry;
},
// `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods
// https://tc39.es/ecma262/#sec-map.prototype.foreach
// https://tc39.es/ecma262/#sec-set.prototype.foreach
forEach: function forEach(callbackfn /* , that = undefined */) {
var state = getInternalState(this);
var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);
var entry;
while (entry = entry ? entry.next : state.first) {
boundFunction(entry.value, entry.key, this);
// revert to the last existing entry
while (entry && entry.removed) entry = entry.previous;
}
},
// `{ Map, Set}.prototype.has(key)` methods
// https://tc39.es/ecma262/#sec-map.prototype.has
// https://tc39.es/ecma262/#sec-set.prototype.has
has: function has(key) {
return !!getEntry(this, key);
}
});
redefineAll(Prototype, IS_MAP ? {
// `Map.prototype.get(key)` method
// https://tc39.es/ecma262/#sec-map.prototype.get
get: function get(key) {
var entry = getEntry(this, key);
return entry && entry.value;
},
// `Map.prototype.set(key, value)` method
// https://tc39.es/ecma262/#sec-map.prototype.set
set: function set(key, value) {
return define(this, key === 0 ? 0 : key, value);
}
} : {
// `Set.prototype.add(value)` method
// https://tc39.es/ecma262/#sec-set.prototype.add
add: function add(value) {
return define(this, value = value === 0 ? 0 : value, value);
}
});
if (DESCRIPTORS) defineProperty(Prototype, 'size', {
get: function () {
return getInternalState(this).size;
}
});
return Constructor;
},
setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {
var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';
var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);
var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);
// `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods
// https://tc39.es/ecma262/#sec-map.prototype.entries
// https://tc39.es/ecma262/#sec-map.prototype.keys
// https://tc39.es/ecma262/#sec-map.prototype.values
// https://tc39.es/ecma262/#sec-map.prototype-@@iterator
// https://tc39.es/ecma262/#sec-set.prototype.entries
// https://tc39.es/ecma262/#sec-set.prototype.keys
// https://tc39.es/ecma262/#sec-set.prototype.values
// https://tc39.es/ecma262/#sec-set.prototype-@@iterator
defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {
setInternalState(this, {
type: ITERATOR_NAME,
target: iterated,
state: getInternalCollectionState(iterated),
kind: kind,
last: undefined
});
}, function () {
var state = getInternalIteratorState(this);
var kind = state.kind;
var entry = state.last;
// revert to the last existing entry
while (entry && entry.removed) entry = entry.previous;
// get next entry
if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {
// or finish the iteration
state.target = undefined;
return { value: undefined, done: true };
}
// return step by kind
if (kind == 'keys') return { value: entry.key, done: false };
if (kind == 'values') return { value: entry.value, done: false };
return { value: [entry.key, entry.value], done: false };
}, IS_MAP ? 'entries' : 'values', !IS_MAP, true);
// `{ Map, Set }.prototype[@@species]` accessors
// https://tc39.es/ecma262/#sec-get-map-@@species
// https://tc39.es/ecma262/#sec-get-set-@@species
setSpecies(CONSTRUCTOR_NAME);
}
};
/***/ }),
/* 212 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var log1p = __webpack_require__(213);
// eslint-disable-next-line es/no-math-acosh -- required for testing
var $acosh = Math.acosh;
var log = Math.log;
var sqrt = Math.sqrt;
var LN2 = Math.LN2;
var FORCED = !$acosh
// V8 bug: https://code.google.com/p/v8/issues/detail?id=3509
|| Math.floor($acosh(Number.MAX_VALUE)) != 710
// Tor Browser bug: Math.acosh(Infinity) -> NaN
|| $acosh(Infinity) != Infinity;
// `Math.acosh` method
// https://tc39.es/ecma262/#sec-math.acosh
$({ target: 'Math', stat: true, forced: FORCED }, {
acosh: function acosh(x) {
return (x = +x) < 1 ? NaN : x > 94906265.62425156
? log(x) + LN2
: log1p(x - 1 + sqrt(x - 1) * sqrt(x + 1));
}
});
/***/ }),
/* 213 */
/***/ (function(module) {
var log = Math.log;
// `Math.log1p` method implementation
// https://tc39.es/ecma262/#sec-math.log1p
// eslint-disable-next-line es/no-math-log1p -- safe
module.exports = Math.log1p || function log1p(x) {
return (x = +x) > -1e-8 && x < 1e-8 ? x - x * x / 2 : log(1 + x);
};
/***/ }),
/* 214 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// eslint-disable-next-line es/no-math-asinh -- required for testing
var $asinh = Math.asinh;
var log = Math.log;
var sqrt = Math.sqrt;
function asinh(x) {
return !isFinite(x = +x) || x == 0 ? x : x < 0 ? -asinh(-x) : log(x + sqrt(x * x + 1));
}
// `Math.asinh` method
// https://tc39.es/ecma262/#sec-math.asinh
// Tor Browser bug: Math.asinh(0) -> -0
$({ target: 'Math', stat: true, forced: !($asinh && 1 / $asinh(0) > 0) }, {
asinh: asinh
});
/***/ }),
/* 215 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// eslint-disable-next-line es/no-math-atanh -- required for testing
var $atanh = Math.atanh;
var log = Math.log;
// `Math.atanh` method
// https://tc39.es/ecma262/#sec-math.atanh
// Tor Browser bug: Math.atanh(-0) -> 0
$({ target: 'Math', stat: true, forced: !($atanh && 1 / $atanh(-0) < 0) }, {
atanh: function atanh(x) {
return (x = +x) == 0 ? x : log((1 + x) / (1 - x)) / 2;
}
});
/***/ }),
/* 216 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var sign = __webpack_require__(217);
var abs = Math.abs;
var pow = Math.pow;
// `Math.cbrt` method
// https://tc39.es/ecma262/#sec-math.cbrt
$({ target: 'Math', stat: true }, {
cbrt: function cbrt(x) {
return sign(x = +x) * pow(abs(x), 1 / 3);
}
});
/***/ }),
/* 217 */
/***/ (function(module) {
// `Math.sign` method implementation
// https://tc39.es/ecma262/#sec-math.sign
// eslint-disable-next-line es/no-math-sign -- safe
module.exports = Math.sign || function sign(x) {
// eslint-disable-next-line no-self-compare -- NaN check
return (x = +x) == 0 || x != x ? x : x < 0 ? -1 : 1;
};
/***/ }),
/* 218 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var floor = Math.floor;
var log = Math.log;
var LOG2E = Math.LOG2E;
// `Math.clz32` method
// https://tc39.es/ecma262/#sec-math.clz32
$({ target: 'Math', stat: true }, {
clz32: function clz32(x) {
return (x >>>= 0) ? 31 - floor(log(x + 0.5) * LOG2E) : 32;
}
});
/***/ }),
/* 219 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var expm1 = __webpack_require__(220);
// eslint-disable-next-line es/no-math-cosh -- required for testing
var $cosh = Math.cosh;
var abs = Math.abs;
var E = Math.E;
// `Math.cosh` method
// https://tc39.es/ecma262/#sec-math.cosh
$({ target: 'Math', stat: true, forced: !$cosh || $cosh(710) === Infinity }, {
cosh: function cosh(x) {
var t = expm1(abs(x) - 1) + 1;
return (t + 1 / (t * E * E)) * (E / 2);
}
});
/***/ }),
/* 220 */
/***/ (function(module) {
// eslint-disable-next-line es/no-math-expm1 -- safe
var $expm1 = Math.expm1;
var exp = Math.exp;
// `Math.expm1` method implementation
// https://tc39.es/ecma262/#sec-math.expm1
module.exports = (!$expm1
// Old FF bug
|| $expm1(10) > 22025.465794806719 || $expm1(10) < 22025.4657948067165168
// Tor Browser bug
|| $expm1(-2e-17) != -2e-17
) ? function expm1(x) {
return (x = +x) == 0 ? x : x > -1e-6 && x < 1e-6 ? x + x * x / 2 : exp(x) - 1;
} : $expm1;
/***/ }),
/* 221 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var expm1 = __webpack_require__(220);
// `Math.expm1` method
// https://tc39.es/ecma262/#sec-math.expm1
// eslint-disable-next-line es/no-math-expm1 -- required for testing
$({ target: 'Math', stat: true, forced: expm1 != Math.expm1 }, { expm1: expm1 });
/***/ }),
/* 222 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fround = __webpack_require__(223);
// `Math.fround` method
// https://tc39.es/ecma262/#sec-math.fround
$({ target: 'Math', stat: true }, { fround: fround });
/***/ }),
/* 223 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var sign = __webpack_require__(217);
var abs = Math.abs;
var pow = Math.pow;
var EPSILON = pow(2, -52);
var EPSILON32 = pow(2, -23);
var MAX32 = pow(2, 127) * (2 - EPSILON32);
var MIN32 = pow(2, -126);
var roundTiesToEven = function (n) {
return n + 1 / EPSILON - 1 / EPSILON;
};
// `Math.fround` method implementation
// https://tc39.es/ecma262/#sec-math.fround
// eslint-disable-next-line es/no-math-fround -- safe
module.exports = Math.fround || function fround(x) {
var $abs = abs(x);
var $sign = sign(x);
var a, result;
if ($abs < MIN32) return $sign * roundTiesToEven($abs / MIN32 / EPSILON32) * MIN32 * EPSILON32;
a = (1 + EPSILON32 / EPSILON) * $abs;
result = a - (a - $abs);
// eslint-disable-next-line no-self-compare -- NaN check
if (result > MAX32 || result != result) return $sign * Infinity;
return $sign * result;
};
/***/ }),
/* 224 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// eslint-disable-next-line es/no-math-hypot -- required for testing
var $hypot = Math.hypot;
var abs = Math.abs;
var sqrt = Math.sqrt;
// Chrome 77 bug
// https://bugs.chromium.org/p/v8/issues/detail?id=9546
var BUGGY = !!$hypot && $hypot(Infinity, NaN) !== Infinity;
// `Math.hypot` method
// https://tc39.es/ecma262/#sec-math.hypot
$({ target: 'Math', stat: true, forced: BUGGY }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
hypot: function hypot(value1, value2) {
var sum = 0;
var i = 0;
var aLen = arguments.length;
var larg = 0;
var arg, div;
while (i < aLen) {
arg = abs(arguments[i++]);
if (larg < arg) {
div = larg / arg;
sum = sum * div * div + 1;
larg = arg;
} else if (arg > 0) {
div = arg / larg;
sum += div * div;
} else sum += arg;
}
return larg === Infinity ? Infinity : larg * sqrt(sum);
}
});
/***/ }),
/* 225 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
// eslint-disable-next-line es/no-math-imul -- required for testing
var $imul = Math.imul;
var FORCED = fails(function () {
return $imul(0xFFFFFFFF, 5) != -5 || $imul.length != 2;
});
// `Math.imul` method
// https://tc39.es/ecma262/#sec-math.imul
// some WebKit versions fails with big numbers, some has wrong arity
$({ target: 'Math', stat: true, forced: FORCED }, {
imul: function imul(x, y) {
var UINT16 = 0xFFFF;
var xn = +x;
var yn = +y;
var xl = UINT16 & xn;
var yl = UINT16 & yn;
return 0 | xl * yl + ((UINT16 & xn >>> 16) * yl + xl * (UINT16 & yn >>> 16) << 16 >>> 0);
}
});
/***/ }),
/* 226 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var log10 = __webpack_require__(227);
// `Math.log10` method
// https://tc39.es/ecma262/#sec-math.log10
$({ target: 'Math', stat: true }, {
log10: log10
});
/***/ }),
/* 227 */
/***/ (function(module) {
var log = Math.log;
var LOG10E = Math.LOG10E;
// eslint-disable-next-line es/no-math-log10 -- safe
module.exports = Math.log10 || function log10(x) {
return log(x) * LOG10E;
};
/***/ }),
/* 228 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var log1p = __webpack_require__(213);
// `Math.log1p` method
// https://tc39.es/ecma262/#sec-math.log1p
$({ target: 'Math', stat: true }, { log1p: log1p });
/***/ }),
/* 229 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var log = Math.log;
var LN2 = Math.LN2;
// `Math.log2` method
// https://tc39.es/ecma262/#sec-math.log2
$({ target: 'Math', stat: true }, {
log2: function log2(x) {
return log(x) / LN2;
}
});
/***/ }),
/* 230 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var sign = __webpack_require__(217);
// `Math.sign` method
// https://tc39.es/ecma262/#sec-math.sign
$({ target: 'Math', stat: true }, {
sign: sign
});
/***/ }),
/* 231 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
var expm1 = __webpack_require__(220);
var abs = Math.abs;
var exp = Math.exp;
var E = Math.E;
var FORCED = fails(function () {
// eslint-disable-next-line es/no-math-sinh -- required for testing
return Math.sinh(-2e-17) != -2e-17;
});
// `Math.sinh` method
// https://tc39.es/ecma262/#sec-math.sinh
// V8 near Chromium 38 has a problem with very small numbers
$({ target: 'Math', stat: true, forced: FORCED }, {
sinh: function sinh(x) {
return abs(x = +x) < 1 ? (expm1(x) - expm1(-x)) / 2 : (exp(x - 1) - exp(-x - 1)) * (E / 2);
}
});
/***/ }),
/* 232 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var expm1 = __webpack_require__(220);
var exp = Math.exp;
// `Math.tanh` method
// https://tc39.es/ecma262/#sec-math.tanh
$({ target: 'Math', stat: true }, {
tanh: function tanh(x) {
var a = expm1(x = +x);
var b = expm1(-x);
return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (exp(x) + exp(-x));
}
});
/***/ }),
/* 233 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var setToStringTag = __webpack_require__(80);
// Math[@@toStringTag] property
// https://tc39.es/ecma262/#sec-math-@@tostringtag
setToStringTag(Math, 'Math', true);
/***/ }),
/* 234 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var ceil = Math.ceil;
var floor = Math.floor;
// `Math.trunc` method
// https://tc39.es/ecma262/#sec-math.trunc
$({ target: 'Math', stat: true }, {
trunc: function trunc(it) {
return (it > 0 ? floor : ceil)(it);
}
});
/***/ }),
/* 235 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var DESCRIPTORS = __webpack_require__(5);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var isForced = __webpack_require__(63);
var redefine = __webpack_require__(45);
var hasOwn = __webpack_require__(36);
var inheritIfRequired = __webpack_require__(104);
var isPrototypeOf = __webpack_require__(22);
var isSymbol = __webpack_require__(20);
var toPrimitive = __webpack_require__(17);
var fails = __webpack_require__(6);
var getOwnPropertyNames = (__webpack_require__(54).f);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
var defineProperty = (__webpack_require__(42).f);
var thisNumberValue = __webpack_require__(236);
var trim = (__webpack_require__(237).trim);
var NUMBER = 'Number';
var NativeNumber = global[NUMBER];
var NumberPrototype = NativeNumber.prototype;
var TypeError = global.TypeError;
var arraySlice = uncurryThis(''.slice);
var charCodeAt = uncurryThis(''.charCodeAt);
// `ToNumeric` abstract operation
// https://tc39.es/ecma262/#sec-tonumeric
var toNumeric = function (value) {
var primValue = toPrimitive(value, 'number');
return typeof primValue == 'bigint' ? primValue : toNumber(primValue);
};
// `ToNumber` abstract operation
// https://tc39.es/ecma262/#sec-tonumber
var toNumber = function (argument) {
var it = toPrimitive(argument, 'number');
var first, third, radix, maxCode, digits, length, index, code;
if (isSymbol(it)) throw TypeError('Cannot convert a Symbol value to a number');
if (typeof it == 'string' && it.length > 2) {
it = trim(it);
first = charCodeAt(it, 0);
if (first === 43 || first === 45) {
third = charCodeAt(it, 2);
if (third === 88 || third === 120) return NaN; // Number('+0x1') should be NaN, old V8 fix
} else if (first === 48) {
switch (charCodeAt(it, 1)) {
case 66: case 98: radix = 2; maxCode = 49; break; // fast equal of /^0b[01]+$/i
case 79: case 111: radix = 8; maxCode = 55; break; // fast equal of /^0o[0-7]+$/i
default: return +it;
}
digits = arraySlice(it, 2);
length = digits.length;
for (index = 0; index < length; index++) {
code = charCodeAt(digits, index);
// parseInt parses a string to a first unavailable symbol
// but ToNumber should return NaN if a string contains unavailable symbols
if (code < 48 || code > maxCode) return NaN;
} return parseInt(digits, radix);
}
} return +it;
};
// `Number` constructor
// https://tc39.es/ecma262/#sec-number-constructor
if (isForced(NUMBER, !NativeNumber(' 0o1') || !NativeNumber('0b1') || NativeNumber('+0x1'))) {
var NumberWrapper = function Number(value) {
var n = arguments.length < 1 ? 0 : NativeNumber(toNumeric(value));
var dummy = this;
// check on 1..constructor(foo) case
return isPrototypeOf(NumberPrototype, dummy) && fails(function () { thisNumberValue(dummy); })
? inheritIfRequired(Object(n), dummy, NumberWrapper) : n;
};
for (var keys = DESCRIPTORS ? getOwnPropertyNames(NativeNumber) : (
// ES3:
'MAX_VALUE,MIN_VALUE,NaN,NEGATIVE_INFINITY,POSITIVE_INFINITY,' +
// ES2015 (in case, if modules with ES2015 Number statics required before):
'EPSILON,MAX_SAFE_INTEGER,MIN_SAFE_INTEGER,isFinite,isInteger,isNaN,isSafeInteger,parseFloat,parseInt,' +
// ESNext
'fromString,range'
).split(','), j = 0, key; keys.length > j; j++) {
if (hasOwn(NativeNumber, key = keys[j]) && !hasOwn(NumberWrapper, key)) {
defineProperty(NumberWrapper, key, getOwnPropertyDescriptor(NativeNumber, key));
}
}
NumberWrapper.prototype = NumberPrototype;
NumberPrototype.constructor = NumberWrapper;
redefine(global, NUMBER, NumberWrapper);
}
/***/ }),
/* 236 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
// `thisNumberValue` abstract operation
// https://tc39.es/ecma262/#sec-thisnumbervalue
module.exports = uncurryThis(1.0.valueOf);
/***/ }),
/* 237 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var requireObjectCoercible = __webpack_require__(15);
var toString = __webpack_require__(66);
var whitespaces = __webpack_require__(238);
var replace = uncurryThis(''.replace);
var whitespace = '[' + whitespaces + ']';
var ltrim = RegExp('^' + whitespace + whitespace + '*');
var rtrim = RegExp(whitespace + whitespace + '*$');
// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation
var createMethod = function (TYPE) {
return function ($this) {
var string = toString(requireObjectCoercible($this));
if (TYPE & 1) string = replace(string, ltrim, '');
if (TYPE & 2) string = replace(string, rtrim, '');
return string;
};
};
module.exports = {
// `String.prototype.{ trimLeft, trimStart }` methods
// https://tc39.es/ecma262/#sec-string.prototype.trimstart
start: createMethod(1),
// `String.prototype.{ trimRight, trimEnd }` methods
// https://tc39.es/ecma262/#sec-string.prototype.trimend
end: createMethod(2),
// `String.prototype.trim` method
// https://tc39.es/ecma262/#sec-string.prototype.trim
trim: createMethod(3)
};
/***/ }),
/* 238 */
/***/ (function(module) {
// a string of all valid unicode whitespaces
module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' +
'\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF';
/***/ }),
/* 239 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// `Number.EPSILON` constant
// https://tc39.es/ecma262/#sec-number.epsilon
$({ target: 'Number', stat: true }, {
EPSILON: Math.pow(2, -52)
});
/***/ }),
/* 240 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var numberIsFinite = __webpack_require__(241);
// `Number.isFinite` method
// https://tc39.es/ecma262/#sec-number.isfinite
$({ target: 'Number', stat: true }, { isFinite: numberIsFinite });
/***/ }),
/* 241 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var globalIsFinite = global.isFinite;
// `Number.isFinite` method
// https://tc39.es/ecma262/#sec-number.isfinite
// eslint-disable-next-line es/no-number-isfinite -- safe
module.exports = Number.isFinite || function isFinite(it) {
return typeof it == 'number' && globalIsFinite(it);
};
/***/ }),
/* 242 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var isIntegralNumber = __webpack_require__(243);
// `Number.isInteger` method
// https://tc39.es/ecma262/#sec-number.isinteger
$({ target: 'Number', stat: true }, {
isInteger: isIntegralNumber
});
/***/ }),
/* 243 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var isObject = __webpack_require__(18);
var floor = Math.floor;
// `IsIntegralNumber` abstract operation
// https://tc39.es/ecma262/#sec-isintegralnumber
// eslint-disable-next-line es/no-number-isinteger -- safe
module.exports = Number.isInteger || function isInteger(it) {
return !isObject(it) && isFinite(it) && floor(it) === it;
};
/***/ }),
/* 244 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// `Number.isNaN` method
// https://tc39.es/ecma262/#sec-number.isnan
$({ target: 'Number', stat: true }, {
isNaN: function isNaN(number) {
// eslint-disable-next-line no-self-compare -- NaN check
return number != number;
}
});
/***/ }),
/* 245 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var isIntegralNumber = __webpack_require__(243);
var abs = Math.abs;
// `Number.isSafeInteger` method
// https://tc39.es/ecma262/#sec-number.issafeinteger
$({ target: 'Number', stat: true }, {
isSafeInteger: function isSafeInteger(number) {
return isIntegralNumber(number) && abs(number) <= 0x1FFFFFFFFFFFFF;
}
});
/***/ }),
/* 246 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// `Number.MAX_SAFE_INTEGER` constant
// https://tc39.es/ecma262/#sec-number.max_safe_integer
$({ target: 'Number', stat: true }, {
MAX_SAFE_INTEGER: 0x1FFFFFFFFFFFFF
});
/***/ }),
/* 247 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// `Number.MIN_SAFE_INTEGER` constant
// https://tc39.es/ecma262/#sec-number.min_safe_integer
$({ target: 'Number', stat: true }, {
MIN_SAFE_INTEGER: -0x1FFFFFFFFFFFFF
});
/***/ }),
/* 248 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var parseFloat = __webpack_require__(249);
// `Number.parseFloat` method
// https://tc39.es/ecma262/#sec-number.parseFloat
// eslint-disable-next-line es/no-number-parsefloat -- required for testing
$({ target: 'Number', stat: true, forced: Number.parseFloat != parseFloat }, {
parseFloat: parseFloat
});
/***/ }),
/* 249 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var fails = __webpack_require__(6);
var uncurryThis = __webpack_require__(13);
var toString = __webpack_require__(66);
var trim = (__webpack_require__(237).trim);
var whitespaces = __webpack_require__(238);
var charAt = uncurryThis(''.charAt);
var n$ParseFloat = global.parseFloat;
var Symbol = global.Symbol;
var ITERATOR = Symbol && Symbol.iterator;
var FORCED = 1 / n$ParseFloat(whitespaces + '-0') !== -Infinity
// MS Edge 18- broken with boxed symbols
|| (ITERATOR && !fails(function () { n$ParseFloat(Object(ITERATOR)); }));
// `parseFloat` method
// https://tc39.es/ecma262/#sec-parsefloat-string
module.exports = FORCED ? function parseFloat(string) {
var trimmedString = trim(toString(string));
var result = n$ParseFloat(trimmedString);
return result === 0 && charAt(trimmedString, 0) == '-' ? -0 : result;
} : n$ParseFloat;
/***/ }),
/* 250 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var parseInt = __webpack_require__(251);
// `Number.parseInt` method
// https://tc39.es/ecma262/#sec-number.parseint
// eslint-disable-next-line es/no-number-parseint -- required for testing
$({ target: 'Number', stat: true, forced: Number.parseInt != parseInt }, {
parseInt: parseInt
});
/***/ }),
/* 251 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var fails = __webpack_require__(6);
var uncurryThis = __webpack_require__(13);
var toString = __webpack_require__(66);
var trim = (__webpack_require__(237).trim);
var whitespaces = __webpack_require__(238);
var $parseInt = global.parseInt;
var Symbol = global.Symbol;
var ITERATOR = Symbol && Symbol.iterator;
var hex = /^[+-]?0x/i;
var exec = uncurryThis(hex.exec);
var FORCED = $parseInt(whitespaces + '08') !== 8 || $parseInt(whitespaces + '0x16') !== 22
// MS Edge 18- broken with boxed symbols
|| (ITERATOR && !fails(function () { $parseInt(Object(ITERATOR)); }));
// `parseInt` method
// https://tc39.es/ecma262/#sec-parseint-string-radix
module.exports = FORCED ? function parseInt(string, radix) {
var S = trim(toString(string));
return $parseInt(S, (radix >>> 0) || (exec(hex, S) ? 16 : 10));
} : $parseInt;
/***/ }),
/* 252 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var toIntegerOrInfinity = __webpack_require__(58);
var thisNumberValue = __webpack_require__(236);
var $repeat = __webpack_require__(192);
var log10 = __webpack_require__(227);
var fails = __webpack_require__(6);
var RangeError = global.RangeError;
var String = global.String;
var isFinite = global.isFinite;
var abs = Math.abs;
var floor = Math.floor;
var pow = Math.pow;
var round = Math.round;
var un$ToExponential = uncurryThis(1.0.toExponential);
var repeat = uncurryThis($repeat);
var stringSlice = uncurryThis(''.slice);
// Edge 17-
var ROUNDS_PROPERLY = un$ToExponential(-6.9e-11, 4) === '-6.9000e-11'
// IE11- && Edge 14-
&& un$ToExponential(1.255, 2) === '1.25e+0'
// FF86-, V8 ~ Chrome 49-50
&& un$ToExponential(12345, 3) === '1.235e+4'
// FF86-, V8 ~ Chrome 49-50
&& un$ToExponential(25, 0) === '3e+1';
// IE8-
var THROWS_ON_INFINITY_FRACTION = fails(function () {
un$ToExponential(1, Infinity);
}) && fails(function () {
un$ToExponential(1, -Infinity);
});
// Safari <11 && FF <50
var PROPER_NON_FINITE_THIS_CHECK = !fails(function () {
un$ToExponential(Infinity, Infinity);
}) && !fails(function () {
un$ToExponential(NaN, Infinity);
});
var FORCED = !ROUNDS_PROPERLY || !THROWS_ON_INFINITY_FRACTION || !PROPER_NON_FINITE_THIS_CHECK;
// `Number.prototype.toExponential` method
// https://tc39.es/ecma262/#sec-number.prototype.toexponential
$({ target: 'Number', proto: true, forced: FORCED }, {
toExponential: function toExponential(fractionDigits) {
var x = thisNumberValue(this);
if (fractionDigits === undefined) return un$ToExponential(x);
var f = toIntegerOrInfinity(fractionDigits);
if (!isFinite(x)) return String(x);
// TODO: ES2018 increased the maximum number of fraction digits to 100, need to improve the implementation
if (f < 0 || f > 20) throw RangeError('Incorrect fraction digits');
if (ROUNDS_PROPERLY) return un$ToExponential(x, f);
var s = '';
var m = '';
var e = 0;
var c = '';
var d = '';
if (x < 0) {
s = '-';
x = -x;
}
if (x === 0) {
e = 0;
m = repeat('0', f + 1);
} else {
// this block is based on https://gist.github.com/SheetJSDev/1100ad56b9f856c95299ed0e068eea08
// TODO: improve accuracy with big fraction digits
var l = log10(x);
e = floor(l);
var n = 0;
var w = pow(10, e - f);
n = round(x / w);
if (2 * x >= (2 * n + 1) * w) {
n += 1;
}
if (n >= pow(10, f + 1)) {
n /= 10;
e += 1;
}
m = String(n);
}
if (f !== 0) {
m = stringSlice(m, 0, 1) + '.' + stringSlice(m, 1);
}
if (e === 0) {
c = '+';
d = '0';
} else {
c = e > 0 ? '+' : '-';
d = String(abs(e));
}
m += 'e' + c + d;
return s + m;
}
});
/***/ }),
/* 253 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var toIntegerOrInfinity = __webpack_require__(58);
var thisNumberValue = __webpack_require__(236);
var $repeat = __webpack_require__(192);
var fails = __webpack_require__(6);
var RangeError = global.RangeError;
var String = global.String;
var floor = Math.floor;
var repeat = uncurryThis($repeat);
var stringSlice = uncurryThis(''.slice);
var un$ToFixed = uncurryThis(1.0.toFixed);
var pow = function (x, n, acc) {
return n === 0 ? acc : n % 2 === 1 ? pow(x, n - 1, acc * x) : pow(x * x, n / 2, acc);
};
var log = function (x) {
var n = 0;
var x2 = x;
while (x2 >= 4096) {
n += 12;
x2 /= 4096;
}
while (x2 >= 2) {
n += 1;
x2 /= 2;
} return n;
};
var multiply = function (data, n, c) {
var index = -1;
var c2 = c;
while (++index < 6) {
c2 += n * data[index];
data[index] = c2 % 1e7;
c2 = floor(c2 / 1e7);
}
};
var divide = function (data, n) {
var index = 6;
var c = 0;
while (--index >= 0) {
c += data[index];
data[index] = floor(c / n);
c = (c % n) * 1e7;
}
};
var dataToString = function (data) {
var index = 6;
var s = '';
while (--index >= 0) {
if (s !== '' || index === 0 || data[index] !== 0) {
var t = String(data[index]);
s = s === '' ? t : s + repeat('0', 7 - t.length) + t;
}
} return s;
};
var FORCED = fails(function () {
return un$ToFixed(0.00008, 3) !== '0.000' ||
un$ToFixed(0.9, 0) !== '1' ||
un$ToFixed(1.255, 2) !== '1.25' ||
un$ToFixed(1000000000000000128.0, 0) !== '1000000000000000128';
}) || !fails(function () {
// V8 ~ Android 4.3-
un$ToFixed({});
});
// `Number.prototype.toFixed` method
// https://tc39.es/ecma262/#sec-number.prototype.tofixed
$({ target: 'Number', proto: true, forced: FORCED }, {
toFixed: function toFixed(fractionDigits) {
var number = thisNumberValue(this);
var fractDigits = toIntegerOrInfinity(fractionDigits);
var data = [0, 0, 0, 0, 0, 0];
var sign = '';
var result = '0';
var e, z, j, k;
// TODO: ES2018 increased the maximum number of fraction digits to 100, need to improve the implementation
if (fractDigits < 0 || fractDigits > 20) throw RangeError('Incorrect fraction digits');
// eslint-disable-next-line no-self-compare -- NaN check
if (number != number) return 'NaN';
if (number <= -1e21 || number >= 1e21) return String(number);
if (number < 0) {
sign = '-';
number = -number;
}
if (number > 1e-21) {
e = log(number * pow(2, 69, 1)) - 69;
z = e < 0 ? number * pow(2, -e, 1) : number / pow(2, e, 1);
z *= 0x10000000000000;
e = 52 - e;
if (e > 0) {
multiply(data, 0, z);
j = fractDigits;
while (j >= 7) {
multiply(data, 1e7, 0);
j -= 7;
}
multiply(data, pow(10, j, 1), 0);
j = e - 1;
while (j >= 23) {
divide(data, 1 << 23);
j -= 23;
}
divide(data, 1 << j);
multiply(data, 1, 1);
divide(data, 2);
result = dataToString(data);
} else {
multiply(data, 0, z);
multiply(data, 1 << -e, 0);
result = dataToString(data) + repeat('0', fractDigits);
}
}
if (fractDigits > 0) {
k = result.length;
result = sign + (k <= fractDigits
? '0.' + repeat('0', fractDigits - k) + result
: stringSlice(result, 0, k - fractDigits) + '.' + stringSlice(result, k - fractDigits));
} else {
result = sign + result;
} return result;
}
});
/***/ }),
/* 254 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var thisNumberValue = __webpack_require__(236);
var un$ToPrecision = uncurryThis(1.0.toPrecision);
var FORCED = fails(function () {
// IE7-
return un$ToPrecision(1, undefined) !== '1';
}) || !fails(function () {
// V8 ~ Android 4.3-
un$ToPrecision({});
});
// `Number.prototype.toPrecision` method
// https://tc39.es/ecma262/#sec-number.prototype.toprecision
$({ target: 'Number', proto: true, forced: FORCED }, {
toPrecision: function toPrecision(precision) {
return precision === undefined
? un$ToPrecision(thisNumberValue(this))
: un$ToPrecision(thisNumberValue(this), precision);
}
});
/***/ }),
/* 255 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var assign = __webpack_require__(256);
// `Object.assign` method
// https://tc39.es/ecma262/#sec-object.assign
// eslint-disable-next-line es/no-object-assign -- required for testing
$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {
assign: assign
});
/***/ }),
/* 256 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var DESCRIPTORS = __webpack_require__(5);
var uncurryThis = __webpack_require__(13);
var call = __webpack_require__(7);
var fails = __webpack_require__(6);
var objectKeys = __webpack_require__(71);
var getOwnPropertySymbolsModule = __webpack_require__(62);
var propertyIsEnumerableModule = __webpack_require__(9);
var toObject = __webpack_require__(37);
var IndexedObject = __webpack_require__(12);
// eslint-disable-next-line es/no-object-assign -- safe
var $assign = Object.assign;
// eslint-disable-next-line es/no-object-defineproperty -- required for testing
var defineProperty = Object.defineProperty;
var concat = uncurryThis([].concat);
// `Object.assign` method
// https://tc39.es/ecma262/#sec-object.assign
module.exports = !$assign || fails(function () {
// should have correct order of operations (Edge bug)
if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {
enumerable: true,
get: function () {
defineProperty(this, 'b', {
value: 3,
enumerable: false
});
}
}), { b: 2 })).b !== 1) return true;
// should work with symbols and should have deterministic property order (V8 bug)
var A = {};
var B = {};
// eslint-disable-next-line es/no-symbol -- safe
var symbol = Symbol();
var alphabet = 'abcdefghijklmnopqrst';
A[symbol] = 7;
alphabet.split('').forEach(function (chr) { B[chr] = chr; });
return $assign({}, A)[symbol] != 7 || objectKeys($assign({}, B)).join('') != alphabet;
}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`
var T = toObject(target);
var argumentsLength = arguments.length;
var index = 1;
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
var propertyIsEnumerable = propertyIsEnumerableModule.f;
while (argumentsLength > index) {
var S = IndexedObject(arguments[index++]);
var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);
var length = keys.length;
var j = 0;
var key;
while (length > j) {
key = keys[j++];
if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];
}
} return T;
} : $assign;
/***/ }),
/* 257 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var create = __webpack_require__(69);
// `Object.create` method
// https://tc39.es/ecma262/#sec-object.create
$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, {
create: create
});
/***/ }),
/* 258 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var FORCED = __webpack_require__(259);
var aCallable = __webpack_require__(28);
var toObject = __webpack_require__(37);
var definePropertyModule = __webpack_require__(42);
// `Object.prototype.__defineGetter__` method
// https://tc39.es/ecma262/#sec-object.prototype.__defineGetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__defineGetter__: function __defineGetter__(P, getter) {
definePropertyModule.f(toObject(this), P, { get: aCallable(getter), enumerable: true, configurable: true });
}
});
}
/***/ }),
/* 259 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var IS_PURE = __webpack_require__(33);
var global = __webpack_require__(3);
var fails = __webpack_require__(6);
var WEBKIT = __webpack_require__(166);
// Forced replacement object prototype accessors methods
module.exports = IS_PURE || !fails(function () {
// This feature detection crashes old WebKit
// https://github.com/zloirock/core-js/issues/232
if (WEBKIT && WEBKIT < 535) return;
var key = Math.random();
// In FF throws only define methods
// eslint-disable-next-line no-undef, no-useless-call -- required for testing
__defineSetter__.call(null, key, function () { /* empty */ });
delete global[key];
});
/***/ }),
/* 260 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var defineProperties = (__webpack_require__(70).f);
// `Object.defineProperties` method
// https://tc39.es/ecma262/#sec-object.defineproperties
// eslint-disable-next-line es/no-object-defineproperties -- safe
$({ target: 'Object', stat: true, forced: Object.defineProperties !== defineProperties, sham: !DESCRIPTORS }, {
defineProperties: defineProperties
});
/***/ }),
/* 261 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var defineProperty = (__webpack_require__(42).f);
// `Object.defineProperty` method
// https://tc39.es/ecma262/#sec-object.defineproperty
// eslint-disable-next-line es/no-object-defineproperty -- safe
$({ target: 'Object', stat: true, forced: Object.defineProperty !== defineProperty, sham: !DESCRIPTORS }, {
defineProperty: defineProperty
});
/***/ }),
/* 262 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var FORCED = __webpack_require__(259);
var aCallable = __webpack_require__(28);
var toObject = __webpack_require__(37);
var definePropertyModule = __webpack_require__(42);
// `Object.prototype.__defineSetter__` method
// https://tc39.es/ecma262/#sec-object.prototype.__defineSetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__defineSetter__: function __defineSetter__(P, setter) {
definePropertyModule.f(toObject(this), P, { set: aCallable(setter), enumerable: true, configurable: true });
}
});
}
/***/ }),
/* 263 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var $entries = (__webpack_require__(264).entries);
// `Object.entries` method
// https://tc39.es/ecma262/#sec-object.entries
$({ target: 'Object', stat: true }, {
entries: function entries(O) {
return $entries(O);
}
});
/***/ }),
/* 264 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var uncurryThis = __webpack_require__(13);
var objectKeys = __webpack_require__(71);
var toIndexedObject = __webpack_require__(11);
var $propertyIsEnumerable = (__webpack_require__(9).f);
var propertyIsEnumerable = uncurryThis($propertyIsEnumerable);
var push = uncurryThis([].push);
// `Object.{ entries, values }` methods implementation
var createMethod = function (TO_ENTRIES) {
return function (it) {
var O = toIndexedObject(it);
var keys = objectKeys(O);
var length = keys.length;
var i = 0;
var result = [];
var key;
while (length > i) {
key = keys[i++];
if (!DESCRIPTORS || propertyIsEnumerable(O, key)) {
push(result, TO_ENTRIES ? [key, O[key]] : O[key]);
}
}
return result;
};
};
module.exports = {
// `Object.entries` method
// https://tc39.es/ecma262/#sec-object.entries
entries: createMethod(true),
// `Object.values` method
// https://tc39.es/ecma262/#sec-object.values
values: createMethod(false)
};
/***/ }),
/* 265 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var FREEZING = __webpack_require__(210);
var fails = __webpack_require__(6);
var isObject = __webpack_require__(18);
var onFreeze = (__webpack_require__(207).onFreeze);
// eslint-disable-next-line es/no-object-freeze -- safe
var $freeze = Object.freeze;
var FAILS_ON_PRIMITIVES = fails(function () { $freeze(1); });
// `Object.freeze` method
// https://tc39.es/ecma262/#sec-object.freeze
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, {
freeze: function freeze(it) {
return $freeze && isObject(it) ? $freeze(onFreeze(it)) : it;
}
});
/***/ }),
/* 266 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var iterate = __webpack_require__(114);
var createProperty = __webpack_require__(75);
// `Object.fromEntries` method
// https://github.com/tc39/proposal-object-from-entries
$({ target: 'Object', stat: true }, {
fromEntries: function fromEntries(iterable) {
var obj = {};
iterate(iterable, function (k, v) {
createProperty(obj, k, v);
}, { AS_ENTRIES: true });
return obj;
}
});
/***/ }),
/* 267 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
var toIndexedObject = __webpack_require__(11);
var nativeGetOwnPropertyDescriptor = (__webpack_require__(4).f);
var DESCRIPTORS = __webpack_require__(5);
var FAILS_ON_PRIMITIVES = fails(function () { nativeGetOwnPropertyDescriptor(1); });
var FORCED = !DESCRIPTORS || FAILS_ON_PRIMITIVES;
// `Object.getOwnPropertyDescriptor` method
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
$({ target: 'Object', stat: true, forced: FORCED, sham: !DESCRIPTORS }, {
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(it, key) {
return nativeGetOwnPropertyDescriptor(toIndexedObject(it), key);
}
});
/***/ }),
/* 268 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var ownKeys = __webpack_require__(53);
var toIndexedObject = __webpack_require__(11);
var getOwnPropertyDescriptorModule = __webpack_require__(4);
var createProperty = __webpack_require__(75);
// `Object.getOwnPropertyDescriptors` method
// https://tc39.es/ecma262/#sec-object.getownpropertydescriptors
$({ target: 'Object', stat: true, sham: !DESCRIPTORS }, {
getOwnPropertyDescriptors: function getOwnPropertyDescriptors(object) {
var O = toIndexedObject(object);
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
var keys = ownKeys(O);
var result = {};
var index = 0;
var key, descriptor;
while (keys.length > index) {
descriptor = getOwnPropertyDescriptor(O, key = keys[index++]);
if (descriptor !== undefined) createProperty(result, key, descriptor);
}
return result;
}
});
/***/ }),
/* 269 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
var getOwnPropertyNames = (__webpack_require__(73).f);
// eslint-disable-next-line es/no-object-getownpropertynames -- required for testing
var FAILS_ON_PRIMITIVES = fails(function () { return !Object.getOwnPropertyNames(1); });
// `Object.getOwnPropertyNames` method
// https://tc39.es/ecma262/#sec-object.getownpropertynames
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
getOwnPropertyNames: getOwnPropertyNames
});
/***/ }),
/* 270 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
var toObject = __webpack_require__(37);
var nativeGetPrototypeOf = __webpack_require__(112);
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(113);
var FAILS_ON_PRIMITIVES = fails(function () { nativeGetPrototypeOf(1); });
// `Object.getPrototypeOf` method
// https://tc39.es/ecma262/#sec-object.getprototypeof
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !CORRECT_PROTOTYPE_GETTER }, {
getPrototypeOf: function getPrototypeOf(it) {
return nativeGetPrototypeOf(toObject(it));
}
});
/***/ }),
/* 271 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var hasOwn = __webpack_require__(36);
// `Object.hasOwn` method
// https://github.com/tc39/proposal-accessible-object-hasownproperty
$({ target: 'Object', stat: true }, {
hasOwn: hasOwn
});
/***/ }),
/* 272 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var is = __webpack_require__(273);
// `Object.is` method
// https://tc39.es/ecma262/#sec-object.is
$({ target: 'Object', stat: true }, {
is: is
});
/***/ }),
/* 273 */
/***/ (function(module) {
// `SameValue` abstract operation
// https://tc39.es/ecma262/#sec-samevalue
// eslint-disable-next-line es/no-object-is -- safe
module.exports = Object.is || function is(x, y) {
// eslint-disable-next-line no-self-compare -- NaN check
return x === y ? x !== 0 || 1 / x === 1 / y : x != x && y != y;
};
/***/ }),
/* 274 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var $isExtensible = __webpack_require__(208);
// `Object.isExtensible` method
// https://tc39.es/ecma262/#sec-object.isextensible
// eslint-disable-next-line es/no-object-isextensible -- safe
$({ target: 'Object', stat: true, forced: Object.isExtensible !== $isExtensible }, {
isExtensible: $isExtensible
});
/***/ }),
/* 275 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
var isObject = __webpack_require__(18);
var classof = __webpack_require__(14);
var ARRAY_BUFFER_NON_EXTENSIBLE = __webpack_require__(209);
// eslint-disable-next-line es/no-object-isfrozen -- safe
var $isFrozen = Object.isFrozen;
var FAILS_ON_PRIMITIVES = fails(function () { $isFrozen(1); });
// `Object.isFrozen` method
// https://tc39.es/ecma262/#sec-object.isfrozen
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE }, {
isFrozen: function isFrozen(it) {
if (!isObject(it)) return true;
if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) == 'ArrayBuffer') return true;
return $isFrozen ? $isFrozen(it) : false;
}
});
/***/ }),
/* 276 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var fails = __webpack_require__(6);
var isObject = __webpack_require__(18);
var classof = __webpack_require__(14);
var ARRAY_BUFFER_NON_EXTENSIBLE = __webpack_require__(209);
// eslint-disable-next-line es/no-object-issealed -- safe
var $isSealed = Object.isSealed;
var FAILS_ON_PRIMITIVES = fails(function () { $isSealed(1); });
// `Object.isSealed` method
// https://tc39.es/ecma262/#sec-object.issealed
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE }, {
isSealed: function isSealed(it) {
if (!isObject(it)) return true;
if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) == 'ArrayBuffer') return true;
return $isSealed ? $isSealed(it) : false;
}
});
/***/ }),
/* 277 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var toObject = __webpack_require__(37);
var nativeKeys = __webpack_require__(71);
var fails = __webpack_require__(6);
var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });
// `Object.keys` method
// https://tc39.es/ecma262/#sec-object.keys
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {
keys: function keys(it) {
return nativeKeys(toObject(it));
}
});
/***/ }),
/* 278 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var FORCED = __webpack_require__(259);
var toObject = __webpack_require__(37);
var toPropertyKey = __webpack_require__(16);
var getPrototypeOf = __webpack_require__(112);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
// `Object.prototype.__lookupGetter__` method
// https://tc39.es/ecma262/#sec-object.prototype.__lookupGetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__lookupGetter__: function __lookupGetter__(P) {
var O = toObject(this);
var key = toPropertyKey(P);
var desc;
do {
if (desc = getOwnPropertyDescriptor(O, key)) return desc.get;
} while (O = getPrototypeOf(O));
}
});
}
/***/ }),
/* 279 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var FORCED = __webpack_require__(259);
var toObject = __webpack_require__(37);
var toPropertyKey = __webpack_require__(16);
var getPrototypeOf = __webpack_require__(112);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
// `Object.prototype.__lookupSetter__` method
// https://tc39.es/ecma262/#sec-object.prototype.__lookupSetter__
if (DESCRIPTORS) {
$({ target: 'Object', proto: true, forced: FORCED }, {
__lookupSetter__: function __lookupSetter__(P) {
var O = toObject(this);
var key = toPropertyKey(P);
var desc;
do {
if (desc = getOwnPropertyDescriptor(O, key)) return desc.set;
} while (O = getPrototypeOf(O));
}
});
}
/***/ }),
/* 280 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var isObject = __webpack_require__(18);
var onFreeze = (__webpack_require__(207).onFreeze);
var FREEZING = __webpack_require__(210);
var fails = __webpack_require__(6);
// eslint-disable-next-line es/no-object-preventextensions -- safe
var $preventExtensions = Object.preventExtensions;
var FAILS_ON_PRIMITIVES = fails(function () { $preventExtensions(1); });
// `Object.preventExtensions` method
// https://tc39.es/ecma262/#sec-object.preventextensions
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, {
preventExtensions: function preventExtensions(it) {
return $preventExtensions && isObject(it) ? $preventExtensions(onFreeze(it)) : it;
}
});
/***/ }),
/* 281 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var isObject = __webpack_require__(18);
var onFreeze = (__webpack_require__(207).onFreeze);
var FREEZING = __webpack_require__(210);
var fails = __webpack_require__(6);
// eslint-disable-next-line es/no-object-seal -- safe
var $seal = Object.seal;
var FAILS_ON_PRIMITIVES = fails(function () { $seal(1); });
// `Object.seal` method
// https://tc39.es/ecma262/#sec-object.seal
$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES, sham: !FREEZING }, {
seal: function seal(it) {
return $seal && isObject(it) ? $seal(onFreeze(it)) : it;
}
});
/***/ }),
/* 282 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var setPrototypeOf = __webpack_require__(102);
// `Object.setPrototypeOf` method
// https://tc39.es/ecma262/#sec-object.setprototypeof
$({ target: 'Object', stat: true }, {
setPrototypeOf: setPrototypeOf
});
/***/ }),
/* 283 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var TO_STRING_TAG_SUPPORT = __webpack_require__(68);
var redefine = __webpack_require__(45);
var toString = __webpack_require__(284);
// `Object.prototype.toString` method
// https://tc39.es/ecma262/#sec-object.prototype.tostring
if (!TO_STRING_TAG_SUPPORT) {
redefine(Object.prototype, 'toString', toString, { unsafe: true });
}
/***/ }),
/* 284 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var TO_STRING_TAG_SUPPORT = __webpack_require__(68);
var classof = __webpack_require__(67);
// `Object.prototype.toString` method implementation
// https://tc39.es/ecma262/#sec-object.prototype.tostring
module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
return '[object ' + classof(this) + ']';
};
/***/ }),
/* 285 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var $values = (__webpack_require__(264).values);
// `Object.values` method
// https://tc39.es/ecma262/#sec-object.values
$({ target: 'Object', stat: true }, {
values: function values(O) {
return $values(O);
}
});
/***/ }),
/* 286 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var $parseFloat = __webpack_require__(249);
// `parseFloat` method
// https://tc39.es/ecma262/#sec-parsefloat-string
$({ global: true, forced: parseFloat != $parseFloat }, {
parseFloat: $parseFloat
});
/***/ }),
/* 287 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var $parseInt = __webpack_require__(251);
// `parseInt` method
// https://tc39.es/ecma262/#sec-parseint-string-radix
$({ global: true, forced: parseInt != $parseInt }, {
parseInt: $parseInt
});
/***/ }),
/* 288 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var IS_PURE = __webpack_require__(33);
var global = __webpack_require__(3);
var getBuiltIn = __webpack_require__(21);
var call = __webpack_require__(7);
var NativePromise = __webpack_require__(289);
var redefine = __webpack_require__(45);
var redefineAll = __webpack_require__(175);
var setPrototypeOf = __webpack_require__(102);
var setToStringTag = __webpack_require__(80);
var setSpecies = __webpack_require__(168);
var aCallable = __webpack_require__(28);
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var anInstance = __webpack_require__(176);
var inspectSource = __webpack_require__(46);
var iterate = __webpack_require__(114);
var checkCorrectnessOfIteration = __webpack_require__(142);
var speciesConstructor = __webpack_require__(182);
var task = (__webpack_require__(290).set);
var microtask = __webpack_require__(293);
var promiseResolve = __webpack_require__(296);
var hostReportErrors = __webpack_require__(298);
var newPromiseCapabilityModule = __webpack_require__(297);
var perform = __webpack_require__(299);
var Queue = __webpack_require__(300);
var InternalStateModule = __webpack_require__(47);
var isForced = __webpack_require__(63);
var wellKnownSymbol = __webpack_require__(31);
var IS_BROWSER = __webpack_require__(301);
var IS_NODE = __webpack_require__(157);
var V8_VERSION = __webpack_require__(25);
var SPECIES = wellKnownSymbol('species');
var PROMISE = 'Promise';
var getInternalState = InternalStateModule.getterFor(PROMISE);
var setInternalState = InternalStateModule.set;
var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
var NativePromisePrototype = NativePromise && NativePromise.prototype;
var PromiseConstructor = NativePromise;
var PromisePrototype = NativePromisePrototype;
var TypeError = global.TypeError;
var document = global.document;
var process = global.process;
var newPromiseCapability = newPromiseCapabilityModule.f;
var newGenericPromiseCapability = newPromiseCapability;
var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);
var NATIVE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);
var UNHANDLED_REJECTION = 'unhandledrejection';
var REJECTION_HANDLED = 'rejectionhandled';
var PENDING = 0;
var FULFILLED = 1;
var REJECTED = 2;
var HANDLED = 1;
var UNHANDLED = 2;
var SUBCLASSING = false;
var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
var FORCED = isForced(PROMISE, function () {
var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(PromiseConstructor);
var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(PromiseConstructor);
// V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables
// https://bugs.chromium.org/p/chromium/issues/detail?id=830565
// We can't detect it synchronously, so just check versions
if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;
// We need Promise#finally in the pure version for preventing prototype pollution
if (IS_PURE && !PromisePrototype['finally']) return true;
// We can't use @@species feature detection in V8 since it causes
// deoptimization and performance degradation
// https://github.com/zloirock/core-js/issues/679
if (V8_VERSION >= 51 && /native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) return false;
// Detect correctness of subclassing with @@species support
var promise = new PromiseConstructor(function (resolve) { resolve(1); });
var FakePromise = function (exec) {
exec(function () { /* empty */ }, function () { /* empty */ });
};
var constructor = promise.constructor = {};
constructor[SPECIES] = FakePromise;
SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;
if (!SUBCLASSING) return true;
// Unhandled rejections tracking support, NodeJS Promise without it fails @@species test
return !GLOBAL_CORE_JS_PROMISE && IS_BROWSER && !NATIVE_REJECTION_EVENT;
});
var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });
});
// helpers
var isThenable = function (it) {
var then;
return isObject(it) && isCallable(then = it.then) ? then : false;
};
var callReaction = function (reaction, state) {
var value = state.value;
var ok = state.state == FULFILLED;
var handler = ok ? reaction.ok : reaction.fail;
var resolve = reaction.resolve;
var reject = reaction.reject;
var domain = reaction.domain;
var result, then, exited;
try {
if (handler) {
if (!ok) {
if (state.rejection === UNHANDLED) onHandleUnhandled(state);
state.rejection = HANDLED;
}
if (handler === true) result = value;
else {
if (domain) domain.enter();
result = handler(value); // can throw
if (domain) {
domain.exit();
exited = true;
}
}
if (result === reaction.promise) {
reject(TypeError('Promise-chain cycle'));
} else if (then = isThenable(result)) {
call(then, result, resolve, reject);
} else resolve(result);
} else reject(value);
} catch (error) {
if (domain && !exited) domain.exit();
reject(error);
}
};
var notify = function (state, isReject) {
if (state.notified) return;
state.notified = true;
microtask(function () {
var reactions = state.reactions;
var reaction;
while (reaction = reactions.get()) {
callReaction(reaction, state);
}
state.notified = false;
if (isReject && !state.rejection) onUnhandled(state);
});
};
var dispatchEvent = function (name, promise, reason) {
var event, handler;
if (DISPATCH_EVENT) {
event = document.createEvent('Event');
event.promise = promise;
event.reason = reason;
event.initEvent(name, false, true);
global.dispatchEvent(event);
} else event = { promise: promise, reason: reason };
if (!NATIVE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);
else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);
};
var onUnhandled = function (state) {
call(task, global, function () {
var promise = state.facade;
var value = state.value;
var IS_UNHANDLED = isUnhandled(state);
var result;
if (IS_UNHANDLED) {
result = perform(function () {
if (IS_NODE) {
process.emit('unhandledRejection', value, promise);
} else dispatchEvent(UNHANDLED_REJECTION, promise, value);
});
// Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should
state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
if (result.error) throw result.value;
}
});
};
var isUnhandled = function (state) {
return state.rejection !== HANDLED && !state.parent;
};
var onHandleUnhandled = function (state) {
call(task, global, function () {
var promise = state.facade;
if (IS_NODE) {
process.emit('rejectionHandled', promise);
} else dispatchEvent(REJECTION_HANDLED, promise, state.value);
});
};
var bind = function (fn, state, unwrap) {
return function (value) {
fn(state, value, unwrap);
};
};
var internalReject = function (state, value, unwrap) {
if (state.done) return;
state.done = true;
if (unwrap) state = unwrap;
state.value = value;
state.state = REJECTED;
notify(state, true);
};
var internalResolve = function (state, value, unwrap) {
if (state.done) return;
state.done = true;
if (unwrap) state = unwrap;
try {
if (state.facade === value) throw TypeError("Promise can't be resolved itself");
var then = isThenable(value);
if (then) {
microtask(function () {
var wrapper = { done: false };
try {
call(then, value,
bind(internalResolve, wrapper, state),
bind(internalReject, wrapper, state)
);
} catch (error) {
internalReject(wrapper, error, state);
}
});
} else {
state.value = value;
state.state = FULFILLED;
notify(state, false);
}
} catch (error) {
internalReject({ done: false }, error, state);
}
};
// constructor polyfill
if (FORCED) {
// 25.4.3.1 Promise(executor)
PromiseConstructor = function Promise(executor) {
anInstance(this, PromisePrototype);
aCallable(executor);
call(Internal, this);
var state = getInternalState(this);
try {
executor(bind(internalResolve, state), bind(internalReject, state));
} catch (error) {
internalReject(state, error);
}
};
PromisePrototype = PromiseConstructor.prototype;
// eslint-disable-next-line no-unused-vars -- required for `.length`
Internal = function Promise(executor) {
setInternalState(this, {
type: PROMISE,
done: false,
notified: false,
parent: false,
reactions: new Queue(),
rejection: false,
state: PENDING,
value: undefined
});
};
Internal.prototype = redefineAll(PromisePrototype, {
// `Promise.prototype.then` method
// https://tc39.es/ecma262/#sec-promise.prototype.then
// eslint-disable-next-line unicorn/no-thenable -- safe
then: function then(onFulfilled, onRejected) {
var state = getInternalPromiseState(this);
var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
state.parent = true;
reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;
reaction.fail = isCallable(onRejected) && onRejected;
reaction.domain = IS_NODE ? process.domain : undefined;
if (state.state == PENDING) state.reactions.add(reaction);
else microtask(function () {
callReaction(reaction, state);
});
return reaction.promise;
},
// `Promise.prototype.catch` method
// https://tc39.es/ecma262/#sec-promise.prototype.catch
'catch': function (onRejected) {
return this.then(undefined, onRejected);
}
});
OwnPromiseCapability = function () {
var promise = new Internal();
var state = getInternalState(promise);
this.promise = promise;
this.resolve = bind(internalResolve, state);
this.reject = bind(internalReject, state);
};
newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
return C === PromiseConstructor || C === PromiseWrapper
? new OwnPromiseCapability(C)
: newGenericPromiseCapability(C);
};
if (!IS_PURE && isCallable(NativePromise) && NativePromisePrototype !== Object.prototype) {
nativeThen = NativePromisePrototype.then;
if (!SUBCLASSING) {
// make `Promise#then` return a polyfilled `Promise` for native promise-based APIs
redefine(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {
var that = this;
return new PromiseConstructor(function (resolve, reject) {
call(nativeThen, that, resolve, reject);
}).then(onFulfilled, onRejected);
// https://github.com/zloirock/core-js/issues/640
}, { unsafe: true });
// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`
redefine(NativePromisePrototype, 'catch', PromisePrototype['catch'], { unsafe: true });
}
// make `.constructor === Promise` work for native promise-based APIs
try {
delete NativePromisePrototype.constructor;
} catch (error) { /* empty */ }
// make `instanceof Promise` work for native promise-based APIs
if (setPrototypeOf) {
setPrototypeOf(NativePromisePrototype, PromisePrototype);
}
}
}
$({ global: true, wrap: true, forced: FORCED }, {
Promise: PromiseConstructor
});
setToStringTag(PromiseConstructor, PROMISE, false, true);
setSpecies(PROMISE);
PromiseWrapper = getBuiltIn(PROMISE);
// statics
$({ target: PROMISE, stat: true, forced: FORCED }, {
// `Promise.reject` method
// https://tc39.es/ecma262/#sec-promise.reject
reject: function reject(r) {
var capability = newPromiseCapability(this);
call(capability.reject, undefined, r);
return capability.promise;
}
});
$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {
// `Promise.resolve` method
// https://tc39.es/ecma262/#sec-promise.resolve
resolve: function resolve(x) {
return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);
}
});
$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {
// `Promise.all` method
// https://tc39.es/ecma262/#sec-promise.all
all: function all(iterable) {
var C = this;
var capability = newPromiseCapability(C);
var resolve = capability.resolve;
var reject = capability.reject;
var result = perform(function () {
var $promiseResolve = aCallable(C.resolve);
var values = [];
var counter = 0;
var remaining = 1;
iterate(iterable, function (promise) {
var index = counter++;
var alreadyCalled = false;
remaining++;
call($promiseResolve, C, promise).then(function (value) {
if (alreadyCalled) return;
alreadyCalled = true;
values[index] = value;
--remaining || resolve(values);
}, reject);
});
--remaining || resolve(values);
});
if (result.error) reject(result.value);
return capability.promise;
},
// `Promise.race` method
// https://tc39.es/ecma262/#sec-promise.race
race: function race(iterable) {
var C = this;
var capability = newPromiseCapability(C);
var reject = capability.reject;
var result = perform(function () {
var $promiseResolve = aCallable(C.resolve);
iterate(iterable, function (promise) {
call($promiseResolve, C, promise).then(capability.resolve, reject);
});
});
if (result.error) reject(result.value);
return capability.promise;
}
});
/***/ }),
/* 289 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
module.exports = global.Promise;
/***/ }),
/* 290 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var apply = __webpack_require__(64);
var bind = __webpack_require__(82);
var isCallable = __webpack_require__(19);
var hasOwn = __webpack_require__(36);
var fails = __webpack_require__(6);
var html = __webpack_require__(72);
var arraySlice = __webpack_require__(76);
var createElement = __webpack_require__(40);
var validateArgumentsLength = __webpack_require__(291);
var IS_IOS = __webpack_require__(292);
var IS_NODE = __webpack_require__(157);
var set = global.setImmediate;
var clear = global.clearImmediate;
var process = global.process;
var Dispatch = global.Dispatch;
var Function = global.Function;
var MessageChannel = global.MessageChannel;
var String = global.String;
var counter = 0;
var queue = {};
var ONREADYSTATECHANGE = 'onreadystatechange';
var location, defer, channel, port;
try {
// Deno throws a ReferenceError on `location` access without `--location` flag
location = global.location;
} catch (error) { /* empty */ }
var run = function (id) {
if (hasOwn(queue, id)) {
var fn = queue[id];
delete queue[id];
fn();
}
};
var runner = function (id) {
return function () {
run(id);
};
};
var listener = function (event) {
run(event.data);
};
var post = function (id) {
// old engines have not location.origin
global.postMessage(String(id), location.protocol + '//' + location.host);
};
// Node.js 0.9+ & IE10+ has setImmediate, otherwise:
if (!set || !clear) {
set = function setImmediate(handler) {
validateArgumentsLength(arguments.length, 1);
var fn = isCallable(handler) ? handler : Function(handler);
var args = arraySlice(arguments, 1);
queue[++counter] = function () {
apply(fn, undefined, args);
};
defer(counter);
return counter;
};
clear = function clearImmediate(id) {
delete queue[id];
};
// Node.js 0.8-
if (IS_NODE) {
defer = function (id) {
process.nextTick(runner(id));
};
// Sphere (JS game engine) Dispatch API
} else if (Dispatch && Dispatch.now) {
defer = function (id) {
Dispatch.now(runner(id));
};
// Browsers with MessageChannel, includes WebWorkers
// except iOS - https://github.com/zloirock/core-js/issues/624
} else if (MessageChannel && !IS_IOS) {
channel = new MessageChannel();
port = channel.port2;
channel.port1.onmessage = listener;
defer = bind(port.postMessage, port);
// Browsers with postMessage, skip WebWorkers
// IE8 has postMessage, but it's sync & typeof its postMessage is 'object'
} else if (
global.addEventListener &&
isCallable(global.postMessage) &&
!global.importScripts &&
location && location.protocol !== 'file:' &&
!fails(post)
) {
defer = post;
global.addEventListener('message', listener, false);
// IE8-
} else if (ONREADYSTATECHANGE in createElement('script')) {
defer = function (id) {
html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
html.removeChild(this);
run(id);
};
};
// Rest old browsers
} else {
defer = function (id) {
setTimeout(runner(id), 0);
};
}
}
module.exports = {
set: set,
clear: clear
};
/***/ }),
/* 291 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var TypeError = global.TypeError;
module.exports = function (passed, required) {
if (passed < required) throw TypeError('Not enough arguments');
return passed;
};
/***/ }),
/* 292 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var userAgent = __webpack_require__(26);
module.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);
/***/ }),
/* 293 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var bind = __webpack_require__(82);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
var macrotask = (__webpack_require__(290).set);
var IS_IOS = __webpack_require__(292);
var IS_IOS_PEBBLE = __webpack_require__(294);
var IS_WEBOS_WEBKIT = __webpack_require__(295);
var IS_NODE = __webpack_require__(157);
var MutationObserver = global.MutationObserver || global.WebKitMutationObserver;
var document = global.document;
var process = global.process;
var Promise = global.Promise;
// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`
var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');
var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
var flush, head, last, notify, toggle, node, promise, then;
// modern engines have queueMicrotask method
if (!queueMicrotask) {
flush = function () {
var parent, fn;
if (IS_NODE && (parent = process.domain)) parent.exit();
while (head) {
fn = head.fn;
head = head.next;
try {
fn();
} catch (error) {
if (head) notify();
else last = undefined;
throw error;
}
} last = undefined;
if (parent) parent.enter();
};
// browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339
// also except WebOS Webkit https://github.com/zloirock/core-js/issues/898
if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {
toggle = true;
node = document.createTextNode('');
new MutationObserver(flush).observe(node, { characterData: true });
notify = function () {
node.data = toggle = !toggle;
};
// environments with maybe non-completely correct, but existent Promise
} else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {
// Promise.resolve without an argument throws an error in LG WebOS 2
promise = Promise.resolve(undefined);
// workaround of WebKit ~ iOS Safari 10.1 bug
promise.constructor = Promise;
then = bind(promise.then, promise);
notify = function () {
then(flush);
};
// Node.js without promises
} else if (IS_NODE) {
notify = function () {
process.nextTick(flush);
};
// for other environments - macrotask based on:
// - setImmediate
// - MessageChannel
// - window.postMessag
// - onreadystatechange
// - setTimeout
} else {
// strange IE + webpack dev server bug - use .bind(global)
macrotask = bind(macrotask, global);
notify = function () {
macrotask(flush);
};
}
}
module.exports = queueMicrotask || function (fn) {
var task = { fn: fn, next: undefined };
if (last) last.next = task;
if (!head) {
head = task;
notify();
} last = task;
};
/***/ }),
/* 294 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var userAgent = __webpack_require__(26);
var global = __webpack_require__(3);
module.exports = /ipad|iphone|ipod/i.test(userAgent) && global.Pebble !== undefined;
/***/ }),
/* 295 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var userAgent = __webpack_require__(26);
module.exports = /web0s(?!.*chrome)/i.test(userAgent);
/***/ }),
/* 296 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var anObject = __webpack_require__(44);
var isObject = __webpack_require__(18);
var newPromiseCapability = __webpack_require__(297);
module.exports = function (C, x) {
anObject(C);
if (isObject(x) && x.constructor === C) return x;
var promiseCapability = newPromiseCapability.f(C);
var resolve = promiseCapability.resolve;
resolve(x);
return promiseCapability.promise;
};
/***/ }),
/* 297 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var aCallable = __webpack_require__(28);
var PromiseCapability = function (C) {
var resolve, reject;
this.promise = new C(function ($$resolve, $$reject) {
if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
resolve = $$resolve;
reject = $$reject;
});
this.resolve = aCallable(resolve);
this.reject = aCallable(reject);
};
// `NewPromiseCapability` abstract operation
// https://tc39.es/ecma262/#sec-newpromisecapability
module.exports.f = function (C) {
return new PromiseCapability(C);
};
/***/ }),
/* 298 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
module.exports = function (a, b) {
var console = global.console;
if (console && console.error) {
arguments.length == 1 ? console.error(a) : console.error(a, b);
}
};
/***/ }),
/* 299 */
/***/ (function(module) {
module.exports = function (exec) {
try {
return { error: false, value: exec() };
} catch (error) {
return { error: true, value: error };
}
};
/***/ }),
/* 300 */
/***/ (function(module) {
var Queue = function () {
this.head = null;
this.tail = null;
};
Queue.prototype = {
add: function (item) {
var entry = { item: item, next: null };
if (this.head) this.tail.next = entry;
else this.head = entry;
this.tail = entry;
},
get: function () {
var entry = this.head;
if (entry) {
this.head = entry.next;
if (this.tail === entry) this.tail = null;
return entry.item;
}
}
};
module.exports = Queue;
/***/ }),
/* 301 */
/***/ (function(module) {
module.exports = typeof window == 'object';
/***/ }),
/* 302 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var call = __webpack_require__(7);
var aCallable = __webpack_require__(28);
var newPromiseCapabilityModule = __webpack_require__(297);
var perform = __webpack_require__(299);
var iterate = __webpack_require__(114);
// `Promise.allSettled` method
// https://tc39.es/ecma262/#sec-promise.allsettled
$({ target: 'Promise', stat: true }, {
allSettled: function allSettled(iterable) {
var C = this;
var capability = newPromiseCapabilityModule.f(C);
var resolve = capability.resolve;
var reject = capability.reject;
var result = perform(function () {
var promiseResolve = aCallable(C.resolve);
var values = [];
var counter = 0;
var remaining = 1;
iterate(iterable, function (promise) {
var index = counter++;
var alreadyCalled = false;
remaining++;
call(promiseResolve, C, promise).then(function (value) {
if (alreadyCalled) return;
alreadyCalled = true;
values[index] = { status: 'fulfilled', value: value };
--remaining || resolve(values);
}, function (error) {
if (alreadyCalled) return;
alreadyCalled = true;
values[index] = { status: 'rejected', reason: error };
--remaining || resolve(values);
});
});
--remaining || resolve(values);
});
if (result.error) reject(result.value);
return capability.promise;
}
});
/***/ }),
/* 303 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var aCallable = __webpack_require__(28);
var getBuiltIn = __webpack_require__(21);
var call = __webpack_require__(7);
var newPromiseCapabilityModule = __webpack_require__(297);
var perform = __webpack_require__(299);
var iterate = __webpack_require__(114);
var PROMISE_ANY_ERROR = 'No one promise resolved';
// `Promise.any` method
// https://tc39.es/ecma262/#sec-promise.any
$({ target: 'Promise', stat: true }, {
any: function any(iterable) {
var C = this;
var AggregateError = getBuiltIn('AggregateError');
var capability = newPromiseCapabilityModule.f(C);
var resolve = capability.resolve;
var reject = capability.reject;
var result = perform(function () {
var promiseResolve = aCallable(C.resolve);
var errors = [];
var counter = 0;
var remaining = 1;
var alreadyResolved = false;
iterate(iterable, function (promise) {
var index = counter++;
var alreadyRejected = false;
remaining++;
call(promiseResolve, C, promise).then(function (value) {
if (alreadyRejected || alreadyResolved) return;
alreadyResolved = true;
resolve(value);
}, function (error) {
if (alreadyRejected || alreadyResolved) return;
alreadyRejected = true;
errors[index] = error;
--remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));
});
});
--remaining || reject(new AggregateError(errors, PROMISE_ANY_ERROR));
});
if (result.error) reject(result.value);
return capability.promise;
}
});
/***/ }),
/* 304 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var IS_PURE = __webpack_require__(33);
var NativePromise = __webpack_require__(289);
var fails = __webpack_require__(6);
var getBuiltIn = __webpack_require__(21);
var isCallable = __webpack_require__(19);
var speciesConstructor = __webpack_require__(182);
var promiseResolve = __webpack_require__(296);
var redefine = __webpack_require__(45);
// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829
var NON_GENERIC = !!NativePromise && fails(function () {
// eslint-disable-next-line unicorn/no-thenable -- required for testing
NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });
});
// `Promise.prototype.finally` method
// https://tc39.es/ecma262/#sec-promise.prototype.finally
$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {
'finally': function (onFinally) {
var C = speciesConstructor(this, getBuiltIn('Promise'));
var isFunction = isCallable(onFinally);
return this.then(
isFunction ? function (x) {
return promiseResolve(C, onFinally()).then(function () { return x; });
} : onFinally,
isFunction ? function (e) {
return promiseResolve(C, onFinally()).then(function () { throw e; });
} : onFinally
);
}
});
// makes sure that native promise-based APIs `Promise#finally` properly works with patched `Promise#then`
if (!IS_PURE && isCallable(NativePromise)) {
var method = getBuiltIn('Promise').prototype['finally'];
if (NativePromise.prototype['finally'] !== method) {
redefine(NativePromise.prototype, 'finally', method, { unsafe: true });
}
}
/***/ }),
/* 305 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var functionApply = __webpack_require__(64);
var aCallable = __webpack_require__(28);
var anObject = __webpack_require__(44);
var fails = __webpack_require__(6);
// MS Edge argumentsList argument is optional
var OPTIONAL_ARGUMENTS_LIST = !fails(function () {
// eslint-disable-next-line es/no-reflect -- required for testing
Reflect.apply(function () { /* empty */ });
});
// `Reflect.apply` method
// https://tc39.es/ecma262/#sec-reflect.apply
$({ target: 'Reflect', stat: true, forced: OPTIONAL_ARGUMENTS_LIST }, {
apply: function apply(target, thisArgument, argumentsList) {
return functionApply(aCallable(target), thisArgument, anObject(argumentsList));
}
});
/***/ }),
/* 306 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var getBuiltIn = __webpack_require__(21);
var apply = __webpack_require__(64);
var bind = __webpack_require__(199);
var aConstructor = __webpack_require__(183);
var anObject = __webpack_require__(44);
var isObject = __webpack_require__(18);
var create = __webpack_require__(69);
var fails = __webpack_require__(6);
var nativeConstruct = getBuiltIn('Reflect', 'construct');
var ObjectPrototype = Object.prototype;
var push = [].push;
// `Reflect.construct` method
// https://tc39.es/ecma262/#sec-reflect.construct
// MS Edge supports only 2 arguments and argumentsList argument is optional
// FF Nightly sets third argument as `new.target`, but does not create `this` from it
var NEW_TARGET_BUG = fails(function () {
function F() { /* empty */ }
return !(nativeConstruct(function () { /* empty */ }, [], F) instanceof F);
});
var ARGS_BUG = !fails(function () {
nativeConstruct(function () { /* empty */ });
});
var FORCED = NEW_TARGET_BUG || ARGS_BUG;
$({ target: 'Reflect', stat: true, forced: FORCED, sham: FORCED }, {
construct: function construct(Target, args /* , newTarget */) {
aConstructor(Target);
anObject(args);
var newTarget = arguments.length < 3 ? Target : aConstructor(arguments[2]);
if (ARGS_BUG && !NEW_TARGET_BUG) return nativeConstruct(Target, args, newTarget);
if (Target == newTarget) {
// w/o altered newTarget, optimization for 0-4 arguments
switch (args.length) {
case 0: return new Target();
case 1: return new Target(args[0]);
case 2: return new Target(args[0], args[1]);
case 3: return new Target(args[0], args[1], args[2]);
case 4: return new Target(args[0], args[1], args[2], args[3]);
}
// w/o altered newTarget, lot of arguments case
var $args = [null];
apply(push, $args, args);
return new (apply(bind, Target, $args))();
}
// with altered newTarget, not support built-in constructors
var proto = newTarget.prototype;
var instance = create(isObject(proto) ? proto : ObjectPrototype);
var result = apply(Target, instance, args);
return isObject(result) ? result : instance;
}
});
/***/ }),
/* 307 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var anObject = __webpack_require__(44);
var toPropertyKey = __webpack_require__(16);
var definePropertyModule = __webpack_require__(42);
var fails = __webpack_require__(6);
// MS Edge has broken Reflect.defineProperty - throwing instead of returning false
var ERROR_INSTEAD_OF_FALSE = fails(function () {
// eslint-disable-next-line es/no-reflect -- required for testing
Reflect.defineProperty(definePropertyModule.f({}, 1, { value: 1 }), 1, { value: 2 });
});
// `Reflect.defineProperty` method
// https://tc39.es/ecma262/#sec-reflect.defineproperty
$({ target: 'Reflect', stat: true, forced: ERROR_INSTEAD_OF_FALSE, sham: !DESCRIPTORS }, {
defineProperty: function defineProperty(target, propertyKey, attributes) {
anObject(target);
var key = toPropertyKey(propertyKey);
anObject(attributes);
try {
definePropertyModule.f(target, key, attributes);
return true;
} catch (error) {
return false;
}
}
});
/***/ }),
/* 308 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var anObject = __webpack_require__(44);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
// `Reflect.deleteProperty` method
// https://tc39.es/ecma262/#sec-reflect.deleteproperty
$({ target: 'Reflect', stat: true }, {
deleteProperty: function deleteProperty(target, propertyKey) {
var descriptor = getOwnPropertyDescriptor(anObject(target), propertyKey);
return descriptor && !descriptor.configurable ? false : delete target[propertyKey];
}
});
/***/ }),
/* 309 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var call = __webpack_require__(7);
var isObject = __webpack_require__(18);
var anObject = __webpack_require__(44);
var isDataDescriptor = __webpack_require__(310);
var getOwnPropertyDescriptorModule = __webpack_require__(4);
var getPrototypeOf = __webpack_require__(112);
// `Reflect.get` method
// https://tc39.es/ecma262/#sec-reflect.get
function get(target, propertyKey /* , receiver */) {
var receiver = arguments.length < 3 ? target : arguments[2];
var descriptor, prototype;
if (anObject(target) === receiver) return target[propertyKey];
descriptor = getOwnPropertyDescriptorModule.f(target, propertyKey);
if (descriptor) return isDataDescriptor(descriptor)
? descriptor.value
: descriptor.get === undefined ? undefined : call(descriptor.get, receiver);
if (isObject(prototype = getPrototypeOf(target))) return get(prototype, propertyKey, receiver);
}
$({ target: 'Reflect', stat: true }, {
get: get
});
/***/ }),
/* 310 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var hasOwn = __webpack_require__(36);
module.exports = function (descriptor) {
return descriptor !== undefined && (hasOwn(descriptor, 'value') || hasOwn(descriptor, 'writable'));
};
/***/ }),
/* 311 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var anObject = __webpack_require__(44);
var getOwnPropertyDescriptorModule = __webpack_require__(4);
// `Reflect.getOwnPropertyDescriptor` method
// https://tc39.es/ecma262/#sec-reflect.getownpropertydescriptor
$({ target: 'Reflect', stat: true, sham: !DESCRIPTORS }, {
getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, propertyKey) {
return getOwnPropertyDescriptorModule.f(anObject(target), propertyKey);
}
});
/***/ }),
/* 312 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var anObject = __webpack_require__(44);
var objectGetPrototypeOf = __webpack_require__(112);
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(113);
// `Reflect.getPrototypeOf` method
// https://tc39.es/ecma262/#sec-reflect.getprototypeof
$({ target: 'Reflect', stat: true, sham: !CORRECT_PROTOTYPE_GETTER }, {
getPrototypeOf: function getPrototypeOf(target) {
return objectGetPrototypeOf(anObject(target));
}
});
/***/ }),
/* 313 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
// `Reflect.has` method
// https://tc39.es/ecma262/#sec-reflect.has
$({ target: 'Reflect', stat: true }, {
has: function has(target, propertyKey) {
return propertyKey in target;
}
});
/***/ }),
/* 314 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var anObject = __webpack_require__(44);
var $isExtensible = __webpack_require__(208);
// `Reflect.isExtensible` method
// https://tc39.es/ecma262/#sec-reflect.isextensible
$({ target: 'Reflect', stat: true }, {
isExtensible: function isExtensible(target) {
anObject(target);
return $isExtensible(target);
}
});
/***/ }),
/* 315 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var ownKeys = __webpack_require__(53);
// `Reflect.ownKeys` method
// https://tc39.es/ecma262/#sec-reflect.ownkeys
$({ target: 'Reflect', stat: true }, {
ownKeys: ownKeys
});
/***/ }),
/* 316 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var getBuiltIn = __webpack_require__(21);
var anObject = __webpack_require__(44);
var FREEZING = __webpack_require__(210);
// `Reflect.preventExtensions` method
// https://tc39.es/ecma262/#sec-reflect.preventextensions
$({ target: 'Reflect', stat: true, sham: !FREEZING }, {
preventExtensions: function preventExtensions(target) {
anObject(target);
try {
var objectPreventExtensions = getBuiltIn('Object', 'preventExtensions');
if (objectPreventExtensions) objectPreventExtensions(target);
return true;
} catch (error) {
return false;
}
}
});
/***/ }),
/* 317 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var call = __webpack_require__(7);
var anObject = __webpack_require__(44);
var isObject = __webpack_require__(18);
var isDataDescriptor = __webpack_require__(310);
var fails = __webpack_require__(6);
var definePropertyModule = __webpack_require__(42);
var getOwnPropertyDescriptorModule = __webpack_require__(4);
var getPrototypeOf = __webpack_require__(112);
var createPropertyDescriptor = __webpack_require__(10);
// `Reflect.set` method
// https://tc39.es/ecma262/#sec-reflect.set
function set(target, propertyKey, V /* , receiver */) {
var receiver = arguments.length < 4 ? target : arguments[3];
var ownDescriptor = getOwnPropertyDescriptorModule.f(anObject(target), propertyKey);
var existingDescriptor, prototype, setter;
if (!ownDescriptor) {
if (isObject(prototype = getPrototypeOf(target))) {
return set(prototype, propertyKey, V, receiver);
}
ownDescriptor = createPropertyDescriptor(0);
}
if (isDataDescriptor(ownDescriptor)) {
if (ownDescriptor.writable === false || !isObject(receiver)) return false;
if (existingDescriptor = getOwnPropertyDescriptorModule.f(receiver, propertyKey)) {
if (existingDescriptor.get || existingDescriptor.set || existingDescriptor.writable === false) return false;
existingDescriptor.value = V;
definePropertyModule.f(receiver, propertyKey, existingDescriptor);
} else definePropertyModule.f(receiver, propertyKey, createPropertyDescriptor(0, V));
} else {
setter = ownDescriptor.set;
if (setter === undefined) return false;
call(setter, receiver, V);
} return true;
}
// MS Edge 17-18 Reflect.set allows setting the property to object
// with non-writable property on the prototype
var MS_EDGE_BUG = fails(function () {
var Constructor = function () { /* empty */ };
var object = definePropertyModule.f(new Constructor(), 'a', { configurable: true });
// eslint-disable-next-line es/no-reflect -- required for testing
return Reflect.set(Constructor.prototype, 'a', 1, object) !== false;
});
$({ target: 'Reflect', stat: true, forced: MS_EDGE_BUG }, {
set: set
});
/***/ }),
/* 318 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var anObject = __webpack_require__(44);
var aPossiblePrototype = __webpack_require__(103);
var objectSetPrototypeOf = __webpack_require__(102);
// `Reflect.setPrototypeOf` method
// https://tc39.es/ecma262/#sec-reflect.setprototypeof
if (objectSetPrototypeOf) $({ target: 'Reflect', stat: true }, {
setPrototypeOf: function setPrototypeOf(target, proto) {
anObject(target);
aPossiblePrototype(proto);
try {
objectSetPrototypeOf(target, proto);
return true;
} catch (error) {
return false;
}
}
});
/***/ }),
/* 319 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var setToStringTag = __webpack_require__(80);
$({ global: true }, { Reflect: {} });
// Reflect[@@toStringTag] property
// https://tc39.es/ecma262/#sec-reflect-@@tostringtag
setToStringTag(global.Reflect, 'Reflect', true);
/***/ }),
/* 320 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var isForced = __webpack_require__(63);
var inheritIfRequired = __webpack_require__(104);
var createNonEnumerableProperty = __webpack_require__(41);
var defineProperty = (__webpack_require__(42).f);
var getOwnPropertyNames = (__webpack_require__(54).f);
var isPrototypeOf = __webpack_require__(22);
var isRegExp = __webpack_require__(321);
var toString = __webpack_require__(66);
var regExpFlags = __webpack_require__(322);
var stickyHelpers = __webpack_require__(323);
var redefine = __webpack_require__(45);
var fails = __webpack_require__(6);
var hasOwn = __webpack_require__(36);
var enforceInternalState = (__webpack_require__(47).enforce);
var setSpecies = __webpack_require__(168);
var wellKnownSymbol = __webpack_require__(31);
var UNSUPPORTED_DOT_ALL = __webpack_require__(324);
var UNSUPPORTED_NCG = __webpack_require__(325);
var MATCH = wellKnownSymbol('match');
var NativeRegExp = global.RegExp;
var RegExpPrototype = NativeRegExp.prototype;
var SyntaxError = global.SyntaxError;
var getFlags = uncurryThis(regExpFlags);
var exec = uncurryThis(RegExpPrototype.exec);
var charAt = uncurryThis(''.charAt);
var replace = uncurryThis(''.replace);
var stringIndexOf = uncurryThis(''.indexOf);
var stringSlice = uncurryThis(''.slice);
// TODO: Use only propper RegExpIdentifierName
var IS_NCG = /^\?<[^\s\d!#%&*+<=>@^][^\s!#%&*+<=>@^]*>/;
var re1 = /a/g;
var re2 = /a/g;
// "new" should create a new object, old webkit bug
var CORRECT_NEW = new NativeRegExp(re1) !== re1;
var MISSED_STICKY = stickyHelpers.MISSED_STICKY;
var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
var BASE_FORCED = DESCRIPTORS &&
(!CORRECT_NEW || MISSED_STICKY || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG || fails(function () {
re2[MATCH] = false;
// RegExp constructor can alter flags and IsRegExp works correct with @@match
return NativeRegExp(re1) != re1 || NativeRegExp(re2) == re2 || NativeRegExp(re1, 'i') != '/a/i';
}));
var handleDotAll = function (string) {
var length = string.length;
var index = 0;
var result = '';
var brackets = false;
var chr;
for (; index <= length; index++) {
chr = charAt(string, index);
if (chr === '\\') {
result += chr + charAt(string, ++index);
continue;
}
if (!brackets && chr === '.') {
result += '[\\s\\S]';
} else {
if (chr === '[') {
brackets = true;
} else if (chr === ']') {
brackets = false;
} result += chr;
}
} return result;
};
var handleNCG = function (string) {
var length = string.length;
var index = 0;
var result = '';
var named = [];
var names = {};
var brackets = false;
var ncg = false;
var groupid = 0;
var groupname = '';
var chr;
for (; index <= length; index++) {
chr = charAt(string, index);
if (chr === '\\') {
chr = chr + charAt(string, ++index);
} else if (chr === ']') {
brackets = false;
} else if (!brackets) switch (true) {
case chr === '[':
brackets = true;
break;
case chr === '(':
if (exec(IS_NCG, stringSlice(string, index + 1))) {
index += 2;
ncg = true;
}
result += chr;
groupid++;
continue;
case chr === '>' && ncg:
if (groupname === '' || hasOwn(names, groupname)) {
throw new SyntaxError('Invalid capture group name');
}
names[groupname] = true;
named[named.length] = [groupname, groupid];
ncg = false;
groupname = '';
continue;
}
if (ncg) groupname += chr;
else result += chr;
} return [result, named];
};
// `RegExp` constructor
// https://tc39.es/ecma262/#sec-regexp-constructor
if (isForced('RegExp', BASE_FORCED)) {
var RegExpWrapper = function RegExp(pattern, flags) {
var thisIsRegExp = isPrototypeOf(RegExpPrototype, this);
var patternIsRegExp = isRegExp(pattern);
var flagsAreUndefined = flags === undefined;
var groups = [];
var rawPattern = pattern;
var rawFlags, dotAll, sticky, handled, result, state;
if (!thisIsRegExp && patternIsRegExp && flagsAreUndefined && pattern.constructor === RegExpWrapper) {
return pattern;
}
if (patternIsRegExp || isPrototypeOf(RegExpPrototype, pattern)) {
pattern = pattern.source;
if (flagsAreUndefined) flags = 'flags' in rawPattern ? rawPattern.flags : getFlags(rawPattern);
}
pattern = pattern === undefined ? '' : toString(pattern);
flags = flags === undefined ? '' : toString(flags);
rawPattern = pattern;
if (UNSUPPORTED_DOT_ALL && 'dotAll' in re1) {
dotAll = !!flags && stringIndexOf(flags, 's') > -1;
if (dotAll) flags = replace(flags, /s/g, '');
}
rawFlags = flags;
if (MISSED_STICKY && 'sticky' in re1) {
sticky = !!flags && stringIndexOf(flags, 'y') > -1;
if (sticky && UNSUPPORTED_Y) flags = replace(flags, /y/g, '');
}
if (UNSUPPORTED_NCG) {
handled = handleNCG(pattern);
pattern = handled[0];
groups = handled[1];
}
result = inheritIfRequired(NativeRegExp(pattern, flags), thisIsRegExp ? this : RegExpPrototype, RegExpWrapper);
if (dotAll || sticky || groups.length) {
state = enforceInternalState(result);
if (dotAll) {
state.dotAll = true;
state.raw = RegExpWrapper(handleDotAll(pattern), rawFlags);
}
if (sticky) state.sticky = true;
if (groups.length) state.groups = groups;
}
if (pattern !== rawPattern) try {
// fails in old engines, but we have no alternatives for unsupported regex syntax
createNonEnumerableProperty(result, 'source', rawPattern === '' ? '(?:)' : rawPattern);
} catch (error) { /* empty */ }
return result;
};
var proxy = function (key) {
key in RegExpWrapper || defineProperty(RegExpWrapper, key, {
configurable: true,
get: function () { return NativeRegExp[key]; },
set: function (it) { NativeRegExp[key] = it; }
});
};
for (var keys = getOwnPropertyNames(NativeRegExp), index = 0; keys.length > index;) {
proxy(keys[index++]);
}
RegExpPrototype.constructor = RegExpWrapper;
RegExpWrapper.prototype = RegExpPrototype;
redefine(global, 'RegExp', RegExpWrapper);
}
// https://tc39.es/ecma262/#sec-get-regexp-@@species
setSpecies('RegExp');
/***/ }),
/* 321 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var isObject = __webpack_require__(18);
var classof = __webpack_require__(14);
var wellKnownSymbol = __webpack_require__(31);
var MATCH = wellKnownSymbol('match');
// `IsRegExp` abstract operation
// https://tc39.es/ecma262/#sec-isregexp
module.exports = function (it) {
var isRegExp;
return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp');
};
/***/ }),
/* 322 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var anObject = __webpack_require__(44);
// `RegExp.prototype.flags` getter implementation
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
module.exports = function () {
var that = anObject(this);
var result = '';
if (that.global) result += 'g';
if (that.ignoreCase) result += 'i';
if (that.multiline) result += 'm';
if (that.dotAll) result += 's';
if (that.unicode) result += 'u';
if (that.sticky) result += 'y';
return result;
};
/***/ }),
/* 323 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var global = __webpack_require__(3);
// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError
var $RegExp = global.RegExp;
var UNSUPPORTED_Y = fails(function () {
var re = $RegExp('a', 'y');
re.lastIndex = 2;
return re.exec('abcd') != null;
});
// UC Browser bug
// https://github.com/zloirock/core-js/issues/1008
var MISSED_STICKY = UNSUPPORTED_Y || fails(function () {
return !$RegExp('a', 'y').sticky;
});
var BROKEN_CARET = UNSUPPORTED_Y || fails(function () {
// https://bugzilla.mozilla.org/show_bug.cgi?id=773687
var re = $RegExp('^r', 'gy');
re.lastIndex = 2;
return re.exec('str') != null;
});
module.exports = {
BROKEN_CARET: BROKEN_CARET,
MISSED_STICKY: MISSED_STICKY,
UNSUPPORTED_Y: UNSUPPORTED_Y
};
/***/ }),
/* 324 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var global = __webpack_require__(3);
// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError
var $RegExp = global.RegExp;
module.exports = fails(function () {
var re = $RegExp('.', 's');
return !(re.dotAll && re.exec('\n') && re.flags === 's');
});
/***/ }),
/* 325 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var global = __webpack_require__(3);
// babel-minify and Closure Compiler transpiles RegExp('(?<a>b)', 'g') -> /(?<a>b)/g and it causes SyntaxError
var $RegExp = global.RegExp;
module.exports = fails(function () {
var re = $RegExp('(?<a>b)', 'g');
return re.exec('b').groups.a !== 'b' ||
'b'.replace(re, '$<a>c') !== 'bc';
});
/***/ }),
/* 326 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var DESCRIPTORS = __webpack_require__(5);
var UNSUPPORTED_DOT_ALL = __webpack_require__(324);
var classof = __webpack_require__(14);
var defineProperty = (__webpack_require__(42).f);
var getInternalState = (__webpack_require__(47).get);
var RegExpPrototype = RegExp.prototype;
var TypeError = global.TypeError;
// `RegExp.prototype.dotAll` getter
// https://tc39.es/ecma262/#sec-get-regexp.prototype.dotall
if (DESCRIPTORS && UNSUPPORTED_DOT_ALL) {
defineProperty(RegExpPrototype, 'dotAll', {
configurable: true,
get: function () {
if (this === RegExpPrototype) return undefined;
// We can't use InternalStateModule.getterFor because
// we don't add metadata for regexps created by a literal.
if (classof(this) === 'RegExp') {
return !!getInternalState(this).dotAll;
}
throw TypeError('Incompatible receiver, RegExp required');
}
});
}
/***/ }),
/* 327 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var exec = __webpack_require__(328);
// `RegExp.prototype.exec` method
// https://tc39.es/ecma262/#sec-regexp.prototype.exec
$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {
exec: exec
});
/***/ }),
/* 328 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */
/* eslint-disable regexp/no-useless-quantifier -- testing */
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var toString = __webpack_require__(66);
var regexpFlags = __webpack_require__(322);
var stickyHelpers = __webpack_require__(323);
var shared = __webpack_require__(32);
var create = __webpack_require__(69);
var getInternalState = (__webpack_require__(47).get);
var UNSUPPORTED_DOT_ALL = __webpack_require__(324);
var UNSUPPORTED_NCG = __webpack_require__(325);
var nativeReplace = shared('native-string-replace', String.prototype.replace);
var nativeExec = RegExp.prototype.exec;
var patchedExec = nativeExec;
var charAt = uncurryThis(''.charAt);
var indexOf = uncurryThis(''.indexOf);
var replace = uncurryThis(''.replace);
var stringSlice = uncurryThis(''.slice);
var UPDATES_LAST_INDEX_WRONG = (function () {
var re1 = /a/;
var re2 = /b*/g;
call(nativeExec, re1, 'a');
call(nativeExec, re2, 'a');
return re1.lastIndex !== 0 || re2.lastIndex !== 0;
})();
var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;
// nonparticipating capturing group, copied from es5-shim's String#split patch.
var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;
var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;
if (PATCH) {
patchedExec = function exec(string) {
var re = this;
var state = getInternalState(re);
var str = toString(string);
var raw = state.raw;
var result, reCopy, lastIndex, match, i, object, group;
if (raw) {
raw.lastIndex = re.lastIndex;
result = call(patchedExec, raw, str);
re.lastIndex = raw.lastIndex;
return result;
}
var groups = state.groups;
var sticky = UNSUPPORTED_Y && re.sticky;
var flags = call(regexpFlags, re);
var source = re.source;
var charsAdded = 0;
var strCopy = str;
if (sticky) {
flags = replace(flags, 'y', '');
if (indexOf(flags, 'g') === -1) {
flags += 'g';
}
strCopy = stringSlice(str, re.lastIndex);
// Support anchored sticky behavior.
if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt(str, re.lastIndex - 1) !== '\n')) {
source = '(?: ' + source + ')';
strCopy = ' ' + strCopy;
charsAdded++;
}
// ^(? + rx + ) is needed, in combination with some str slicing, to
// simulate the 'y' flag.
reCopy = new RegExp('^(?:' + source + ')', flags);
}
if (NPCG_INCLUDED) {
reCopy = new RegExp('^' + source + '$(?!\\s)', flags);
}
if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;
match = call(nativeExec, sticky ? reCopy : re, strCopy);
if (sticky) {
if (match) {
match.input = stringSlice(match.input, charsAdded);
match[0] = stringSlice(match[0], charsAdded);
match.index = re.lastIndex;
re.lastIndex += match[0].length;
} else re.lastIndex = 0;
} else if (UPDATES_LAST_INDEX_WRONG && match) {
re.lastIndex = re.global ? match.index + match[0].length : lastIndex;
}
if (NPCG_INCLUDED && match && match.length > 1) {
// Fix browsers whose `exec` methods don't consistently return `undefined`
// for NPCG, like IE8. NOTE: This doesn' work for /(.?)?/
call(nativeReplace, match[0], reCopy, function () {
for (i = 1; i < arguments.length - 2; i++) {
if (arguments[i] === undefined) match[i] = undefined;
}
});
}
if (match && groups) {
match.groups = object = create(null);
for (i = 0; i < groups.length; i++) {
group = groups[i];
object[group[0]] = match[group[1]];
}
}
return match;
};
}
module.exports = patchedExec;
/***/ }),
/* 329 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var DESCRIPTORS = __webpack_require__(5);
var objectDefinePropertyModule = __webpack_require__(42);
var regExpFlags = __webpack_require__(322);
var fails = __webpack_require__(6);
var RegExpPrototype = RegExp.prototype;
var FORCED = DESCRIPTORS && fails(function () {
// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
return Object.getOwnPropertyDescriptor(RegExpPrototype, 'flags').get.call({ dotAll: true, sticky: true }) !== 'sy';
});
// `RegExp.prototype.flags` getter
// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags
if (FORCED) objectDefinePropertyModule.f(RegExpPrototype, 'flags', {
configurable: true,
get: regExpFlags
});
/***/ }),
/* 330 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var DESCRIPTORS = __webpack_require__(5);
var MISSED_STICKY = (__webpack_require__(323).MISSED_STICKY);
var classof = __webpack_require__(14);
var defineProperty = (__webpack_require__(42).f);
var getInternalState = (__webpack_require__(47).get);
var RegExpPrototype = RegExp.prototype;
var TypeError = global.TypeError;
// `RegExp.prototype.sticky` getter
// https://tc39.es/ecma262/#sec-get-regexp.prototype.sticky
if (DESCRIPTORS && MISSED_STICKY) {
defineProperty(RegExpPrototype, 'sticky', {
configurable: true,
get: function () {
if (this === RegExpPrototype) return undefined;
// We can't use InternalStateModule.getterFor because
// we don't add metadata for regexps created by a literal.
if (classof(this) === 'RegExp') {
return !!getInternalState(this).sticky;
}
throw TypeError('Incompatible receiver, RegExp required');
}
});
}
/***/ }),
/* 331 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
// TODO: Remove from `core-js@4` since it's moved to entry points
__webpack_require__(327);
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var isCallable = __webpack_require__(19);
var isObject = __webpack_require__(18);
var DELEGATES_TO_EXEC = function () {
var execCalled = false;
var re = /[ac]/;
re.exec = function () {
execCalled = true;
return /./.exec.apply(this, arguments);
};
return re.test('abc') === true && execCalled;
}();
var Error = global.Error;
var un$Test = uncurryThis(/./.test);
// `RegExp.prototype.test` method
// https://tc39.es/ecma262/#sec-regexp.prototype.test
$({ target: 'RegExp', proto: true, forced: !DELEGATES_TO_EXEC }, {
test: function (str) {
var exec = this.exec;
if (!isCallable(exec)) return un$Test(this, str);
var result = call(exec, this, str);
if (result !== null && !isObject(result)) {
throw new Error('RegExp exec method returned something other than an Object or null');
}
return !!result;
}
});
/***/ }),
/* 332 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var uncurryThis = __webpack_require__(13);
var PROPER_FUNCTION_NAME = (__webpack_require__(51).PROPER);
var redefine = __webpack_require__(45);
var anObject = __webpack_require__(44);
var isPrototypeOf = __webpack_require__(22);
var $toString = __webpack_require__(66);
var fails = __webpack_require__(6);
var regExpFlags = __webpack_require__(322);
var TO_STRING = 'toString';
var RegExpPrototype = RegExp.prototype;
var n$ToString = RegExpPrototype[TO_STRING];
var getFlags = uncurryThis(regExpFlags);
var NOT_GENERIC = fails(function () { return n$ToString.call({ source: 'a', flags: 'b' }) != '/a/b'; });
// FF44- RegExp#toString has a wrong name
var INCORRECT_NAME = PROPER_FUNCTION_NAME && n$ToString.name != TO_STRING;
// `RegExp.prototype.toString` method
// https://tc39.es/ecma262/#sec-regexp.prototype.tostring
if (NOT_GENERIC || INCORRECT_NAME) {
redefine(RegExp.prototype, TO_STRING, function toString() {
var R = anObject(this);
var p = $toString(R.source);
var rf = R.flags;
var f = $toString(rf === undefined && isPrototypeOf(RegExpPrototype, R) && !('flags' in RegExpPrototype) ? getFlags(R) : rf);
return '/' + p + '/' + f;
}, { unsafe: true });
}
/***/ }),
/* 333 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var collection = __webpack_require__(206);
var collectionStrong = __webpack_require__(211);
// `Set` constructor
// https://tc39.es/ecma262/#sec-set-objects
collection('Set', function (init) {
return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };
}, collectionStrong);
/***/ }),
/* 334 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var requireObjectCoercible = __webpack_require__(15);
var toIntegerOrInfinity = __webpack_require__(58);
var toString = __webpack_require__(66);
var fails = __webpack_require__(6);
var charAt = uncurryThis(''.charAt);
var FORCED = fails(function () {
return '𠮷'.at(-2) !== '\uD842';
});
// `String.prototype.at` method
// https://github.com/tc39/proposal-relative-indexing-method
$({ target: 'String', proto: true, forced: FORCED }, {
at: function at(index) {
var S = toString(requireObjectCoercible(this));
var len = S.length;
var relativeIndex = toIntegerOrInfinity(index);
var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
return (k < 0 || k >= len) ? undefined : charAt(S, k);
}
});
/***/ }),
/* 335 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var codeAt = (__webpack_require__(336).codeAt);
// `String.prototype.codePointAt` method
// https://tc39.es/ecma262/#sec-string.prototype.codepointat
$({ target: 'String', proto: true }, {
codePointAt: function codePointAt(pos) {
return codeAt(this, pos);
}
});
/***/ }),
/* 336 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var toIntegerOrInfinity = __webpack_require__(58);
var toString = __webpack_require__(66);
var requireObjectCoercible = __webpack_require__(15);
var charAt = uncurryThis(''.charAt);
var charCodeAt = uncurryThis(''.charCodeAt);
var stringSlice = uncurryThis(''.slice);
var createMethod = function (CONVERT_TO_STRING) {
return function ($this, pos) {
var S = toString(requireObjectCoercible($this));
var position = toIntegerOrInfinity(pos);
var size = S.length;
var first, second;
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
first = charCodeAt(S, position);
return first < 0xD800 || first > 0xDBFF || position + 1 === size
|| (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF
? CONVERT_TO_STRING
? charAt(S, position)
: first
: CONVERT_TO_STRING
? stringSlice(S, position, position + 2)
: (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
};
};
module.exports = {
// `String.prototype.codePointAt` method
// https://tc39.es/ecma262/#sec-string.prototype.codepointat
codeAt: createMethod(false),
// `String.prototype.at` method
// https://github.com/mathiasbynens/String.prototype.at
charAt: createMethod(true)
};
/***/ }),
/* 337 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
var toLength = __webpack_require__(60);
var toString = __webpack_require__(66);
var notARegExp = __webpack_require__(338);
var requireObjectCoercible = __webpack_require__(15);
var correctIsRegExpLogic = __webpack_require__(339);
var IS_PURE = __webpack_require__(33);
// eslint-disable-next-line es/no-string-prototype-endswith -- safe
var un$EndsWith = uncurryThis(''.endsWith);
var slice = uncurryThis(''.slice);
var min = Math.min;
var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('endsWith');
// https://github.com/zloirock/core-js/pull/702
var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {
var descriptor = getOwnPropertyDescriptor(String.prototype, 'endsWith');
return descriptor && !descriptor.writable;
}();
// `String.prototype.endsWith` method
// https://tc39.es/ecma262/#sec-string.prototype.endswith
$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
endsWith: function endsWith(searchString /* , endPosition = @length */) {
var that = toString(requireObjectCoercible(this));
notARegExp(searchString);
var endPosition = arguments.length > 1 ? arguments[1] : undefined;
var len = that.length;
var end = endPosition === undefined ? len : min(toLength(endPosition), len);
var search = toString(searchString);
return un$EndsWith
? un$EndsWith(that, search, end)
: slice(that, end - search.length, end) === search;
}
});
/***/ }),
/* 338 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var isRegExp = __webpack_require__(321);
var TypeError = global.TypeError;
module.exports = function (it) {
if (isRegExp(it)) {
throw TypeError("The method doesn't accept regular expressions");
} return it;
};
/***/ }),
/* 339 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var wellKnownSymbol = __webpack_require__(31);
var MATCH = wellKnownSymbol('match');
module.exports = function (METHOD_NAME) {
var regexp = /./;
try {
'/./'[METHOD_NAME](regexp);
} catch (error1) {
try {
regexp[MATCH] = false;
return '/./'[METHOD_NAME](regexp);
} catch (error2) { /* empty */ }
} return false;
};
/***/ }),
/* 340 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var toAbsoluteIndex = __webpack_require__(57);
var RangeError = global.RangeError;
var fromCharCode = String.fromCharCode;
// eslint-disable-next-line es/no-string-fromcodepoint -- required for testing
var $fromCodePoint = String.fromCodePoint;
var join = uncurryThis([].join);
// length should be 1, old FF problem
var INCORRECT_LENGTH = !!$fromCodePoint && $fromCodePoint.length != 1;
// `String.fromCodePoint` method
// https://tc39.es/ecma262/#sec-string.fromcodepoint
$({ target: 'String', stat: true, forced: INCORRECT_LENGTH }, {
// eslint-disable-next-line no-unused-vars -- required for `.length`
fromCodePoint: function fromCodePoint(x) {
var elements = [];
var length = arguments.length;
var i = 0;
var code;
while (length > i) {
code = +arguments[i++];
if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw RangeError(code + ' is not a valid code point');
elements[i] = code < 0x10000
? fromCharCode(code)
: fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00);
} return join(elements, '');
}
});
/***/ }),
/* 341 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var notARegExp = __webpack_require__(338);
var requireObjectCoercible = __webpack_require__(15);
var toString = __webpack_require__(66);
var correctIsRegExpLogic = __webpack_require__(339);
var stringIndexOf = uncurryThis(''.indexOf);
// `String.prototype.includes` method
// https://tc39.es/ecma262/#sec-string.prototype.includes
$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {
includes: function includes(searchString /* , position = 0 */) {
return !!~stringIndexOf(
toString(requireObjectCoercible(this)),
toString(notARegExp(searchString)),
arguments.length > 1 ? arguments[1] : undefined
);
}
});
/***/ }),
/* 342 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var charAt = (__webpack_require__(336).charAt);
var toString = __webpack_require__(66);
var InternalStateModule = __webpack_require__(47);
var defineIterator = __webpack_require__(147);
var STRING_ITERATOR = 'String Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
// `String.prototype[@@iterator]` method
// https://tc39.es/ecma262/#sec-string.prototype-@@iterator
defineIterator(String, 'String', function (iterated) {
setInternalState(this, {
type: STRING_ITERATOR,
string: toString(iterated),
index: 0
});
// `%StringIteratorPrototype%.next` method
// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next
}, function next() {
var state = getInternalState(this);
var string = state.string;
var index = state.index;
var point;
if (index >= string.length) return { value: undefined, done: true };
point = charAt(string, index);
state.index += point.length;
return { value: point, done: false };
});
/***/ }),
/* 343 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var call = __webpack_require__(7);
var fixRegExpWellKnownSymbolLogic = __webpack_require__(344);
var anObject = __webpack_require__(44);
var toLength = __webpack_require__(60);
var toString = __webpack_require__(66);
var requireObjectCoercible = __webpack_require__(15);
var getMethod = __webpack_require__(27);
var advanceStringIndex = __webpack_require__(345);
var regExpExec = __webpack_require__(346);
// @@match logic
fixRegExpWellKnownSymbolLogic('match', function (MATCH, nativeMatch, maybeCallNative) {
return [
// `String.prototype.match` method
// https://tc39.es/ecma262/#sec-string.prototype.match
function match(regexp) {
var O = requireObjectCoercible(this);
var matcher = regexp == undefined ? undefined : getMethod(regexp, MATCH);
return matcher ? call(matcher, regexp, O) : new RegExp(regexp)[MATCH](toString(O));
},
// `RegExp.prototype[@@match]` method
// https://tc39.es/ecma262/#sec-regexp.prototype-@@match
function (string) {
var rx = anObject(this);
var S = toString(string);
var res = maybeCallNative(nativeMatch, rx, S);
if (res.done) return res.value;
if (!rx.global) return regExpExec(rx, S);
var fullUnicode = rx.unicode;
rx.lastIndex = 0;
var A = [];
var n = 0;
var result;
while ((result = regExpExec(rx, S)) !== null) {
var matchStr = toString(result[0]);
A[n] = matchStr;
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
n++;
}
return n === 0 ? null : A;
}
];
});
/***/ }),
/* 344 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
// TODO: Remove from `core-js@4` since it's moved to entry points
__webpack_require__(327);
var uncurryThis = __webpack_require__(13);
var redefine = __webpack_require__(45);
var regexpExec = __webpack_require__(328);
var fails = __webpack_require__(6);
var wellKnownSymbol = __webpack_require__(31);
var createNonEnumerableProperty = __webpack_require__(41);
var SPECIES = wellKnownSymbol('species');
var RegExpPrototype = RegExp.prototype;
module.exports = function (KEY, exec, FORCED, SHAM) {
var SYMBOL = wellKnownSymbol(KEY);
var DELEGATES_TO_SYMBOL = !fails(function () {
// String methods call symbol-named RegEp methods
var O = {};
O[SYMBOL] = function () { return 7; };
return ''[KEY](O) != 7;
});
var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {
// Symbol-named RegExp methods call .exec
var execCalled = false;
var re = /a/;
if (KEY === 'split') {
// We can't use real regex here since it causes deoptimization
// and serious performance degradation in V8
// https://github.com/zloirock/core-js/issues/306
re = {};
// RegExp[@@split] doesn't call the regex's exec method, but first creates
// a new one. We need to return the patched regex when creating the new one.
re.constructor = {};
re.constructor[SPECIES] = function () { return re; };
re.flags = '';
re[SYMBOL] = /./[SYMBOL];
}
re.exec = function () { execCalled = true; return null; };
re[SYMBOL]('');
return !execCalled;
});
if (
!DELEGATES_TO_SYMBOL ||
!DELEGATES_TO_EXEC ||
FORCED
) {
var uncurriedNativeRegExpMethod = uncurryThis(/./[SYMBOL]);
var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {
var uncurriedNativeMethod = uncurryThis(nativeMethod);
var $exec = regexp.exec;
if ($exec === regexpExec || $exec === RegExpPrototype.exec) {
if (DELEGATES_TO_SYMBOL && !forceStringMethod) {
// The native String method already delegates to @@method (this
// polyfilled function), leasing to infinite recursion.
// We avoid it by directly calling the native @@method method.
return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };
}
return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };
}
return { done: false };
});
redefine(String.prototype, KEY, methods[0]);
redefine(RegExpPrototype, SYMBOL, methods[1]);
}
if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);
};
/***/ }),
/* 345 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var charAt = (__webpack_require__(336).charAt);
// `AdvanceStringIndex` abstract operation
// https://tc39.es/ecma262/#sec-advancestringindex
module.exports = function (S, index, unicode) {
return index + (unicode ? charAt(S, index).length : 1);
};
/***/ }),
/* 346 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var anObject = __webpack_require__(44);
var isCallable = __webpack_require__(19);
var classof = __webpack_require__(14);
var regexpExec = __webpack_require__(328);
var TypeError = global.TypeError;
// `RegExpExec` abstract operation
// https://tc39.es/ecma262/#sec-regexpexec
module.exports = function (R, S) {
var exec = R.exec;
if (isCallable(exec)) {
var result = call(exec, R, S);
if (result !== null) anObject(result);
return result;
}
if (classof(R) === 'RegExp') return call(regexpExec, R, S);
throw TypeError('RegExp#exec called on incompatible receiver');
};
/***/ }),
/* 347 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
/* eslint-disable es/no-string-prototype-matchall -- safe */
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var createIteratorConstructor = __webpack_require__(148);
var requireObjectCoercible = __webpack_require__(15);
var toLength = __webpack_require__(60);
var toString = __webpack_require__(66);
var anObject = __webpack_require__(44);
var classof = __webpack_require__(14);
var isPrototypeOf = __webpack_require__(22);
var isRegExp = __webpack_require__(321);
var regExpFlags = __webpack_require__(322);
var getMethod = __webpack_require__(27);
var redefine = __webpack_require__(45);
var fails = __webpack_require__(6);
var wellKnownSymbol = __webpack_require__(31);
var speciesConstructor = __webpack_require__(182);
var advanceStringIndex = __webpack_require__(345);
var regExpExec = __webpack_require__(346);
var InternalStateModule = __webpack_require__(47);
var IS_PURE = __webpack_require__(33);
var MATCH_ALL = wellKnownSymbol('matchAll');
var REGEXP_STRING = 'RegExp String';
var REGEXP_STRING_ITERATOR = REGEXP_STRING + ' Iterator';
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(REGEXP_STRING_ITERATOR);
var RegExpPrototype = RegExp.prototype;
var TypeError = global.TypeError;
var getFlags = uncurryThis(regExpFlags);
var stringIndexOf = uncurryThis(''.indexOf);
var un$MatchAll = uncurryThis(''.matchAll);
var WORKS_WITH_NON_GLOBAL_REGEX = !!un$MatchAll && !fails(function () {
un$MatchAll('a', /./);
});
var $RegExpStringIterator = createIteratorConstructor(function RegExpStringIterator(regexp, string, $global, fullUnicode) {
setInternalState(this, {
type: REGEXP_STRING_ITERATOR,
regexp: regexp,
string: string,
global: $global,
unicode: fullUnicode,
done: false
});
}, REGEXP_STRING, function next() {
var state = getInternalState(this);
if (state.done) return { value: undefined, done: true };
var R = state.regexp;
var S = state.string;
var match = regExpExec(R, S);
if (match === null) return { value: undefined, done: state.done = true };
if (state.global) {
if (toString(match[0]) === '') R.lastIndex = advanceStringIndex(S, toLength(R.lastIndex), state.unicode);
return { value: match, done: false };
}
state.done = true;
return { value: match, done: false };
});
var $matchAll = function (string) {
var R = anObject(this);
var S = toString(string);
var C, flagsValue, flags, matcher, $global, fullUnicode;
C = speciesConstructor(R, RegExp);
flagsValue = R.flags;
if (flagsValue === undefined && isPrototypeOf(RegExpPrototype, R) && !('flags' in RegExpPrototype)) {
flagsValue = getFlags(R);
}
flags = flagsValue === undefined ? '' : toString(flagsValue);
matcher = new C(C === RegExp ? R.source : R, flags);
$global = !!~stringIndexOf(flags, 'g');
fullUnicode = !!~stringIndexOf(flags, 'u');
matcher.lastIndex = toLength(R.lastIndex);
return new $RegExpStringIterator(matcher, S, $global, fullUnicode);
};
// `String.prototype.matchAll` method
// https://tc39.es/ecma262/#sec-string.prototype.matchall
$({ target: 'String', proto: true, forced: WORKS_WITH_NON_GLOBAL_REGEX }, {
matchAll: function matchAll(regexp) {
var O = requireObjectCoercible(this);
var flags, S, matcher, rx;
if (regexp != null) {
if (isRegExp(regexp)) {
flags = toString(requireObjectCoercible('flags' in RegExpPrototype
? regexp.flags
: getFlags(regexp)
));
if (!~stringIndexOf(flags, 'g')) throw TypeError('`.matchAll` does not allow non-global regexes');
}
if (WORKS_WITH_NON_GLOBAL_REGEX) return un$MatchAll(O, regexp);
matcher = getMethod(regexp, MATCH_ALL);
if (matcher === undefined && IS_PURE && classof(regexp) == 'RegExp') matcher = $matchAll;
if (matcher) return call(matcher, regexp, O);
} else if (WORKS_WITH_NON_GLOBAL_REGEX) return un$MatchAll(O, regexp);
S = toString(O);
rx = new RegExp(regexp, 'g');
return IS_PURE ? call($matchAll, rx, S) : rx[MATCH_ALL](S);
}
});
IS_PURE || MATCH_ALL in RegExpPrototype || redefine(RegExpPrototype, MATCH_ALL, $matchAll);
/***/ }),
/* 348 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $padEnd = (__webpack_require__(191).end);
var WEBKIT_BUG = __webpack_require__(349);
// `String.prototype.padEnd` method
// https://tc39.es/ecma262/#sec-string.prototype.padend
$({ target: 'String', proto: true, forced: WEBKIT_BUG }, {
padEnd: function padEnd(maxLength /* , fillString = ' ' */) {
return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 349 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// https://github.com/zloirock/core-js/issues/280
var userAgent = __webpack_require__(26);
module.exports = /Version\/10(?:\.\d+){1,2}(?: [\w./]+)?(?: Mobile\/\w+)? Safari\//.test(userAgent);
/***/ }),
/* 350 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $padStart = (__webpack_require__(191).start);
var WEBKIT_BUG = __webpack_require__(349);
// `String.prototype.padStart` method
// https://tc39.es/ecma262/#sec-string.prototype.padstart
$({ target: 'String', proto: true, forced: WEBKIT_BUG }, {
padStart: function padStart(maxLength /* , fillString = ' ' */) {
return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
}
});
/***/ }),
/* 351 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var toIndexedObject = __webpack_require__(11);
var toObject = __webpack_require__(37);
var toString = __webpack_require__(66);
var lengthOfArrayLike = __webpack_require__(59);
var push = uncurryThis([].push);
var join = uncurryThis([].join);
// `String.raw` method
// https://tc39.es/ecma262/#sec-string.raw
$({ target: 'String', stat: true }, {
raw: function raw(template) {
var rawTemplate = toIndexedObject(toObject(template).raw);
var literalSegments = lengthOfArrayLike(rawTemplate);
var argumentsLength = arguments.length;
var elements = [];
var i = 0;
while (literalSegments > i) {
push(elements, toString(rawTemplate[i++]));
if (i === literalSegments) return join(elements, '');
if (i < argumentsLength) push(elements, toString(arguments[i]));
}
}
});
/***/ }),
/* 352 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var repeat = __webpack_require__(192);
// `String.prototype.repeat` method
// https://tc39.es/ecma262/#sec-string.prototype.repeat
$({ target: 'String', proto: true }, {
repeat: repeat
});
/***/ }),
/* 353 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var apply = __webpack_require__(64);
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var fixRegExpWellKnownSymbolLogic = __webpack_require__(344);
var fails = __webpack_require__(6);
var anObject = __webpack_require__(44);
var isCallable = __webpack_require__(19);
var toIntegerOrInfinity = __webpack_require__(58);
var toLength = __webpack_require__(60);
var toString = __webpack_require__(66);
var requireObjectCoercible = __webpack_require__(15);
var advanceStringIndex = __webpack_require__(345);
var getMethod = __webpack_require__(27);
var getSubstitution = __webpack_require__(354);
var regExpExec = __webpack_require__(346);
var wellKnownSymbol = __webpack_require__(31);
var REPLACE = wellKnownSymbol('replace');
var max = Math.max;
var min = Math.min;
var concat = uncurryThis([].concat);
var push = uncurryThis([].push);
var stringIndexOf = uncurryThis(''.indexOf);
var stringSlice = uncurryThis(''.slice);
var maybeToString = function (it) {
return it === undefined ? it : String(it);
};
// IE <= 11 replaces $0 with the whole match, as if it was $&
// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0
var REPLACE_KEEPS_$0 = (function () {
// eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing
return 'a'.replace(/./, '$0') === '$0';
})();
// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string
var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {
if (/./[REPLACE]) {
return /./[REPLACE]('a', '$0') === '';
}
return false;
})();
var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {
var re = /./;
re.exec = function () {
var result = [];
result.groups = { a: '7' };
return result;
};
// eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive
return ''.replace(re, '$<a>') !== '7';
});
// @@replace logic
fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {
var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';
return [
// `String.prototype.replace` method
// https://tc39.es/ecma262/#sec-string.prototype.replace
function replace(searchValue, replaceValue) {
var O = requireObjectCoercible(this);
var replacer = searchValue == undefined ? undefined : getMethod(searchValue, REPLACE);
return replacer
? call(replacer, searchValue, O, replaceValue)
: call(nativeReplace, toString(O), searchValue, replaceValue);
},
// `RegExp.prototype[@@replace]` method
// https://tc39.es/ecma262/#sec-regexp.prototype-@@replace
function (string, replaceValue) {
var rx = anObject(this);
var S = toString(string);
if (
typeof replaceValue == 'string' &&
stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&
stringIndexOf(replaceValue, '$<') === -1
) {
var res = maybeCallNative(nativeReplace, rx, S, replaceValue);
if (res.done) return res.value;
}
var functionalReplace = isCallable(replaceValue);
if (!functionalReplace) replaceValue = toString(replaceValue);
var global = rx.global;
if (global) {
var fullUnicode = rx.unicode;
rx.lastIndex = 0;
}
var results = [];
while (true) {
var result = regExpExec(rx, S);
if (result === null) break;
push(results, result);
if (!global) break;
var matchStr = toString(result[0]);
if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);
}
var accumulatedResult = '';
var nextSourcePosition = 0;
for (var i = 0; i < results.length; i++) {
result = results[i];
var matched = toString(result[0]);
var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);
var captures = [];
// NOTE: This is equivalent to
// captures = result.slice(1).map(maybeToString)
// but for some reason `nativeSlice.call(result, 1, result.length)` (called in
// the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and
// causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.
for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));
var namedCaptures = result.groups;
if (functionalReplace) {
var replacerArgs = concat([matched], captures, position, S);
if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);
var replacement = toString(apply(replaceValue, undefined, replacerArgs));
} else {
replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);
}
if (position >= nextSourcePosition) {
accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;
nextSourcePosition = position + matched.length;
}
}
return accumulatedResult + stringSlice(S, nextSourcePosition);
}
];
}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);
/***/ }),
/* 354 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var toObject = __webpack_require__(37);
var floor = Math.floor;
var charAt = uncurryThis(''.charAt);
var replace = uncurryThis(''.replace);
var stringSlice = uncurryThis(''.slice);
var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g;
var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g;
// `GetSubstitution` abstract operation
// https://tc39.es/ecma262/#sec-getsubstitution
module.exports = function (matched, str, position, captures, namedCaptures, replacement) {
var tailPos = position + matched.length;
var m = captures.length;
var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;
if (namedCaptures !== undefined) {
namedCaptures = toObject(namedCaptures);
symbols = SUBSTITUTION_SYMBOLS;
}
return replace(replacement, symbols, function (match, ch) {
var capture;
switch (charAt(ch, 0)) {
case '$': return '$';
case '&': return matched;
case '`': return stringSlice(str, 0, position);
case "'": return stringSlice(str, tailPos);
case '<':
capture = namedCaptures[stringSlice(ch, 1, -1)];
break;
default: // \d\d?
var n = +ch;
if (n === 0) return match;
if (n > m) {
var f = floor(n / 10);
if (f === 0) return match;
if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);
return match;
}
capture = captures[n - 1];
}
return capture === undefined ? '' : capture;
});
};
/***/ }),
/* 355 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var requireObjectCoercible = __webpack_require__(15);
var isCallable = __webpack_require__(19);
var isRegExp = __webpack_require__(321);
var toString = __webpack_require__(66);
var getMethod = __webpack_require__(27);
var regExpFlags = __webpack_require__(322);
var getSubstitution = __webpack_require__(354);
var wellKnownSymbol = __webpack_require__(31);
var IS_PURE = __webpack_require__(33);
var REPLACE = wellKnownSymbol('replace');
var RegExpPrototype = RegExp.prototype;
var TypeError = global.TypeError;
var getFlags = uncurryThis(regExpFlags);
var indexOf = uncurryThis(''.indexOf);
var replace = uncurryThis(''.replace);
var stringSlice = uncurryThis(''.slice);
var max = Math.max;
var stringIndexOf = function (string, searchValue, fromIndex) {
if (fromIndex > string.length) return -1;
if (searchValue === '') return fromIndex;
return indexOf(string, searchValue, fromIndex);
};
// `String.prototype.replaceAll` method
// https://tc39.es/ecma262/#sec-string.prototype.replaceall
$({ target: 'String', proto: true }, {
replaceAll: function replaceAll(searchValue, replaceValue) {
var O = requireObjectCoercible(this);
var IS_REG_EXP, flags, replacer, string, searchString, functionalReplace, searchLength, advanceBy, replacement;
var position = 0;
var endOfLastMatch = 0;
var result = '';
if (searchValue != null) {
IS_REG_EXP = isRegExp(searchValue);
if (IS_REG_EXP) {
flags = toString(requireObjectCoercible('flags' in RegExpPrototype
? searchValue.flags
: getFlags(searchValue)
));
if (!~indexOf(flags, 'g')) throw TypeError('`.replaceAll` does not allow non-global regexes');
}
replacer = getMethod(searchValue, REPLACE);
if (replacer) {
return call(replacer, searchValue, O, replaceValue);
} else if (IS_PURE && IS_REG_EXP) {
return replace(toString(O), searchValue, replaceValue);
}
}
string = toString(O);
searchString = toString(searchValue);
functionalReplace = isCallable(replaceValue);
if (!functionalReplace) replaceValue = toString(replaceValue);
searchLength = searchString.length;
advanceBy = max(1, searchLength);
position = stringIndexOf(string, searchString, 0);
while (position !== -1) {
replacement = functionalReplace
? toString(replaceValue(searchString, position, string))
: getSubstitution(searchString, string, position, [], undefined, replaceValue);
result += stringSlice(string, endOfLastMatch, position) + replacement;
endOfLastMatch = position + searchLength;
position = stringIndexOf(string, searchString, position + advanceBy);
}
if (endOfLastMatch < string.length) {
result += stringSlice(string, endOfLastMatch);
}
return result;
}
});
/***/ }),
/* 356 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var call = __webpack_require__(7);
var fixRegExpWellKnownSymbolLogic = __webpack_require__(344);
var anObject = __webpack_require__(44);
var requireObjectCoercible = __webpack_require__(15);
var sameValue = __webpack_require__(273);
var toString = __webpack_require__(66);
var getMethod = __webpack_require__(27);
var regExpExec = __webpack_require__(346);
// @@search logic
fixRegExpWellKnownSymbolLogic('search', function (SEARCH, nativeSearch, maybeCallNative) {
return [
// `String.prototype.search` method
// https://tc39.es/ecma262/#sec-string.prototype.search
function search(regexp) {
var O = requireObjectCoercible(this);
var searcher = regexp == undefined ? undefined : getMethod(regexp, SEARCH);
return searcher ? call(searcher, regexp, O) : new RegExp(regexp)[SEARCH](toString(O));
},
// `RegExp.prototype[@@search]` method
// https://tc39.es/ecma262/#sec-regexp.prototype-@@search
function (string) {
var rx = anObject(this);
var S = toString(string);
var res = maybeCallNative(nativeSearch, rx, S);
if (res.done) return res.value;
var previousLastIndex = rx.lastIndex;
if (!sameValue(previousLastIndex, 0)) rx.lastIndex = 0;
var result = regExpExec(rx, S);
if (!sameValue(rx.lastIndex, previousLastIndex)) rx.lastIndex = previousLastIndex;
return result === null ? -1 : result.index;
}
];
});
/***/ }),
/* 357 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var apply = __webpack_require__(64);
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var fixRegExpWellKnownSymbolLogic = __webpack_require__(344);
var isRegExp = __webpack_require__(321);
var anObject = __webpack_require__(44);
var requireObjectCoercible = __webpack_require__(15);
var speciesConstructor = __webpack_require__(182);
var advanceStringIndex = __webpack_require__(345);
var toLength = __webpack_require__(60);
var toString = __webpack_require__(66);
var getMethod = __webpack_require__(27);
var arraySlice = __webpack_require__(74);
var callRegExpExec = __webpack_require__(346);
var regexpExec = __webpack_require__(328);
var stickyHelpers = __webpack_require__(323);
var fails = __webpack_require__(6);
var UNSUPPORTED_Y = stickyHelpers.UNSUPPORTED_Y;
var MAX_UINT32 = 0xFFFFFFFF;
var min = Math.min;
var $push = [].push;
var exec = uncurryThis(/./.exec);
var push = uncurryThis($push);
var stringSlice = uncurryThis(''.slice);
// Chrome 51 has a buggy "split" implementation when RegExp#exec !== nativeExec
// Weex JS has frozen built-in prototypes, so use try / catch wrapper
var SPLIT_WORKS_WITH_OVERWRITTEN_EXEC = !fails(function () {
// eslint-disable-next-line regexp/no-empty-group -- required for testing
var re = /(?:)/;
var originalExec = re.exec;
re.exec = function () { return originalExec.apply(this, arguments); };
var result = 'ab'.split(re);
return result.length !== 2 || result[0] !== 'a' || result[1] !== 'b';
});
// @@split logic
fixRegExpWellKnownSymbolLogic('split', function (SPLIT, nativeSplit, maybeCallNative) {
var internalSplit;
if (
'abbc'.split(/(b)*/)[1] == 'c' ||
// eslint-disable-next-line regexp/no-empty-group -- required for testing
'test'.split(/(?:)/, -1).length != 4 ||
'ab'.split(/(?:ab)*/).length != 2 ||
'.'.split(/(.?)(.?)/).length != 4 ||
// eslint-disable-next-line regexp/no-empty-capturing-group, regexp/no-empty-group -- required for testing
'.'.split(/()()/).length > 1 ||
''.split(/.?/).length
) {
// based on es5-shim implementation, need to rework it
internalSplit = function (separator, limit) {
var string = toString(requireObjectCoercible(this));
var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
if (lim === 0) return [];
if (separator === undefined) return [string];
// If `separator` is not a regex, use native split
if (!isRegExp(separator)) {
return call(nativeSplit, string, separator, lim);
}
var output = [];
var flags = (separator.ignoreCase ? 'i' : '') +
(separator.multiline ? 'm' : '') +
(separator.unicode ? 'u' : '') +
(separator.sticky ? 'y' : '');
var lastLastIndex = 0;
// Make `global` and avoid `lastIndex` issues by working with a copy
var separatorCopy = new RegExp(separator.source, flags + 'g');
var match, lastIndex, lastLength;
while (match = call(regexpExec, separatorCopy, string)) {
lastIndex = separatorCopy.lastIndex;
if (lastIndex > lastLastIndex) {
push(output, stringSlice(string, lastLastIndex, match.index));
if (match.length > 1 && match.index < string.length) apply($push, output, arraySlice(match, 1));
lastLength = match[0].length;
lastLastIndex = lastIndex;
if (output.length >= lim) break;
}
if (separatorCopy.lastIndex === match.index) separatorCopy.lastIndex++; // Avoid an infinite loop
}
if (lastLastIndex === string.length) {
if (lastLength || !exec(separatorCopy, '')) push(output, '');
} else push(output, stringSlice(string, lastLastIndex));
return output.length > lim ? arraySlice(output, 0, lim) : output;
};
// Chakra, V8
} else if ('0'.split(undefined, 0).length) {
internalSplit = function (separator, limit) {
return separator === undefined && limit === 0 ? [] : call(nativeSplit, this, separator, limit);
};
} else internalSplit = nativeSplit;
return [
// `String.prototype.split` method
// https://tc39.es/ecma262/#sec-string.prototype.split
function split(separator, limit) {
var O = requireObjectCoercible(this);
var splitter = separator == undefined ? undefined : getMethod(separator, SPLIT);
return splitter
? call(splitter, separator, O, limit)
: call(internalSplit, toString(O), separator, limit);
},
// `RegExp.prototype[@@split]` method
// https://tc39.es/ecma262/#sec-regexp.prototype-@@split
//
// NOTE: This cannot be properly polyfilled in engines that don't support
// the 'y' flag.
function (string, limit) {
var rx = anObject(this);
var S = toString(string);
var res = maybeCallNative(internalSplit, rx, S, limit, internalSplit !== nativeSplit);
if (res.done) return res.value;
var C = speciesConstructor(rx, RegExp);
var unicodeMatching = rx.unicode;
var flags = (rx.ignoreCase ? 'i' : '') +
(rx.multiline ? 'm' : '') +
(rx.unicode ? 'u' : '') +
(UNSUPPORTED_Y ? 'g' : 'y');
// ^(? + rx + ) is needed, in combination with some S slicing, to
// simulate the 'y' flag.
var splitter = new C(UNSUPPORTED_Y ? '^(?:' + rx.source + ')' : rx, flags);
var lim = limit === undefined ? MAX_UINT32 : limit >>> 0;
if (lim === 0) return [];
if (S.length === 0) return callRegExpExec(splitter, S) === null ? [S] : [];
var p = 0;
var q = 0;
var A = [];
while (q < S.length) {
splitter.lastIndex = UNSUPPORTED_Y ? 0 : q;
var z = callRegExpExec(splitter, UNSUPPORTED_Y ? stringSlice(S, q) : S);
var e;
if (
z === null ||
(e = min(toLength(splitter.lastIndex + (UNSUPPORTED_Y ? q : 0)), S.length)) === p
) {
q = advanceStringIndex(S, q, unicodeMatching);
} else {
push(A, stringSlice(S, p, q));
if (A.length === lim) return A;
for (var i = 1; i <= z.length - 1; i++) {
push(A, z[i]);
if (A.length === lim) return A;
}
q = p = e;
}
}
push(A, stringSlice(S, p));
return A;
}
];
}, !SPLIT_WORKS_WITH_OVERWRITTEN_EXEC, UNSUPPORTED_Y);
/***/ }),
/* 358 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var getOwnPropertyDescriptor = (__webpack_require__(4).f);
var toLength = __webpack_require__(60);
var toString = __webpack_require__(66);
var notARegExp = __webpack_require__(338);
var requireObjectCoercible = __webpack_require__(15);
var correctIsRegExpLogic = __webpack_require__(339);
var IS_PURE = __webpack_require__(33);
// eslint-disable-next-line es/no-string-prototype-startswith -- safe
var un$StartsWith = uncurryThis(''.startsWith);
var stringSlice = uncurryThis(''.slice);
var min = Math.min;
var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');
// https://github.com/zloirock/core-js/pull/702
var MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {
var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');
return descriptor && !descriptor.writable;
}();
// `String.prototype.startsWith` method
// https://tc39.es/ecma262/#sec-string.prototype.startswith
$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {
startsWith: function startsWith(searchString /* , position = 0 */) {
var that = toString(requireObjectCoercible(this));
notARegExp(searchString);
var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));
var search = toString(searchString);
return un$StartsWith
? un$StartsWith(that, search, index)
: stringSlice(that, index, index + search.length) === search;
}
});
/***/ }),
/* 359 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var requireObjectCoercible = __webpack_require__(15);
var toIntegerOrInfinity = __webpack_require__(58);
var toString = __webpack_require__(66);
var stringSlice = uncurryThis(''.slice);
var max = Math.max;
var min = Math.min;
// eslint-disable-next-line unicorn/prefer-string-slice -- required for testing
var FORCED = !''.substr || 'ab'.substr(-1) !== 'b';
// `String.prototype.substr` method
// https://tc39.es/ecma262/#sec-string.prototype.substr
$({ target: 'String', proto: true, forced: FORCED }, {
substr: function substr(start, length) {
var that = toString(requireObjectCoercible(this));
var size = that.length;
var intStart = toIntegerOrInfinity(start);
var intLength, intEnd;
if (intStart === Infinity) intStart = 0;
if (intStart < 0) intStart = max(size + intStart, 0);
intLength = length === undefined ? size : toIntegerOrInfinity(length);
if (intLength <= 0 || intLength === Infinity) return '';
intEnd = min(intStart + intLength, size);
return intStart >= intEnd ? '' : stringSlice(that, intStart, intEnd);
}
});
/***/ }),
/* 360 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $trim = (__webpack_require__(237).trim);
var forcedStringTrimMethod = __webpack_require__(361);
// `String.prototype.trim` method
// https://tc39.es/ecma262/#sec-string.prototype.trim
$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {
trim: function trim() {
return $trim(this);
}
});
/***/ }),
/* 361 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var PROPER_FUNCTION_NAME = (__webpack_require__(51).PROPER);
var fails = __webpack_require__(6);
var whitespaces = __webpack_require__(238);
var non = '\u200B\u0085\u180E';
// check that a method works with the correct list
// of whitespaces and has a correct name
module.exports = function (METHOD_NAME) {
return fails(function () {
return !!whitespaces[METHOD_NAME]()
|| non[METHOD_NAME]() !== non
|| (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);
});
};
/***/ }),
/* 362 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $trimEnd = (__webpack_require__(237).end);
var forcedStringTrimMethod = __webpack_require__(361);
var FORCED = forcedStringTrimMethod('trimEnd');
var trimEnd = FORCED ? function trimEnd() {
return $trimEnd(this);
// eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe
} : ''.trimEnd;
// `String.prototype.{ trimEnd, trimRight }` methods
// https://tc39.es/ecma262/#sec-string.prototype.trimend
// https://tc39.es/ecma262/#String.prototype.trimright
$({ target: 'String', proto: true, name: 'trimEnd', forced: FORCED }, {
trimEnd: trimEnd,
trimRight: trimEnd
});
/***/ }),
/* 363 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var $trimStart = (__webpack_require__(237).start);
var forcedStringTrimMethod = __webpack_require__(361);
var FORCED = forcedStringTrimMethod('trimStart');
var trimStart = FORCED ? function trimStart() {
return $trimStart(this);
// eslint-disable-next-line es/no-string-prototype-trimstart-trimend -- safe
} : ''.trimStart;
// `String.prototype.{ trimStart, trimLeft }` methods
// https://tc39.es/ecma262/#sec-string.prototype.trimstart
// https://tc39.es/ecma262/#String.prototype.trimleft
$({ target: 'String', proto: true, name: 'trimStart', forced: FORCED }, {
trimStart: trimStart,
trimLeft: trimStart
});
/***/ }),
/* 364 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.anchor` method
// https://tc39.es/ecma262/#sec-string.prototype.anchor
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('anchor') }, {
anchor: function anchor(name) {
return createHTML(this, 'a', 'name', name);
}
});
/***/ }),
/* 365 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var uncurryThis = __webpack_require__(13);
var requireObjectCoercible = __webpack_require__(15);
var toString = __webpack_require__(66);
var quot = /"/g;
var replace = uncurryThis(''.replace);
// `CreateHTML` abstract operation
// https://tc39.es/ecma262/#sec-createhtml
module.exports = function (string, tag, attribute, value) {
var S = toString(requireObjectCoercible(string));
var p1 = '<' + tag;
if (attribute !== '') p1 += ' ' + attribute + '="' + replace(toString(value), quot, '"') + '"';
return p1 + '>' + S + '</' + tag + '>';
};
/***/ }),
/* 366 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
// check the existence of a method, lowercase
// of a tag and escaping quotes in arguments
module.exports = function (METHOD_NAME) {
return fails(function () {
var test = ''[METHOD_NAME]('"');
return test !== test.toLowerCase() || test.split('"').length > 3;
});
};
/***/ }),
/* 367 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.big` method
// https://tc39.es/ecma262/#sec-string.prototype.big
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('big') }, {
big: function big() {
return createHTML(this, 'big', '', '');
}
});
/***/ }),
/* 368 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.blink` method
// https://tc39.es/ecma262/#sec-string.prototype.blink
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('blink') }, {
blink: function blink() {
return createHTML(this, 'blink', '', '');
}
});
/***/ }),
/* 369 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.bold` method
// https://tc39.es/ecma262/#sec-string.prototype.bold
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('bold') }, {
bold: function bold() {
return createHTML(this, 'b', '', '');
}
});
/***/ }),
/* 370 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.fixed` method
// https://tc39.es/ecma262/#sec-string.prototype.fixed
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fixed') }, {
fixed: function fixed() {
return createHTML(this, 'tt', '', '');
}
});
/***/ }),
/* 371 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.fontcolor` method
// https://tc39.es/ecma262/#sec-string.prototype.fontcolor
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontcolor') }, {
fontcolor: function fontcolor(color) {
return createHTML(this, 'font', 'color', color);
}
});
/***/ }),
/* 372 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.fontsize` method
// https://tc39.es/ecma262/#sec-string.prototype.fontsize
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('fontsize') }, {
fontsize: function fontsize(size) {
return createHTML(this, 'font', 'size', size);
}
});
/***/ }),
/* 373 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.italics` method
// https://tc39.es/ecma262/#sec-string.prototype.italics
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('italics') }, {
italics: function italics() {
return createHTML(this, 'i', '', '');
}
});
/***/ }),
/* 374 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.link` method
// https://tc39.es/ecma262/#sec-string.prototype.link
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('link') }, {
link: function link(url) {
return createHTML(this, 'a', 'href', url);
}
});
/***/ }),
/* 375 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.small` method
// https://tc39.es/ecma262/#sec-string.prototype.small
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('small') }, {
small: function small() {
return createHTML(this, 'small', '', '');
}
});
/***/ }),
/* 376 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.strike` method
// https://tc39.es/ecma262/#sec-string.prototype.strike
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('strike') }, {
strike: function strike() {
return createHTML(this, 'strike', '', '');
}
});
/***/ }),
/* 377 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.sub` method
// https://tc39.es/ecma262/#sec-string.prototype.sub
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sub') }, {
sub: function sub() {
return createHTML(this, 'sub', '', '');
}
});
/***/ }),
/* 378 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var createHTML = __webpack_require__(365);
var forcedStringHTMLMethod = __webpack_require__(366);
// `String.prototype.sup` method
// https://tc39.es/ecma262/#sec-string.prototype.sup
$({ target: 'String', proto: true, forced: forcedStringHTMLMethod('sup') }, {
sup: function sup() {
return createHTML(this, 'sup', '', '');
}
});
/***/ }),
/* 379 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Float32Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Float32', function (init) {
return function Float32Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 380 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var DESCRIPTORS = __webpack_require__(5);
var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(381);
var ArrayBufferViewCore = __webpack_require__(180);
var ArrayBufferModule = __webpack_require__(173);
var anInstance = __webpack_require__(176);
var createPropertyDescriptor = __webpack_require__(10);
var createNonEnumerableProperty = __webpack_require__(41);
var isIntegralNumber = __webpack_require__(243);
var toLength = __webpack_require__(60);
var toIndex = __webpack_require__(177);
var toOffset = __webpack_require__(382);
var toPropertyKey = __webpack_require__(16);
var hasOwn = __webpack_require__(36);
var classof = __webpack_require__(67);
var isObject = __webpack_require__(18);
var isSymbol = __webpack_require__(20);
var create = __webpack_require__(69);
var isPrototypeOf = __webpack_require__(22);
var setPrototypeOf = __webpack_require__(102);
var getOwnPropertyNames = (__webpack_require__(54).f);
var typedArrayFrom = __webpack_require__(384);
var forEach = (__webpack_require__(81).forEach);
var setSpecies = __webpack_require__(168);
var definePropertyModule = __webpack_require__(42);
var getOwnPropertyDescriptorModule = __webpack_require__(4);
var InternalStateModule = __webpack_require__(47);
var inheritIfRequired = __webpack_require__(104);
var getInternalState = InternalStateModule.get;
var setInternalState = InternalStateModule.set;
var nativeDefineProperty = definePropertyModule.f;
var nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
var round = Math.round;
var RangeError = global.RangeError;
var ArrayBuffer = ArrayBufferModule.ArrayBuffer;
var ArrayBufferPrototype = ArrayBuffer.prototype;
var DataView = ArrayBufferModule.DataView;
var NATIVE_ARRAY_BUFFER_VIEWS = ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS;
var TYPED_ARRAY_CONSTRUCTOR = ArrayBufferViewCore.TYPED_ARRAY_CONSTRUCTOR;
var TYPED_ARRAY_TAG = ArrayBufferViewCore.TYPED_ARRAY_TAG;
var TypedArray = ArrayBufferViewCore.TypedArray;
var TypedArrayPrototype = ArrayBufferViewCore.TypedArrayPrototype;
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
var isTypedArray = ArrayBufferViewCore.isTypedArray;
var BYTES_PER_ELEMENT = 'BYTES_PER_ELEMENT';
var WRONG_LENGTH = 'Wrong length';
var fromList = function (C, list) {
aTypedArrayConstructor(C);
var index = 0;
var length = list.length;
var result = new C(length);
while (length > index) result[index] = list[index++];
return result;
};
var addGetter = function (it, key) {
nativeDefineProperty(it, key, { get: function () {
return getInternalState(this)[key];
} });
};
var isArrayBuffer = function (it) {
var klass;
return isPrototypeOf(ArrayBufferPrototype, it) || (klass = classof(it)) == 'ArrayBuffer' || klass == 'SharedArrayBuffer';
};
var isTypedArrayIndex = function (target, key) {
return isTypedArray(target)
&& !isSymbol(key)
&& key in target
&& isIntegralNumber(+key)
&& key >= 0;
};
var wrappedGetOwnPropertyDescriptor = function getOwnPropertyDescriptor(target, key) {
key = toPropertyKey(key);
return isTypedArrayIndex(target, key)
? createPropertyDescriptor(2, target[key])
: nativeGetOwnPropertyDescriptor(target, key);
};
var wrappedDefineProperty = function defineProperty(target, key, descriptor) {
key = toPropertyKey(key);
if (isTypedArrayIndex(target, key)
&& isObject(descriptor)
&& hasOwn(descriptor, 'value')
&& !hasOwn(descriptor, 'get')
&& !hasOwn(descriptor, 'set')
// TODO: add validation descriptor w/o calling accessors
&& !descriptor.configurable
&& (!hasOwn(descriptor, 'writable') || descriptor.writable)
&& (!hasOwn(descriptor, 'enumerable') || descriptor.enumerable)
) {
target[key] = descriptor.value;
return target;
} return nativeDefineProperty(target, key, descriptor);
};
if (DESCRIPTORS) {
if (!NATIVE_ARRAY_BUFFER_VIEWS) {
getOwnPropertyDescriptorModule.f = wrappedGetOwnPropertyDescriptor;
definePropertyModule.f = wrappedDefineProperty;
addGetter(TypedArrayPrototype, 'buffer');
addGetter(TypedArrayPrototype, 'byteOffset');
addGetter(TypedArrayPrototype, 'byteLength');
addGetter(TypedArrayPrototype, 'length');
}
$({ target: 'Object', stat: true, forced: !NATIVE_ARRAY_BUFFER_VIEWS }, {
getOwnPropertyDescriptor: wrappedGetOwnPropertyDescriptor,
defineProperty: wrappedDefineProperty
});
module.exports = function (TYPE, wrapper, CLAMPED) {
var BYTES = TYPE.match(/\d+$/)[0] / 8;
var CONSTRUCTOR_NAME = TYPE + (CLAMPED ? 'Clamped' : '') + 'Array';
var GETTER = 'get' + TYPE;
var SETTER = 'set' + TYPE;
var NativeTypedArrayConstructor = global[CONSTRUCTOR_NAME];
var TypedArrayConstructor = NativeTypedArrayConstructor;
var TypedArrayConstructorPrototype = TypedArrayConstructor && TypedArrayConstructor.prototype;
var exported = {};
var getter = function (that, index) {
var data = getInternalState(that);
return data.view[GETTER](index * BYTES + data.byteOffset, true);
};
var setter = function (that, index, value) {
var data = getInternalState(that);
if (CLAMPED) value = (value = round(value)) < 0 ? 0 : value > 0xFF ? 0xFF : value & 0xFF;
data.view[SETTER](index * BYTES + data.byteOffset, value, true);
};
var addElement = function (that, index) {
nativeDefineProperty(that, index, {
get: function () {
return getter(this, index);
},
set: function (value) {
return setter(this, index, value);
},
enumerable: true
});
};
if (!NATIVE_ARRAY_BUFFER_VIEWS) {
TypedArrayConstructor = wrapper(function (that, data, offset, $length) {
anInstance(that, TypedArrayConstructorPrototype);
var index = 0;
var byteOffset = 0;
var buffer, byteLength, length;
if (!isObject(data)) {
length = toIndex(data);
byteLength = length * BYTES;
buffer = new ArrayBuffer(byteLength);
} else if (isArrayBuffer(data)) {
buffer = data;
byteOffset = toOffset(offset, BYTES);
var $len = data.byteLength;
if ($length === undefined) {
if ($len % BYTES) throw RangeError(WRONG_LENGTH);
byteLength = $len - byteOffset;
if (byteLength < 0) throw RangeError(WRONG_LENGTH);
} else {
byteLength = toLength($length) * BYTES;
if (byteLength + byteOffset > $len) throw RangeError(WRONG_LENGTH);
}
length = byteLength / BYTES;
} else if (isTypedArray(data)) {
return fromList(TypedArrayConstructor, data);
} else {
return call(typedArrayFrom, TypedArrayConstructor, data);
}
setInternalState(that, {
buffer: buffer,
byteOffset: byteOffset,
byteLength: byteLength,
length: length,
view: new DataView(buffer)
});
while (index < length) addElement(that, index++);
});
if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
TypedArrayConstructorPrototype = TypedArrayConstructor.prototype = create(TypedArrayPrototype);
} else if (TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS) {
TypedArrayConstructor = wrapper(function (dummy, data, typedArrayOffset, $length) {
anInstance(dummy, TypedArrayConstructorPrototype);
return inheritIfRequired(function () {
if (!isObject(data)) return new NativeTypedArrayConstructor(toIndex(data));
if (isArrayBuffer(data)) return $length !== undefined
? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES), $length)
: typedArrayOffset !== undefined
? new NativeTypedArrayConstructor(data, toOffset(typedArrayOffset, BYTES))
: new NativeTypedArrayConstructor(data);
if (isTypedArray(data)) return fromList(TypedArrayConstructor, data);
return call(typedArrayFrom, TypedArrayConstructor, data);
}(), dummy, TypedArrayConstructor);
});
if (setPrototypeOf) setPrototypeOf(TypedArrayConstructor, TypedArray);
forEach(getOwnPropertyNames(NativeTypedArrayConstructor), function (key) {
if (!(key in TypedArrayConstructor)) {
createNonEnumerableProperty(TypedArrayConstructor, key, NativeTypedArrayConstructor[key]);
}
});
TypedArrayConstructor.prototype = TypedArrayConstructorPrototype;
}
if (TypedArrayConstructorPrototype.constructor !== TypedArrayConstructor) {
createNonEnumerableProperty(TypedArrayConstructorPrototype, 'constructor', TypedArrayConstructor);
}
createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_CONSTRUCTOR, TypedArrayConstructor);
if (TYPED_ARRAY_TAG) {
createNonEnumerableProperty(TypedArrayConstructorPrototype, TYPED_ARRAY_TAG, CONSTRUCTOR_NAME);
}
exported[CONSTRUCTOR_NAME] = TypedArrayConstructor;
$({
global: true, forced: TypedArrayConstructor != NativeTypedArrayConstructor, sham: !NATIVE_ARRAY_BUFFER_VIEWS
}, exported);
if (!(BYTES_PER_ELEMENT in TypedArrayConstructor)) {
createNonEnumerableProperty(TypedArrayConstructor, BYTES_PER_ELEMENT, BYTES);
}
if (!(BYTES_PER_ELEMENT in TypedArrayConstructorPrototype)) {
createNonEnumerableProperty(TypedArrayConstructorPrototype, BYTES_PER_ELEMENT, BYTES);
}
setSpecies(CONSTRUCTOR_NAME);
};
} else module.exports = function () { /* empty */ };
/***/ }),
/* 381 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
/* eslint-disable no-new -- required for testing */
var global = __webpack_require__(3);
var fails = __webpack_require__(6);
var checkCorrectnessOfIteration = __webpack_require__(142);
var NATIVE_ARRAY_BUFFER_VIEWS = (__webpack_require__(180).NATIVE_ARRAY_BUFFER_VIEWS);
var ArrayBuffer = global.ArrayBuffer;
var Int8Array = global.Int8Array;
module.exports = !NATIVE_ARRAY_BUFFER_VIEWS || !fails(function () {
Int8Array(1);
}) || !fails(function () {
new Int8Array(-1);
}) || !checkCorrectnessOfIteration(function (iterable) {
new Int8Array();
new Int8Array(null);
new Int8Array(1.5);
new Int8Array(iterable);
}, true) || fails(function () {
// Safari (11+) bug - a reason why even Safari 13 should load a typed array polyfill
return new Int8Array(new ArrayBuffer(2), 1, undefined).length !== 1;
});
/***/ }),
/* 382 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var toPositiveInteger = __webpack_require__(383);
var RangeError = global.RangeError;
module.exports = function (it, BYTES) {
var offset = toPositiveInteger(it);
if (offset % BYTES) throw RangeError('Wrong offset');
return offset;
};
/***/ }),
/* 383 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var toIntegerOrInfinity = __webpack_require__(58);
var RangeError = global.RangeError;
module.exports = function (it) {
var result = toIntegerOrInfinity(it);
if (result < 0) throw RangeError("The argument can't be less than 0");
return result;
};
/***/ }),
/* 384 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var bind = __webpack_require__(82);
var call = __webpack_require__(7);
var aConstructor = __webpack_require__(183);
var toObject = __webpack_require__(37);
var lengthOfArrayLike = __webpack_require__(59);
var getIterator = __webpack_require__(117);
var getIteratorMethod = __webpack_require__(118);
var isArrayIteratorMethod = __webpack_require__(115);
var aTypedArrayConstructor = (__webpack_require__(180).aTypedArrayConstructor);
module.exports = function from(source /* , mapfn, thisArg */) {
var C = aConstructor(this);
var O = toObject(source);
var argumentsLength = arguments.length;
var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
var mapping = mapfn !== undefined;
var iteratorMethod = getIteratorMethod(O);
var i, length, result, step, iterator, next;
if (iteratorMethod && !isArrayIteratorMethod(iteratorMethod)) {
iterator = getIterator(O, iteratorMethod);
next = iterator.next;
O = [];
while (!(step = call(next, iterator)).done) {
O.push(step.value);
}
}
if (mapping && argumentsLength > 2) {
mapfn = bind(mapfn, arguments[2]);
}
length = lengthOfArrayLike(O);
result = new (aTypedArrayConstructor(C))(length);
for (i = 0; length > i; i++) {
result[i] = mapping ? mapfn(O[i], i) : O[i];
}
return result;
};
/***/ }),
/* 385 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Float64Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Float64', function (init) {
return function Float64Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 386 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Int8Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Int8', function (init) {
return function Int8Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 387 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Int16Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Int16', function (init) {
return function Int16Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 388 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Int32Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Int32', function (init) {
return function Int32Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 389 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Uint8Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint8', function (init) {
return function Uint8Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 390 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Uint8ClampedArray` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint8', function (init) {
return function Uint8ClampedArray(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
}, true);
/***/ }),
/* 391 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Uint16Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint16', function (init) {
return function Uint16Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 392 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var createTypedArrayConstructor = __webpack_require__(380);
// `Uint32Array` constructor
// https://tc39.es/ecma262/#sec-typedarray-objects
createTypedArrayConstructor('Uint32', function (init) {
return function Uint32Array(data, byteOffset, length) {
return init(this, data, byteOffset, length);
};
});
/***/ }),
/* 393 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var lengthOfArrayLike = __webpack_require__(59);
var toIntegerOrInfinity = __webpack_require__(58);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.at` method
// https://github.com/tc39/proposal-relative-indexing-method
exportTypedArrayMethod('at', function at(index) {
var O = aTypedArray(this);
var len = lengthOfArrayLike(O);
var relativeIndex = toIntegerOrInfinity(index);
var k = relativeIndex >= 0 ? relativeIndex : len + relativeIndex;
return (k < 0 || k >= len) ? undefined : O[k];
});
/***/ }),
/* 394 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var uncurryThis = __webpack_require__(13);
var ArrayBufferViewCore = __webpack_require__(180);
var $ArrayCopyWithin = __webpack_require__(126);
var u$ArrayCopyWithin = uncurryThis($ArrayCopyWithin);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.copyWithin` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.copywithin
exportTypedArrayMethod('copyWithin', function copyWithin(target, start /* , end */) {
return u$ArrayCopyWithin(aTypedArray(this), target, start, arguments.length > 2 ? arguments[2] : undefined);
});
/***/ }),
/* 395 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $every = (__webpack_require__(81).every);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.every` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.every
exportTypedArrayMethod('every', function every(callbackfn /* , thisArg */) {
return $every(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 396 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var call = __webpack_require__(7);
var $fill = __webpack_require__(130);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.fill` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.fill
exportTypedArrayMethod('fill', function fill(value /* , start, end */) {
var length = arguments.length;
return call(
$fill,
aTypedArray(this),
value,
length > 1 ? arguments[1] : undefined,
length > 2 ? arguments[2] : undefined
);
});
/***/ }),
/* 397 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $filter = (__webpack_require__(81).filter);
var fromSpeciesAndList = __webpack_require__(398);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.filter` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.filter
exportTypedArrayMethod('filter', function filter(callbackfn /* , thisArg */) {
var list = $filter(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
return fromSpeciesAndList(this, list);
});
/***/ }),
/* 398 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var arrayFromConstructorAndList = __webpack_require__(399);
var typedArraySpeciesConstructor = __webpack_require__(400);
module.exports = function (instance, list) {
return arrayFromConstructorAndList(typedArraySpeciesConstructor(instance), list);
};
/***/ }),
/* 399 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var lengthOfArrayLike = __webpack_require__(59);
module.exports = function (Constructor, list) {
var index = 0;
var length = lengthOfArrayLike(list);
var result = new Constructor(length);
while (length > index) result[index] = list[index++];
return result;
};
/***/ }),
/* 400 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var ArrayBufferViewCore = __webpack_require__(180);
var speciesConstructor = __webpack_require__(182);
var TYPED_ARRAY_CONSTRUCTOR = ArrayBufferViewCore.TYPED_ARRAY_CONSTRUCTOR;
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
// a part of `TypedArraySpeciesCreate` abstract operation
// https://tc39.es/ecma262/#typedarray-species-create
module.exports = function (originalArray) {
return aTypedArrayConstructor(speciesConstructor(originalArray, originalArray[TYPED_ARRAY_CONSTRUCTOR]));
};
/***/ }),
/* 401 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $find = (__webpack_require__(81).find);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.find` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.find
exportTypedArrayMethod('find', function find(predicate /* , thisArg */) {
return $find(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 402 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $findIndex = (__webpack_require__(81).findIndex);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.findIndex` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.findindex
exportTypedArrayMethod('findIndex', function findIndex(predicate /* , thisArg */) {
return $findIndex(aTypedArray(this), predicate, arguments.length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 403 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $forEach = (__webpack_require__(81).forEach);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.forEach` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.foreach
exportTypedArrayMethod('forEach', function forEach(callbackfn /* , thisArg */) {
$forEach(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 404 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(381);
var exportTypedArrayStaticMethod = (__webpack_require__(180).exportTypedArrayStaticMethod);
var typedArrayFrom = __webpack_require__(384);
// `%TypedArray%.from` method
// https://tc39.es/ecma262/#sec-%typedarray%.from
exportTypedArrayStaticMethod('from', typedArrayFrom, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS);
/***/ }),
/* 405 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $includes = (__webpack_require__(56).includes);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.includes` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.includes
exportTypedArrayMethod('includes', function includes(searchElement /* , fromIndex */) {
return $includes(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 406 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $indexOf = (__webpack_require__(56).indexOf);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.indexOf` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.indexof
exportTypedArrayMethod('indexOf', function indexOf(searchElement /* , fromIndex */) {
return $indexOf(aTypedArray(this), searchElement, arguments.length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 407 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var fails = __webpack_require__(6);
var uncurryThis = __webpack_require__(13);
var ArrayBufferViewCore = __webpack_require__(180);
var ArrayIterators = __webpack_require__(146);
var wellKnownSymbol = __webpack_require__(31);
var ITERATOR = wellKnownSymbol('iterator');
var Uint8Array = global.Uint8Array;
var arrayValues = uncurryThis(ArrayIterators.values);
var arrayKeys = uncurryThis(ArrayIterators.keys);
var arrayEntries = uncurryThis(ArrayIterators.entries);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var TypedArrayPrototype = Uint8Array && Uint8Array.prototype;
var GENERIC = !fails(function () {
TypedArrayPrototype[ITERATOR].call([1]);
});
var ITERATOR_IS_VALUES = !!TypedArrayPrototype
&& TypedArrayPrototype.values
&& TypedArrayPrototype[ITERATOR] === TypedArrayPrototype.values
&& TypedArrayPrototype.values.name === 'values';
var typedArrayValues = function values() {
return arrayValues(aTypedArray(this));
};
// `%TypedArray%.prototype.entries` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.entries
exportTypedArrayMethod('entries', function entries() {
return arrayEntries(aTypedArray(this));
}, GENERIC);
// `%TypedArray%.prototype.keys` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.keys
exportTypedArrayMethod('keys', function keys() {
return arrayKeys(aTypedArray(this));
}, GENERIC);
// `%TypedArray%.prototype.values` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.values
exportTypedArrayMethod('values', typedArrayValues, GENERIC || !ITERATOR_IS_VALUES, { name: 'values' });
// `%TypedArray%.prototype[@@iterator]` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype-@@iterator
exportTypedArrayMethod(ITERATOR, typedArrayValues, GENERIC || !ITERATOR_IS_VALUES, { name: 'values' });
/***/ }),
/* 408 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var uncurryThis = __webpack_require__(13);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var $join = uncurryThis([].join);
// `%TypedArray%.prototype.join` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.join
exportTypedArrayMethod('join', function join(separator) {
return $join(aTypedArray(this), separator);
});
/***/ }),
/* 409 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var apply = __webpack_require__(64);
var $lastIndexOf = __webpack_require__(152);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.lastIndexOf` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.lastindexof
exportTypedArrayMethod('lastIndexOf', function lastIndexOf(searchElement /* , fromIndex */) {
var length = arguments.length;
return apply($lastIndexOf, aTypedArray(this), length > 1 ? [searchElement, arguments[1]] : [searchElement]);
});
/***/ }),
/* 410 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $map = (__webpack_require__(81).map);
var typedArraySpeciesConstructor = __webpack_require__(400);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.map` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.map
exportTypedArrayMethod('map', function map(mapfn /* , thisArg */) {
return $map(aTypedArray(this), mapfn, arguments.length > 1 ? arguments[1] : undefined, function (O, length) {
return new (typedArraySpeciesConstructor(O))(length);
});
});
/***/ }),
/* 411 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS = __webpack_require__(381);
var aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;
var exportTypedArrayStaticMethod = ArrayBufferViewCore.exportTypedArrayStaticMethod;
// `%TypedArray%.of` method
// https://tc39.es/ecma262/#sec-%typedarray%.of
exportTypedArrayStaticMethod('of', function of(/* ...items */) {
var index = 0;
var length = arguments.length;
var result = new (aTypedArrayConstructor(this))(length);
while (length > index) result[index] = arguments[index++];
return result;
}, TYPED_ARRAYS_CONSTRUCTORS_REQUIRES_WRAPPERS);
/***/ }),
/* 412 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $reduce = (__webpack_require__(156).left);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.reduce` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduce
exportTypedArrayMethod('reduce', function reduce(callbackfn /* , initialValue */) {
var length = arguments.length;
return $reduce(aTypedArray(this), callbackfn, length, length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 413 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $reduceRight = (__webpack_require__(156).right);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.reduceRicht` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reduceright
exportTypedArrayMethod('reduceRight', function reduceRight(callbackfn /* , initialValue */) {
var length = arguments.length;
return $reduceRight(aTypedArray(this), callbackfn, length, length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 414 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var floor = Math.floor;
// `%TypedArray%.prototype.reverse` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.reverse
exportTypedArrayMethod('reverse', function reverse() {
var that = this;
var length = aTypedArray(that).length;
var middle = floor(length / 2);
var index = 0;
var value;
while (index < middle) {
value = that[index];
that[index++] = that[--length];
that[length] = value;
} return that;
});
/***/ }),
/* 415 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var call = __webpack_require__(7);
var ArrayBufferViewCore = __webpack_require__(180);
var lengthOfArrayLike = __webpack_require__(59);
var toOffset = __webpack_require__(382);
var toIndexedObject = __webpack_require__(37);
var fails = __webpack_require__(6);
var RangeError = global.RangeError;
var Int8Array = global.Int8Array;
var Int8ArrayPrototype = Int8Array && Int8Array.prototype;
var $set = Int8ArrayPrototype && Int8ArrayPrototype.set;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS = !fails(function () {
// eslint-disable-next-line es/no-typed-arrays -- required for testing
var array = new Uint8ClampedArray(2);
call($set, array, { length: 1, 0: 3 }, 1);
return array[1] !== 3;
});
// https://bugs.chromium.org/p/v8/issues/detail?id=11294 and other
var TO_OBJECT_BUG = WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS && ArrayBufferViewCore.NATIVE_ARRAY_BUFFER_VIEWS && fails(function () {
var array = new Int8Array(2);
array.set(1);
array.set('2', 1);
return array[0] !== 0 || array[1] !== 2;
});
// `%TypedArray%.prototype.set` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.set
exportTypedArrayMethod('set', function set(arrayLike /* , offset */) {
aTypedArray(this);
var offset = toOffset(arguments.length > 1 ? arguments[1] : undefined, 1);
var src = toIndexedObject(arrayLike);
if (WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS) return call($set, this, src, offset);
var length = this.length;
var len = lengthOfArrayLike(src);
var index = 0;
if (len + offset > length) throw RangeError('Wrong length');
while (index < len) this[offset + index] = src[index++];
}, !WORKS_WITH_OBJECTS_AND_GEERIC_ON_TYPED_ARRAYS || TO_OBJECT_BUG);
/***/ }),
/* 416 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var typedArraySpeciesConstructor = __webpack_require__(400);
var fails = __webpack_require__(6);
var arraySlice = __webpack_require__(76);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var FORCED = fails(function () {
// eslint-disable-next-line es/no-typed-arrays -- required for testing
new Int8Array(1).slice();
});
// `%TypedArray%.prototype.slice` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.slice
exportTypedArrayMethod('slice', function slice(start, end) {
var list = arraySlice(aTypedArray(this), start, end);
var C = typedArraySpeciesConstructor(this);
var index = 0;
var length = list.length;
var result = new C(length);
while (length > index) result[index] = list[index++];
return result;
}, FORCED);
/***/ }),
/* 417 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var $some = (__webpack_require__(81).some);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.some` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.some
exportTypedArrayMethod('some', function some(callbackfn /* , thisArg */) {
return $some(aTypedArray(this), callbackfn, arguments.length > 1 ? arguments[1] : undefined);
});
/***/ }),
/* 418 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var aCallable = __webpack_require__(28);
var internalSort = __webpack_require__(163);
var ArrayBufferViewCore = __webpack_require__(180);
var FF = __webpack_require__(164);
var IE_OR_EDGE = __webpack_require__(165);
var V8 = __webpack_require__(25);
var WEBKIT = __webpack_require__(166);
var Array = global.Array;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var Uint16Array = global.Uint16Array;
var un$Sort = Uint16Array && uncurryThis(Uint16Array.prototype.sort);
// WebKit
var ACCEPT_INCORRECT_ARGUMENTS = !!un$Sort && !(fails(function () {
un$Sort(new Uint16Array(2), null);
}) && fails(function () {
un$Sort(new Uint16Array(2), {});
}));
var STABLE_SORT = !!un$Sort && !fails(function () {
// feature detection can be too slow, so check engines versions
if (V8) return V8 < 74;
if (FF) return FF < 67;
if (IE_OR_EDGE) return true;
if (WEBKIT) return WEBKIT < 602;
var array = new Uint16Array(516);
var expected = Array(516);
var index, mod;
for (index = 0; index < 516; index++) {
mod = index % 4;
array[index] = 515 - index;
expected[index] = index - 2 * mod + 3;
}
un$Sort(array, function (a, b) {
return (a / 4 | 0) - (b / 4 | 0);
});
for (index = 0; index < 516; index++) {
if (array[index] !== expected[index]) return true;
}
});
var getSortCompare = function (comparefn) {
return function (x, y) {
if (comparefn !== undefined) return +comparefn(x, y) || 0;
// eslint-disable-next-line no-self-compare -- NaN check
if (y !== y) return -1;
// eslint-disable-next-line no-self-compare -- NaN check
if (x !== x) return 1;
if (x === 0 && y === 0) return 1 / x > 0 && 1 / y < 0 ? 1 : -1;
return x > y;
};
};
// `%TypedArray%.prototype.sort` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.sort
exportTypedArrayMethod('sort', function sort(comparefn) {
if (comparefn !== undefined) aCallable(comparefn);
if (STABLE_SORT) return un$Sort(this, comparefn);
return internalSort(aTypedArray(this), getSortCompare(comparefn));
}, !STABLE_SORT || ACCEPT_INCORRECT_ARGUMENTS);
/***/ }),
/* 419 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var ArrayBufferViewCore = __webpack_require__(180);
var toLength = __webpack_require__(60);
var toAbsoluteIndex = __webpack_require__(57);
var typedArraySpeciesConstructor = __webpack_require__(400);
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
// `%TypedArray%.prototype.subarray` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.subarray
exportTypedArrayMethod('subarray', function subarray(begin, end) {
var O = aTypedArray(this);
var length = O.length;
var beginIndex = toAbsoluteIndex(begin, length);
var C = typedArraySpeciesConstructor(O);
return new C(
O.buffer,
O.byteOffset + beginIndex * O.BYTES_PER_ELEMENT,
toLength((end === undefined ? length : toAbsoluteIndex(end, length)) - beginIndex)
);
});
/***/ }),
/* 420 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var apply = __webpack_require__(64);
var ArrayBufferViewCore = __webpack_require__(180);
var fails = __webpack_require__(6);
var arraySlice = __webpack_require__(76);
var Int8Array = global.Int8Array;
var aTypedArray = ArrayBufferViewCore.aTypedArray;
var exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;
var $toLocaleString = [].toLocaleString;
// iOS Safari 6.x fails here
var TO_LOCALE_STRING_BUG = !!Int8Array && fails(function () {
$toLocaleString.call(new Int8Array(1));
});
var FORCED = fails(function () {
return [1, 2].toLocaleString() != new Int8Array([1, 2]).toLocaleString();
}) || !fails(function () {
Int8Array.prototype.toLocaleString.call([1, 2]);
});
// `%TypedArray%.prototype.toLocaleString` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tolocalestring
exportTypedArrayMethod('toLocaleString', function toLocaleString() {
return apply(
$toLocaleString,
TO_LOCALE_STRING_BUG ? arraySlice(aTypedArray(this)) : aTypedArray(this),
arraySlice(arguments)
);
}, FORCED);
/***/ }),
/* 421 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var exportTypedArrayMethod = (__webpack_require__(180).exportTypedArrayMethod);
var fails = __webpack_require__(6);
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var Uint8Array = global.Uint8Array;
var Uint8ArrayPrototype = Uint8Array && Uint8Array.prototype || {};
var arrayToString = [].toString;
var join = uncurryThis([].join);
if (fails(function () { arrayToString.call({}); })) {
arrayToString = function toString() {
return join(this);
};
}
var IS_NOT_ARRAY_METHOD = Uint8ArrayPrototype.toString != arrayToString;
// `%TypedArray%.prototype.toString` method
// https://tc39.es/ecma262/#sec-%typedarray%.prototype.tostring
exportTypedArrayMethod('toString', arrayToString, IS_NOT_ARRAY_METHOD);
/***/ }),
/* 422 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var uncurryThis = __webpack_require__(13);
var toString = __webpack_require__(66);
var fromCharCode = String.fromCharCode;
var charAt = uncurryThis(''.charAt);
var exec = uncurryThis(/./.exec);
var stringSlice = uncurryThis(''.slice);
var hex2 = /^[\da-f]{2}$/i;
var hex4 = /^[\da-f]{4}$/i;
// `unescape` method
// https://tc39.es/ecma262/#sec-unescape-string
$({ global: true }, {
unescape: function unescape(string) {
var str = toString(string);
var result = '';
var length = str.length;
var index = 0;
var chr, part;
while (index < length) {
chr = charAt(str, index++);
if (chr === '%') {
if (charAt(str, index) === 'u') {
part = stringSlice(str, index + 1, index + 5);
if (exec(hex4, part)) {
result += fromCharCode(parseInt(part, 16));
index += 5;
continue;
}
} else {
part = stringSlice(str, index, index + 2);
if (exec(hex2, part)) {
result += fromCharCode(parseInt(part, 16));
index += 2;
continue;
}
}
}
result += chr;
} return result;
}
});
/***/ }),
/* 423 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var redefineAll = __webpack_require__(175);
var InternalMetadataModule = __webpack_require__(207);
var collection = __webpack_require__(206);
var collectionWeak = __webpack_require__(424);
var isObject = __webpack_require__(18);
var isExtensible = __webpack_require__(208);
var enforceInternalState = (__webpack_require__(47).enforce);
var NATIVE_WEAK_MAP = __webpack_require__(48);
var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;
var InternalWeakMap;
var wrapper = function (init) {
return function WeakMap() {
return init(this, arguments.length ? arguments[0] : undefined);
};
};
// `WeakMap` constructor
// https://tc39.es/ecma262/#sec-weakmap-constructor
var $WeakMap = collection('WeakMap', wrapper, collectionWeak);
// IE11 WeakMap frozen keys fix
// We can't use feature detection because it crash some old IE builds
// https://github.com/zloirock/core-js/issues/485
if (NATIVE_WEAK_MAP && IS_IE11) {
InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true);
InternalMetadataModule.enable();
var WeakMapPrototype = $WeakMap.prototype;
var nativeDelete = uncurryThis(WeakMapPrototype['delete']);
var nativeHas = uncurryThis(WeakMapPrototype.has);
var nativeGet = uncurryThis(WeakMapPrototype.get);
var nativeSet = uncurryThis(WeakMapPrototype.set);
redefineAll(WeakMapPrototype, {
'delete': function (key) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceInternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
return nativeDelete(this, key) || state.frozen['delete'](key);
} return nativeDelete(this, key);
},
has: function has(key) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceInternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
return nativeHas(this, key) || state.frozen.has(key);
} return nativeHas(this, key);
},
get: function get(key) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceInternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
return nativeHas(this, key) ? nativeGet(this, key) : state.frozen.get(key);
} return nativeGet(this, key);
},
set: function set(key, value) {
if (isObject(key) && !isExtensible(key)) {
var state = enforceInternalState(this);
if (!state.frozen) state.frozen = new InternalWeakMap();
nativeHas(this, key) ? nativeSet(this, key, value) : state.frozen.set(key, value);
} else nativeSet(this, key, value);
return this;
}
});
}
/***/ }),
/* 424 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var uncurryThis = __webpack_require__(13);
var redefineAll = __webpack_require__(175);
var getWeakData = (__webpack_require__(207).getWeakData);
var anObject = __webpack_require__(44);
var isObject = __webpack_require__(18);
var anInstance = __webpack_require__(176);
var iterate = __webpack_require__(114);
var ArrayIterationModule = __webpack_require__(81);
var hasOwn = __webpack_require__(36);
var InternalStateModule = __webpack_require__(47);
var setInternalState = InternalStateModule.set;
var internalStateGetterFor = InternalStateModule.getterFor;
var find = ArrayIterationModule.find;
var findIndex = ArrayIterationModule.findIndex;
var splice = uncurryThis([].splice);
var id = 0;
// fallback for uncaught frozen keys
var uncaughtFrozenStore = function (store) {
return store.frozen || (store.frozen = new UncaughtFrozenStore());
};
var UncaughtFrozenStore = function () {
this.entries = [];
};
var findUncaughtFrozen = function (store, key) {
return find(store.entries, function (it) {
return it[0] === key;
});
};
UncaughtFrozenStore.prototype = {
get: function (key) {
var entry = findUncaughtFrozen(this, key);
if (entry) return entry[1];
},
has: function (key) {
return !!findUncaughtFrozen(this, key);
},
set: function (key, value) {
var entry = findUncaughtFrozen(this, key);
if (entry) entry[1] = value;
else this.entries.push([key, value]);
},
'delete': function (key) {
var index = findIndex(this.entries, function (it) {
return it[0] === key;
});
if (~index) splice(this.entries, index, 1);
return !!~index;
}
};
module.exports = {
getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {
var Constructor = wrapper(function (that, iterable) {
anInstance(that, Prototype);
setInternalState(that, {
type: CONSTRUCTOR_NAME,
id: id++,
frozen: undefined
});
if (iterable != undefined) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });
});
var Prototype = Constructor.prototype;
var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);
var define = function (that, key, value) {
var state = getInternalState(that);
var data = getWeakData(anObject(key), true);
if (data === true) uncaughtFrozenStore(state).set(key, value);
else data[state.id] = value;
return that;
};
redefineAll(Prototype, {
// `{ WeakMap, WeakSet }.prototype.delete(key)` methods
// https://tc39.es/ecma262/#sec-weakmap.prototype.delete
// https://tc39.es/ecma262/#sec-weakset.prototype.delete
'delete': function (key) {
var state = getInternalState(this);
if (!isObject(key)) return false;
var data = getWeakData(key);
if (data === true) return uncaughtFrozenStore(state)['delete'](key);
return data && hasOwn(data, state.id) && delete data[state.id];
},
// `{ WeakMap, WeakSet }.prototype.has(key)` methods
// https://tc39.es/ecma262/#sec-weakmap.prototype.has
// https://tc39.es/ecma262/#sec-weakset.prototype.has
has: function has(key) {
var state = getInternalState(this);
if (!isObject(key)) return false;
var data = getWeakData(key);
if (data === true) return uncaughtFrozenStore(state).has(key);
return data && hasOwn(data, state.id);
}
});
redefineAll(Prototype, IS_MAP ? {
// `WeakMap.prototype.get(key)` method
// https://tc39.es/ecma262/#sec-weakmap.prototype.get
get: function get(key) {
var state = getInternalState(this);
if (isObject(key)) {
var data = getWeakData(key);
if (data === true) return uncaughtFrozenStore(state).get(key);
return data ? data[state.id] : undefined;
}
},
// `WeakMap.prototype.set(key, value)` method
// https://tc39.es/ecma262/#sec-weakmap.prototype.set
set: function set(key, value) {
return define(this, key, value);
}
} : {
// `WeakSet.prototype.add(value)` method
// https://tc39.es/ecma262/#sec-weakset.prototype.add
add: function add(value) {
return define(this, value, true);
}
});
return Constructor;
}
};
/***/ }),
/* 425 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var collection = __webpack_require__(206);
var collectionWeak = __webpack_require__(424);
// `WeakSet` constructor
// https://tc39.es/ecma262/#sec-weakset-constructor
collection('WeakSet', function (init) {
return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };
}, collectionWeak);
/***/ }),
/* 426 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var getBuiltIn = __webpack_require__(21);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var toString = __webpack_require__(66);
var hasOwn = __webpack_require__(36);
var validateArgumentsLength = __webpack_require__(291);
var ctoi = (__webpack_require__(427).ctoi);
var disallowed = /[^\d+/a-z]/i;
var whitespaces = /[\t\n\f\r ]+/g;
var finalEq = /[=]+$/;
var $atob = getBuiltIn('atob');
var fromCharCode = String.fromCharCode;
var charAt = uncurryThis(''.charAt);
var replace = uncurryThis(''.replace);
var exec = uncurryThis(disallowed.exec);
var NO_SPACES_IGNORE = fails(function () {
return atob(' ') !== '';
});
var NO_ARG_RECEIVING_CHECK = !NO_SPACES_IGNORE && !fails(function () {
$atob();
});
// `atob` method
// https://html.spec.whatwg.org/multipage/webappapis.html#dom-atob
$({ global: true, enumerable: true, forced: NO_SPACES_IGNORE || NO_ARG_RECEIVING_CHECK }, {
atob: function atob(data) {
validateArgumentsLength(arguments.length, 1);
if (NO_ARG_RECEIVING_CHECK) return $atob(data);
var string = replace(toString(data), whitespaces, '');
var output = '';
var position = 0;
var bc = 0;
var chr, bs;
if (string.length % 4 == 0) {
string = replace(string, finalEq, '');
}
if (string.length % 4 == 1 || exec(disallowed, string)) {
throw new (getBuiltIn('DOMException'))('The string is not correctly encoded', 'InvalidCharacterError');
}
while (chr = charAt(string, position++)) {
if (hasOwn(ctoi, chr)) {
bs = bc % 4 ? bs * 64 + ctoi[chr] : ctoi[chr];
if (bc++ % 4) output += fromCharCode(255 & bs >> (-2 * bc & 6));
}
} return output;
}
});
/***/ }),
/* 427 */
/***/ (function(module) {
var itoc = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
var ctoi = {};
for (var index = 0; index < 66; index++) ctoi[itoc.charAt(index)] = index;
module.exports = {
itoc: itoc,
ctoi: ctoi
};
/***/ }),
/* 428 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var getBuiltIn = __webpack_require__(21);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var toString = __webpack_require__(66);
var validateArgumentsLength = __webpack_require__(291);
var itoc = (__webpack_require__(427).itoc);
var $btoa = getBuiltIn('btoa');
var charAt = uncurryThis(''.charAt);
var charCodeAt = uncurryThis(''.charCodeAt);
var NO_ARG_RECEIVING_CHECK = !!$btoa && !fails(function () {
$btoa();
});
// `btoa` method
// https://html.spec.whatwg.org/multipage/webappapis.html#dom-btoa
$({ global: true, enumerable: true, forced: NO_ARG_RECEIVING_CHECK }, {
btoa: function btoa(data) {
validateArgumentsLength(arguments.length, 1);
if (NO_ARG_RECEIVING_CHECK) return $btoa(data);
var string = toString(data);
var output = '';
var position = 0;
var map = itoc;
var block, charCode;
while (charAt(string, position) || (map = '=', position % 1)) {
charCode = charCodeAt(string, position += 3 / 4);
if (charCode > 0xFF) {
throw new (getBuiltIn('DOMException'))('The string contains characters outside of the Latin1 range', 'InvalidCharacterError');
}
block = block << 8 | charCode;
output += charAt(map, 63 & block >> 8 - position % 1 * 8);
} return output;
}
});
/***/ }),
/* 429 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var DOMIterables = __webpack_require__(430);
var DOMTokenListPrototype = __webpack_require__(431);
var forEach = __webpack_require__(138);
var createNonEnumerableProperty = __webpack_require__(41);
var handlePrototype = function (CollectionPrototype) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {
createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);
} catch (error) {
CollectionPrototype.forEach = forEach;
}
};
for (var COLLECTION_NAME in DOMIterables) {
if (DOMIterables[COLLECTION_NAME]) {
handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);
}
}
handlePrototype(DOMTokenListPrototype);
/***/ }),
/* 430 */
/***/ (function(module) {
// iterable DOM collections
// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods
module.exports = {
CSSRuleList: 0,
CSSStyleDeclaration: 0,
CSSValueList: 0,
ClientRectList: 0,
DOMRectList: 0,
DOMStringList: 0,
DOMTokenList: 1,
DataTransferItemList: 0,
FileList: 0,
HTMLAllCollection: 0,
HTMLCollection: 0,
HTMLFormElement: 0,
HTMLSelectElement: 0,
MediaList: 0,
MimeTypeArray: 0,
NamedNodeMap: 0,
NodeList: 1,
PaintRequestList: 0,
Plugin: 0,
PluginArray: 0,
SVGLengthList: 0,
SVGNumberList: 0,
SVGPathSegList: 0,
SVGPointList: 0,
SVGStringList: 0,
SVGTransformList: 0,
SourceBufferList: 0,
StyleSheetList: 0,
TextTrackCueList: 0,
TextTrackList: 0,
TouchList: 0
};
/***/ }),
/* 431 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`
var documentCreateElement = __webpack_require__(40);
var classList = documentCreateElement('span').classList;
var DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;
module.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;
/***/ }),
/* 432 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var global = __webpack_require__(3);
var DOMIterables = __webpack_require__(430);
var DOMTokenListPrototype = __webpack_require__(431);
var ArrayIteratorMethods = __webpack_require__(146);
var createNonEnumerableProperty = __webpack_require__(41);
var wellKnownSymbol = __webpack_require__(31);
var ITERATOR = wellKnownSymbol('iterator');
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
var ArrayValues = ArrayIteratorMethods.values;
var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {
if (CollectionPrototype) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype[ITERATOR] !== ArrayValues) try {
createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
} catch (error) {
CollectionPrototype[ITERATOR] = ArrayValues;
}
if (!CollectionPrototype[TO_STRING_TAG]) {
createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
}
if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {
// some Chrome versions have non-configurable methods on DOMTokenList
if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {
createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
} catch (error) {
CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
}
}
}
};
for (var COLLECTION_NAME in DOMIterables) {
handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);
}
handlePrototype(DOMTokenListPrototype, 'DOMTokenList');
/***/ }),
/* 433 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var tryNodeRequire = __webpack_require__(434);
var getBuiltIn = __webpack_require__(21);
var fails = __webpack_require__(6);
var create = __webpack_require__(69);
var createPropertyDescriptor = __webpack_require__(10);
var defineProperty = (__webpack_require__(42).f);
var defineProperties = (__webpack_require__(70).f);
var redefine = __webpack_require__(45);
var hasOwn = __webpack_require__(36);
var anInstance = __webpack_require__(176);
var anObject = __webpack_require__(44);
var errorToString = __webpack_require__(110);
var normalizeStringArgument = __webpack_require__(105);
var DOMExceptionConstants = __webpack_require__(435);
var clearErrorStack = __webpack_require__(107);
var InternalStateModule = __webpack_require__(47);
var DESCRIPTORS = __webpack_require__(5);
var IS_PURE = __webpack_require__(33);
var DOM_EXCEPTION = 'DOMException';
var DATA_CLONE_ERR = 'DATA_CLONE_ERR';
var Error = getBuiltIn('Error');
// NodeJS < 17.0 does not expose `DOMException` to global
var NativeDOMException = getBuiltIn(DOM_EXCEPTION) || (function () {
try {
// NodeJS < 15.0 does not expose `MessageChannel` to global
var MessageChannel = getBuiltIn('MessageChannel') || tryNodeRequire('worker_threads').MessageChannel;
// eslint-disable-next-line es/no-weak-map, unicorn/require-post-message-target-origin -- safe
new MessageChannel().port1.postMessage(new WeakMap());
} catch (error) {
if (error.name == DATA_CLONE_ERR && error.code == 25) return error.constructor;
}
})();
var NativeDOMExceptionPrototype = NativeDOMException && NativeDOMException.prototype;
var ErrorPrototype = Error.prototype;
var setInternalState = InternalStateModule.set;
var getInternalState = InternalStateModule.getterFor(DOM_EXCEPTION);
var HAS_STACK = 'stack' in Error(DOM_EXCEPTION);
var codeFor = function (name) {
return hasOwn(DOMExceptionConstants, name) && DOMExceptionConstants[name].m ? DOMExceptionConstants[name].c : 0;
};
var $DOMException = function DOMException() {
anInstance(this, DOMExceptionPrototype);
var argumentsLength = arguments.length;
var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);
var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');
var code = codeFor(name);
setInternalState(this, {
type: DOM_EXCEPTION,
name: name,
message: message,
code: code
});
if (!DESCRIPTORS) {
this.name = name;
this.message = message;
this.code = code;
}
if (HAS_STACK) {
var error = Error(message);
error.name = DOM_EXCEPTION;
defineProperty(this, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));
}
};
var DOMExceptionPrototype = $DOMException.prototype = create(ErrorPrototype);
var createGetterDescriptor = function (get) {
return { enumerable: true, configurable: true, get: get };
};
var getterFor = function (key) {
return createGetterDescriptor(function () {
return getInternalState(this)[key];
});
};
if (DESCRIPTORS) defineProperties(DOMExceptionPrototype, {
name: getterFor('name'),
message: getterFor('message'),
code: getterFor('code')
});
defineProperty(DOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, $DOMException));
// FF36- DOMException is a function, but can't be constructed
var INCORRECT_CONSTRUCTOR = fails(function () {
return !(new NativeDOMException() instanceof Error);
});
// Safari 10.1 / Chrome 32- / IE8- DOMException.prototype.toString bugs
var INCORRECT_TO_STRING = INCORRECT_CONSTRUCTOR || fails(function () {
return ErrorPrototype.toString !== errorToString || String(new NativeDOMException(1, 2)) !== '2: 1';
});
// Deno 1.6.3- DOMException.prototype.code just missed
var INCORRECT_CODE = INCORRECT_CONSTRUCTOR || fails(function () {
return new NativeDOMException(1, 'DataCloneError').code !== 25;
});
// Deno 1.6.3- DOMException constants just missed
var MISSED_CONSTANTS = INCORRECT_CONSTRUCTOR
|| NativeDOMException[DATA_CLONE_ERR] !== 25
|| NativeDOMExceptionPrototype[DATA_CLONE_ERR] !== 25;
var FORCED_CONSTRUCTOR = IS_PURE ? INCORRECT_TO_STRING || INCORRECT_CODE || MISSED_CONSTANTS : INCORRECT_CONSTRUCTOR;
// `DOMException` constructor
// https://webidl.spec.whatwg.org/#idl-DOMException
$({ global: true, forced: FORCED_CONSTRUCTOR }, {
DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException
});
var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);
var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;
if (INCORRECT_TO_STRING && (IS_PURE || NativeDOMException === PolyfilledDOMException)) {
redefine(PolyfilledDOMExceptionPrototype, 'toString', errorToString);
}
if (INCORRECT_CODE && DESCRIPTORS && NativeDOMException === PolyfilledDOMException) {
defineProperty(PolyfilledDOMExceptionPrototype, 'code', createGetterDescriptor(function () {
return codeFor(anObject(this).name);
}));
}
for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {
var constant = DOMExceptionConstants[key];
var constantName = constant.s;
var descriptor = createPropertyDescriptor(6, constant.c);
if (!hasOwn(PolyfilledDOMException, constantName)) {
defineProperty(PolyfilledDOMException, constantName, descriptor);
}
if (!hasOwn(PolyfilledDOMExceptionPrototype, constantName)) {
defineProperty(PolyfilledDOMExceptionPrototype, constantName, descriptor);
}
}
/***/ }),
/* 434 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var IS_NODE = __webpack_require__(157);
module.exports = function (name) {
try {
// eslint-disable-next-line no-new-func -- safe
if (IS_NODE) return Function('return require("' + name + '")')();
} catch (error) { /* empty */ }
};
/***/ }),
/* 435 */
/***/ (function(module) {
module.exports = {
IndexSizeError: { s: 'INDEX_SIZE_ERR', c: 1, m: 1 },
DOMStringSizeError: { s: 'DOMSTRING_SIZE_ERR', c: 2, m: 0 },
HierarchyRequestError: { s: 'HIERARCHY_REQUEST_ERR', c: 3, m: 1 },
WrongDocumentError: { s: 'WRONG_DOCUMENT_ERR', c: 4, m: 1 },
InvalidCharacterError: { s: 'INVALID_CHARACTER_ERR', c: 5, m: 1 },
NoDataAllowedError: { s: 'NO_DATA_ALLOWED_ERR', c: 6, m: 0 },
NoModificationAllowedError: { s: 'NO_MODIFICATION_ALLOWED_ERR', c: 7, m: 1 },
NotFoundError: { s: 'NOT_FOUND_ERR', c: 8, m: 1 },
NotSupportedError: { s: 'NOT_SUPPORTED_ERR', c: 9, m: 1 },
InUseAttributeError: { s: 'INUSE_ATTRIBUTE_ERR', c: 10, m: 1 },
InvalidStateError: { s: 'INVALID_STATE_ERR', c: 11, m: 1 },
SyntaxError: { s: 'SYNTAX_ERR', c: 12, m: 1 },
InvalidModificationError: { s: 'INVALID_MODIFICATION_ERR', c: 13, m: 1 },
NamespaceError: { s: 'NAMESPACE_ERR', c: 14, m: 1 },
InvalidAccessError: { s: 'INVALID_ACCESS_ERR', c: 15, m: 1 },
ValidationError: { s: 'VALIDATION_ERR', c: 16, m: 0 },
TypeMismatchError: { s: 'TYPE_MISMATCH_ERR', c: 17, m: 1 },
SecurityError: { s: 'SECURITY_ERR', c: 18, m: 1 },
NetworkError: { s: 'NETWORK_ERR', c: 19, m: 1 },
AbortError: { s: 'ABORT_ERR', c: 20, m: 1 },
URLMismatchError: { s: 'URL_MISMATCH_ERR', c: 21, m: 1 },
QuotaExceededError: { s: 'QUOTA_EXCEEDED_ERR', c: 22, m: 1 },
TimeoutError: { s: 'TIMEOUT_ERR', c: 23, m: 1 },
InvalidNodeTypeError: { s: 'INVALID_NODE_TYPE_ERR', c: 24, m: 1 },
DataCloneError: { s: 'DATA_CLONE_ERR', c: 25, m: 1 }
};
/***/ }),
/* 436 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var getBuiltIn = __webpack_require__(21);
var createPropertyDescriptor = __webpack_require__(10);
var defineProperty = (__webpack_require__(42).f);
var hasOwn = __webpack_require__(36);
var anInstance = __webpack_require__(176);
var inheritIfRequired = __webpack_require__(104);
var normalizeStringArgument = __webpack_require__(105);
var DOMExceptionConstants = __webpack_require__(435);
var clearErrorStack = __webpack_require__(107);
var IS_PURE = __webpack_require__(33);
var DOM_EXCEPTION = 'DOMException';
var Error = getBuiltIn('Error');
var NativeDOMException = getBuiltIn(DOM_EXCEPTION);
var $DOMException = function DOMException() {
anInstance(this, DOMExceptionPrototype);
var argumentsLength = arguments.length;
var message = normalizeStringArgument(argumentsLength < 1 ? undefined : arguments[0]);
var name = normalizeStringArgument(argumentsLength < 2 ? undefined : arguments[1], 'Error');
var that = new NativeDOMException(message, name);
var error = Error(message);
error.name = DOM_EXCEPTION;
defineProperty(that, 'stack', createPropertyDescriptor(1, clearErrorStack(error.stack, 1)));
inheritIfRequired(that, this, $DOMException);
return that;
};
var DOMExceptionPrototype = $DOMException.prototype = NativeDOMException.prototype;
var ERROR_HAS_STACK = 'stack' in Error(DOM_EXCEPTION);
var DOM_EXCEPTION_HAS_STACK = 'stack' in new NativeDOMException(1, 2);
var FORCED_CONSTRUCTOR = ERROR_HAS_STACK && !DOM_EXCEPTION_HAS_STACK;
// `DOMException` constructor patch for `.stack` where it's required
// https://webidl.spec.whatwg.org/#es-DOMException-specialness
$({ global: true, forced: IS_PURE || FORCED_CONSTRUCTOR }, { // TODO: fix export logic
DOMException: FORCED_CONSTRUCTOR ? $DOMException : NativeDOMException
});
var PolyfilledDOMException = getBuiltIn(DOM_EXCEPTION);
var PolyfilledDOMExceptionPrototype = PolyfilledDOMException.prototype;
if (PolyfilledDOMExceptionPrototype.constructor !== PolyfilledDOMException) {
if (!IS_PURE) {
defineProperty(PolyfilledDOMExceptionPrototype, 'constructor', createPropertyDescriptor(1, PolyfilledDOMException));
}
for (var key in DOMExceptionConstants) if (hasOwn(DOMExceptionConstants, key)) {
var constant = DOMExceptionConstants[key];
var constantName = constant.s;
if (!hasOwn(PolyfilledDOMException, constantName)) {
defineProperty(PolyfilledDOMException, constantName, createPropertyDescriptor(6, constant.c));
}
}
}
/***/ }),
/* 437 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var getBuiltIn = __webpack_require__(21);
var setToStringTag = __webpack_require__(80);
var DOM_EXCEPTION = 'DOMException';
setToStringTag(getBuiltIn(DOM_EXCEPTION), DOM_EXCEPTION);
/***/ }),
/* 438 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var task = __webpack_require__(290);
var FORCED = !global.setImmediate || !global.clearImmediate;
// http://w3c.github.io/setImmediate/
$({ global: true, bind: true, enumerable: true, forced: FORCED }, {
// `setImmediate` method
// http://w3c.github.io/setImmediate/#si-setImmediate
setImmediate: task.set,
// `clearImmediate` method
// http://w3c.github.io/setImmediate/#si-clearImmediate
clearImmediate: task.clear
});
/***/ }),
/* 439 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var microtask = __webpack_require__(293);
var aCallable = __webpack_require__(28);
var validateArgumentsLength = __webpack_require__(291);
var IS_NODE = __webpack_require__(157);
var process = global.process;
// `queueMicrotask` method
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-queuemicrotask
$({ global: true, enumerable: true, noTargetGet: true }, {
queueMicrotask: function queueMicrotask(fn) {
validateArgumentsLength(arguments.length, 1);
aCallable(fn);
var domain = IS_NODE && process.domain;
microtask(domain ? domain.bind(fn) : fn);
}
});
/***/ }),
/* 440 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var IS_PURE = __webpack_require__(33);
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var getBuiltin = __webpack_require__(21);
var uncurryThis = __webpack_require__(13);
var fails = __webpack_require__(6);
var uid = __webpack_require__(38);
var isCallable = __webpack_require__(19);
var isConstructor = __webpack_require__(85);
var isObject = __webpack_require__(18);
var isSymbol = __webpack_require__(20);
var iterate = __webpack_require__(114);
var anObject = __webpack_require__(44);
var classof = __webpack_require__(67);
var hasOwn = __webpack_require__(36);
var createProperty = __webpack_require__(75);
var createNonEnumerableProperty = __webpack_require__(41);
var lengthOfArrayLike = __webpack_require__(59);
var validateArgumentsLength = __webpack_require__(291);
var regExpFlags = __webpack_require__(322);
var ERROR_STACK_INSTALLABLE = __webpack_require__(108);
var Object = global.Object;
var Date = global.Date;
var Error = global.Error;
var EvalError = global.EvalError;
var RangeError = global.RangeError;
var ReferenceError = global.ReferenceError;
var SyntaxError = global.SyntaxError;
var TypeError = global.TypeError;
var URIError = global.URIError;
var PerformanceMark = global.PerformanceMark;
var WebAssembly = global.WebAssembly;
var CompileError = WebAssembly && WebAssembly.CompileError || Error;
var LinkError = WebAssembly && WebAssembly.LinkError || Error;
var RuntimeError = WebAssembly && WebAssembly.RuntimeError || Error;
var DOMException = getBuiltin('DOMException');
var Set = getBuiltin('Set');
var Map = getBuiltin('Map');
var MapPrototype = Map.prototype;
var mapHas = uncurryThis(MapPrototype.has);
var mapGet = uncurryThis(MapPrototype.get);
var mapSet = uncurryThis(MapPrototype.set);
var setAdd = uncurryThis(Set.prototype.add);
var objectKeys = getBuiltin('Object', 'keys');
var push = uncurryThis([].push);
var booleanValueOf = uncurryThis(true.valueOf);
var numberValueOf = uncurryThis(1.0.valueOf);
var stringValueOf = uncurryThis(''.valueOf);
var getFlags = uncurryThis(regExpFlags);
var getTime = uncurryThis(Date.prototype.getTime);
var PERFORMANCE_MARK = uid('structuredClone');
var DATA_CLONE_ERROR = 'DataCloneError';
var TRANSFERRING = 'Transferring';
var checkBasicSemantic = function (structuredCloneImplementation) {
return !fails(function () {
var set1 = new global.Set([7]);
var set2 = structuredCloneImplementation(set1);
var number = structuredCloneImplementation(Object(7));
return set2 == set1 || !set2.has(7) || typeof number != 'object' || number != 7;
}) && structuredCloneImplementation;
};
// https://github.com/whatwg/html/pull/5749
var checkNewErrorsSemantic = function (structuredCloneImplementation) {
return !fails(function () {
var test = structuredCloneImplementation(new global.AggregateError([1], PERFORMANCE_MARK, { cause: 3 }));
return test.name != 'AggregateError' || test.errors[0] != 1 || test.message != PERFORMANCE_MARK || test.cause != 3;
}) && structuredCloneImplementation;
};
// FF94+, Safari TP134+, Chrome Canary 98+, NodeJS 17.0+, Deno 1.13+
// current FF and Safari implementations can't clone errors
// https://bugzilla.mozilla.org/show_bug.cgi?id=1556604
// no one of current implementations supports new (html/5749) error cloning semantic
var nativeStructuredClone = global.structuredClone;
var FORCED_REPLACEMENT = IS_PURE || !checkNewErrorsSemantic(nativeStructuredClone);
// Chrome 82+, Safari 14.1+, Deno 1.11+
// Chrome 78-81 implementation swaps `.name` and `.message` of cloned `DOMException`
// Safari 14.1 implementation doesn't clone some `RegExp` flags, so requires a workaround
// current Safari implementation can't clone errors
// Deno 1.2-1.10 implementations too naive
// NodeJS 16.0+ does not have `PerformanceMark` constructor, structured cloning implementation
// from `performance.mark` is too naive and can't clone, for example, `RegExp` or some boxed primitives
// https://github.com/nodejs/node/issues/40840
// no one of current implementations supports new (html/5749) error cloning semantic
var structuredCloneFromMark = !nativeStructuredClone && checkBasicSemantic(function (value) {
return new PerformanceMark(PERFORMANCE_MARK, { detail: value }).detail;
});
var nativeRestrictedStructuredClone = checkBasicSemantic(nativeStructuredClone) || structuredCloneFromMark;
var throwUncloneable = function (type) {
throw new DOMException('Uncloneable type: ' + type, DATA_CLONE_ERROR);
};
var throwUnpolyfillable = function (type, kind) {
throw new DOMException((kind || 'Cloning') + ' of ' + type + ' cannot be properly polyfilled in this engine', DATA_CLONE_ERROR);
};
var structuredCloneInternal = function (value, map) {
if (isSymbol(value)) throwUncloneable('Symbol');
if (!isObject(value)) return value;
// effectively preserves circular references
if (map) {
if (mapHas(map, value)) return mapGet(map, value);
} else map = new Map();
var type = classof(value);
var deep = false;
var C, name, cloned, dataTransfer, i, length, keys, key, source, target;
switch (type) {
case 'Array':
cloned = [];
deep = true;
break;
case 'Object':
cloned = {};
deep = true;
break;
case 'Map':
cloned = new Map();
deep = true;
break;
case 'Set':
cloned = new Set();
deep = true;
break;
case 'RegExp':
// in this block because of a Safari 14.1 bug
// old FF does not clone regexes passed to the constructor, so get the source and flags directly
cloned = new RegExp(value.source, 'flags' in value ? value.flags : getFlags(value));
break;
case 'Error':
name = value.name;
switch (name) {
case 'AggregateError':
cloned = getBuiltin('AggregateError')([]);
break;
case 'EvalError':
cloned = EvalError();
break;
case 'RangeError':
cloned = RangeError();
break;
case 'ReferenceError':
cloned = ReferenceError();
break;
case 'SyntaxError':
cloned = SyntaxError();
break;
case 'TypeError':
cloned = TypeError();
break;
case 'URIError':
cloned = URIError();
break;
case 'CompileError':
cloned = CompileError();
break;
case 'LinkError':
cloned = LinkError();
break;
case 'RuntimeError':
cloned = RuntimeError();
break;
default:
cloned = Error();
}
deep = true;
break;
case 'DOMException':
cloned = new DOMException(value.message, value.name);
deep = true;
break;
case 'DataView':
case 'Int8Array':
case 'Uint8Array':
case 'Uint8ClampedArray':
case 'Int16Array':
case 'Uint16Array':
case 'Int32Array':
case 'Uint32Array':
case 'Float32Array':
case 'Float64Array':
case 'BigInt64Array':
case 'BigUint64Array':
C = global[type];
// in some old engines like Safari 9, typeof C is 'object'
// on Uint8ClampedArray or some other constructors
if (!isObject(C)) throwUnpolyfillable(type);
cloned = new C(
// this is safe, since arraybuffer cannot have circular references
structuredCloneInternal(value.buffer, map),
value.byteOffset,
type === 'DataView' ? value.byteLength : value.length
);
break;
case 'DOMQuad':
try {
cloned = new DOMQuad(
structuredCloneInternal(value.p1, map),
structuredCloneInternal(value.p2, map),
structuredCloneInternal(value.p3, map),
structuredCloneInternal(value.p4, map)
);
} catch (error) {
if (nativeRestrictedStructuredClone) {
cloned = nativeRestrictedStructuredClone(value);
} else throwUnpolyfillable(type);
}
break;
case 'FileList':
C = global.DataTransfer;
if (isConstructor(C)) {
dataTransfer = new C();
for (i = 0, length = lengthOfArrayLike(value); i < length; i++) {
dataTransfer.items.add(structuredCloneInternal(value[i], map));
}
cloned = dataTransfer.files;
} else if (nativeRestrictedStructuredClone) {
cloned = nativeRestrictedStructuredClone(value);
} else throwUnpolyfillable(type);
break;
case 'ImageData':
// Safari 9 ImageData is a constructor, but typeof ImageData is 'object'
try {
cloned = new ImageData(
structuredCloneInternal(value.data, map),
value.width,
value.height,
{ colorSpace: value.colorSpace }
);
} catch (error) {
if (nativeRestrictedStructuredClone) {
cloned = nativeRestrictedStructuredClone(value);
} else throwUnpolyfillable(type);
} break;
default:
if (nativeRestrictedStructuredClone) {
cloned = nativeRestrictedStructuredClone(value);
} else switch (type) {
case 'BigInt':
// can be a 3rd party polyfill
cloned = Object(value.valueOf());
break;
case 'Boolean':
cloned = Object(booleanValueOf(value));
break;
case 'Number':
cloned = Object(numberValueOf(value));
break;
case 'String':
cloned = Object(stringValueOf(value));
break;
case 'Date':
cloned = new Date(getTime(value));
break;
case 'ArrayBuffer':
C = global.DataView;
// `ArrayBuffer#slice` is not available in IE10
// `ArrayBuffer#slice` and `DataView` are not available in old FF
if (!C && typeof value.slice != 'function') throwUnpolyfillable(type);
// detached buffers throws in `DataView` and `.slice`
try {
if (typeof value.slice == 'function') {
cloned = value.slice(0);
} else {
length = value.byteLength;
cloned = new ArrayBuffer(length);
source = new C(value);
target = new C(cloned);
for (i = 0; i < length; i++) {
target.setUint8(i, source.getUint8(i));
}
}
} catch (error) {
throw new DOMException('ArrayBuffer is detached', DATA_CLONE_ERROR);
} break;
case 'SharedArrayBuffer':
// SharedArrayBuffer should use shared memory, we can't polyfill it, so return the original
cloned = value;
break;
case 'Blob':
try {
cloned = value.slice(0, value.size, value.type);
} catch (error) {
throwUnpolyfillable(type);
} break;
case 'DOMPoint':
case 'DOMPointReadOnly':
C = global[type];
try {
cloned = C.fromPoint
? C.fromPoint(value)
: new C(value.x, value.y, value.z, value.w);
} catch (error) {
throwUnpolyfillable(type);
} break;
case 'DOMRect':
case 'DOMRectReadOnly':
C = global[type];
try {
cloned = C.fromRect
? C.fromRect(value)
: new C(value.x, value.y, value.width, value.height);
} catch (error) {
throwUnpolyfillable(type);
} break;
case 'DOMMatrix':
case 'DOMMatrixReadOnly':
C = global[type];
try {
cloned = C.fromMatrix
? C.fromMatrix(value)
: new C(value);
} catch (error) {
throwUnpolyfillable(type);
} break;
case 'AudioData':
case 'VideoFrame':
if (!isCallable(value.clone)) throwUnpolyfillable(type);
try {
cloned = value.clone();
} catch (error) {
throwUncloneable(type);
} break;
case 'File':
try {
cloned = new File([value], value.name, value);
} catch (error) {
throwUnpolyfillable(type);
} break;
case 'CryptoKey':
case 'GPUCompilationMessage':
case 'GPUCompilationInfo':
case 'ImageBitmap':
case 'RTCCertificate':
case 'WebAssembly.Module':
throwUnpolyfillable(type);
// break omitted
default:
throwUncloneable(type);
}
}
mapSet(map, value, cloned);
if (deep) switch (type) {
case 'Array':
case 'Object':
keys = objectKeys(value);
for (i = 0, length = lengthOfArrayLike(keys); i < length; i++) {
key = keys[i];
createProperty(cloned, key, structuredCloneInternal(value[key], map));
} break;
case 'Map':
value.forEach(function (v, k) {
mapSet(cloned, structuredCloneInternal(k, map), structuredCloneInternal(v, map));
});
break;
case 'Set':
value.forEach(function (v) {
setAdd(cloned, structuredCloneInternal(v, map));
});
break;
case 'Error':
createNonEnumerableProperty(cloned, 'message', structuredCloneInternal(value.message, map));
if (hasOwn(value, 'cause')) {
createNonEnumerableProperty(cloned, 'cause', structuredCloneInternal(value.cause, map));
}
if (name == 'AggregateError') {
cloned.errors = structuredCloneInternal(value.errors, map);
} // break omitted
case 'DOMException':
if (ERROR_STACK_INSTALLABLE) {
createNonEnumerableProperty(cloned, 'stack', structuredCloneInternal(value.stack, map));
}
}
return cloned;
};
var PROPER_TRANSFER = nativeStructuredClone && !fails(function () {
var buffer = new ArrayBuffer(8);
var clone = nativeStructuredClone(buffer, { transfer: [buffer] });
return buffer.byteLength != 0 || clone.byteLength != 8;
});
var tryToTransfer = function (rawTransfer, map) {
if (!isObject(rawTransfer)) throw TypeError('Transfer option cannot be converted to a sequence');
var transfer = [];
iterate(rawTransfer, function (value) {
push(transfer, anObject(value));
});
var i = 0;
var length = lengthOfArrayLike(transfer);
var value, type, C, transferredArray, transferred, canvas, context;
if (PROPER_TRANSFER) {
transferredArray = nativeStructuredClone(transfer, { transfer: transfer });
while (i < length) mapSet(map, transfer[i], transferredArray[i++]);
} else while (i < length) {
value = transfer[i++];
if (mapHas(map, value)) throw new DOMException('Duplicate transferable', DATA_CLONE_ERROR);
type = classof(value);
switch (type) {
case 'ImageBitmap':
C = global.OffscreenCanvas;
if (!isConstructor(C)) throwUnpolyfillable(type, TRANSFERRING);
try {
canvas = new C(value.width, value.height);
context = canvas.getContext('bitmaprenderer');
context.transferFromImageBitmap(value);
transferred = canvas.transferToImageBitmap();
} catch (error) { /* empty */ }
break;
case 'AudioData':
case 'VideoFrame':
if (!isCallable(value.clone) || !isCallable(value.close)) throwUnpolyfillable(type, TRANSFERRING);
try {
transferred = value.clone();
value.close();
} catch (error) { /* empty */ }
break;
case 'ArrayBuffer':
case 'MessagePort':
case 'OffscreenCanvas':
case 'ReadableStream':
case 'TransformStream':
case 'WritableStream':
throwUnpolyfillable(type, TRANSFERRING);
}
if (transferred === undefined) throw new DOMException('This object cannot be transferred: ' + type, DATA_CLONE_ERROR);
mapSet(map, value, transferred);
}
};
$({ global: true, enumerable: true, sham: !PROPER_TRANSFER, forced: FORCED_REPLACEMENT }, {
structuredClone: function structuredClone(value /* , { transfer } */) {
var options = validateArgumentsLength(arguments.length, 1) > 1 ? anObject(arguments[1]) : undefined;
var transfer = options ? options.transfer : undefined;
var map;
if (transfer !== undefined) {
map = new Map();
tryToTransfer(transfer, map);
}
return structuredCloneInternal(value, map);
}
});
/***/ }),
/* 441 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var apply = __webpack_require__(64);
var isCallable = __webpack_require__(19);
var userAgent = __webpack_require__(26);
var arraySlice = __webpack_require__(76);
var validateArgumentsLength = __webpack_require__(291);
var MSIE = /MSIE .\./.test(userAgent); // <- dirty ie9- check
var Function = global.Function;
var wrap = function (scheduler) {
return function (handler, timeout /* , ...arguments */) {
var boundArgs = validateArgumentsLength(arguments.length, 1) > 2;
var fn = isCallable(handler) ? handler : Function(handler);
var args = boundArgs ? arraySlice(arguments, 2) : undefined;
return scheduler(boundArgs ? function () {
apply(fn, this, args);
} : fn, timeout);
};
};
// ie9- setTimeout & setInterval additional parameters fix
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#timers
$({ global: true, bind: true, forced: MSIE }, {
// `setTimeout` method
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-settimeout
setTimeout: wrap(global.setTimeout),
// `setInterval` method
// https://html.spec.whatwg.org/multipage/timers-and-user-prompts.html#dom-setinterval
setInterval: wrap(global.setInterval)
});
/***/ }),
/* 442 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
__webpack_require__(342);
var $ = __webpack_require__(2);
var DESCRIPTORS = __webpack_require__(5);
var USE_NATIVE_URL = __webpack_require__(443);
var global = __webpack_require__(3);
var bind = __webpack_require__(82);
var uncurryThis = __webpack_require__(13);
var defineProperties = (__webpack_require__(70).f);
var redefine = __webpack_require__(45);
var anInstance = __webpack_require__(176);
var hasOwn = __webpack_require__(36);
var assign = __webpack_require__(256);
var arrayFrom = __webpack_require__(140);
var arraySlice = __webpack_require__(74);
var codeAt = (__webpack_require__(336).codeAt);
var toASCII = __webpack_require__(444);
var $toString = __webpack_require__(66);
var setToStringTag = __webpack_require__(80);
var validateArgumentsLength = __webpack_require__(291);
var URLSearchParamsModule = __webpack_require__(445);
var InternalStateModule = __webpack_require__(47);
var setInternalState = InternalStateModule.set;
var getInternalURLState = InternalStateModule.getterFor('URL');
var URLSearchParams = URLSearchParamsModule.URLSearchParams;
var getInternalSearchParamsState = URLSearchParamsModule.getState;
var NativeURL = global.URL;
var TypeError = global.TypeError;
var parseInt = global.parseInt;
var floor = Math.floor;
var pow = Math.pow;
var charAt = uncurryThis(''.charAt);
var exec = uncurryThis(/./.exec);
var join = uncurryThis([].join);
var numberToString = uncurryThis(1.0.toString);
var pop = uncurryThis([].pop);
var push = uncurryThis([].push);
var replace = uncurryThis(''.replace);
var shift = uncurryThis([].shift);
var split = uncurryThis(''.split);
var stringSlice = uncurryThis(''.slice);
var toLowerCase = uncurryThis(''.toLowerCase);
var unshift = uncurryThis([].unshift);
var INVALID_AUTHORITY = 'Invalid authority';
var INVALID_SCHEME = 'Invalid scheme';
var INVALID_HOST = 'Invalid host';
var INVALID_PORT = 'Invalid port';
var ALPHA = /[a-z]/i;
// eslint-disable-next-line regexp/no-obscure-range -- safe
var ALPHANUMERIC = /[\d+-.a-z]/i;
var DIGIT = /\d/;
var HEX_START = /^0x/i;
var OCT = /^[0-7]+$/;
var DEC = /^\d+$/;
var HEX = /^[\da-f]+$/i;
/* eslint-disable regexp/no-control-character -- safe */
var FORBIDDEN_HOST_CODE_POINT = /[\0\t\n\r #%/:<>?@[\\\]^|]/;
var FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\0\t\n\r #/:<>?@[\\\]^|]/;
var LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\u0000-\u0020]+|[\u0000-\u0020]+$/g;
var TAB_AND_NEW_LINE = /[\t\n\r]/g;
/* eslint-enable regexp/no-control-character -- safe */
var EOF;
// https://url.spec.whatwg.org/#ipv4-number-parser
var parseIPv4 = function (input) {
var parts = split(input, '.');
var partsLength, numbers, index, part, radix, number, ipv4;
if (parts.length && parts[parts.length - 1] == '') {
parts.length--;
}
partsLength = parts.length;
if (partsLength > 4) return input;
numbers = [];
for (index = 0; index < partsLength; index++) {
part = parts[index];
if (part == '') return input;
radix = 10;
if (part.length > 1 && charAt(part, 0) == '0') {
radix = exec(HEX_START, part) ? 16 : 8;
part = stringSlice(part, radix == 8 ? 1 : 2);
}
if (part === '') {
number = 0;
} else {
if (!exec(radix == 10 ? DEC : radix == 8 ? OCT : HEX, part)) return input;
number = parseInt(part, radix);
}
push(numbers, number);
}
for (index = 0; index < partsLength; index++) {
number = numbers[index];
if (index == partsLength - 1) {
if (number >= pow(256, 5 - partsLength)) return null;
} else if (number > 255) return null;
}
ipv4 = pop(numbers);
for (index = 0; index < numbers.length; index++) {
ipv4 += numbers[index] * pow(256, 3 - index);
}
return ipv4;
};
// https://url.spec.whatwg.org/#concept-ipv6-parser
// eslint-disable-next-line max-statements -- TODO
var parseIPv6 = function (input) {
var address = [0, 0, 0, 0, 0, 0, 0, 0];
var pieceIndex = 0;
var compress = null;
var pointer = 0;
var value, length, numbersSeen, ipv4Piece, number, swaps, swap;
var chr = function () {
return charAt(input, pointer);
};
if (chr() == ':') {
if (charAt(input, 1) != ':') return;
pointer += 2;
pieceIndex++;
compress = pieceIndex;
}
while (chr()) {
if (pieceIndex == 8) return;
if (chr() == ':') {
if (compress !== null) return;
pointer++;
pieceIndex++;
compress = pieceIndex;
continue;
}
value = length = 0;
while (length < 4 && exec(HEX, chr())) {
value = value * 16 + parseInt(chr(), 16);
pointer++;
length++;
}
if (chr() == '.') {
if (length == 0) return;
pointer -= length;
if (pieceIndex > 6) return;
numbersSeen = 0;
while (chr()) {
ipv4Piece = null;
if (numbersSeen > 0) {
if (chr() == '.' && numbersSeen < 4) pointer++;
else return;
}
if (!exec(DIGIT, chr())) return;
while (exec(DIGIT, chr())) {
number = parseInt(chr(), 10);
if (ipv4Piece === null) ipv4Piece = number;
else if (ipv4Piece == 0) return;
else ipv4Piece = ipv4Piece * 10 + number;
if (ipv4Piece > 255) return;
pointer++;
}
address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;
numbersSeen++;
if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++;
}
if (numbersSeen != 4) return;
break;
} else if (chr() == ':') {
pointer++;
if (!chr()) return;
} else if (chr()) return;
address[pieceIndex++] = value;
}
if (compress !== null) {
swaps = pieceIndex - compress;
pieceIndex = 7;
while (pieceIndex != 0 && swaps > 0) {
swap = address[pieceIndex];
address[pieceIndex--] = address[compress + swaps - 1];
address[compress + --swaps] = swap;
}
} else if (pieceIndex != 8) return;
return address;
};
var findLongestZeroSequence = function (ipv6) {
var maxIndex = null;
var maxLength = 1;
var currStart = null;
var currLength = 0;
var index = 0;
for (; index < 8; index++) {
if (ipv6[index] !== 0) {
if (currLength > maxLength) {
maxIndex = currStart;
maxLength = currLength;
}
currStart = null;
currLength = 0;
} else {
if (currStart === null) currStart = index;
++currLength;
}
}
if (currLength > maxLength) {
maxIndex = currStart;
maxLength = currLength;
}
return maxIndex;
};
// https://url.spec.whatwg.org/#host-serializing
var serializeHost = function (host) {
var result, index, compress, ignore0;
// ipv4
if (typeof host == 'number') {
result = [];
for (index = 0; index < 4; index++) {
unshift(result, host % 256);
host = floor(host / 256);
} return join(result, '.');
// ipv6
} else if (typeof host == 'object') {
result = '';
compress = findLongestZeroSequence(host);
for (index = 0; index < 8; index++) {
if (ignore0 && host[index] === 0) continue;
if (ignore0) ignore0 = false;
if (compress === index) {
result += index ? ':' : '::';
ignore0 = true;
} else {
result += numberToString(host[index], 16);
if (index < 7) result += ':';
}
}
return '[' + result + ']';
} return host;
};
var C0ControlPercentEncodeSet = {};
var fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {
' ': 1, '"': 1, '<': 1, '>': 1, '`': 1
});
var pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {
'#': 1, '?': 1, '{': 1, '}': 1
});
var userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {
'/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\': 1, ']': 1, '^': 1, '|': 1
});
var percentEncode = function (chr, set) {
var code = codeAt(chr, 0);
return code > 0x20 && code < 0x7F && !hasOwn(set, chr) ? chr : encodeURIComponent(chr);
};
// https://url.spec.whatwg.org/#special-scheme
var specialSchemes = {
ftp: 21,
file: null,
http: 80,
https: 443,
ws: 80,
wss: 443
};
// https://url.spec.whatwg.org/#windows-drive-letter
var isWindowsDriveLetter = function (string, normalized) {
var second;
return string.length == 2 && exec(ALPHA, charAt(string, 0))
&& ((second = charAt(string, 1)) == ':' || (!normalized && second == '|'));
};
// https://url.spec.whatwg.org/#start-with-a-windows-drive-letter
var startsWithWindowsDriveLetter = function (string) {
var third;
return string.length > 1 && isWindowsDriveLetter(stringSlice(string, 0, 2)) && (
string.length == 2 ||
((third = charAt(string, 2)) === '/' || third === '\\' || third === '?' || third === '#')
);
};
// https://url.spec.whatwg.org/#single-dot-path-segment
var isSingleDot = function (segment) {
return segment === '.' || toLowerCase(segment) === '%2e';
};
// https://url.spec.whatwg.org/#double-dot-path-segment
var isDoubleDot = function (segment) {
segment = toLowerCase(segment);
return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';
};
// States:
var SCHEME_START = {};
var SCHEME = {};
var NO_SCHEME = {};
var SPECIAL_RELATIVE_OR_AUTHORITY = {};
var PATH_OR_AUTHORITY = {};
var RELATIVE = {};
var RELATIVE_SLASH = {};
var SPECIAL_AUTHORITY_SLASHES = {};
var SPECIAL_AUTHORITY_IGNORE_SLASHES = {};
var AUTHORITY = {};
var HOST = {};
var HOSTNAME = {};
var PORT = {};
var FILE = {};
var FILE_SLASH = {};
var FILE_HOST = {};
var PATH_START = {};
var PATH = {};
var CANNOT_BE_A_BASE_URL_PATH = {};
var QUERY = {};
var FRAGMENT = {};
var URLState = function (url, isBase, base) {
var urlString = $toString(url);
var baseState, failure, searchParams;
if (isBase) {
failure = this.parse(urlString);
if (failure) throw TypeError(failure);
this.searchParams = null;
} else {
if (base !== undefined) baseState = new URLState(base, true);
failure = this.parse(urlString, null, baseState);
if (failure) throw TypeError(failure);
searchParams = getInternalSearchParamsState(new URLSearchParams());
searchParams.bindURL(this);
this.searchParams = searchParams;
}
};
URLState.prototype = {
type: 'URL',
// https://url.spec.whatwg.org/#url-parsing
// eslint-disable-next-line max-statements -- TODO
parse: function (input, stateOverride, base) {
var url = this;
var state = stateOverride || SCHEME_START;
var pointer = 0;
var buffer = '';
var seenAt = false;
var seenBracket = false;
var seenPasswordToken = false;
var codePoints, chr, bufferCodePoints, failure;
input = $toString(input);
if (!stateOverride) {
url.scheme = '';
url.username = '';
url.password = '';
url.host = null;
url.port = null;
url.path = [];
url.query = null;
url.fragment = null;
url.cannotBeABaseURL = false;
input = replace(input, LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');
}
input = replace(input, TAB_AND_NEW_LINE, '');
codePoints = arrayFrom(input);
while (pointer <= codePoints.length) {
chr = codePoints[pointer];
switch (state) {
case SCHEME_START:
if (chr && exec(ALPHA, chr)) {
buffer += toLowerCase(chr);
state = SCHEME;
} else if (!stateOverride) {
state = NO_SCHEME;
continue;
} else return INVALID_SCHEME;
break;
case SCHEME:
if (chr && (exec(ALPHANUMERIC, chr) || chr == '+' || chr == '-' || chr == '.')) {
buffer += toLowerCase(chr);
} else if (chr == ':') {
if (stateOverride && (
(url.isSpecial() != hasOwn(specialSchemes, buffer)) ||
(buffer == 'file' && (url.includesCredentials() || url.port !== null)) ||
(url.scheme == 'file' && !url.host)
)) return;
url.scheme = buffer;
if (stateOverride) {
if (url.isSpecial() && specialSchemes[url.scheme] == url.port) url.port = null;
return;
}
buffer = '';
if (url.scheme == 'file') {
state = FILE;
} else if (url.isSpecial() && base && base.scheme == url.scheme) {
state = SPECIAL_RELATIVE_OR_AUTHORITY;
} else if (url.isSpecial()) {
state = SPECIAL_AUTHORITY_SLASHES;
} else if (codePoints[pointer + 1] == '/') {
state = PATH_OR_AUTHORITY;
pointer++;
} else {
url.cannotBeABaseURL = true;
push(url.path, '');
state = CANNOT_BE_A_BASE_URL_PATH;
}
} else if (!stateOverride) {
buffer = '';
state = NO_SCHEME;
pointer = 0;
continue;
} else return INVALID_SCHEME;
break;
case NO_SCHEME:
if (!base || (base.cannotBeABaseURL && chr != '#')) return INVALID_SCHEME;
if (base.cannotBeABaseURL && chr == '#') {
url.scheme = base.scheme;
url.path = arraySlice(base.path);
url.query = base.query;
url.fragment = '';
url.cannotBeABaseURL = true;
state = FRAGMENT;
break;
}
state = base.scheme == 'file' ? FILE : RELATIVE;
continue;
case SPECIAL_RELATIVE_OR_AUTHORITY:
if (chr == '/' && codePoints[pointer + 1] == '/') {
state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
pointer++;
} else {
state = RELATIVE;
continue;
} break;
case PATH_OR_AUTHORITY:
if (chr == '/') {
state = AUTHORITY;
break;
} else {
state = PATH;
continue;
}
case RELATIVE:
url.scheme = base.scheme;
if (chr == EOF) {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = arraySlice(base.path);
url.query = base.query;
} else if (chr == '/' || (chr == '\\' && url.isSpecial())) {
state = RELATIVE_SLASH;
} else if (chr == '?') {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = arraySlice(base.path);
url.query = '';
state = QUERY;
} else if (chr == '#') {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = arraySlice(base.path);
url.query = base.query;
url.fragment = '';
state = FRAGMENT;
} else {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
url.path = arraySlice(base.path);
url.path.length--;
state = PATH;
continue;
} break;
case RELATIVE_SLASH:
if (url.isSpecial() && (chr == '/' || chr == '\\')) {
state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
} else if (chr == '/') {
state = AUTHORITY;
} else {
url.username = base.username;
url.password = base.password;
url.host = base.host;
url.port = base.port;
state = PATH;
continue;
} break;
case SPECIAL_AUTHORITY_SLASHES:
state = SPECIAL_AUTHORITY_IGNORE_SLASHES;
if (chr != '/' || charAt(buffer, pointer + 1) != '/') continue;
pointer++;
break;
case SPECIAL_AUTHORITY_IGNORE_SLASHES:
if (chr != '/' && chr != '\\') {
state = AUTHORITY;
continue;
} break;
case AUTHORITY:
if (chr == '@') {
if (seenAt) buffer = '%40' + buffer;
seenAt = true;
bufferCodePoints = arrayFrom(buffer);
for (var i = 0; i < bufferCodePoints.length; i++) {
var codePoint = bufferCodePoints[i];
if (codePoint == ':' && !seenPasswordToken) {
seenPasswordToken = true;
continue;
}
var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);
if (seenPasswordToken) url.password += encodedCodePoints;
else url.username += encodedCodePoints;
}
buffer = '';
} else if (
chr == EOF || chr == '/' || chr == '?' || chr == '#' ||
(chr == '\\' && url.isSpecial())
) {
if (seenAt && buffer == '') return INVALID_AUTHORITY;
pointer -= arrayFrom(buffer).length + 1;
buffer = '';
state = HOST;
} else buffer += chr;
break;
case HOST:
case HOSTNAME:
if (stateOverride && url.scheme == 'file') {
state = FILE_HOST;
continue;
} else if (chr == ':' && !seenBracket) {
if (buffer == '') return INVALID_HOST;
failure = url.parseHost(buffer);
if (failure) return failure;
buffer = '';
state = PORT;
if (stateOverride == HOSTNAME) return;
} else if (
chr == EOF || chr == '/' || chr == '?' || chr == '#' ||
(chr == '\\' && url.isSpecial())
) {
if (url.isSpecial() && buffer == '') return INVALID_HOST;
if (stateOverride && buffer == '' && (url.includesCredentials() || url.port !== null)) return;
failure = url.parseHost(buffer);
if (failure) return failure;
buffer = '';
state = PATH_START;
if (stateOverride) return;
continue;
} else {
if (chr == '[') seenBracket = true;
else if (chr == ']') seenBracket = false;
buffer += chr;
} break;
case PORT:
if (exec(DIGIT, chr)) {
buffer += chr;
} else if (
chr == EOF || chr == '/' || chr == '?' || chr == '#' ||
(chr == '\\' && url.isSpecial()) ||
stateOverride
) {
if (buffer != '') {
var port = parseInt(buffer, 10);
if (port > 0xFFFF) return INVALID_PORT;
url.port = (url.isSpecial() && port === specialSchemes[url.scheme]) ? null : port;
buffer = '';
}
if (stateOverride) return;
state = PATH_START;
continue;
} else return INVALID_PORT;
break;
case FILE:
url.scheme = 'file';
if (chr == '/' || chr == '\\') state = FILE_SLASH;
else if (base && base.scheme == 'file') {
if (chr == EOF) {
url.host = base.host;
url.path = arraySlice(base.path);
url.query = base.query;
} else if (chr == '?') {
url.host = base.host;
url.path = arraySlice(base.path);
url.query = '';
state = QUERY;
} else if (chr == '#') {
url.host = base.host;
url.path = arraySlice(base.path);
url.query = base.query;
url.fragment = '';
state = FRAGMENT;
} else {
if (!startsWithWindowsDriveLetter(join(arraySlice(codePoints, pointer), ''))) {
url.host = base.host;
url.path = arraySlice(base.path);
url.shortenPath();
}
state = PATH;
continue;
}
} else {
state = PATH;
continue;
} break;
case FILE_SLASH:
if (chr == '/' || chr == '\\') {
state = FILE_HOST;
break;
}
if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(join(arraySlice(codePoints, pointer), ''))) {
if (isWindowsDriveLetter(base.path[0], true)) push(url.path, base.path[0]);
else url.host = base.host;
}
state = PATH;
continue;
case FILE_HOST:
if (chr == EOF || chr == '/' || chr == '\\' || chr == '?' || chr == '#') {
if (!stateOverride && isWindowsDriveLetter(buffer)) {
state = PATH;
} else if (buffer == '') {
url.host = '';
if (stateOverride) return;
state = PATH_START;
} else {
failure = url.parseHost(buffer);
if (failure) return failure;
if (url.host == 'localhost') url.host = '';
if (stateOverride) return;
buffer = '';
state = PATH_START;
} continue;
} else buffer += chr;
break;
case PATH_START:
if (url.isSpecial()) {
state = PATH;
if (chr != '/' && chr != '\\') continue;
} else if (!stateOverride && chr == '?') {
url.query = '';
state = QUERY;
} else if (!stateOverride && chr == '#') {
url.fragment = '';
state = FRAGMENT;
} else if (chr != EOF) {
state = PATH;
if (chr != '/') continue;
} break;
case PATH:
if (
chr == EOF || chr == '/' ||
(chr == '\\' && url.isSpecial()) ||
(!stateOverride && (chr == '?' || chr == '#'))
) {
if (isDoubleDot(buffer)) {
url.shortenPath();
if (chr != '/' && !(chr == '\\' && url.isSpecial())) {
push(url.path, '');
}
} else if (isSingleDot(buffer)) {
if (chr != '/' && !(chr == '\\' && url.isSpecial())) {
push(url.path, '');
}
} else {
if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {
if (url.host) url.host = '';
buffer = charAt(buffer, 0) + ':'; // normalize windows drive letter
}
push(url.path, buffer);
}
buffer = '';
if (url.scheme == 'file' && (chr == EOF || chr == '?' || chr == '#')) {
while (url.path.length > 1 && url.path[0] === '') {
shift(url.path);
}
}
if (chr == '?') {
url.query = '';
state = QUERY;
} else if (chr == '#') {
url.fragment = '';
state = FRAGMENT;
}
} else {
buffer += percentEncode(chr, pathPercentEncodeSet);
} break;
case CANNOT_BE_A_BASE_URL_PATH:
if (chr == '?') {
url.query = '';
state = QUERY;
} else if (chr == '#') {
url.fragment = '';
state = FRAGMENT;
} else if (chr != EOF) {
url.path[0] += percentEncode(chr, C0ControlPercentEncodeSet);
} break;
case QUERY:
if (!stateOverride && chr == '#') {
url.fragment = '';
state = FRAGMENT;
} else if (chr != EOF) {
if (chr == "'" && url.isSpecial()) url.query += '%27';
else if (chr == '#') url.query += '%23';
else url.query += percentEncode(chr, C0ControlPercentEncodeSet);
} break;
case FRAGMENT:
if (chr != EOF) url.fragment += percentEncode(chr, fragmentPercentEncodeSet);
break;
}
pointer++;
}
},
// https://url.spec.whatwg.org/#host-parsing
parseHost: function (input) {
var result, codePoints, index;
if (charAt(input, 0) == '[') {
if (charAt(input, input.length - 1) != ']') return INVALID_HOST;
result = parseIPv6(stringSlice(input, 1, -1));
if (!result) return INVALID_HOST;
this.host = result;
// opaque host
} else if (!this.isSpecial()) {
if (exec(FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT, input)) return INVALID_HOST;
result = '';
codePoints = arrayFrom(input);
for (index = 0; index < codePoints.length; index++) {
result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);
}
this.host = result;
} else {
input = toASCII(input);
if (exec(FORBIDDEN_HOST_CODE_POINT, input)) return INVALID_HOST;
result = parseIPv4(input);
if (result === null) return INVALID_HOST;
this.host = result;
}
},
// https://url.spec.whatwg.org/#cannot-have-a-username-password-port
cannotHaveUsernamePasswordPort: function () {
return !this.host || this.cannotBeABaseURL || this.scheme == 'file';
},
// https://url.spec.whatwg.org/#include-credentials
includesCredentials: function () {
return this.username != '' || this.password != '';
},
// https://url.spec.whatwg.org/#is-special
isSpecial: function () {
return hasOwn(specialSchemes, this.scheme);
},
// https://url.spec.whatwg.org/#shorten-a-urls-path
shortenPath: function () {
var path = this.path;
var pathSize = path.length;
if (pathSize && (this.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {
path.length--;
}
},
// https://url.spec.whatwg.org/#concept-url-serializer
serialize: function () {
var url = this;
var scheme = url.scheme;
var username = url.username;
var password = url.password;
var host = url.host;
var port = url.port;
var path = url.path;
var query = url.query;
var fragment = url.fragment;
var output = scheme + ':';
if (host !== null) {
output += '//';
if (url.includesCredentials()) {
output += username + (password ? ':' + password : '') + '@';
}
output += serializeHost(host);
if (port !== null) output += ':' + port;
} else if (scheme == 'file') output += '//';
output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + join(path, '/') : '';
if (query !== null) output += '?' + query;
if (fragment !== null) output += '#' + fragment;
return output;
},
// https://url.spec.whatwg.org/#dom-url-href
setHref: function (href) {
var failure = this.parse(href);
if (failure) throw TypeError(failure);
this.searchParams.update();
},
// https://url.spec.whatwg.org/#dom-url-origin
getOrigin: function () {
var scheme = this.scheme;
var port = this.port;
if (scheme == 'blob') try {
return new URLConstructor(scheme.path[0]).origin;
} catch (error) {
return 'null';
}
if (scheme == 'file' || !this.isSpecial()) return 'null';
return scheme + '://' + serializeHost(this.host) + (port !== null ? ':' + port : '');
},
// https://url.spec.whatwg.org/#dom-url-protocol
getProtocol: function () {
return this.scheme + ':';
},
setProtocol: function (protocol) {
this.parse($toString(protocol) + ':', SCHEME_START);
},
// https://url.spec.whatwg.org/#dom-url-username
getUsername: function () {
return this.username;
},
setUsername: function (username) {
var codePoints = arrayFrom($toString(username));
if (this.cannotHaveUsernamePasswordPort()) return;
this.username = '';
for (var i = 0; i < codePoints.length; i++) {
this.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);
}
},
// https://url.spec.whatwg.org/#dom-url-password
getPassword: function () {
return this.password;
},
setPassword: function (password) {
var codePoints = arrayFrom($toString(password));
if (this.cannotHaveUsernamePasswordPort()) return;
this.password = '';
for (var i = 0; i < codePoints.length; i++) {
this.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);
}
},
// https://url.spec.whatwg.org/#dom-url-host
getHost: function () {
var host = this.host;
var port = this.port;
return host === null ? ''
: port === null ? serializeHost(host)
: serializeHost(host) + ':' + port;
},
setHost: function (host) {
if (this.cannotBeABaseURL) return;
this.parse(host, HOST);
},
// https://url.spec.whatwg.org/#dom-url-hostname
getHostname: function () {
var host = this.host;
return host === null ? '' : serializeHost(host);
},
setHostname: function (hostname) {
if (this.cannotBeABaseURL) return;
this.parse(hostname, HOSTNAME);
},
// https://url.spec.whatwg.org/#dom-url-port
getPort: function () {
var port = this.port;
return port === null ? '' : $toString(port);
},
setPort: function (port) {
if (this.cannotHaveUsernamePasswordPort()) return;
port = $toString(port);
if (port == '') this.port = null;
else this.parse(port, PORT);
},
// https://url.spec.whatwg.org/#dom-url-pathname
getPathname: function () {
var path = this.path;
return this.cannotBeABaseURL ? path[0] : path.length ? '/' + join(path, '/') : '';
},
setPathname: function (pathname) {
if (this.cannotBeABaseURL) return;
this.path = [];
this.parse(pathname, PATH_START);
},
// https://url.spec.whatwg.org/#dom-url-search
getSearch: function () {
var query = this.query;
return query ? '?' + query : '';
},
setSearch: function (search) {
search = $toString(search);
if (search == '') {
this.query = null;
} else {
if ('?' == charAt(search, 0)) search = stringSlice(search, 1);
this.query = '';
this.parse(search, QUERY);
}
this.searchParams.update();
},
// https://url.spec.whatwg.org/#dom-url-searchparams
getSearchParams: function () {
return this.searchParams.facade;
},
// https://url.spec.whatwg.org/#dom-url-hash
getHash: function () {
var fragment = this.fragment;
return fragment ? '#' + fragment : '';
},
setHash: function (hash) {
hash = $toString(hash);
if (hash == '') {
this.fragment = null;
return;
}
if ('#' == charAt(hash, 0)) hash = stringSlice(hash, 1);
this.fragment = '';
this.parse(hash, FRAGMENT);
},
update: function () {
this.query = this.searchParams.serialize() || null;
}
};
// `URL` constructor
// https://url.spec.whatwg.org/#url-class
var URLConstructor = function URL(url /* , base */) {
var that = anInstance(this, URLPrototype);
var base = validateArgumentsLength(arguments.length, 1) > 1 ? arguments[1] : undefined;
var state = setInternalState(that, new URLState(url, false, base));
if (!DESCRIPTORS) {
that.href = state.serialize();
that.origin = state.getOrigin();
that.protocol = state.getProtocol();
that.username = state.getUsername();
that.password = state.getPassword();
that.host = state.getHost();
that.hostname = state.getHostname();
that.port = state.getPort();
that.pathname = state.getPathname();
that.search = state.getSearch();
that.searchParams = state.getSearchParams();
that.hash = state.getHash();
}
};
var URLPrototype = URLConstructor.prototype;
var accessorDescriptor = function (getter, setter) {
return {
get: function () {
return getInternalURLState(this)[getter]();
},
set: setter && function (value) {
return getInternalURLState(this)[setter](value);
},
configurable: true,
enumerable: true
};
};
if (DESCRIPTORS) {
defineProperties(URLPrototype, {
// `URL.prototype.href` accessors pair
// https://url.spec.whatwg.org/#dom-url-href
href: accessorDescriptor('serialize', 'setHref'),
// `URL.prototype.origin` getter
// https://url.spec.whatwg.org/#dom-url-origin
origin: accessorDescriptor('getOrigin'),
// `URL.prototype.protocol` accessors pair
// https://url.spec.whatwg.org/#dom-url-protocol
protocol: accessorDescriptor('getProtocol', 'setProtocol'),
// `URL.prototype.username` accessors pair
// https://url.spec.whatwg.org/#dom-url-username
username: accessorDescriptor('getUsername', 'setUsername'),
// `URL.prototype.password` accessors pair
// https://url.spec.whatwg.org/#dom-url-password
password: accessorDescriptor('getPassword', 'setPassword'),
// `URL.prototype.host` accessors pair
// https://url.spec.whatwg.org/#dom-url-host
host: accessorDescriptor('getHost', 'setHost'),
// `URL.prototype.hostname` accessors pair
// https://url.spec.whatwg.org/#dom-url-hostname
hostname: accessorDescriptor('getHostname', 'setHostname'),
// `URL.prototype.port` accessors pair
// https://url.spec.whatwg.org/#dom-url-port
port: accessorDescriptor('getPort', 'setPort'),
// `URL.prototype.pathname` accessors pair
// https://url.spec.whatwg.org/#dom-url-pathname
pathname: accessorDescriptor('getPathname', 'setPathname'),
// `URL.prototype.search` accessors pair
// https://url.spec.whatwg.org/#dom-url-search
search: accessorDescriptor('getSearch', 'setSearch'),
// `URL.prototype.searchParams` getter
// https://url.spec.whatwg.org/#dom-url-searchparams
searchParams: accessorDescriptor('getSearchParams'),
// `URL.prototype.hash` accessors pair
// https://url.spec.whatwg.org/#dom-url-hash
hash: accessorDescriptor('getHash', 'setHash')
});
}
// `URL.prototype.toJSON` method
// https://url.spec.whatwg.org/#dom-url-tojson
redefine(URLPrototype, 'toJSON', function toJSON() {
return getInternalURLState(this).serialize();
}, { enumerable: true });
// `URL.prototype.toString` method
// https://url.spec.whatwg.org/#URL-stringification-behavior
redefine(URLPrototype, 'toString', function toString() {
return getInternalURLState(this).serialize();
}, { enumerable: true });
if (NativeURL) {
var nativeCreateObjectURL = NativeURL.createObjectURL;
var nativeRevokeObjectURL = NativeURL.revokeObjectURL;
// `URL.createObjectURL` method
// https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL
if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', bind(nativeCreateObjectURL, NativeURL));
// `URL.revokeObjectURL` method
// https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL
if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', bind(nativeRevokeObjectURL, NativeURL));
}
setToStringTag(URLConstructor, 'URL');
$({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, {
URL: URLConstructor
});
/***/ }),
/* 443 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
var fails = __webpack_require__(6);
var wellKnownSymbol = __webpack_require__(31);
var IS_PURE = __webpack_require__(33);
var ITERATOR = wellKnownSymbol('iterator');
module.exports = !fails(function () {
// eslint-disable-next-line unicorn/relative-url-style -- required for testing
var url = new URL('b?a=1&b=2&c=3', 'http://a');
var searchParams = url.searchParams;
var result = '';
url.pathname = 'c%20d';
searchParams.forEach(function (value, key) {
searchParams['delete']('b');
result += key + value;
});
return (IS_PURE && !url.toJSON)
|| !searchParams.sort
|| url.href !== 'http://a/c%20d?a=1&c=3'
|| searchParams.get('c') !== '3'
|| String(new URLSearchParams('?a=1')) !== 'a=1'
|| !searchParams[ITERATOR]
// throws in Edge
|| new URL('https://a@b').username !== 'a'
|| new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'
// not punycoded in Edge
|| new URL('http://тест').host !== 'xn--e1aybc'
// not escaped in Chrome 62-
|| new URL('http://a#б').hash !== '#%D0%B1'
// fails in Chrome 66-
|| result !== 'a1c3'
// throws in Safari
|| new URL('http://x', undefined).host !== 'x';
});
/***/ }),
/* 444 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js
var global = __webpack_require__(3);
var uncurryThis = __webpack_require__(13);
var maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1
var base = 36;
var tMin = 1;
var tMax = 26;
var skew = 38;
var damp = 700;
var initialBias = 72;
var initialN = 128; // 0x80
var delimiter = '-'; // '\x2D'
var regexNonASCII = /[^\0-\u007E]/; // non-ASCII chars
var regexSeparators = /[.\u3002\uFF0E\uFF61]/g; // RFC 3490 separators
var OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';
var baseMinusTMin = base - tMin;
var RangeError = global.RangeError;
var exec = uncurryThis(regexSeparators.exec);
var floor = Math.floor;
var fromCharCode = String.fromCharCode;
var charCodeAt = uncurryThis(''.charCodeAt);
var join = uncurryThis([].join);
var push = uncurryThis([].push);
var replace = uncurryThis(''.replace);
var split = uncurryThis(''.split);
var toLowerCase = uncurryThis(''.toLowerCase);
/**
* Creates an array containing the numeric code points of each Unicode
* character in the string. While JavaScript uses UCS-2 internally,
* this function will convert a pair of surrogate halves (each of which
* UCS-2 exposes as separate characters) into a single code point,
* matching UTF-16.
*/
var ucs2decode = function (string) {
var output = [];
var counter = 0;
var length = string.length;
while (counter < length) {
var value = charCodeAt(string, counter++);
if (value >= 0xD800 && value <= 0xDBFF && counter < length) {
// It's a high surrogate, and there is a next character.
var extra = charCodeAt(string, counter++);
if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.
push(output, ((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);
} else {
// It's an unmatched surrogate; only append this code unit, in case the
// next code unit is the high surrogate of a surrogate pair.
push(output, value);
counter--;
}
} else {
push(output, value);
}
}
return output;
};
/**
* Converts a digit/integer into a basic code point.
*/
var digitToBasic = function (digit) {
// 0..25 map to ASCII a..z or A..Z
// 26..35 map to ASCII 0..9
return digit + 22 + 75 * (digit < 26);
};
/**
* Bias adaptation function as per section 3.4 of RFC 3492.
* https://tools.ietf.org/html/rfc3492#section-3.4
*/
var adapt = function (delta, numPoints, firstTime) {
var k = 0;
delta = firstTime ? floor(delta / damp) : delta >> 1;
delta += floor(delta / numPoints);
while (delta > baseMinusTMin * tMax >> 1) {
delta = floor(delta / baseMinusTMin);
k += base;
}
return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));
};
/**
* Converts a string of Unicode symbols (e.g. a domain name label) to a
* Punycode string of ASCII-only symbols.
*/
var encode = function (input) {
var output = [];
// Convert the input in UCS-2 to an array of Unicode code points.
input = ucs2decode(input);
// Cache the length.
var inputLength = input.length;
// Initialize the state.
var n = initialN;
var delta = 0;
var bias = initialBias;
var i, currentValue;
// Handle the basic code points.
for (i = 0; i < input.length; i++) {
currentValue = input[i];
if (currentValue < 0x80) {
push(output, fromCharCode(currentValue));
}
}
var basicLength = output.length; // number of basic code points.
var handledCPCount = basicLength; // number of code points that have been handled;
// Finish the basic string with a delimiter unless it's empty.
if (basicLength) {
push(output, delimiter);
}
// Main encoding loop:
while (handledCPCount < inputLength) {
// All non-basic code points < n have been handled already. Find the next larger one:
var m = maxInt;
for (i = 0; i < input.length; i++) {
currentValue = input[i];
if (currentValue >= n && currentValue < m) {
m = currentValue;
}
}
// Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.
var handledCPCountPlusOne = handledCPCount + 1;
if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {
throw RangeError(OVERFLOW_ERROR);
}
delta += (m - n) * handledCPCountPlusOne;
n = m;
for (i = 0; i < input.length; i++) {
currentValue = input[i];
if (currentValue < n && ++delta > maxInt) {
throw RangeError(OVERFLOW_ERROR);
}
if (currentValue == n) {
// Represent delta as a generalized variable-length integer.
var q = delta;
var k = base;
while (true) {
var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);
if (q < t) break;
var qMinusT = q - t;
var baseMinusT = base - t;
push(output, fromCharCode(digitToBasic(t + qMinusT % baseMinusT)));
q = floor(qMinusT / baseMinusT);
k += base;
}
push(output, fromCharCode(digitToBasic(q)));
bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);
delta = 0;
handledCPCount++;
}
}
delta++;
n++;
}
return join(output, '');
};
module.exports = function (input) {
var encoded = [];
var labels = split(replace(toLowerCase(input), regexSeparators, '\u002E'), '.');
var i, label;
for (i = 0; i < labels.length; i++) {
label = labels[i];
push(encoded, exec(regexNonASCII, label) ? 'xn--' + encode(label) : label);
}
return join(encoded, '.');
};
/***/ }),
/* 445 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
"use strict";
// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`
__webpack_require__(146);
var $ = __webpack_require__(2);
var global = __webpack_require__(3);
var getBuiltIn = __webpack_require__(21);
var call = __webpack_require__(7);
var uncurryThis = __webpack_require__(13);
var USE_NATIVE_URL = __webpack_require__(443);
var redefine = __webpack_require__(45);
var redefineAll = __webpack_require__(175);
var setToStringTag = __webpack_require__(80);
var createIteratorConstructor = __webpack_require__(148);
var InternalStateModule = __webpack_require__(47);
var anInstance = __webpack_require__(176);
var isCallable = __webpack_require__(19);
var hasOwn = __webpack_require__(36);
var bind = __webpack_require__(82);
var classof = __webpack_require__(67);
var anObject = __webpack_require__(44);
var isObject = __webpack_require__(18);
var $toString = __webpack_require__(66);
var create = __webpack_require__(69);
var createPropertyDescriptor = __webpack_require__(10);
var getIterator = __webpack_require__(117);
var getIteratorMethod = __webpack_require__(118);
var validateArgumentsLength = __webpack_require__(291);
var wellKnownSymbol = __webpack_require__(31);
var arraySort = __webpack_require__(163);
var ITERATOR = wellKnownSymbol('iterator');
var URL_SEARCH_PARAMS = 'URLSearchParams';
var URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';
var setInternalState = InternalStateModule.set;
var getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);
var getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);
var n$Fetch = getBuiltIn('fetch');
var N$Request = getBuiltIn('Request');
var Headers = getBuiltIn('Headers');
var RequestPrototype = N$Request && N$Request.prototype;
var HeadersPrototype = Headers && Headers.prototype;
var RegExp = global.RegExp;
var TypeError = global.TypeError;
var decodeURIComponent = global.decodeURIComponent;
var encodeURIComponent = global.encodeURIComponent;
var charAt = uncurryThis(''.charAt);
var join = uncurryThis([].join);
var push = uncurryThis([].push);
var replace = uncurryThis(''.replace);
var shift = uncurryThis([].shift);
var splice = uncurryThis([].splice);
var split = uncurryThis(''.split);
var stringSlice = uncurryThis(''.slice);
var plus = /\+/g;
var sequences = Array(4);
var percentSequence = function (bytes) {
return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\da-f]{2}){' + bytes + '})', 'gi'));
};
var percentDecode = function (sequence) {
try {
return decodeURIComponent(sequence);
} catch (error) {
return sequence;
}
};
var deserialize = function (it) {
var result = replace(it, plus, ' ');
var bytes = 4;
try {
return decodeURIComponent(result);
} catch (error) {
while (bytes) {
result = replace(result, percentSequence(bytes--), percentDecode);
}
return result;
}
};
var find = /[!'()~]|%20/g;
var replacements = {
'!': '%21',
"'": '%27',
'(': '%28',
')': '%29',
'~': '%7E',
'%20': '+'
};
var replacer = function (match) {
return replacements[match];
};
var serialize = function (it) {
return replace(encodeURIComponent(it), find, replacer);
};
var URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {
setInternalState(this, {
type: URL_SEARCH_PARAMS_ITERATOR,
iterator: getIterator(getInternalParamsState(params).entries),
kind: kind
});
}, 'Iterator', function next() {
var state = getInternalIteratorState(this);
var kind = state.kind;
var step = state.iterator.next();
var entry = step.value;
if (!step.done) {
step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];
} return step;
}, true);
var URLSearchParamsState = function (init) {
this.entries = [];
this.url = null;
if (init !== undefined) {
if (isObject(init)) this.parseObject(init);
else this.parseQuery(typeof init == 'string' ? charAt(init, 0) === '?' ? stringSlice(init, 1) : init : $toString(init));
}
};
URLSearchParamsState.prototype = {
type: URL_SEARCH_PARAMS,
bindURL: function (url) {
this.url = url;
this.update();
},
parseObject: function (object) {
var iteratorMethod = getIteratorMethod(object);
var iterator, next, step, entryIterator, entryNext, first, second;
if (iteratorMethod) {
iterator = getIterator(object, iteratorMethod);
next = iterator.next;
while (!(step = call(next, iterator)).done) {
entryIterator = getIterator(anObject(step.value));
entryNext = entryIterator.next;
if (
(first = call(entryNext, entryIterator)).done ||
(second = call(entryNext, entryIterator)).done ||
!call(entryNext, entryIterator).done
) throw TypeError('Expected sequence with length 2');
push(this.entries, { key: $toString(first.value), value: $toString(second.value) });
}
} else for (var key in object) if (hasOwn(object, key)) {
push(this.entries, { key: key, value: $toString(object[key]) });
}
},
parseQuery: function (query) {
if (query) {
var attributes = split(query, '&');
var index = 0;
var attribute, entry;
while (index < attributes.length) {
attribute = attributes[index++];
if (attribute.length) {
entry = split(attribute, '=');
push(this.entries, {
key: deserialize(shift(entry)),
value: deserialize(join(entry, '='))
});
}
}
}
},
serialize: function () {
var entries = this.entries;
var result = [];
var index = 0;
var entry;
while (index < entries.length) {
entry = entries[index++];
push(result, serialize(entry.key) + '=' + serialize(entry.value));
} return join(result, '&');
},
update: function () {
this.entries.length = 0;
this.parseQuery(this.url.query);
},
updateURL: function () {
if (this.url) this.url.update();
}
};
// `URLSearchParams` constructor
// https://url.spec.whatwg.org/#interface-urlsearchparams
var URLSearchParamsConstructor = function URLSearchParams(/* init */) {
anInstance(this, URLSearchParamsPrototype);
var init = arguments.length > 0 ? arguments[0] : undefined;
setInternalState(this, new URLSearchParamsState(init));
};
var URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;
redefineAll(URLSearchParamsPrototype, {
// `URLSearchParams.prototype.append` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-append
append: function append(name, value) {
validateArgumentsLength(arguments.length, 2);
var state = getInternalParamsState(this);
push(state.entries, { key: $toString(name), value: $toString(value) });
state.updateURL();
},
// `URLSearchParams.prototype.delete` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-delete
'delete': function (name) {
validateArgumentsLength(arguments.length, 1);
var state = getInternalParamsState(this);
var entries = state.entries;
var key = $toString(name);
var index = 0;
while (index < entries.length) {
if (entries[index].key === key) splice(entries, index, 1);
else index++;
}
state.updateURL();
},
// `URLSearchParams.prototype.get` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-get
get: function get(name) {
validateArgumentsLength(arguments.length, 1);
var entries = getInternalParamsState(this).entries;
var key = $toString(name);
var index = 0;
for (; index < entries.length; index++) {
if (entries[index].key === key) return entries[index].value;
}
return null;
},
// `URLSearchParams.prototype.getAll` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-getall
getAll: function getAll(name) {
validateArgumentsLength(arguments.length, 1);
var entries = getInternalParamsState(this).entries;
var key = $toString(name);
var result = [];
var index = 0;
for (; index < entries.length; index++) {
if (entries[index].key === key) push(result, entries[index].value);
}
return result;
},
// `URLSearchParams.prototype.has` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-has
has: function has(name) {
validateArgumentsLength(arguments.length, 1);
var entries = getInternalParamsState(this).entries;
var key = $toString(name);
var index = 0;
while (index < entries.length) {
if (entries[index++].key === key) return true;
}
return false;
},
// `URLSearchParams.prototype.set` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-set
set: function set(name, value) {
validateArgumentsLength(arguments.length, 1);
var state = getInternalParamsState(this);
var entries = state.entries;
var found = false;
var key = $toString(name);
var val = $toString(value);
var index = 0;
var entry;
for (; index < entries.length; index++) {
entry = entries[index];
if (entry.key === key) {
if (found) splice(entries, index--, 1);
else {
found = true;
entry.value = val;
}
}
}
if (!found) push(entries, { key: key, value: val });
state.updateURL();
},
// `URLSearchParams.prototype.sort` method
// https://url.spec.whatwg.org/#dom-urlsearchparams-sort
sort: function sort() {
var state = getInternalParamsState(this);
arraySort(state.entries, function (a, b) {
return a.key > b.key ? 1 : -1;
});
state.updateURL();
},
// `URLSearchParams.prototype.forEach` method
forEach: function forEach(callback /* , thisArg */) {
var entries = getInternalParamsState(this).entries;
var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined);
var index = 0;
var entry;
while (index < entries.length) {
entry = entries[index++];
boundFunction(entry.value, entry.key, this);
}
},
// `URLSearchParams.prototype.keys` method
keys: function keys() {
return new URLSearchParamsIterator(this, 'keys');
},
// `URLSearchParams.prototype.values` method
values: function values() {
return new URLSearchParamsIterator(this, 'values');
},
// `URLSearchParams.prototype.entries` method
entries: function entries() {
return new URLSearchParamsIterator(this, 'entries');
}
}, { enumerable: true });
// `URLSearchParams.prototype[@@iterator]` method
redefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries, { name: 'entries' });
// `URLSearchParams.prototype.toString` method
// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior
redefine(URLSearchParamsPrototype, 'toString', function toString() {
return getInternalParamsState(this).serialize();
}, { enumerable: true });
setToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);
$({ global: true, forced: !USE_NATIVE_URL }, {
URLSearchParams: URLSearchParamsConstructor
});
// Wrap `fetch` and `Request` for correct work with polyfilled `URLSearchParams`
if (!USE_NATIVE_URL && isCallable(Headers)) {
var headersHas = uncurryThis(HeadersPrototype.has);
var headersSet = uncurryThis(HeadersPrototype.set);
var wrapRequestOptions = function (init) {
if (isObject(init)) {
var body = init.body;
var headers;
if (classof(body) === URL_SEARCH_PARAMS) {
headers = init.headers ? new Headers(init.headers) : new Headers();
if (!headersHas(headers, 'content-type')) {
headersSet(headers, 'content-type', 'application/x-www-form-urlencoded;charset=UTF-8');
}
return create(init, {
body: createPropertyDescriptor(0, $toString(body)),
headers: createPropertyDescriptor(0, headers)
});
}
} return init;
};
if (isCallable(n$Fetch)) {
$({ global: true, enumerable: true, forced: true }, {
fetch: function fetch(input /* , init */) {
return n$Fetch(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
}
});
}
if (isCallable(N$Request)) {
var RequestConstructor = function Request(input /* , init */) {
anInstance(this, RequestPrototype);
return new N$Request(input, arguments.length > 1 ? wrapRequestOptions(arguments[1]) : {});
};
RequestPrototype.constructor = RequestConstructor;
RequestConstructor.prototype = RequestPrototype;
$({ global: true, forced: true }, {
Request: RequestConstructor
});
}
}
module.exports = {
URLSearchParams: URLSearchParamsConstructor,
getState: getInternalParamsState
};
/***/ }),
/* 446 */
/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
"use strict";
var $ = __webpack_require__(2);
var call = __webpack_require__(7);
// `URL.prototype.toJSON` method
// https://url.spec.whatwg.org/#dom-url-tojson
$({ target: 'URL', proto: true, enumerable: true }, {
toJSON: function toJSON() {
return call(URL.prototype.toString, this);
}
});
/***/ }),
/* 447 */
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
"use strict";
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
"default": function() { return /* binding */ BubbleCompare; }
});
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/setPrototypeOf.js
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
;// CONCATENATED MODULE: ./node_modules/@babel/runtime/helpers/esm/inheritsLoose.js
function _inheritsLoose(subClass, superClass) {
subClass.prototype = Object.create(superClass.prototype);
subClass.prototype.constructor = subClass;
_setPrototypeOf(subClass, superClass);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selector.js
function none() {}
/* harmony default export */ function selector(selector) {
return selector == null ? none : function () {
return this.querySelector(selector);
};
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/select.js
/* harmony default export */ function selection_select(select) {
if (typeof select !== "function") select = selector(select);
for (var groups = this._groups, m = groups.length, subgroups = Array(m), j = 0; j < m; ++j) {
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = Array(n), node, subnode, i = 0; i < n; ++i) {
if ((node = group[i]) && (subnode = select.call(node, node.__data__, i, group))) {
if ("__data__" in node) subnode.__data__ = node.__data__;
subgroup[i] = subnode;
}
}
}
return new Selection(subgroups, this._parents);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/array.js
// Given something array like (or null), returns something that is strictly an
// array. This is used to ensure that array-like objects passed to d3.selectAll
// or selection.selectAll are converted into proper arrays when creating a
// selection; we don’t ever want to create a selection backed by a live
// HTMLCollection or NodeList. However, note that selection.selectAll will use a
// static NodeList as a group, since it safely derived from querySelectorAll.
function array(x) {
return x == null ? [] : Array.isArray(x) ? x : Array.from(x);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selectorAll.js
function empty() {
return [];
}
/* harmony default export */ function selectorAll(selector) {
return selector == null ? empty : function () {
return this.querySelectorAll(selector);
};
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/selectAll.js
function arrayAll(select) {
return function () {
return array(select.apply(this, arguments));
};
}
/* harmony default export */ function selectAll(select) {
if (typeof select === "function") select = arrayAll(select);else select = selectorAll(select);
for (var groups = this._groups, m = groups.length, subgroups = [], parents = [], j = 0; j < m; ++j) {
for (var group = groups[j], n = group.length, node, i = 0; i < n; ++i) {
if (node = group[i]) {
subgroups.push(select.call(node, node.__data__, i, group));
parents.push(node);
}
}
}
return new Selection(subgroups, parents);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/matcher.js
/* harmony default export */ function matcher(selector) {
return function () {
return this.matches(selector);
};
}
function childMatcher(selector) {
return function (node) {
return node.matches(selector);
};
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/selectChild.js
var find = Array.prototype.find;
function childFind(match) {
return function () {
return find.call(this.children, match);
};
}
function childFirst() {
return this.firstElementChild;
}
/* harmony default export */ function selectChild(match) {
return this.select(match == null ? childFirst : childFind(typeof match === "function" ? match : childMatcher(match)));
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/selectChildren.js
var filter = Array.prototype.filter;
function children() {
return Array.from(this.children);
}
function childrenFilter(match) {
return function () {
return filter.call(this.children, match);
};
}
/* harmony default export */ function selectChildren(match) {
return this.selectAll(match == null ? children : childrenFilter(typeof match === "function" ? match : childMatcher(match)));
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/filter.js
/* harmony default export */ function selection_filter(match) {
if (typeof match !== "function") match = matcher(match);
for (var groups = this._groups, m = groups.length, subgroups = Array(m), j = 0; j < m; ++j) {
for (var group = groups[j], n = group.length, subgroup = subgroups[j] = [], node, i = 0; i < n; ++i) {
if ((node = group[i]) && match.call(node, node.__data__, i, group)) {
subgroup.push(node);
}
}
}
return new Selection(subgroups, this._parents);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/sparse.js
/* harmony default export */ function sparse(update) {
return Array(update.length);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/enter.js
/* harmony default export */ function enter() {
return new Selection(this._enter || this._groups.map(sparse), this._parents);
}
function EnterNode(parent, datum) {
this.ownerDocument = parent.ownerDocument;
this.namespaceURI = parent.namespaceURI;
this._next = null;
this._parent = parent;
this.__data__ = datum;
}
EnterNode.prototype = {
constructor: EnterNode,
appendChild: function appendChild(child) {
return this._parent.insertBefore(child, this._next);
},
insertBefore: function insertBefore(child, next) {
return this._parent.insertBefore(child, next);
},
querySelector: function querySelector(selector) {
return this._parent.querySelector(selector);
},
querySelectorAll: function querySelectorAll(selector) {
return this._parent.querySelectorAll(selector);
}
};
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/constant.js
/* harmony default export */ function constant(x) {
return function () {
return x;
};
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/data.js
function bindIndex(parent, group, enter, update, exit, data) {
var i = 0,
node,
groupLength = group.length,
dataLength = data.length; // Put any non-null nodes that fit into update.
// Put any null nodes into enter.
// Put any remaining data into enter.
for (; i < dataLength; ++i) {
if (node = group[i]) {
node.__data__ = data[i];
update[i] = node;
} else {
enter[i] = new EnterNode(parent, data[i]);
}
} // Put any non-null nodes that don’t fit into exit.
for (; i < groupLength; ++i) {
if (node = group[i]) {
exit[i] = node;
}
}
}
function bindKey(parent, group, enter, update, exit, data, key) {
var i,
node,
nodeByKeyValue = new Map(),
groupLength = group.length,
dataLength = data.length,
keyValues = Array(groupLength),
keyValue; // Compute the key for each node.
// If multiple nodes have the same key, the duplicates are added to exit.
for (i = 0; i < groupLength; ++i) {
if (node = group[i]) {
keyValues[i] = keyValue = key.call(node, node.__data__, i, group) + "";
if (nodeByKeyValue.has(keyValue)) {
exit[i] = node;
} else {
nodeByKeyValue.set(keyValue, node);
}
}
} // Compute the key for each datum.
// If there a node associated with this key, join and add it to update.
// If there is not (or the key is a duplicate), add it to enter.
for (i = 0; i < dataLength; ++i) {
keyValue = key.call(parent, data[i], i, data) + "";
if (node = nodeByKeyValue.get(keyValue)) {
update[i] = node;
node.__data__ = data[i];
nodeByKeyValue.delete(keyValue);
} else {
enter[i] = new EnterNode(parent, data[i]);
}
} // Add any remaining nodes that were not bound to data to exit.
for (i = 0; i < groupLength; ++i) {
if ((node = group[i]) && nodeByKeyValue.get(keyValues[i]) === node) {
exit[i] = node;
}
}
}
function datum(node) {
return node.__data__;
}
/* harmony default export */ function data(value, key) {
if (!arguments.length) return Array.from(this, datum);
var bind = key ? bindKey : bindIndex,
parents = this._parents,
groups = this._groups;
if (typeof value !== "function") value = constant(value);
for (var m = groups.length, update = Array(m), enter = Array(m), exit = Array(m), j = 0; j < m; ++j) {
var parent = parents[j],
group = groups[j],
groupLength = group.length,
data = arraylike(value.call(parent, parent && parent.__data__, j, parents)),
dataLength = data.length,
enterGroup = enter[j] = Array(dataLength),
updateGroup = update[j] = Array(dataLength),
exitGroup = exit[j] = Array(groupLength);
bind(parent, group, enterGroup, updateGroup, exitGroup, data, key); // Now connect the enter nodes to their following update node, such that
// appendChild can insert the materialized enter node before this node,
// rather than at the end of the parent node.
for (var i0 = 0, i1 = 0, previous, next; i0 < dataLength; ++i0) {
if (previous = enterGroup[i0]) {
if (i0 >= i1) i1 = i0 + 1;
while (!(next = updateGroup[i1]) && ++i1 < dataLength) {}
previous._next = next || null;
}
}
}
update = new Selection(update, parents);
update._enter = enter;
update._exit = exit;
return update;
} // Given some data, this returns an array-like view of it: an object that
// exposes a length property and allows numeric indexing. Note that unlike
// selectAll, this isn’t worried about “live” collections because the resulting
// array will only be used briefly while data is being bound. (It is possible to
// cause the data to change while iterating by using a key function, but please
// don’t; we’d rather avoid a gratuitous copy.)
function arraylike(data) {
return typeof data === "object" && "length" in data ? data // Array, TypedArray, NodeList, array-like
: Array.from(data); // Map, Set, iterable, string, or anything else
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/exit.js
/* harmony default export */ function exit() {
return new Selection(this._exit || this._groups.map(sparse), this._parents);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/join.js
/* harmony default export */ function join(onenter, onupdate, onexit) {
var enter = this.enter(),
update = this,
exit = this.exit();
if (typeof onenter === "function") {
enter = onenter(enter);
if (enter) enter = enter.selection();
} else {
enter = enter.append(onenter + "");
}
if (onupdate != null) {
update = onupdate(update);
if (update) update = update.selection();
}
if (onexit == null) exit.remove();else onexit(exit);
return enter && update ? enter.merge(update).order() : update;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/merge.js
/* harmony default export */ function merge(context) {
for (var selection = context.selection ? context.selection() : context, groups0 = this._groups, groups1 = selection._groups, m0 = groups0.length, m1 = groups1.length, m = Math.min(m0, m1), merges = Array(m0), j = 0; j < m; ++j) {
for (var group0 = groups0[j], group1 = groups1[j], n = group0.length, merge = merges[j] = Array(n), node, i = 0; i < n; ++i) {
if (node = group0[i] || group1[i]) {
merge[i] = node;
}
}
}
for (; j < m0; ++j) {
merges[j] = groups0[j];
}
return new Selection(merges, this._parents);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/order.js
/* harmony default export */ function order() {
for (var groups = this._groups, j = -1, m = groups.length; ++j < m;) {
for (var group = groups[j], i = group.length - 1, next = group[i], node; --i >= 0;) {
if (node = group[i]) {
if (next && node.compareDocumentPosition(next) ^ 4) next.parentNode.insertBefore(node, next);
next = node;
}
}
}
return this;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/sort.js
/* harmony default export */ function sort(compare) {
if (!compare) compare = ascending;
function compareNode(a, b) {
return a && b ? compare(a.__data__, b.__data__) : !a - !b;
}
for (var groups = this._groups, m = groups.length, sortgroups = Array(m), j = 0; j < m; ++j) {
for (var group = groups[j], n = group.length, sortgroup = sortgroups[j] = Array(n), node, i = 0; i < n; ++i) {
if (node = group[i]) {
sortgroup[i] = node;
}
}
sortgroup.sort(compareNode);
}
return new Selection(sortgroups, this._parents).order();
}
function ascending(a, b) {
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/call.js
/* harmony default export */ function call() {
var callback = arguments[0];
arguments[0] = this;
callback.apply(null, arguments);
return this;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/nodes.js
/* harmony default export */ function nodes() {
return Array.from(this);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/node.js
/* harmony default export */ function node() {
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
node = group[i];
if (node) return node;
}
}
return null;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/size.js
function _createForOfIteratorHelperLoose(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (it) return (it = it.call(o)).next.bind(it); if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; return function () { if (i >= o.length) return { done: !0 }; return { done: !1, value: o[i++] }; }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
/* harmony default export */ function size() {
var size = 0;
for (var _iterator = _createForOfIteratorHelperLoose(this), _step; !(_step = _iterator()).done;) {
_step.value;
++size;
} // eslint-disable-line no-unused-vars
return size;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/empty.js
/* harmony default export */ function selection_empty() {
return !this.node();
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/each.js
/* harmony default export */ function each(callback) {
for (var groups = this._groups, j = 0, m = groups.length; j < m; ++j) {
for (var group = groups[j], i = 0, n = group.length, node; i < n; ++i) {
if (node = group[i]) callback.call(node, node.__data__, i, group);
}
}
return this;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/namespaces.js
var xhtml = "http://www.w3.org/1999/xhtml";
/* harmony default export */ var namespaces = ({
svg: "http://www.w3.org/2000/svg",
xhtml: "http://www.w3.org/1999/xhtml",
xlink: "http://www.w3.org/1999/xlink",
xml: "http://www.w3.org/XML/1998/namespace",
xmlns: "http://www.w3.org/2000/xmlns/"
});
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/namespace.js
/* harmony default export */ function namespace(name) {
var prefix = name += "",
i = prefix.indexOf(":");
if (i >= 0 && (prefix = name.slice(0, i)) !== "xmlns") name = name.slice(i + 1);
return namespaces.hasOwnProperty(prefix) ? {
space: namespaces[prefix],
local: name
} : name; // eslint-disable-line no-prototype-builtins
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/attr.js
function attrRemove(name) {
return function () {
this.removeAttribute(name);
};
}
function attrRemoveNS(fullname) {
return function () {
this.removeAttributeNS(fullname.space, fullname.local);
};
}
function attrConstant(name, value) {
return function () {
this.setAttribute(name, value);
};
}
function attrConstantNS(fullname, value) {
return function () {
this.setAttributeNS(fullname.space, fullname.local, value);
};
}
function attrFunction(name, value) {
return function () {
var v = value.apply(this, arguments);
if (v == null) this.removeAttribute(name);else this.setAttribute(name, v);
};
}
function attrFunctionNS(fullname, value) {
return function () {
var v = value.apply(this, arguments);
if (v == null) this.removeAttributeNS(fullname.space, fullname.local);else this.setAttributeNS(fullname.space, fullname.local, v);
};
}
/* harmony default export */ function attr(name, value) {
var fullname = namespace(name);
if (arguments.length < 2) {
var node = this.node();
return fullname.local ? node.getAttributeNS(fullname.space, fullname.local) : node.getAttribute(fullname);
}
return this.each((value == null ? fullname.local ? attrRemoveNS : attrRemove : typeof value === "function" ? fullname.local ? attrFunctionNS : attrFunction : fullname.local ? attrConstantNS : attrConstant)(fullname, value));
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/window.js
/* harmony default export */ function src_window(node) {
return node.ownerDocument && node.ownerDocument.defaultView // node is a Node
|| node.document && node // node is a Window
|| node.defaultView; // node is a Document
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/style.js
function styleRemove(name) {
return function () {
this.style.removeProperty(name);
};
}
function styleConstant(name, value, priority) {
return function () {
this.style.setProperty(name, value, priority);
};
}
function styleFunction(name, value, priority) {
return function () {
var v = value.apply(this, arguments);
if (v == null) this.style.removeProperty(name);else this.style.setProperty(name, v, priority);
};
}
/* harmony default export */ function style(name, value, priority) {
return arguments.length > 1 ? this.each((value == null ? styleRemove : typeof value === "function" ? styleFunction : styleConstant)(name, value, priority == null ? "" : priority)) : styleValue(this.node(), name);
}
function styleValue(node, name) {
return node.style.getPropertyValue(name) || src_window(node).getComputedStyle(node, null).getPropertyValue(name);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/property.js
function propertyRemove(name) {
return function () {
delete this[name];
};
}
function propertyConstant(name, value) {
return function () {
this[name] = value;
};
}
function propertyFunction(name, value) {
return function () {
var v = value.apply(this, arguments);
if (v == null) delete this[name];else this[name] = v;
};
}
/* harmony default export */ function property(name, value) {
return arguments.length > 1 ? this.each((value == null ? propertyRemove : typeof value === "function" ? propertyFunction : propertyConstant)(name, value)) : this.node()[name];
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/classed.js
function classArray(string) {
return string.trim().split(/^|\s+/);
}
function classList(node) {
return node.classList || new ClassList(node);
}
function ClassList(node) {
this._node = node;
this._names = classArray(node.getAttribute("class") || "");
}
ClassList.prototype = {
add: function add(name) {
var i = this._names.indexOf(name);
if (i < 0) {
this._names.push(name);
this._node.setAttribute("class", this._names.join(" "));
}
},
remove: function remove(name) {
var i = this._names.indexOf(name);
if (i >= 0) {
this._names.splice(i, 1);
this._node.setAttribute("class", this._names.join(" "));
}
},
contains: function contains(name) {
return this._names.indexOf(name) >= 0;
}
};
function classedAdd(node, names) {
var list = classList(node),
i = -1,
n = names.length;
while (++i < n) {
list.add(names[i]);
}
}
function classedRemove(node, names) {
var list = classList(node),
i = -1,
n = names.length;
while (++i < n) {
list.remove(names[i]);
}
}
function classedTrue(names) {
return function () {
classedAdd(this, names);
};
}
function classedFalse(names) {
return function () {
classedRemove(this, names);
};
}
function classedFunction(names, value) {
return function () {
(value.apply(this, arguments) ? classedAdd : classedRemove)(this, names);
};
}
/* harmony default export */ function classed(name, value) {
var names = classArray(name + "");
if (arguments.length < 2) {
var list = classList(this.node()),
i = -1,
n = names.length;
while (++i < n) {
if (!list.contains(names[i])) return !1;
}
return !0;
}
return this.each((typeof value === "function" ? classedFunction : value ? classedTrue : classedFalse)(names, value));
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/text.js
function textRemove() {
this.textContent = "";
}
function textConstant(value) {
return function () {
this.textContent = value;
};
}
function textFunction(value) {
return function () {
var v = value.apply(this, arguments);
this.textContent = v == null ? "" : v;
};
}
/* harmony default export */ function selection_text(value) {
return arguments.length ? this.each(value == null ? textRemove : (typeof value === "function" ? textFunction : textConstant)(value)) : this.node().textContent;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/html.js
function htmlRemove() {
this.innerHTML = "";
}
function htmlConstant(value) {
return function () {
this.innerHTML = value;
};
}
function htmlFunction(value) {
return function () {
var v = value.apply(this, arguments);
this.innerHTML = v == null ? "" : v;
};
}
/* harmony default export */ function html(value) {
return arguments.length ? this.each(value == null ? htmlRemove : (typeof value === "function" ? htmlFunction : htmlConstant)(value)) : this.node().innerHTML;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/raise.js
function raise() {
if (this.nextSibling) this.parentNode.appendChild(this);
}
/* harmony default export */ function selection_raise() {
return this.each(raise);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/lower.js
function lower() {
if (this.previousSibling) this.parentNode.insertBefore(this, this.parentNode.firstChild);
}
/* harmony default export */ function selection_lower() {
return this.each(lower);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/creator.js
function creatorInherit(name) {
return function () {
var document = this.ownerDocument,
uri = this.namespaceURI;
return uri === xhtml && document.documentElement.namespaceURI === xhtml ? document.createElement(name) : document.createElementNS(uri, name);
};
}
function creatorFixed(fullname) {
return function () {
return this.ownerDocument.createElementNS(fullname.space, fullname.local);
};
}
/* harmony default export */ function creator(name) {
var fullname = namespace(name);
return (fullname.local ? creatorFixed : creatorInherit)(fullname);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/append.js
/* harmony default export */ function append(name) {
var create = typeof name === "function" ? name : creator(name);
return this.select(function () {
return this.appendChild(create.apply(this, arguments));
});
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/insert.js
function constantNull() {
return null;
}
/* harmony default export */ function insert(name, before) {
var create = typeof name === "function" ? name : creator(name),
select = before == null ? constantNull : typeof before === "function" ? before : selector(before);
return this.select(function () {
return this.insertBefore(create.apply(this, arguments), select.apply(this, arguments) || null);
});
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/remove.js
function remove() {
var parent = this.parentNode;
if (parent) parent.removeChild(this);
}
/* harmony default export */ function selection_remove() {
return this.each(remove);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/clone.js
function selection_cloneShallow() {
var clone = this.cloneNode(!1),
parent = this.parentNode;
return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
}
function selection_cloneDeep() {
var clone = this.cloneNode(!0),
parent = this.parentNode;
return parent ? parent.insertBefore(clone, this.nextSibling) : clone;
}
/* harmony default export */ function clone(deep) {
return this.select(deep ? selection_cloneDeep : selection_cloneShallow);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/datum.js
/* harmony default export */ function selection_datum(value) {
return arguments.length ? this.property("__data__", value) : this.node().__data__;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/on.js
function contextListener(listener) {
return function (event) {
listener.call(this, event, this.__data__);
};
}
function parseTypenames(typenames) {
return typenames.trim().split(/^|\s+/).map(function (t) {
var name = "",
i = t.indexOf(".");
if (i >= 0) name = t.slice(i + 1), t = t.slice(0, i);
return {
type: t,
name: name
};
});
}
function onRemove(typename) {
return function () {
var on = this.__on;
if (!on) return;
for (var j = 0, i = -1, m = on.length, o; j < m; ++j) {
if (o = on[j], (!typename.type || o.type === typename.type) && o.name === typename.name) {
this.removeEventListener(o.type, o.listener, o.options);
} else {
on[++i] = o;
}
}
if (++i) on.length = i;else delete this.__on;
};
}
function onAdd(typename, value, options) {
return function () {
var on = this.__on,
o,
listener = contextListener(value);
if (on) for (var j = 0, m = on.length; j < m; ++j) {
if ((o = on[j]).type === typename.type && o.name === typename.name) {
this.removeEventListener(o.type, o.listener, o.options);
this.addEventListener(o.type, o.listener = listener, o.options = options);
o.value = value;
return;
}
}
this.addEventListener(typename.type, listener, options);
o = {
type: typename.type,
name: typename.name,
value: value,
listener: listener,
options: options
};
if (!on) this.__on = [o];else on.push(o);
};
}
/* harmony default export */ function on(typename, value, options) {
var typenames = parseTypenames(typename + ""),
i,
n = typenames.length,
t;
if (arguments.length < 2) {
var on = this.node().__on;
if (on) for (var j = 0, m = on.length, o; j < m; ++j) {
for (i = 0, o = on[j]; i < n; ++i) {
if ((t = typenames[i]).type === o.type && t.name === o.name) {
return o.value;
}
}
}
return;
}
on = value ? onAdd : onRemove;
for (i = 0; i < n; ++i) {
this.each(on(typenames[i], value, options));
}
return this;
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/dispatch.js
function dispatchEvent(node, type, params) {
var window = src_window(node),
event = window.CustomEvent;
if (typeof event === "function") {
event = new event(type, params);
} else {
event = window.document.createEvent("Event");
if (params) event.initEvent(type, params.bubbles, params.cancelable), event.detail = params.detail;else event.initEvent(type, !1, !1);
}
node.dispatchEvent(event);
}
function dispatchConstant(type, params) {
return function () {
return dispatchEvent(this, type, params);
};
}
function dispatchFunction(type, params) {
return function () {
return dispatchEvent(this, type, params.apply(this, arguments));
};
}
/* harmony default export */ function dispatch(type, params) {
return this.each((typeof params === "function" ? dispatchFunction : dispatchConstant)(type, params));
}
// EXTERNAL MODULE: ./node_modules/@babel/runtime/regenerator/index.js
var regenerator = __webpack_require__(448);
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/iterator.js
var _marked = /*#__PURE__*/regenerator.mark(_callee);
function _callee() {
var groups, j, m, group, i, n, node;
return regenerator.wrap(function (_context) {
while (1) {
switch (_context.prev = _context.next) {
case 0:
groups = this._groups, j = 0, m = groups.length;
case 1:
if (!(j < m)) {
_context.next = 13;
break;
}
group = groups[j], i = 0, n = group.length;
case 3:
if (!(i < n)) {
_context.next = 10;
break;
}
if (!(node = group[i])) {
_context.next = 7;
break;
}
_context.next = 7;
return node;
case 7:
++i;
_context.next = 3;
break;
case 10:
++j;
_context.next = 1;
break;
case 13:
case "end":
return _context.stop();
}
}
}, _marked, this);
}
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/selection/index.js
var _selection$prototype;
var root = [null];
function Selection(groups, parents) {
this._groups = groups;
this._parents = parents;
}
function selection() {
return new Selection([[document.documentElement]], root);
}
function selection_selection() {
return this;
}
Selection.prototype = selection.prototype = (_selection$prototype = {
constructor: Selection,
select: selection_select,
selectAll: selectAll,
selectChild: selectChild,
selectChildren: selectChildren,
filter: selection_filter,
data: data,
enter: enter,
exit: exit,
join: join,
merge: merge,
selection: selection_selection,
order: order,
sort: sort,
call: call,
nodes: nodes,
node: node,
size: size,
empty: selection_empty,
each: each,
attr: attr,
style: style,
property: property,
classed: classed,
text: selection_text,
html: html,
raise: selection_raise,
lower: selection_lower,
append: append,
insert: insert,
remove: selection_remove,
clone: clone,
datum: selection_datum,
on: on,
dispatch: dispatch
}, _selection$prototype[Symbol.iterator] = _callee, _selection$prototype);
/* harmony default export */ var src_selection = (selection);
;// CONCATENATED MODULE: ./node_modules/d3-selection/src/select.js
/* harmony default export */ function src_select(selector) {
return typeof selector === "string" ? new Selection([[document.querySelector(selector)]], [document.documentElement]) : new Selection([[selector]], root);
}
;// CONCATENATED MODULE: ./src/Plugin/Plugin.ts
/**
* Copyright (c) 2017 ~ present NAVER Corp.
* billboard.js project is licensed under the MIT license
*/
/**
* Base class to generate billboard.js plugin
* @class Plugin
*/
/**
* Version info string for plugin
* @name version
* @static
* @memberof Plugin
* @type {string}
* @example
* bb.plugin.stanford.version; // ex) 1.9.0
*/
var Plugin = /*#__PURE__*/function () {
/**
* Constructor
* @param {Any} options config option object
* @private
*/
function Plugin(options) {
if (options === void 0) {
options = {};
}
this.$$ = void 0;
this.options = void 0;
this.options = options;
}
/**
* Lifecycle hook for 'beforeInit' phase.
* @private
*/
var _proto = Plugin.prototype;
_proto.$beforeInit = function $beforeInit() {}
/**
* Lifecycle hook for 'init' phase.
* @private
*/
;
_proto.$init = function $init() {}
/**
* Lifecycle hook for 'afterInit' phase.
* @private
*/
;
_proto.$afterInit = function $afterInit() {}
/**
* Lifecycle hook for 'redraw' phase.
* @private
*/
;
_proto.$redraw = function $redraw() {}
/**
* Lifecycle hook for 'willDestroy' phase.
* @private
*/
;
_proto.$willDestroy = function $willDestroy() {
var _this = this;
Object.keys(this).forEach(function (key) {
_this[key] = null;
delete _this[key];
});
};
return Plugin;
}();
Plugin.version = "3.3.1";
;// CONCATENATED MODULE: ./src/Plugin/bubblecompare/index.ts
/**
* Bubble compare diagram plugin.<br>
* Compare data 3-dimensional ways: x-axis, y-axis & bubble-size.
* - **NOTE:**
* - Plugins aren't built-in. Need to be loaded or imported to be used.
* - Non required modules from billboard.js core, need to be installed separately.
* - **Required modules:**
* - [d3-selection](https://github.com/d3/d3-selection)
* @class plugin-bubblecompare
* @requires d3-selection
* @param {object} options bubble compare plugin options
* @augments Plugin
* @returns {BubbleCompare}
* @example
* // Plugin must be loaded before the use.
* <script src="$YOUR_PATH/plugin/billboardjs-plugin-bubblecompare.js"></script>
*
* var chart = bb.generate({
* data: {
* columns: [ ... ],
* type: "bubble"
* }
* ...
* plugins: [
* new bb.plugin.bubblecompare({
* minR: 11,
* maxR: 74,
* expandScale: 1.1
* }),
* ]
* });
* @example
* import {bb} from "billboard.js";
* import BubbleCompare from "billboard.js/dist/billboardjs-plugin-bubblecompare";
*
* bb.generate({
* plugins: [
* new BubbleCompare({ ... })
* ]
* })
*/
var BubbleCompare = /*#__PURE__*/function (_Plugin) {
_inheritsLoose(BubbleCompare, _Plugin);
function BubbleCompare(options) {
var _this = _Plugin.call(this, options) || this;
_this.$$ = void 0;
return _assertThisInitialized(_this) || _assertThisInitialized(_this);
}
var _proto = BubbleCompare.prototype;
_proto.$init = function $init() {
var $$ = this.$$;
$$.findClosest = this.findClosest.bind(this);
$$.getBubbleR = this.getBubbleR.bind(this);
$$.pointExpandedR = this.pointExpandedR.bind(this);
};
_proto.pointExpandedR = function pointExpandedR(d) {
var baseR = this.getBubbleR(d),
_this$options$expandS = this.options.expandScale,
expandScale = _this$options$expandS === void 0 ? 1 : _this$options$expandS;
BubbleCompare.raiseFocusedBubbleLayer(d);
this.changeCursorPoint();
return baseR * expandScale;
};
BubbleCompare.raiseFocusedBubbleLayer = function raiseFocusedBubbleLayer(d) {
d.raise && src_select(d.node().parentNode.parentNode).raise();
};
_proto.changeCursorPoint = function changeCursorPoint() {
this.$$.$el.svg.select(".bb-event-rect").style("cursor", "pointer");
};
_proto.findClosest = function findClosest(values, pos) {
var _this2 = this,
$$ = this.$$;
return values.filter(function (v) {
return v && !$$.isBarType(v.id);
}).reduce(function (acc, cur) {
var d = $$.dist(cur, pos);
return d < _this2.getBubbleR(cur) ? cur : acc;
}, 0);
};
_proto.getBubbleR = function getBubbleR(d) {
var _this3 = this,
_this$options = this.options,
minR = _this$options.minR,
maxR = _this$options.maxR,
curVal = this.getZData(d);
if (!curVal) return minR;
var _this$$$$data$targets = this.$$.data.targets.reduce(function (_ref, cur) {
var accMin = _ref[0],
accMax = _ref[1],
val = _this3.getZData(cur.values[0]);
return [Math.min(accMin, val), Math.max(accMax, val)];
}, [1e4, 0]),
min = _this$$$$data$targets[0],
max = _this$$$$data$targets[1],
size = min > 0 && max === min ? 0 : curVal / max;
return Math.abs(size) * (maxR - minR) + minR;
};
_proto.getZData = function getZData(d) {
return this.$$.isBubbleZType(d) ? this.$$.getBubbleZData(d.value, "z") : d.value;
};
return BubbleCompare;
}(Plugin);
BubbleCompare.version = "0.0.1";
/***/ }),
/* 448 */
/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
module.exports = __webpack_require__(449);
/***/ }),
/* 449 */
/***/ (function(module) {
/**
* Copyright (c) 2014-present, Facebook, Inc.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
var runtime = (function (exports) {
"use strict";
var Op = Object.prototype;
var hasOwn = Op.hasOwnProperty;
var undefined; // More compressible than void 0.
var $Symbol = typeof Symbol === "function" ? Symbol : {};
var iteratorSymbol = $Symbol.iterator || "@@iterator";
var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
function define(obj, key, value) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
return obj[key];
}
try {
// IE 8 has a broken Object.defineProperty that only works on DOM objects.
define({}, "");
} catch (err) {
define = function(obj, key, value) {
return obj[key] = value;
};
}
function wrap(innerFn, outerFn, self, tryLocsList) {
// If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.
var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
var generator = Object.create(protoGenerator.prototype);
var context = new Context(tryLocsList || []);
// The ._invoke method unifies the implementations of the .next,
// .throw, and .return methods.
generator._invoke = makeInvokeMethod(innerFn, self, context);
return generator;
}
exports.wrap = wrap;
// Try/catch helper to minimize deoptimizations. Returns a completion
// record like context.tryEntries[i].completion. This interface could
// have been (and was previously) designed to take a closure to be
// invoked without arguments, but in all the cases we care about we
// already have an existing method we want to call, so there's no need
// to create a new function object. We can even get away with assuming
// the method takes exactly one argument, since that happens to be true
// in every case, so we don't have to touch the arguments object. The
// only additional allocation required is the completion record, which
// has a stable shape and so hopefully should be cheap to allocate.
function tryCatch(fn, obj, arg) {
try {
return { type: "normal", arg: fn.call(obj, arg) };
} catch (err) {
return { type: "throw", arg: err };
}
}
var GenStateSuspendedStart = "suspendedStart";
var GenStateSuspendedYield = "suspendedYield";
var GenStateExecuting = "executing";
var GenStateCompleted = "completed";
// Returning this object from the innerFn has the same effect as
// breaking out of the dispatch switch statement.
var ContinueSentinel = {};
// Dummy constructor functions that we use as the .constructor and
// .constructor.prototype properties for functions that return Generator
// objects. For full spec compliance, you may wish to configure your
// minifier not to mangle the names of these two functions.
function Generator() {}
function GeneratorFunction() {}
function GeneratorFunctionPrototype() {}
// This is a polyfill for %IteratorPrototype% for environments that
// don't natively support it.
var IteratorPrototype = {};
define(IteratorPrototype, iteratorSymbol, function () {
return this;
});
var getProto = Object.getPrototypeOf;
var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
if (NativeIteratorPrototype &&
NativeIteratorPrototype !== Op &&
hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
// This environment has a native %IteratorPrototype%; use it instead
// of the polyfill.
IteratorPrototype = NativeIteratorPrototype;
}
var Gp = GeneratorFunctionPrototype.prototype =
Generator.prototype = Object.create(IteratorPrototype);
GeneratorFunction.prototype = GeneratorFunctionPrototype;
define(Gp, "constructor", GeneratorFunctionPrototype);
define(GeneratorFunctionPrototype, "constructor", GeneratorFunction);
GeneratorFunction.displayName = define(
GeneratorFunctionPrototype,
toStringTagSymbol,
"GeneratorFunction"
);
// Helper for defining the .next, .throw, and .return methods of the
// Iterator interface in terms of a single ._invoke method.
function defineIteratorMethods(prototype) {
["next", "throw", "return"].forEach(function(method) {
define(prototype, method, function(arg) {
return this._invoke(method, arg);
});
});
}
exports.isGeneratorFunction = function(genFun) {
var ctor = typeof genFun === "function" && genFun.constructor;
return ctor
? ctor === GeneratorFunction ||
// For the native GeneratorFunction constructor, the best we can
// do is to check its .name property.
(ctor.displayName || ctor.name) === "GeneratorFunction"
: false;
};
exports.mark = function(genFun) {
if (Object.setPrototypeOf) {
Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
} else {
genFun.__proto__ = GeneratorFunctionPrototype;
define(genFun, toStringTagSymbol, "GeneratorFunction");
}
genFun.prototype = Object.create(Gp);
return genFun;
};
// Within the body of any async function, `await x` is transformed to
// `yield regeneratorRuntime.awrap(x)`, so that the runtime can test
// `hasOwn.call(value, "__await")` to determine if the yielded value is
// meant to be awaited.
exports.awrap = function(arg) {
return { __await: arg };
};
function AsyncIterator(generator, PromiseImpl) {
function invoke(method, arg, resolve, reject) {
var record = tryCatch(generator[method], generator, arg);
if (record.type === "throw") {
reject(record.arg);
} else {
var result = record.arg;
var value = result.value;
if (value &&
typeof value === "object" &&
hasOwn.call(value, "__await")) {
return PromiseImpl.resolve(value.__await).then(function(value) {
invoke("next", value, resolve, reject);
}, function(err) {
invoke("throw", err, resolve, reject);
});
}
return PromiseImpl.resolve(value).then(function(unwrapped) {
// When a yielded Promise is resolved, its final value becomes
// the .value of the Promise<{value,done}> result for the
// current iteration.
result.value = unwrapped;
resolve(result);
}, function(error) {
// If a rejected Promise was yielded, throw the rejection back
// into the async generator function so it can be handled there.
return invoke("throw", error, resolve, reject);
});
}
}
var previousPromise;
function enqueue(method, arg) {
function callInvokeWithMethodAndArg() {
return new PromiseImpl(function(resolve, reject) {
invoke(method, arg, resolve, reject);
});
}
return previousPromise =
// If enqueue has been called before, then we want to wait until
// all previous Promises have been resolved before calling invoke,
// so that results are always delivered in the correct order. If
// enqueue has not been called before, then it is important to
// call invoke immediately, without waiting on a callback to fire,
// so that the async generator function has the opportunity to do
// any necessary setup in a predictable way. This predictability
// is why the Promise constructor synchronously invokes its
// executor callback, and why async functions synchronously
// execute code before the first await. Since we implement simple
// async functions in terms of async generators, it is especially
// important to get this right, even though it requires care.
previousPromise ? previousPromise.then(
callInvokeWithMethodAndArg,
// Avoid propagating failures to Promises returned by later
// invocations of the iterator.
callInvokeWithMethodAndArg
) : callInvokeWithMethodAndArg();
}
// Define the unified helper method that is used to implement .next,
// .throw, and .return (see defineIteratorMethods).
this._invoke = enqueue;
}
defineIteratorMethods(AsyncIterator.prototype);
define(AsyncIterator.prototype, asyncIteratorSymbol, function () {
return this;
});
exports.AsyncIterator = AsyncIterator;
// Note that simple async functions are implemented on top of
// AsyncIterator objects; they just return a Promise for the value of
// the final result produced by the iterator.
exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {
if (PromiseImpl === void 0) PromiseImpl = Promise;
var iter = new AsyncIterator(
wrap(innerFn, outerFn, self, tryLocsList),
PromiseImpl
);
return exports.isGeneratorFunction(outerFn)
? iter // If outerFn is a generator, return the full iterator.
: iter.next().then(function(result) {
return result.done ? result.value : iter.next();
});
};
function makeInvokeMethod(innerFn, self, context) {
var state = GenStateSuspendedStart;
return function invoke(method, arg) {
if (state === GenStateExecuting) {
throw new Error("Generator is already running");
}
if (state === GenStateCompleted) {
if (method === "throw") {
throw arg;
}
// Be forgiving, per 25.3.3.3.3 of the spec:
// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume
return doneResult();
}
context.method = method;
context.arg = arg;
while (true) {
var delegate = context.delegate;
if (delegate) {
var delegateResult = maybeInvokeDelegate(delegate, context);
if (delegateResult) {
if (delegateResult === ContinueSentinel) continue;
return delegateResult;
}
}
if (context.method === "next") {
// Setting context._sent for legacy support of Babel's
// function.sent implementation.
context.sent = context._sent = context.arg;
} else if (context.method === "throw") {
if (state === GenStateSuspendedStart) {
state = GenStateCompleted;
throw context.arg;
}
context.dispatchException(context.arg);
} else if (context.method === "return") {
context.abrupt("return", context.arg);
}
state = GenStateExecuting;
var record = tryCatch(innerFn, self, context);
if (record.type === "normal") {
// If an exception is thrown from innerFn, we leave state ===
// GenStateExecuting and loop back for another invocation.
state = context.done
? GenStateCompleted
: GenStateSuspendedYield;
if (record.arg === ContinueSentinel) {
continue;
}
return {
value: record.arg,
done: context.done
};
} else if (record.type === "throw") {
state = GenStateCompleted;
// Dispatch the exception by looping back around to the
// context.dispatchException(context.arg) call above.
context.method = "throw";
context.arg = record.arg;
}
}
};
}
// Call delegate.iterator[context.method](context.arg) and handle the
// result, either by returning a { value, done } result from the
// delegate iterator, or by modifying context.method and context.arg,
// setting context.delegate to null, and returning the ContinueSentinel.
function maybeInvokeDelegate(delegate, context) {
var method = delegate.iterator[context.method];
if (method === undefined) {
// A .throw or .return when the delegate iterator has no .throw
// method always terminates the yield* loop.
context.delegate = null;
if (context.method === "throw") {
// Note: ["return"] must be used for ES3 parsing compatibility.
if (delegate.iterator["return"]) {
// If the delegate iterator has a return method, give it a
// chance to clean up.
context.method = "return";
context.arg = undefined;
maybeInvokeDelegate(delegate, context);
if (context.method === "throw") {
// If maybeInvokeDelegate(context) changed context.method from
// "return" to "throw", let that override the TypeError below.
return ContinueSentinel;
}
}
context.method = "throw";
context.arg = new TypeError(
"The iterator does not provide a 'throw' method");
}
return ContinueSentinel;
}
var record = tryCatch(method, delegate.iterator, context.arg);
if (record.type === "throw") {
context.method = "throw";
context.arg = record.arg;
context.delegate = null;
return ContinueSentinel;
}
var info = record.arg;
if (! info) {
context.method = "throw";
context.arg = new TypeError("iterator result is not an object");
context.delegate = null;
return ContinueSentinel;
}
if (info.done) {
// Assign the result of the finished delegate to the temporary
// variable specified by delegate.resultName (see delegateYield).
context[delegate.resultName] = info.value;
// Resume execution at the desired location (see delegateYield).
context.next = delegate.nextLoc;
// If context.method was "throw" but the delegate handled the
// exception, let the outer generator proceed normally. If
// context.method was "next", forget context.arg since it has been
// "consumed" by the delegate iterator. If context.method was
// "return", allow the original .return call to continue in the
// outer generator.
if (context.method !== "return") {
context.method = "next";
context.arg = undefined;
}
} else {
// Re-yield the result returned by the delegate method.
return info;
}
// The delegate iterator is finished, so forget it and continue with
// the outer generator.
context.delegate = null;
return ContinueSentinel;
}
// Define Generator.prototype.{next,throw,return} in terms of the
// unified ._invoke helper method.
defineIteratorMethods(Gp);
define(Gp, toStringTagSymbol, "Generator");
// A Generator should always return itself as the iterator object when the
// @@iterator function is called on it. Some browsers' implementations of the
// iterator prototype chain incorrectly implement this, causing the Generator
// object to not be returned from this call. This ensures that doesn't happen.
// See https://github.com/facebook/regenerator/issues/274 for more details.
define(Gp, iteratorSymbol, function() {
return this;
});
define(Gp, "toString", function() {
return "[object Generator]";
});
function pushTryEntry(locs) {
var entry = { tryLoc: locs[0] };
if (1 in locs) {
entry.catchLoc = locs[1];
}
if (2 in locs) {
entry.finallyLoc = locs[2];
entry.afterLoc = locs[3];
}
this.tryEntries.push(entry);
}
function resetTryEntry(entry) {
var record = entry.completion || {};
record.type = "normal";
delete record.arg;
entry.completion = record;
}
function Context(tryLocsList) {
// The root entry object (effectively a try statement without a catch
// or a finally block) gives us a place to store values thrown from
// locations where there is no enclosing try statement.
this.tryEntries = [{ tryLoc: "root" }];
tryLocsList.forEach(pushTryEntry, this);
this.reset(true);
}
exports.keys = function(object) {
var keys = [];
for (var key in object) {
keys.push(key);
}
keys.reverse();
// Rather than returning an object with a next method, we keep
// things simple and return the next function itself.
return function next() {
while (keys.length) {
var key = keys.pop();
if (key in object) {
next.value = key;
next.done = false;
return next;
}
}
// To avoid creating an additional object, we just hang the .value
// and .done properties off the next function object itself. This
// also ensures that the minifier will not anonymize the function.
next.done = true;
return next;
};
};
function values(iterable) {
if (iterable) {
var iteratorMethod = iterable[iteratorSymbol];
if (iteratorMethod) {
return iteratorMethod.call(iterable);
}
if (typeof iterable.next === "function") {
return iterable;
}
if (!isNaN(iterable.length)) {
var i = -1, next = function next() {
while (++i < iterable.length) {
if (hasOwn.call(iterable, i)) {
next.value = iterable[i];
next.done = false;
return next;
}
}
next.value = undefined;
next.done = true;
return next;
};
return next.next = next;
}
}
// Return an iterator with no values.
return { next: doneResult };
}
exports.values = values;
function doneResult() {
return { value: undefined, done: true };
}
Context.prototype = {
constructor: Context,
reset: function(skipTempReset) {
this.prev = 0;
this.next = 0;
// Resetting context._sent for legacy support of Babel's
// function.sent implementation.
this.sent = this._sent = undefined;
this.done = false;
this.delegate = null;
this.method = "next";
this.arg = undefined;
this.tryEntries.forEach(resetTryEntry);
if (!skipTempReset) {
for (var name in this) {
// Not sure about the optimal order of these conditions:
if (name.charAt(0) === "t" &&
hasOwn.call(this, name) &&
!isNaN(+name.slice(1))) {
this[name] = undefined;
}
}
}
},
stop: function() {
this.done = true;
var rootEntry = this.tryEntries[0];
var rootRecord = rootEntry.completion;
if (rootRecord.type === "throw") {
throw rootRecord.arg;
}
return this.rval;
},
dispatchException: function(exception) {
if (this.done) {
throw exception;
}
var context = this;
function handle(loc, caught) {
record.type = "throw";
record.arg = exception;
context.next = loc;
if (caught) {
// If the dispatched exception was caught by a catch block,
// then let that catch block handle the exception normally.
context.method = "next";
context.arg = undefined;
}
return !! caught;
}
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
var record = entry.completion;
if (entry.tryLoc === "root") {
// Exception thrown outside of any try block that could handle
// it, so set the completion value of the entire function to
// throw the exception.
return handle("end");
}
if (entry.tryLoc <= this.prev) {
var hasCatch = hasOwn.call(entry, "catchLoc");
var hasFinally = hasOwn.call(entry, "finallyLoc");
if (hasCatch && hasFinally) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
} else if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else if (hasCatch) {
if (this.prev < entry.catchLoc) {
return handle(entry.catchLoc, true);
}
} else if (hasFinally) {
if (this.prev < entry.finallyLoc) {
return handle(entry.finallyLoc);
}
} else {
throw new Error("try statement without catch or finally");
}
}
}
},
abrupt: function(type, arg) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc <= this.prev &&
hasOwn.call(entry, "finallyLoc") &&
this.prev < entry.finallyLoc) {
var finallyEntry = entry;
break;
}
}
if (finallyEntry &&
(type === "break" ||
type === "continue") &&
finallyEntry.tryLoc <= arg &&
arg <= finallyEntry.finallyLoc) {
// Ignore the finally entry if control is not jumping to a
// location outside the try/catch block.
finallyEntry = null;
}
var record = finallyEntry ? finallyEntry.completion : {};
record.type = type;
record.arg = arg;
if (finallyEntry) {
this.method = "next";
this.next = finallyEntry.finallyLoc;
return ContinueSentinel;
}
return this.complete(record);
},
complete: function(record, afterLoc) {
if (record.type === "throw") {
throw record.arg;
}
if (record.type === "break" ||
record.type === "continue") {
this.next = record.arg;
} else if (record.type === "return") {
this.rval = this.arg = record.arg;
this.method = "return";
this.next = "end";
} else if (record.type === "normal" && afterLoc) {
this.next = afterLoc;
}
return ContinueSentinel;
},
finish: function(finallyLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.finallyLoc === finallyLoc) {
this.complete(entry.completion, entry.afterLoc);
resetTryEntry(entry);
return ContinueSentinel;
}
}
},
"catch": function(tryLoc) {
for (var i = this.tryEntries.length - 1; i >= 0; --i) {
var entry = this.tryEntries[i];
if (entry.tryLoc === tryLoc) {
var record = entry.completion;
if (record.type === "throw") {
var thrown = record.arg;
resetTryEntry(entry);
}
return thrown;
}
}
// The context.catch method must only be called with a location
// argument that corresponds to a known catch block.
throw new Error("illegal catch attempt");
},
delegateYield: function(iterable, resultName, nextLoc) {
this.delegate = {
iterator: values(iterable),
resultName: resultName,
nextLoc: nextLoc
};
if (this.method === "next") {
// Deliberately forget the last sent value so that we don't
// accidentally pass it on to the delegate.
this.arg = undefined;
}
return ContinueSentinel;
}
};
// Regardless of whether this script is executing as a CommonJS module
// or not, return the runtime object so that we can declare the variable
// regeneratorRuntime in the outer scope, which allows this module to be
// injected easily by `bin/regenerator --include-runtime script.js`.
return exports;
}(
// If this script is executing as a CommonJS module, use module.exports
// as the regeneratorRuntime namespace. Otherwise create a new empty
// object. Either way, the resulting object will be used to initialize
// the regeneratorRuntime variable at the top of this file.
true ? module.exports : 0
));
try {
regeneratorRuntime = runtime;
} catch (accidentalStrictMode) {
// This module should not be running in strict mode, so the above
// assignment should always work unless something is misconfigured. Just
// in case runtime.js accidentally runs in strict mode, in modern engines
// we can explicitly access globalThis. In older engines we can escape
// strict mode using a global Function call. This could conceivably fail
// if a Content Security Policy forbids using Function, but in that case
// the proper solution is to fix the accidental strict mode problem. If
// you've misconfigured your bundler to force strict mode and applied a
// CSP to forbid Function, and you're not willing to fix either of those
// problems, please detail your unique predicament in a GitHub issue.
if (typeof globalThis === "object") {
globalThis.regeneratorRuntime = runtime;
} else {
Function("r", "regeneratorRuntime = r")(runtime);
}
}
/***/ })
/******/ ]);
/************************************************************************/
/******/ // The module cache
/******/ var __webpack_module_cache__ = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ var cachedModule = __webpack_module_cache__[moduleId];
/******/ if (cachedModule !== undefined) {
/******/ return cachedModule.exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = __webpack_module_cache__[moduleId] = {
/******/ // no module.id needed
/******/ // no module.loaded needed
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/************************************************************************/
/******/ /* webpack/runtime/define property getters */
/******/ !function() {
/******/ // define getter functions for harmony exports
/******/ __webpack_require__.d = function(exports, definition) {
/******/ for(var key in definition) {
/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ }
/******/ }
/******/ };
/******/ }();
/******/
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ !function() {
/******/ __webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
/******/ }();
/******/
/************************************************************************/
/******/
/******/ // startup
/******/ // Load entry module and return exports
/******/ // This entry module used 'module' so it can't be inlined
/******/ __webpack_require__(0);
/******/ var __webpack_exports__ = __webpack_require__(447);
/******/ __webpack_exports__ = __webpack_exports__["default"];
/******/
/******/ return __webpack_exports__;
/******/ })()
;
}); |
'use strict';
var cli = require('./cli');
var assert = require('assert');
describe('test', function() {
this.timeout(10000);
describe('test valid data', function() {
it('should pass if expected result is valid', function (done) {
cli('test -s test/schema.json -d test/valid_data.json --valid', function (error, stdout, stderr) {
assert.strictEqual(error, null);
assertNoErrors(stdout, 1, /\spassed/);
assert.equal(stderr, '');
done();
});
});
it('should pass multiple files if expected result is valid', function (done) {
cli('test -s test/schema.json -d "test/valid*.json" --valid', function (error, stdout, stderr) {
assert.strictEqual(error, null);
assertNoErrors(stdout, 2, /\spassed/);
assert.equal(stderr, '');
done();
});
});
it('should fail if expected result is invalid', function (done) {
cli('test -s test/schema.json -d test/valid_data.json --invalid', function (error, stdout, stderr) {
assert(error instanceof Error);
assertNoErrors(stderr, 1, /\sfailed/);
assert.equal(stdout, '');
done();
});
});
it('should fail multiple files if expected result is invalid', function (done) {
cli('test -s test/schema.json -d "test/valid*.json" --invalid', function (error, stdout, stderr) {
assert(error instanceof Error);
assertNoErrors(stderr, 2, /\sfailed/);
assert.equal(stdout, '');
done();
});
});
});
describe('test invalid data', function() {
it('should pass if expected result is invalid', function (done) {
cli('test -s test/schema.json -d test/invalid_data.json --invalid --errors=line', function (error, stdout, stderr) {
assert.strictEqual(error, null);
assertRequiredErrors(stdout, 1, /\spassed/);
assert.equal(stderr, '');
done();
});
});
it('should pass if expected result is invalid (valid=false)', function (done) {
cli('test -s test/schema.json -d test/invalid_data.json --valid=false --errors=line', function (error, stdout, stderr) {
assert.strictEqual(error, null);
assertRequiredErrors(stdout, 1, /\spassed/);
assert.equal(stderr, '');
done();
});
});
it('should pass multiple files if expected result is invalid', function (done) {
cli('test -s test/schema.json -d "test/invalid*.json" --invalid --errors=line', function (error, stdout, stderr) {
assert.strictEqual(error, null);
assertRequiredErrors(stdout, 2, /\spassed/);
assert.equal(stderr, '');
done();
});
});
it('should fail if expected result is valid', function (done) {
cli('test -s test/schema.json -d test/invalid_data.json --valid --errors=line', function (error, stdout, stderr) {
assert(error instanceof Error);
assertRequiredErrors(stderr, 1, /\sfailed/);
assert.equal(stdout, '');
done();
});
});
it('should fail multiple files if expected result is valid', function (done) {
cli('test -s test/schema.json -d "test/invalid*.json" --valid --errors=line', function (error, stdout, stderr) {
assert(error instanceof Error);
assertRequiredErrors(stderr, 2, /\sfailed/);
assert.equal(stdout, '');
done();
});
});
});
describe('test valid and invalid data', function() {
it('should pass valid, fail invalid and return error if expected result is valid', function (done) {
cli('test -s test/schema.json -d test/valid_data.json -d test/invalid_data.json --valid --errors=line', function (error, stdout, stderr) {
assert(error instanceof Error);
assertNoErrors(stdout, 1, /\spassed/);
assertRequiredErrors(stderr, 1, /\sfailed/);
done();
});
});
it('should fail valid, pass invalid and return error if expected result is invalid', function (done) {
cli('test -s test/schema.json -d test/valid_data.json -d test/invalid_data.json --invalid --errors=line', function (error, stdout, stderr) {
assert(error instanceof Error);
assertNoErrors(stderr, 1, /\sfailed/);
assertRequiredErrors(stdout, 1, /\spassed/);
done();
});
});
});
});
function assertNoErrors(out, count, regexp) {
var lines = out.split('\n');
assert.equal(lines.length, count + 1);
for (var i=0; i<count; i++)
assert(regexp.test(lines[i]));
}
function assertErrors(out, count, regexp) {
var lines = out.split('\n');
assert.equal(lines.length, count*2 + 1);
var results = [];
for (var i=0; i<count; i+=2) {
assert(regexp.test(lines[i]));
results.push(JSON.parse(lines[i+1]));
}
return results;
}
function assertRequiredErrors(out, count, regexp, schemaRef) {
schemaRef = schemaRef || '#';
var results = assertErrors(out, count, regexp);
results.forEach(function (errors) {
var err = errors[0];
assert.equal(err.keyword, 'required');
assert.equal(err.dataPath, '[0].dimensions');
assert.equal(err.schemaPath, schemaRef + '/items/properties/dimensions/required');
assert.deepEqual(err.params, { missingProperty: 'height' });
});
}
|
var logger = require("../logger");
/*
* GET home page.
*/
exports.index = function(req, res){
logger.logRequest(req);
res.render('recordings', { title: 'CamPi.js' });
}; |
import expect from 'expect'
import { toPaths } from '../../src/utils/toPaths'
import { Model } from 'falcor'
const $ref = Model.ref
const $atom = Model.atom
const $error = Model.error
describe('Utils', () => {
describe('toPaths', () => {
it('should throw if not plain object was provided', () => {
let input = null
expect(() => toPaths(input)).
toThrow('Please provide a plain object to `toPaths`')
input = [1, 2, 3]
expect(() => toPaths(input)).
toThrow('Please provide a plain object to `toPaths`')
})
it('should return paths given a tree', () => {
const input = {
a1: {
b1: {
c1: {
d1: null,
d2: 'd2'
},
c2: {
d3: 'd3'
}
},
b2: {
c3: null
}
},
a2: {
b3: {
0: {
c4: 'c4'
},
1: {
c4: null
},
2: {
c4: 'c4'
}
}
},
a3: null
}
const output = [
['a3'],
['a1', 'b2', 'c3'],
['a1', 'b1', 'c1', ['d1', 'd2']],
['a1', 'b1', 'c2', 'd3'],
['a2', 'b3', { from: 0, to: 2 }, 'c4']
]
expect(toPaths(input)).toEqual(output)
})
it('should take into account JsonGraph primitives', () => {
const input = {
a1: {
b1: {
c1: {
d1: null,
d2: $ref(['c2', 'b3', 0])
},
c2: {
d3: 'd3'
}
},
b2: {
c3: $atom(['I', 'am', 'atom'])
}
},
a2: {
b3: {
0: {
c4: 'c4'
},
1: {
c4: $error('I am error')
},
2: {
c4: 'c4'
}
}
},
a3: null
}
const output = [
['a3'],
['a1', 'b2', 'c3'],
['a1', 'b1', 'c1', ['d1', 'd2']],
['a1', 'b1', 'c2', 'd3'],
['a2', 'b3', { from: 0, to: 2 }, 'c4']
]
expect(toPaths(input, true)).toEqual(output)
})
})
})
|
require('./support');
var loopback = require('../');
var User;
var AccessToken;
var MailConnector = require('../lib/connectors/mail');
var userMemory = loopback.createDataSource({
connector: 'memory'
});
describe('User', function() {
var validCredentialsEmail = 'foo@bar.com';
var validCredentials = {email: validCredentialsEmail, password: 'bar'};
var validCredentialsEmailVerified = {email: 'foo1@bar.com', password: 'bar1', emailVerified: true};
var validCredentialsEmailVerifiedOverREST = {email: 'foo2@bar.com', password: 'bar2', emailVerified: true};
var validCredentialsWithTTL = {email: 'foo@bar.com', password: 'bar', ttl: 3600};
var validCredentialsWithTTLAndScope = {email: 'foo@bar.com', password: 'bar', ttl: 3600, scope: 'all'};
var invalidCredentials = {email: 'foo1@bar.com', password: 'invalid'};
var incompleteCredentials = {password: 'bar1'};
var defaultApp;
beforeEach(function() {
// FIXME: [rfeng] Remove loopback.User.app so that remote hooks don't go
// to the wrong app instance
defaultApp = loopback.User.app;
loopback.User.app = null;
User = loopback.User.extend('TestUser', {}, {http: {path: 'test-users'}});
AccessToken = loopback.AccessToken.extend('TestAccessToken');
User.email = loopback.Email.extend('email');
loopback.autoAttach();
// Update the AccessToken relation to use the subclass of User
AccessToken.belongsTo(User, {as: 'user', foreignKey: 'userId'});
User.hasMany(AccessToken, {as: 'accessTokens', foreignKey: 'userId'});
// allow many User.afterRemote's to be called
User.setMaxListeners(0);
});
beforeEach(function(done) {
app.enableAuth();
app.use(loopback.token({model: AccessToken}));
app.use(loopback.rest());
app.model(User);
User.create(validCredentials, function(err, user) {
User.create(validCredentialsEmailVerified, done);
});
});
afterEach(function(done) {
loopback.User.app = defaultApp;
User.destroyAll(function(err) {
User.accessToken.destroyAll(done);
});
});
describe('User.create', function() {
it('Create a new user', function(done) {
User.create({email: 'f@b.com', password: 'bar'}, function(err, user) {
assert(!err);
assert(user.id);
assert(user.email);
done();
});
});
it('credentials/challenges are object types', function(done) {
User.create({email: 'f1@b.com', password: 'bar1',
credentials: {cert: 'xxxxx', key: '111'},
challenges: {x: 'X', a: 1}
}, function(err, user) {
assert(!err);
User.findById(user.id, function(err, user) {
assert(user.id);
assert(user.email);
assert.deepEqual(user.credentials, {cert: 'xxxxx', key: '111'});
assert.deepEqual(user.challenges, {x: 'X', a: 1});
done();
});
});
});
it('Email is required', function(done) {
User.create({password: '123'}, function(err) {
assert(err);
assert.equal(err.name, 'ValidationError');
assert.equal(err.statusCode, 422);
assert.equal(err.details.context, User.modelName);
assert.deepEqual(err.details.codes.email, [
'presence',
'format.null'
]);
done();
});
});
// will change in future versions where password will be optional by default
it('Password is required', function(done) {
var u = new User({email: '123@456.com'});
User.create({email: 'c@d.com'}, function(err) {
assert(err);
done();
});
});
it('Requires a valid email', function(done) {
User.create({email: 'foo@', password: '123'}, function(err) {
assert(err);
done();
});
});
it('Requires a unique email', function(done) {
User.create({email: 'a@b.com', password: 'foobar'}, function() {
User.create({email: 'a@b.com', password: 'batbaz'}, function(err) {
assert(err, 'should error because the email is not unique!');
done();
});
});
});
it('Requires a unique username', function(done) {
User.create({email: 'a@b.com', username: 'abc', password: 'foobar'}, function() {
User.create({email: 'b@b.com', username: 'abc', password: 'batbaz'}, function(err) {
assert(err, 'should error because the username is not unique!');
done();
});
});
});
it('Requires a password to login with basic auth', function(done) {
User.create({email: 'b@c.com'}, function(err) {
User.login({email: 'b@c.com'}, function(err, accessToken) {
assert(!accessToken, 'should not create a accessToken without a valid password');
assert(err, 'should not login without a password');
assert.equal(err.code, 'LOGIN_FAILED');
done();
});
});
});
it('Hashes the given password', function() {
var u = new User({username: 'foo', password: 'bar'});
assert(u.password !== 'bar');
});
it('does not hash the password if it\'s already hashed', function() {
var u1 = new User({username: 'foo', password: 'bar'});
assert(u1.password !== 'bar');
var u2 = new User({username: 'foo', password: u1.password});
assert(u2.password === u1.password);
});
describe('custom password hash', function() {
var defaultHashPassword;
var defaultValidatePassword;
beforeEach(function() {
defaultHashPassword = User.hashPassword;
defaultValidatePassword = User.validatePassword;
User.hashPassword = function(plain) {
return plain.toUpperCase();
};
User.validatePassword = function(plain) {
if (!plain || plain.length < 3) {
throw new Error('Password must have at least 3 chars');
}
return true;
};
});
afterEach(function() {
User.hashPassword = defaultHashPassword;
User.validatePassword = defaultValidatePassword;
});
it('Reports invalid password', function() {
try {
var u = new User({username: 'foo', password: 'aa'});
assert(false, 'Error should have been thrown');
} catch (e) {
// Ignore
}
});
it('Hashes the given password', function() {
var u = new User({username: 'foo', password: 'bar'});
assert(u.password === 'BAR');
});
});
it('Create a user over REST should remove emailVerified property', function(done) {
request(app)
.post('/test-users')
.expect('Content-Type', /json/)
.expect(200)
.send(validCredentialsEmailVerifiedOverREST)
.end(function(err, res) {
if (err) {
return done(err);
}
assert(!res.body.emailVerified);
done();
});
});
});
describe('User.login', function() {
it('Login a user by providing credentials', function(done) {
User.login(validCredentials, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.id.length, 64);
done();
});
});
it('Login a user by providing credentials with TTL', function(done) {
User.login(validCredentialsWithTTL, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.ttl, validCredentialsWithTTL.ttl);
assert.equal(accessToken.id.length, 64);
done();
});
});
it('honors default `createAccessToken` implementation', function(done) {
User.login(validCredentialsWithTTL, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
User.findById(accessToken.userId, function(err, user) {
user.createAccessToken(120, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.ttl, 120);
assert.equal(accessToken.id.length, 64);
done();
});
});
});
});
it('honors default `createAccessToken` implementation - promise variant', function(done) {
User.login(validCredentialsWithTTL, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
User.findById(accessToken.userId, function(err, user) {
user.createAccessToken(120)
.then(function(accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.ttl, 120);
assert.equal(accessToken.id.length, 64);
done();
})
.catch(function(err) {
done(err);
});
});
});
});
it('Login a user using a custom createAccessToken', function(done) {
var createToken = User.prototype.createAccessToken; // Save the original method
// Override createAccessToken
User.prototype.createAccessToken = function(ttl, cb) {
// Reduce the ttl by half for testing purpose
this.accessTokens.create({ttl: ttl / 2 }, cb);
};
User.login(validCredentialsWithTTL, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.ttl, 1800);
assert.equal(accessToken.id.length, 64);
User.findById(accessToken.userId, function(err, user) {
user.createAccessToken(120, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.ttl, 60);
assert.equal(accessToken.id.length, 64);
// Restore create access token
User.prototype.createAccessToken = createToken;
done();
});
});
});
});
it('Login a user using a custom createAccessToken with options',
function(done) {
var createToken = User.prototype.createAccessToken; // Save the original method
// Override createAccessToken
User.prototype.createAccessToken = function(ttl, options, cb) {
// Reduce the ttl by half for testing purpose
this.accessTokens.create({ttl: ttl / 2, scopes: options.scope}, cb);
};
User.login(validCredentialsWithTTLAndScope, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.ttl, 1800);
assert.equal(accessToken.id.length, 64);
assert.equal(accessToken.scopes, 'all');
User.findById(accessToken.userId, function(err, user) {
user.createAccessToken(120, {scope: 'default'}, function(err, accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.ttl, 60);
assert.equal(accessToken.id.length, 64);
assert.equal(accessToken.scopes, 'default');
// Restore create access token
User.prototype.createAccessToken = createToken;
done();
});
});
});
});
it('Login should only allow correct credentials', function(done) {
User.login(invalidCredentials, function(err, accessToken) {
assert(err);
assert.equal(err.code, 'LOGIN_FAILED');
assert(!accessToken);
done();
});
});
it('Login should only allow correct credentials - promise variant', function(done) {
User.login(invalidCredentials)
.then(function(accessToken) {
assert(!accessToken);
done();
})
.catch(function(err) {
assert(err);
assert.equal(err.code, 'LOGIN_FAILED');
done();
});
});
it('Login a user providing incomplete credentials', function(done) {
User.login(incompleteCredentials, function(err, accessToken) {
assert(err);
assert.equal(err.code, 'USERNAME_EMAIL_REQUIRED');
done();
});
});
it('Login a user providing incomplete credentials - promise variant', function(done) {
User.login(incompleteCredentials)
.then(function(accessToken) {
assert(!accessToken);
done();
})
.catch(function(err) {
assert(err);
assert.equal(err.code, 'USERNAME_EMAIL_REQUIRED');
done();
});
});
it('Login a user over REST by providing credentials', function(done) {
request(app)
.post('/test-users/login')
.expect('Content-Type', /json/)
.expect(200)
.send(validCredentials)
.end(function(err, res) {
if (err) {
return done(err);
}
var accessToken = res.body;
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.id.length, 64);
assert(accessToken.user === undefined);
done();
});
});
it('Login a user over REST by providing invalid credentials', function(done) {
request(app)
.post('/test-users/login')
.expect('Content-Type', /json/)
.expect(401)
.send(invalidCredentials)
.end(function(err, res) {
if (err) {
return done(err);
}
var errorResponse = res.body.error;
assert.equal(errorResponse.code, 'LOGIN_FAILED');
done();
});
});
it('Login a user over REST by providing incomplete credentials', function(done) {
request(app)
.post('/test-users/login')
.expect('Content-Type', /json/)
.expect(400)
.send(incompleteCredentials)
.end(function(err, res) {
if (err) {
return done(err);
}
var errorResponse = res.body.error;
assert.equal(errorResponse.code, 'USERNAME_EMAIL_REQUIRED');
done();
});
});
it('Login a user over REST with the wrong Content-Type', function(done) {
request(app)
.post('/test-users/login')
.set('Content-Type', null)
.expect('Content-Type', /json/)
.expect(400)
.send(JSON.stringify(validCredentials))
.end(function(err, res) {
if (err) {
return done(err);
}
var errorResponse = res.body.error;
assert.equal(errorResponse.code, 'USERNAME_EMAIL_REQUIRED');
done();
});
});
it('Returns current user when `include` is `USER`', function(done) {
request(app)
.post('/test-users/login?include=USER')
.send(validCredentials)
.expect(200)
.expect('Content-Type', /json/)
.end(function(err, res) {
if (err) {
return done(err);
}
var token = res.body;
expect(token.user, 'body.user').to.not.equal(undefined);
expect(token.user, 'body.user')
.to.have.property('email', validCredentials.email);
done();
});
});
it('should handle multiple `include`', function(done) {
request(app)
.post('/test-users/login?include=USER&include=Post')
.send(validCredentials)
.expect(200)
.expect('Content-Type', /json/)
.end(function(err, res) {
if (err) {
return done(err);
}
var token = res.body;
expect(token.user, 'body.user').to.not.equal(undefined);
expect(token.user, 'body.user')
.to.have.property('email', validCredentials.email);
done();
});
});
});
function assertGoodToken(accessToken) {
assert(accessToken.userId);
assert(accessToken.id);
assert.equal(accessToken.id.length, 64);
}
describe('User.login requiring email verification', function() {
beforeEach(function() {
User.settings.emailVerificationRequired = true;
});
afterEach(function() {
User.settings.emailVerificationRequired = false;
});
it('Require valid and complete credentials for email verification error', function(done) {
User.login({ email: validCredentialsEmail }, function(err, accessToken) {
// strongloop/loopback#931
// error message should be "login failed" and not "login failed as the email has not been verified"
assert(err && !/verified/.test(err.message), ('expecting "login failed" error message, received: "' + err.message + '"'));
assert.equal(err.code, 'LOGIN_FAILED');
done();
});
});
it('Require valid and complete credentials for email verification error - promise variant', function(done) {
User.login({ email: validCredentialsEmail })
.then(function(accessToken) {
done();
})
.catch(function(err) {
// strongloop/loopback#931
// error message should be "login failed" and not "login failed as the email has not been verified"
assert(err && !/verified/.test(err.message), ('expecting "login failed" error message, received: "' + err.message + '"'));
assert.equal(err.code, 'LOGIN_FAILED');
done();
});
});
it('Login a user by without email verification', function(done) {
User.login(validCredentials, function(err, accessToken) {
assert(err);
assert.equal(err.code, 'LOGIN_FAILED_EMAIL_NOT_VERIFIED');
done();
});
});
it('Login a user by without email verification - promise variant', function(done) {
User.login(validCredentials)
.then(function(err, accessToken) {
done();
})
.catch(function(err) {
assert(err);
assert.equal(err.code, 'LOGIN_FAILED_EMAIL_NOT_VERIFIED');
done();
});
});
it('Login a user by with email verification', function(done) {
User.login(validCredentialsEmailVerified, function(err, accessToken) {
assertGoodToken(accessToken);
done();
});
});
it('Login a user by with email verification - promise variant', function(done) {
User.login(validCredentialsEmailVerified)
.then(function(accessToken) {
assertGoodToken(accessToken);
done();
})
.catch(function(err) {
done(err);
});
});
it('Login a user over REST when email verification is required', function(done) {
request(app)
.post('/test-users/login')
.expect('Content-Type', /json/)
.expect(200)
.send(validCredentialsEmailVerified)
.end(function(err, res) {
if (err) {
return done(err);
}
var accessToken = res.body;
assertGoodToken(accessToken);
assert(accessToken.user === undefined);
done();
});
});
it('Login a user over REST require complete and valid credentials for email verification error message', function(done) {
request(app)
.post('/test-users/login')
.expect('Content-Type', /json/)
.expect(401)
.send({ email: validCredentialsEmail })
.end(function(err, res) {
if (err) {
return done(err);
}
// strongloop/loopback#931
// error message should be "login failed" and not "login failed as the email has not been verified"
var errorResponse = res.body.error;
assert(errorResponse && !/verified/.test(errorResponse.message), ('expecting "login failed" error message, received: "' + errorResponse.message + '"'));
assert.equal(errorResponse.code, 'LOGIN_FAILED');
done();
});
});
it('Login a user over REST without email verification when it is required', function(done) {
request(app)
.post('/test-users/login')
.expect('Content-Type', /json/)
.expect(401)
.send(validCredentials)
.end(function(err, res) {
if (err) {
return done(err);
}
var errorResponse = res.body.error;
assert.equal(errorResponse.code, 'LOGIN_FAILED_EMAIL_NOT_VERIFIED');
done();
});
});
});
describe('User.login requiring realm', function() {
var User;
var AccessToken;
before(function() {
User = loopback.User.extend('RealmUser', {},
{realmRequired: true, realmDelimiter: ':'});
AccessToken = loopback.AccessToken.extend('RealmAccessToken');
loopback.autoAttach();
// Update the AccessToken relation to use the subclass of User
AccessToken.belongsTo(User, {as: 'user', foreignKey: 'userId'});
User.hasMany(AccessToken, {as: 'accessTokens', foreignKey: 'userId'});
// allow many User.afterRemote's to be called
User.setMaxListeners(0);
});
var realm1User = {
realm: 'realm1',
username: 'foo100',
email: 'foo100@bar.com',
password: 'pass100'
};
var realm2User = {
realm: 'realm2',
username: 'foo100',
email: 'foo100@bar.com',
password: 'pass200'
};
var credentialWithoutRealm = {
username: 'foo100',
email: 'foo100@bar.com',
password: 'pass100'
};
var credentialWithBadPass = {
realm: 'realm1',
username: 'foo100',
email: 'foo100@bar.com',
password: 'pass001'
};
var credentialWithBadRealm = {
realm: 'realm3',
username: 'foo100',
email: 'foo100@bar.com',
password: 'pass100'
};
var credentialWithRealm = {
realm: 'realm1',
username: 'foo100',
password: 'pass100'
};
var credentialRealmInUsername = {
username: 'realm1:foo100',
password: 'pass100'
};
var credentialRealmInEmail = {
email: 'realm1:foo100@bar.com',
password: 'pass100'
};
var user1;
beforeEach(function(done) {
User.create(realm1User, function(err, u) {
if (err) {
return done(err);
}
user1 = u;
User.create(realm2User, done);
});
});
afterEach(function(done) {
User.deleteAll({realm: 'realm1'}, function(err) {
if (err) {
return done(err);
}
User.deleteAll({realm: 'realm2'}, done);
});
});
it('rejects a user by without realm', function(done) {
User.login(credentialWithoutRealm, function(err, accessToken) {
assert(err);
assert.equal(err.code, 'REALM_REQUIRED');
done();
});
});
it('rejects a user by with bad realm', function(done) {
User.login(credentialWithBadRealm, function(err, accessToken) {
assert(err);
assert.equal(err.code, 'LOGIN_FAILED');
done();
});
});
it('rejects a user by with bad pass', function(done) {
User.login(credentialWithBadPass, function(err, accessToken) {
assert(err);
assert.equal(err.code, 'LOGIN_FAILED');
done();
});
});
it('logs in a user by with realm', function(done) {
User.login(credentialWithRealm, function(err, accessToken) {
assertGoodToken(accessToken);
assert.equal(accessToken.userId, user1.id);
done();
});
});
it('logs in a user by with realm in username', function(done) {
User.login(credentialRealmInUsername, function(err, accessToken) {
assertGoodToken(accessToken);
assert.equal(accessToken.userId, user1.id);
done();
});
});
it('logs in a user by with realm in email', function(done) {
User.login(credentialRealmInEmail, function(err, accessToken) {
assertGoodToken(accessToken);
assert.equal(accessToken.userId, user1.id);
done();
});
});
describe('User.login with realmRequired but no realmDelimiter', function() {
before(function() {
User.settings.realmDelimiter = undefined;
});
after(function() {
User.settings.realmDelimiter = ':';
});
it('logs in a user by with realm', function(done) {
User.login(credentialWithRealm, function(err, accessToken) {
assertGoodToken(accessToken);
assert.equal(accessToken.userId, user1.id);
done();
});
});
it('rejects a user by with realm in email if realmDelimiter is not set',
function(done) {
User.login(credentialRealmInEmail, function(err, accessToken) {
assert(err);
assert.equal(err.code, 'REALM_REQUIRED');
done();
});
});
});
});
describe('User.logout', function() {
it('Logout a user by providing the current accessToken id (using node)', function(done) {
login(logout);
function login(fn) {
User.login({email: 'foo@bar.com', password: 'bar'}, fn);
}
function logout(err, accessToken) {
User.logout(accessToken.id, verify(accessToken.id, done));
}
});
it('Logout a user by providing the current accessToken id (using node) - promise variant', function(done) {
login(logout);
function login(fn) {
User.login({email: 'foo@bar.com', password: 'bar'}, fn);
}
function logout(err, accessToken) {
User.logout(accessToken.id)
.then(function() {
verify(accessToken.id, done);
})
.catch(done(err));
}
});
it('Logout a user by providing the current accessToken id (over rest)', function(done) {
login(logout);
function login(fn) {
request(app)
.post('/test-users/login')
.expect('Content-Type', /json/)
.expect(200)
.send({email: 'foo@bar.com', password: 'bar'})
.end(function(err, res) {
if (err) {
return done(err);
}
var accessToken = res.body;
assert(accessToken.userId);
assert(accessToken.id);
fn(null, accessToken.id);
});
}
function logout(err, token) {
request(app)
.post('/test-users/logout')
.set('Authorization', token)
.expect(204)
.end(verify(token, done));
}
});
function verify(token, done) {
assert(token);
return function(err) {
if (err) {
return done(err);
}
AccessToken.findById(token, function(err, accessToken) {
assert(!accessToken, 'accessToken should not exist after logging out');
done(err);
});
};
}
});
describe('user.hasPassword(plain, fn)', function() {
it('Determine if the password matches the stored password', function(done) {
var u = new User({username: 'foo', password: 'bar'});
u.hasPassword('bar', function(err, isMatch) {
assert(isMatch, 'password doesnt match');
done();
});
});
it('Determine if the password matches the stored password - promise variant', function(done) {
var u = new User({username: 'foo', password: 'bar'});
u.hasPassword('bar')
.then(function(isMatch) {
assert(isMatch, 'password doesnt match');
done();
})
.catch(function(err) {
done(err);
});
});
it('should match a password when saved', function(done) {
var u = new User({username: 'a', password: 'b', email: 'z@z.net'});
u.save(function(err, user) {
User.findById(user.id, function(err, uu) {
uu.hasPassword('b', function(err, isMatch) {
assert(isMatch);
done();
});
});
});
});
it('should match a password after it is changed', function(done) {
User.create({email: 'foo@baz.net', username: 'bat', password: 'baz'}, function(err, user) {
User.findById(user.id, function(err, foundUser) {
assert(foundUser);
foundUser.hasPassword('baz', function(err, isMatch) {
assert(isMatch);
foundUser.password = 'baz2';
foundUser.save(function(err, updatedUser) {
updatedUser.hasPassword('baz2', function(err, isMatch) {
assert(isMatch);
User.findById(user.id, function(err, uu) {
uu.hasPassword('baz2', function(err, isMatch) {
assert(isMatch);
done();
});
});
});
});
});
});
});
});
});
describe('Verification', function() {
describe('user.verify(options, fn)', function() {
it('Verify a user\'s email address', function(done) {
User.afterRemote('create', function(ctx, user, next) {
assert(user, 'afterRemote should include result');
var options = {
type: 'email',
to: user.email,
from: 'noreply@myapp.org',
redirect: '/',
protocol: ctx.req.protocol,
host: ctx.req.get('host')
};
user.verify(options, function(err, result) {
assert(result.email);
assert(result.email.response);
assert(result.token);
var msg = result.email.response.toString('utf-8');
assert(~msg.indexOf('/api/test-users/confirm'));
assert(~msg.indexOf('To: bar@bat.com'));
done();
});
});
request(app)
.post('/test-users')
.expect('Content-Type', /json/)
.expect(200)
.send({email: 'bar@bat.com', password: 'bar'})
.end(function(err, res) {
if (err) {
return done(err);
}
});
});
it('Verify a user\'s email address - promise variant', function(done) {
User.afterRemote('create', function(ctx, user, next) {
assert(user, 'afterRemote should include result');
var options = {
type: 'email',
to: user.email,
from: 'noreply@myapp.org',
redirect: '/',
protocol: ctx.req.protocol,
host: ctx.req.get('host')
};
user.verify(options)
.then(function(result) {
console.log('here in then function');
assert(result.email);
assert(result.email.response);
assert(result.token);
var msg = result.email.response.toString('utf-8');
assert(~msg.indexOf('/api/test-users/confirm'));
assert(~msg.indexOf('To: bar@bat.com'));
done();
})
.catch(function(err) {
done(err);
});
});
request(app)
.post('/test-users')
.send({email: 'bar@bat.com', password: 'bar'})
.expect('Content-Type', /json/)
.expect(200)
.end(function(err, res) {
if (err) {
return done(err);
}
});
});
it('Verify a user\'s email address with custom header', function(done) {
User.afterRemote('create', function(ctx, user, next) {
assert(user, 'afterRemote should include result');
var options = {
type: 'email',
to: user.email,
from: 'noreply@myapp.org',
redirect: '/',
protocol: ctx.req.protocol,
host: ctx.req.get('host'),
headers: {'message-id':'custom-header-value'}
};
user.verify(options, function(err, result) {
assert(result.email);
assert.equal(result.email.messageId, 'custom-header-value');
done();
});
});
request(app)
.post('/test-users')
.expect('Content-Type', /json/)
.expect(200)
.send({email: 'bar@bat.com', password: 'bar'})
.end(function(err, res) {
if (err) {
return done(err);
}
});
});
it('Verify a user\'s email address with custom token generator', function(done) {
User.afterRemote('create', function(ctx, user, next) {
assert(user, 'afterRemote should include result');
var options = {
type: 'email',
to: user.email,
from: 'noreply@myapp.org',
redirect: '/',
protocol: ctx.req.protocol,
host: ctx.req.get('host'),
generateVerificationToken: function(user, cb) {
assert(user);
assert.equal(user.email, 'bar@bat.com');
assert(cb);
assert.equal(typeof cb, 'function');
// let's ensure async execution works on this one
process.nextTick(function() {
cb(null, 'token-123456');
});
}
};
user.verify(options, function(err, result) {
assert(result.email);
assert(result.email.response);
assert(result.token);
assert.equal(result.token, 'token-123456');
var msg = result.email.response.toString('utf-8');
assert(~msg.indexOf('token-123456'));
done();
});
});
request(app)
.post('/test-users')
.expect('Content-Type', /json/)
.expect(200)
.send({email: 'bar@bat.com', password: 'bar'})
.end(function(err, res) {
if (err) {
return done(err);
}
});
});
it('Fails if custom token generator returns error', function(done) {
User.afterRemote('create', function(ctx, user, next) {
assert(user, 'afterRemote should include result');
var options = {
type: 'email',
to: user.email,
from: 'noreply@myapp.org',
redirect: '/',
protocol: ctx.req.protocol,
host: ctx.req.get('host'),
generateVerificationToken: function(user, cb) {
// let's ensure async execution works on this one
process.nextTick(function() {
cb(new Error('Fake error'));
});
}
};
user.verify(options, function(err, result) {
assert(err);
assert.equal(err.message, 'Fake error');
assert.equal(result, undefined);
done();
});
});
request(app)
.post('/test-users')
.expect('Content-Type', /json/)
.expect(200)
.send({email: 'bar@bat.com', password: 'bar'})
.end(function(err, res) {
if (err) {
return done(err);
}
});
});
});
describe('User.confirm(options, fn)', function() {
var options;
function testConfirm(testFunc, done) {
User.afterRemote('create', function(ctx, user, next) {
assert(user, 'afterRemote should include result');
options = {
type: 'email',
to: user.email,
from: 'noreply@myapp.org',
redirect: 'http://foo.com/bar',
protocol: ctx.req.protocol,
host: ctx.req.get('host')
};
user.verify(options, function(err, result) {
if (err) {
return done(err);
}
testFunc(result, done);
});
});
request(app)
.post('/test-users')
.expect('Content-Type', /json/)
.expect(302)
.send({email: 'bar@bat.com', password: 'bar'})
.end(function(err, res) {
if (err) {
return done(err);
}
});
}
it('Confirm a user verification', function(done) {
testConfirm(function(result, done) {
request(app)
.get('/test-users/confirm?uid=' + (result.uid) +
'&token=' + encodeURIComponent(result.token) +
'&redirect=' + encodeURIComponent(options.redirect))
.expect(302)
.end(function(err, res) {
if (err) {
return done(err);
}
done();
});
}, done);
});
it('Should report 302 when redirect url is set', function(done) {
testConfirm(function(result, done) {
request(app)
.get('/test-users/confirm?uid=' + (result.uid) +
'&token=' + encodeURIComponent(result.token) +
'&redirect=http://foo.com/bar')
.expect(302)
.expect('Location', 'http://foo.com/bar')
.end(done);
}, done);
});
it('Should report 204 when redirect url is not set', function(done) {
testConfirm(function(result, done) {
request(app)
.get('/test-users/confirm?uid=' + (result.uid) +
'&token=' + encodeURIComponent(result.token))
.expect(204)
.end(done);
}, done);
});
it('Report error for invalid user id during verification', function(done) {
testConfirm(function(result, done) {
request(app)
.get('/test-users/confirm?uid=' + (result.uid + '_invalid') +
'&token=' + encodeURIComponent(result.token) +
'&redirect=' + encodeURIComponent(options.redirect))
.expect(404)
.end(function(err, res) {
if (err) {
return done(err);
}
var errorResponse = res.body.error;
assert(errorResponse);
assert.equal(errorResponse.code, 'USER_NOT_FOUND');
done();
});
}, done);
});
it('Report error for invalid token during verification', function(done) {
testConfirm(function(result, done) {
request(app)
.get('/test-users/confirm?uid=' + result.uid +
'&token=' + encodeURIComponent(result.token) + '_invalid' +
'&redirect=' + encodeURIComponent(options.redirect))
.expect(400)
.end(function(err, res) {
if (err) {
return done(err);
}
var errorResponse = res.body.error;
assert(errorResponse);
assert.equal(errorResponse.code, 'INVALID_TOKEN');
done();
});
}, done);
});
});
});
describe('Password Reset', function() {
describe('User.resetPassword(options, cb)', function() {
var email = 'foo@bar.com';
it('Requires email address to reset password', function(done) {
User.resetPassword({ }, function(err) {
assert(err);
assert.equal(err.code, 'EMAIL_REQUIRED');
done();
});
});
it('Requires email address to reset password - promise variant', function(done) {
User.resetPassword({ })
.then(function() {
throw new Error('Error should NOT be thrown');
})
.catch(function(err) {
assert(err);
assert.equal(err.code, 'EMAIL_REQUIRED');
done();
});
});
it('Creates a temp accessToken to allow a user to change password', function(done) {
var calledBack = false;
User.resetPassword({
email: email
}, function() {
calledBack = true;
});
User.once('resetPasswordRequest', function(info) {
assert(info.email);
assert(info.accessToken);
assert(info.accessToken.id);
assert.equal(info.accessToken.ttl / 60, 15);
assert(calledBack);
info.accessToken.user(function(err, user) {
if (err) return done(err);
assert.equal(user.email, email);
done();
});
});
});
it('Password reset over REST rejected without email address', function(done) {
request(app)
.post('/test-users/reset')
.expect('Content-Type', /json/)
.expect(400)
.send({ })
.end(function(err, res) {
if (err) {
return done(err);
}
var errorResponse = res.body.error;
assert(errorResponse);
assert.equal(errorResponse.code, 'EMAIL_REQUIRED');
done();
});
});
it('Password reset over REST requires email address', function(done) {
request(app)
.post('/test-users/reset')
.expect('Content-Type', /json/)
.expect(204)
.send({ email: email })
.end(function(err, res) {
if (err) {
return done(err);
}
assert.deepEqual(res.body, { });
done();
});
});
});
});
describe('ctor', function() {
it('exports default Email model', function() {
expect(User.email, 'User.email').to.be.a('function');
expect(User.email.modelName, 'modelName').to.eql('email');
});
it('exports default AccessToken model', function() {
expect(User.accessToken, 'User.accessToken').to.be.a('function');
expect(User.accessToken.modelName, 'modelName').to.eql('AccessToken');
});
});
describe('ttl', function() {
var User2;
beforeEach(function() {
User2 = loopback.User.extend('User2', {}, { ttl: 10 });
});
it('should override ttl setting in based User model', function() {
expect(User2.settings.ttl).to.equal(10);
});
});
});
|
goog.provide('gpub.book.epub.Builder');
/**
* Helper for building an ebook.
* @param {!gpub.opts.Metadata} opts
* @constructor @struct @final
*/
gpub.book.epub.Builder = function(opts) {
/** @type {!gpub.opts.Metadata} */
this.opts = opts;
/**
* @type {!Array<!gpub.book.File>}
*/
this.allFiles = [
gpub.book.epub.mimetypeFile(),
gpub.book.epub.containerFile(),
];
/** @type {!Array<!gpub.book.File>} */
this.manifestFiles = [];
/** @type {!Array<!gpub.book.File>} */
this.navFiles = [];
/** @type {!Array<string>} spineIds */
this.spineIds = [];
};
gpub.book.epub.Builder.prototype = {
/**
* Return the files necessary for a book.
* @return {!Array<!gpub.book.File>}
*/
build: function() {
var nav = gpub.book.epub.nav(this.navFiles);
this.allFiles.push(nav);
this.manifestFiles.push(nav);
var opfFile = gpub.book.epub.opf.content(
this.opts, this.manifestFiles, this.spineIds);
this.allFiles.push(opfFile);
return this.allFiles;
},
/**
* Add a content file, which also adds the file to spine, manifest, and nav.
* @param {!gpub.book.File} file
* @return {!gpub.book.epub.Builder} this
*/
addContentFile: function(file) {
this.allFiles.push(file);
this.navFiles.push(file);
this.spineIds.push(file.id);
this.manifestFiles.push(file);
return this;
},
/**
* Add a file to the manifest.
* @param {!gpub.book.File} file
* @return {!gpub.book.epub.Builder} this
*/
addManifestFile: function(file) {
this.allFiles.push(file);
this.manifestFiles.push(file);
return this;
},
};
|
(function() {
var weather = window.weather;
/*
======== A Handy Little QUnit Reference ========
http://api.qunitjs.com/
Test methods:
module(name, {[setup][ ,teardown]})
test(name, callback)
expect(numberOfAssertions)
stop(increment)
start(decrement)
Test assertions:
ok(value, [message])
equal(actual, expected, [message])
notEqual(actual, expected, [message])
deepEqual(actual, expected, [message])
notDeepEqual(actual, expected, [message])
strictEqual(actual, expected, [message])
notStrictEqual(actual, expected, [message])
throws(block, [expected], [message])
*/
module('weather');
test('is a function', function() {
expect(1);
// Not a bad test to run on collection methods.
strictEqual(typeof weather, 'function', 'is a function');
});
test('errors on bad information', function() {
expect(1);
stop();
weather('abcdefghij', function(err) {
ok(err, 'errored on a bad location');
start();
});
});
test('errors on bad information', function() {
expect(1);
stop();
weather('abcdefghij', function(err) {
ok(err, 'errored on a bad location');
start();
});
});
test('works with zip code', function() {
expect(2);
stop();
weather('02210', function(err, weather) {
strictEqual(err, null, 'no error');
ok(weather.condition, 'weather\'s condition object returned');
start();
});
});
test('doesn\'t works with non-US locale', function () {
expect(2);
stop();
weather([47.0397925, 28.835163299999994], function (err, weather) {
notEqual(err, null, 'there are errors');
equal(weather, undefined, 'weather\'s condition object is not returned');
start();
});
});
}());
|
/**
* Problem: https://leetcode.com/problems/intersection-of-two-arrays/
Given two arrays, write a function to compute their intersection.
* Example:
Given nums1 = [1, 2, 2, 1], nums2 = [2, 2], return [2].
* Note:
Each element in the result must be unique.
The result can be in any order.
* @param {number[]} nums1
* @param {number[]} nums2
* @return {number[]}
* Analysis: we can either use hash or sort the input array then apply 2pointers or binary search.
*/
export const intersectOf2Arr = {};
/**
* Solution 1: use hash.
*
* "N" is max nums.length.
* Time complexity: O(N)
* Space complexity: O(N)
*/
intersectOf2Arr.hash = (nums1, nums2) => {
if (
!(
nums1 &&
nums2 &&
typeof nums1 === "object" &&
typeof nums2 === "object" &&
nums1.length > 0 &&
nums2.length > 0
)
) {
return [];
}
const _hash = {};
const intersectSet = new Set();
for (let i = nums1.length - 1; i >= 0; i--) {
_hash[nums1[i]] = true;
}
for (let i = nums2.length - 1; i >= 0; i--) {
if (_hash[nums2[i]] && !intersectSet.has(nums2[i])) {
intersectSet.add(nums2[i]);
}
}
return Array.from(intersectSet);
};
/**
* Solution 2: sort the array, then use binary search.
*
* "N" is nums.length.
* Time complexity: O(NlgN)
* Space complexity: O(N)
*/
intersectOf2Arr.sortedBSearch = (nums1, nums2) => {
if (
!(
nums1 &&
nums2 &&
typeof nums1 === "object" &&
typeof nums2 === "object" &&
nums1.length > 0 &&
nums2.length > 0
)
) {
return [];
}
const nums1Last = nums1.length - 1;
const nums2Last = nums2.length - 1;
const binarySearch = (arr, target, lo) => {
let hi = arr.length - 1;
let mid;
while (lo <= hi) {
mid = Math.floor((lo + hi) / 2);
if (arr[mid] > target) {
hi = mid - 1;
} else if (arr[mid] < target) {
lo = mid + 1;
} else {
lastTarget = target;
low2 = mid + 1;
return true;
}
}
return false;
};
const ascSort = (a, b) => a - b;
let low2 = 0;
let lastTarget = null;
const result = [];
nums1.sort(ascSort);
nums2.sort(ascSort);
for (let low1 = 0; low1 <= nums1Last; low1 += 1) {
// check edge
if (nums1[low1] > nums2[nums2Last] || nums2[low2] > nums1[nums1Last]) {
return result;
}
// avoid duplication & binary Search
if (lastTarget !== nums1[low1] && binarySearch(nums2, nums1[low1], low2)) {
result.push(nums1[low1]);
}
}
return result;
};
/**
* Solution 3: sort the array, then use 2 pointer.
*
* "N" is nums.length.
* Time complexity: O(NlgN)
* Space complexity: O(N)
*/
intersectOf2Arr.sorted2Pointer = (nums1, nums2) => {
if (
!(
nums1 &&
nums2 &&
typeof nums1 === "object" &&
typeof nums2 === "object" &&
nums1.length > 0 &&
nums2.length > 0
)
) {
return [];
}
const nums1Last = nums1.length - 1;
const nums2Last = nums2.length - 1;
const ascSort = (a, b) => a - b;
nums1.sort(ascSort);
nums2.sort(ascSort);
let low2 = 0;
const result = [];
let lastTarget = null;
for (let low1 = 0; low1 <= nums1Last; low1 += 1) {
// check edge
if (nums1[low1] > nums2[nums2Last] || nums2[low2] > nums1[nums1Last]) {
return result;
}
while (nums1[low1] >= nums2[low2]) {
if (nums1[low1] !== lastTarget && nums1[low1] === nums2[low2]) {
result.push(nums1[low1]);
lastTarget = nums1[low1];
}
low2 += 1;
}
}
return result;
};
/**
* Lessons:
1. 2-pointer is basically use index-pointers to loop over.
*/
|
/**
* Created by jonas on 2016-04-16.
*/
var Entity = function (game, cx, cy, spriteName, spriteName2) {
Phaser.Sprite.call(this, game, cx, cy, spriteName, spriteName2);
this.game.physics.enable(this);
this.anchor.setTo(0.5, 0.5); //so it flips around its middle
};
Entity.prototype = Object.create(Phaser.Sprite.prototype);
Entity.prototype.constructor = Entity;
Entity.prototype.update = function() {
// keep the unit withing the visible game area
if (this.x < this.game.width / 2) {
this.x += this.game.world.width - this.game.width;
}
else if (this.x > this.game.world.width - this.game.width / 2) {
this.x -= this.game.world.width - this.game.width;
}
if (this.y < this.game.height / 2) {
this.y += this.game.world.height - this.game.height;
}
else if (this.y > this.game.world.height - this.game.height / 2) {
this.y -= this.game.world.height - this.game.height;
}
if (this !== g_game.player) {
// keep this unit within view of player
if (this.x < this.game.width && g_game.player.x > this.game.world.width/2) {
this.x = this.game.world.width - this.game.width + this.x;
}
else if (this.x > this.game.world.width - this.game.width && g_game.player.x < this.game.world.width/2) {
this.x = this.x - (this.game.world.width - this.game.width);
}
if (this.y < this.game.height && g_game.player.y > this.game.world.height/2) {
this.y = this.game.world.height - this.game.height + this.y;
}
else if (this.y > this.game.world.height - this.game.height && g_game.player.y < this.game.world.height/2) {
this.y = this.y - (this.game.world.height - this.game.height);
}
}
}; |
'use strict';
const conf = require('./conf/' + process.argv[2]);
const fs = require('fs');
const chokidar = require('chokidar');
const zlib = require('zlib');
const readline = require('readline');
const elasticsearch = require('elasticsearch');
const node_statsd = require('node-statsd');
var elastic = new elasticsearch.Client({
host: conf.host
//, log: 'trace'
});
var statsd = new node_statsd({
host: '10.1.0.116',
prefix: 'cdnlogs.'
});
//var indexPrefixes = ['cdnlogs-media-', 'cdnlogs-ildccdn-', 'cdnlogs-other-'];
var newPath = 'new';
var inflatedPath = 'inflated';
var processedPath = 'processed';
var logPath = 'logs/info.log';
var errorPath = 'logs/error.log';
var newFiles = {};
var queuedFiles = [];
var interval = 15000; // ms
var alreadyCheckingSize = false;
var alreadyProcessing = false;
var date;
var gzFile, inflatedFile;
var logs = [];
var howmany = 1000;
var watcher = chokidar.watch(newPath, {
ignored: /[\/\\]\./,
persistent: true
});
watcher
.on('error', (error) => { error('watcher error: ', error); })
.on('add', (path) => {
log('added: ' + path);
newFiles[path] = {};
var stats = fs.statSync(path);
newFiles[path].size = stats.size;
setTimeout(hasSizeChanged, interval);
})
.on('change', (path, stats) => {
if (stats) {
//log('changed: ' + path + ' - size: ' + stats.size);
}
});
function hasSizeChanged() {
log('hasSizeChanged');
if (alreadyCheckingSize)
log('alreadyCheckingSize');
else {
alreadyCheckingSize = true;
for (var path in newFiles) {
var size = newFiles[path].size;
var stats = fs.statSync(path);
if (size === stats.size) {
queuedFiles.push(path);
log('pushed to queue: ' + path);
delete newFiles[path];
setTimeout(checkForQueuedFiles, interval);
}
else {
log('changed: ' + path + ' - size: ' + stats.size);
newFiles[path].size = stats.size;
setTimeout(hasSizeChanged, interval);
}
}
alreadyCheckingSize = false;
}
}
function checkForQueuedFiles() {
log('checkForQueuedFiles');
if (alreadyProcessing)
log('alreadyProcessing');
else if (queuedFiles.length) {
alreadyProcessing = true;
startProcess(queuedFiles.shift());
}
else
log('no queued files');
}
function startProcess(file) {
var start_process = process.hrtime(); //stats
log('start processing: ' + file);
date = file.split('_')[2];
statsd.timing('start_process', getTime(start_process)); //stats
inflateFile(file);
}
function inflateFile(file) {
var inflate_file = process.hrtime(); //stats
gzFile = file;
inflatedFile = gzFile.replace('.gz', '');
inflatedFile = inflatedFile.replace(newPath, inflatedPath);
fs.readFile(gzFile, (err, data) => {
if (err)
error(err);
else {
zlib.gunzip(data, (err, result) => {
if (err)
error(err);
else {
fs.writeFileSync(inflatedFile, result);
log('inflated: ' + inflatedFile);
statsd.timing('inflate_file', getTime(inflate_file)); //stats
loadFile(inflatedFile);
}
});
}
});
}
function loadFile(file) {
var load_file = process.hrtime(); //stats
const rl = readline.createInterface({ input: fs.createReadStream(file) });
rl.on('line', (line) => { logs.push(line); });
rl.on('close', () => {
log('loaded: ' + file);
statsd.timing('load_file', getTime(load_file)); //stats
log('parsing: ' + file);
parseLogs(logs.splice(0, howmany));
});
}
function parseLogs(logs) {
var parse_logs = process.hrtime(); //stats
var bulk = [];
for (var i=0; i < logs.length; i++) {
var line = logs[i].split(' ');
var url = line[6];
var timestamp = line[3].substring(1).split(':');
var d = new Date(timestamp[0]);
var doc = {};
doc.timestamp = d.toISOString().split('T')[0] + 'T' + timestamp.slice(1).join(':') + '.000Z';
doc.ip = line[0];
doc.code = line[8];
doc.bytes = line[9];
doc.referrer = line[10].replace(/"/g, '');
doc.agent = line.slice(11).join(' ').split('"')[1];
var action = {};
var index = {};
if (url.includes('media.imaginelearning.net')) {
index._index = 'cdnlogs-media-' + date;
url = url.replace(/80305E\/media\//, '');
}
else if (url.includes('ildc.cdn.imaginelearning.com')) {
index._index = 'cdnlogs-ildccdn-' + date;
url = url.replace(/80305E\/ildccdn\//, '');
}
else
index._index = 'cdnlogs-other-' + date;
var extension = '-';
var url_split = url.split('/');
var file = url_split.slice(3).join('/');
if (file.includes('.')) {
if (file.includes('QualityLevels') || file.includes('Manifest')) {
extension = 'ism';
//console.log(file, extension);
}
else {
var file_split = file.split('.');
extension = file_split[file_split.length - 1].toLowerCase();
}
}
doc.origin = url_split[2];
doc.file = file;
doc.extension = extension;
doc.url = url;
index._type = 'cdnlogs';
action.index = index;
bulk.push(action);
bulk.push(doc);
}
statsd.timing('parse_logs', getTime(parse_logs)); //stats
elasticBulk(bulk);
}
function elasticBulk(bulk) {
var elastic_bulk = process.hrtime(); //stats
elastic.bulk({ body: bulk }, (err, res) => {
//statsd.timing('elastic_bulk', getTime(process.hrtime(elastic_bulk))); //stats
statsd.timing('elastic_bulk', getTime(elastic_bulk)); //stats
if (err) {
statsd.increment('elastic_bulk_err'); //stats
error(err);
}
else {
//console.log(res);
statsd.increment('elastic_bulk'); //stats
if (logs.length > 0)
parseLogs(logs.splice(0, howmany));
else {
log('finished processing: ' + inflatedFile);
cleanUp();
}
}
//process.stdout.write('remaining: ' + logs.length + ' \r');
});
}
function cleanUp() {
var clean_up = process.hrtime(); //stats
fs.unlinkSync(inflatedFile);
fs.renameSync(gzFile, gzFile.replace(newPath, processedPath));
log('cleaned up: ' + gzFile);
statsd.timing('clean_up', getTime(clean_up)); //stats
if (queuedFiles.length)
startProcess(queuedFiles.shift());
else {
//statsd.socket.close();
log('no more files to process');
alreadyProcessing = false;
}
}
function log(message) {
var data = new Date().toJSON() + ' - ' + message + '\n';
fs.appendFile(logPath, data, (err) => {
if (err)
error(err);
else {
//console.log('log appended');
}
});
}
function error(message) {
var data = new Date().toJSON() + ' - ' + message + '\n';
fs.appendFile(errorPath, data, (err) => {
if (err)
console.error(err);
else {
//console.log('error appended');
}
});
}
function getTime(hrtimeObj) {
var diff = process.hrtime(hrtimeObj);
return Math.round(diff[0] * 1000 + diff[1] / 1000000);
}
statsd.socket.on('error', (err) => {
error(err);
});
process.on('uncaughtException', (err) => {
error(err);
});
/*
var clean_up = process.hrtime(); //stats
statsd.timing('clean_up', getTime(clean_up)); //stats
*/
|
/**
* React Starter Kit (https://www.reactstarterkit.com/)
*
* Copyright © 2014-2016 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.
*/
export const listenAddress = process.env.IP || 'localhost';
export const port = process.env.PORT || 5000;
export const host = process.env.WEBSITE_HOSTNAME || process.env.C9_HOSTNAME || `${listenAddress}:${port}`;
|
'use strict';
var angular = require('angular');
require('angular-messages');
require('angular-animate');
require('angular-strap');
require('angular-strap-tpl-modal');
require('angular-strap-tpl-popover');
require('../views/_views');
require('../components/controllers/init');
require('../components/filters/init');
require('../components/directives/init');
require('../components/animations/init');
require('../components/services/init');
require('../components/models/init');
var appInfo = require('info');
module.exports = angular.module(appInfo.name, [
appInfo.moduleName('controllers'),
appInfo.moduleName('filters'),
appInfo.moduleName('directives'),
appInfo.moduleName('animations'),
appInfo.moduleName('services'),
appInfo.moduleName('models'),
appInfo.moduleName('views'),
require('angular-ui-router'),
'mgcrea.ngStrap.modal',
'mgcrea.ngStrap.tooltip',
'mgcrea.ngStrap.popover',
require('angular-route'),
require('angular-loading-bar'),
'ngMessages',
'ngAnimate'
]); |
/**
* Created by Bhavinkumar on 3/3/2016.
*/
(function() {
'use strict';
angular.module('febatlas').controller('UserController', UserController);
UserController.$inject = ['UserService','$rootScope','$http','$location'];
function UserController(UserService,$rootScope,$http,$location) {
var userCntl = this;
userCntl.login = function(){
UserService.login(userCntl.userCredential)
.then(function(data) {
$http.defaults.headers.common.Authorization = 'Bearer ' + data.token;
localStorage.setItem("token", 'Bearer '+data.token);
return UserService.getUserByEmail(userCntl.userCredential.email);
}).then(function(data) {
$rootScope.user= data;
$location.path('/titles');
})
.catch(function(error) {
alert('Invalid Username Or Password');
userCntl.userCredential=null;
});
};
userCntl.logout = function(){
$http.defaults.headers.common.Authorization = '';
$rootScope.user=null;
localStorage.removeItem("token");
};
}
})(); |
/* eslint @typescript-eslint/no-use-before-define: "off" */
import React from 'react';
import { mount } from 'enzyme';
import Transfer from '..';
import TransferList from '../list';
import TransferOperation from '../operation';
import TransferSearch from '../search';
import TransferItem from '../ListItem';
import Button from '../../button';
import Checkbox from '../../checkbox';
import mountTest from '../../../tests/shared/mountTest';
import rtlTest from '../../../tests/shared/rtlTest';
const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
const listCommonProps = {
dataSource: [
{
key: 'a',
title: 'a',
},
{
key: 'b',
title: 'b',
},
{
key: 'c',
title: 'c',
disabled: true,
},
],
selectedKeys: ['a'],
targetKeys: ['b'],
};
const listDisabledProps = {
dataSource: [
{
key: 'a',
title: 'a',
disabled: true,
},
{
key: 'b',
title: 'b',
},
],
selectedKeys: ['a', 'b'],
targetKeys: [],
};
const searchTransferProps = {
dataSource: [
{
key: '0',
title: 'content1',
description: 'description of content1',
chosen: false,
},
{
key: '1',
title: 'content2',
description: 'description of content2',
chosen: false,
},
{
key: '2',
title: 'content3',
description: 'description of content3',
chosen: false,
},
{
key: '3',
title: 'content4',
description: 'description of content4',
chosen: false,
},
{
key: '4',
title: 'content5',
description: 'description of content5',
chosen: false,
},
{
key: '5',
title: 'content6',
description: 'description of content6',
chosen: false,
},
],
selectedKeys: [],
targetKeys: ['3', '4'],
};
describe('Transfer', () => {
mountTest(Transfer);
rtlTest(Transfer);
it('should render correctly', () => {
const wrapper = mount(<Transfer {...listCommonProps} />);
expect(wrapper).toMatchRenderedSnapshot();
});
it('should move selected keys to corresponding list', () => {
const handleChange = jest.fn();
const wrapper = mount(<Transfer {...listCommonProps} onChange={handleChange} />);
wrapper.find(TransferOperation).find(Button).at(0).simulate('click'); // move selected keys to right list
expect(handleChange).toHaveBeenCalledWith(['a', 'b'], 'right', ['a']);
});
it('should move selected keys to left list', () => {
const handleChange = jest.fn();
const wrapper = mount(
<Transfer
{...listCommonProps}
selectedKeys={['a']}
targetKeys={['a']}
onChange={handleChange}
/>,
);
wrapper.find(TransferOperation).find(Button).at(1).simulate('click'); // move selected keys to left list
expect(handleChange).toHaveBeenCalledWith([], 'left', ['a']);
});
it('should move selected keys expect disabled to corresponding list', () => {
const handleChange = jest.fn();
const wrapper = mount(<Transfer {...listDisabledProps} onChange={handleChange} />);
wrapper.find(TransferOperation).find(Button).at(0).simulate('click'); // move selected keys to right list
expect(handleChange).toHaveBeenCalledWith(['b'], 'right', ['b']);
});
it('should uncheck checkbox when click on checked item', () => {
const handleSelectChange = jest.fn();
const wrapper = mount(<Transfer {...listCommonProps} onSelectChange={handleSelectChange} />);
wrapper
.find(TransferItem)
.filterWhere(n => n.prop('item').key === 'a')
.simulate('click');
expect(handleSelectChange).toHaveBeenLastCalledWith([], []);
});
it('should check checkbox when click on unchecked item', () => {
const handleSelectChange = jest.fn();
const wrapper = mount(<Transfer {...listCommonProps} onSelectChange={handleSelectChange} />);
wrapper
.find(TransferItem)
.filterWhere(n => n.prop('item').key === 'b')
.simulate('click');
expect(handleSelectChange).toHaveBeenLastCalledWith(['a'], ['b']);
});
it('should not check checkbox when component disabled', () => {
const handleSelectChange = jest.fn();
const wrapper = mount(
<Transfer {...listCommonProps} disabled onSelectChange={handleSelectChange} />,
);
wrapper
.find(TransferItem)
.filterWhere(n => n.prop('item').key === 'a')
.simulate('click');
expect(handleSelectChange).not.toHaveBeenCalled();
});
it('should not check checkbox when click on disabled item', () => {
const handleSelectChange = jest.fn();
const wrapper = mount(<Transfer {...listCommonProps} onSelectChange={handleSelectChange} />);
wrapper
.find(TransferItem)
.filterWhere(n => n.prop('item').key === 'c')
.simulate('click');
expect(handleSelectChange).not.toHaveBeenCalled();
});
it('should check all item when click on check all', () => {
const handleSelectChange = jest.fn();
const wrapper = mount(<Transfer {...listCommonProps} onSelectChange={handleSelectChange} />);
wrapper
.find('.ant-transfer-list-header input[type="checkbox"]')
.filterWhere(n => !n.prop('checked'))
.simulate('change');
expect(handleSelectChange).toHaveBeenCalledWith(['a'], ['b']);
});
it('should uncheck all item when click on uncheck all', () => {
const handleSelectChange = jest.fn();
const wrapper = mount(<Transfer {...listCommonProps} onSelectChange={handleSelectChange} />);
wrapper
.find('.ant-transfer-list-header input[type="checkbox"]')
.filterWhere(n => n.prop('checked'))
.simulate('change');
expect(handleSelectChange).toHaveBeenCalledWith([], []);
});
it('should call `filterOption` when use input in search box', () => {
const filterOption = (inputValue, option) => inputValue === option.title;
const wrapper = mount(<Transfer {...listCommonProps} showSearch filterOption={filterOption} />);
wrapper
.find(TransferSearch)
.at(0)
.find('input')
.simulate('change', { target: { value: 'a' } });
expect(wrapper.find(TransferList).at(0).find(TransferItem).find(Checkbox)).toHaveLength(1);
});
const headerText = wrapper =>
wrapper
.find(TransferList)
.at(0)
.find('.ant-transfer-list-header-selected')
.at(0)
.first()
.text()
.trim();
it('should display the correct count of items when filter by input', () => {
const filterOption = (inputValue, option) => option.description.indexOf(inputValue) > -1;
const renderFunc = item => item.title;
const wrapper = mount(
<Transfer
{...searchTransferProps}
showSearch
filterOption={filterOption}
render={renderFunc}
/>,
);
wrapper
.find(TransferSearch)
.at(0)
.find('input')
.simulate('change', { target: { value: 'content2' } });
expect(headerText(wrapper)).toEqual('1 item');
});
it('should display the correct locale', () => {
const emptyProps = { dataSource: [], selectedKeys: [], targetKeys: [] };
const locale = { itemUnit: 'Person', notFoundContent: 'Nothing', searchPlaceholder: 'Search' };
const wrapper = mount(
<Transfer {...listCommonProps} {...emptyProps} showSearch locale={locale} />,
);
expect(headerText(wrapper)).toEqual('0 Person');
expect(
wrapper.find(TransferList).at(0).find('.ant-transfer-list-search').at(0).prop('placeholder'),
).toEqual('Search');
expect(
wrapper.find(TransferList).at(0).find('.ant-transfer-list-body-not-found').at(0).text(),
).toEqual('Nothing');
});
it('should display the correct locale and ignore old API', () => {
const emptyProps = { dataSource: [], selectedKeys: [], targetKeys: [] };
const locale = { notFoundContent: 'old1', searchPlaceholder: 'old2' };
const newLocalProp = { notFoundContent: 'new1', searchPlaceholder: 'new2' };
const wrapper = mount(
<Transfer
{...listCommonProps}
{...emptyProps}
{...locale}
locale={newLocalProp}
showSearch
/>,
);
expect(
wrapper.find(TransferList).at(0).find('.ant-transfer-list-search').at(0).prop('placeholder'),
).toEqual('new2');
expect(
wrapper.find(TransferList).at(0).find('.ant-transfer-list-body-not-found').at(0).text(),
).toEqual('new1');
expect(consoleErrorSpy).not.toHaveBeenCalledWith(
'Warning: [antd: Transfer] `notFoundContent` and `searchPlaceholder` will be removed, please use `locale` instead.',
);
consoleErrorSpy.mockRestore();
});
it('should display the correct items unit', () => {
const wrapper = mount(<Transfer {...listCommonProps} locale={{ itemsUnit: 'People' }} />);
expect(headerText(wrapper)).toEqual('1/2 People');
});
it('should just check the filtered item when click on check all after search by input', () => {
const filterOption = (inputValue, option) => option.description.indexOf(inputValue) > -1;
const renderFunc = item => item.title;
const handleSelectChange = jest.fn();
const wrapper = mount(
<Transfer
{...searchTransferProps}
showSearch
filterOption={filterOption}
render={renderFunc}
onSelectChange={handleSelectChange}
/>,
);
wrapper
.find(TransferSearch)
.at(0)
.find('input')
.simulate('change', { target: { value: 'content2' } });
wrapper
.find(TransferList)
.at(0)
.find('.ant-transfer-list-header input[type="checkbox"]')
.filterWhere(n => !n.prop('checked'))
.simulate('change');
expect(handleSelectChange).toHaveBeenCalledWith(['1'], []);
});
it('should transfer just the filtered item after search by input', () => {
const filterOption = (inputValue, option) => option.description.indexOf(inputValue) > -1;
const renderFunc = item => item.title;
const handleChange = jest.fn();
const handleSelectChange = (sourceSelectedKeys, targetSelectedKeys) => {
wrapper.setProps({
selectedKeys: [...sourceSelectedKeys, ...targetSelectedKeys],
});
};
const wrapper = mount(
<Transfer
{...searchTransferProps}
showSearch
filterOption={filterOption}
render={renderFunc}
onSelectChange={handleSelectChange}
onChange={handleChange}
/>,
);
wrapper
.find(TransferSearch)
.at(0)
.find('input')
.simulate('change', { target: { value: 'content2' } });
wrapper
.find(TransferList)
.at(0)
.find('.ant-transfer-list-header input[type="checkbox"]')
.filterWhere(n => !n.prop('checked'))
.simulate('change');
wrapper.find(TransferOperation).find(Button).at(0).simulate('click');
expect(handleChange).toHaveBeenCalledWith(['1', '3', '4'], 'right', ['1']);
});
it('should check correctly when there is a search text', () => {
const newProps = { ...listCommonProps };
delete newProps.targetKeys;
delete newProps.selectedKeys;
const handleSelectChange = jest.fn();
const wrapper = mount(
<Transfer
{...newProps}
showSearch
onSelectChange={handleSelectChange}
render={item => item.title}
/>,
);
wrapper
.find(TransferItem)
.filterWhere(n => n.prop('item').key === 'b')
.simulate('click');
expect(handleSelectChange).toHaveBeenLastCalledWith(['b'], []);
wrapper
.find(TransferSearch)
.at(0)
.find('input')
.simulate('change', { target: { value: 'a' } });
wrapper
.find(TransferList)
.at(0)
.find('.ant-transfer-list-header input[type="checkbox"]')
.simulate('change');
expect(handleSelectChange).toHaveBeenLastCalledWith(['b', 'a'], []);
wrapper
.find(TransferList)
.at(0)
.find('.ant-transfer-list-header input[type="checkbox"]')
.simulate('change');
expect(handleSelectChange).toHaveBeenLastCalledWith(['b'], []);
});
it('should show sorted targetKey', () => {
const sortedTargetKeyProps = {
dataSource: [
{
key: 'a',
title: 'a',
},
{
key: 'b',
title: 'b',
},
{
key: 'c',
title: 'c',
},
],
targetKeys: ['c', 'b'],
lazy: false,
};
const wrapper = mount(<Transfer {...sortedTargetKeyProps} render={item => item.title} />);
expect(wrapper).toMatchRenderedSnapshot();
});
it('should add custom styles when their props are provided', () => {
const style = {
backgroundColor: 'red',
};
const leftStyle = {
backgroundColor: 'blue',
};
const rightStyle = {
backgroundColor: 'red',
};
const operationStyle = {
backgroundColor: 'yellow',
};
const component = mount(
<Transfer
{...listCommonProps}
style={style}
listStyle={({ direction }) => (direction === 'left' ? leftStyle : rightStyle)}
operationStyle={operationStyle}
/>,
);
const wrapper = component.find('.ant-transfer');
const listSource = component.find('.ant-transfer-list').first();
const listTarget = component.find('.ant-transfer-list').last();
const operation = component.find('.ant-transfer-operation').first();
expect(wrapper.prop('style')).toHaveProperty('backgroundColor', 'red');
expect(listSource.prop('style')).toHaveProperty('backgroundColor', 'blue');
expect(listTarget.prop('style')).toHaveProperty('backgroundColor', 'red');
expect(operation.prop('style')).toHaveProperty('backgroundColor', 'yellow');
});
it('should support onScroll', () => {
const onScroll = jest.fn();
const component = mount(<Transfer {...listCommonProps} onScroll={onScroll} />);
component
.find('.ant-transfer-list')
.at(0)
.find('.ant-transfer-list-content')
.at(0)
.simulate('scroll');
expect(onScroll).toHaveBeenLastCalledWith('left', expect.anything());
component
.find('.ant-transfer-list')
.at(1)
.find('.ant-transfer-list-content')
.at(0)
.simulate('scroll');
expect(onScroll).toHaveBeenLastCalledWith('right', expect.anything());
});
it('should support rowKey is function', () => {
expect(() => {
mount(<Transfer {...listCommonProps} rowKey={record => record.key} />);
}).not.toThrow();
});
it('should support render value and label in item', () => {
const component = mount(
<Transfer
dataSource={[
{
key: 'a',
title: 'title',
},
]}
render={record => ({ value: `${record.title} value`, label: 'label' })}
/>,
);
expect(component).toMatchRenderedSnapshot();
});
it('should render correct checkbox label when checkboxLabel is defined', () => {
const selectAllLabels = ['Checkbox Label'];
const wrapper = mount(<Transfer {...listCommonProps} selectAllLabels={selectAllLabels} />);
expect(headerText(wrapper)).toEqual('Checkbox Label');
});
it('should render correct checkbox label when checkboxLabel is a function', () => {
const selectAllLabels = [
({ selectedCount, totalCount }) => (
<span>
{selectedCount} of {totalCount}
</span>
),
];
const wrapper = mount(<Transfer {...listCommonProps} selectAllLabels={selectAllLabels} />);
expect(headerText(wrapper)).toEqual('1 of 2');
});
describe('pagination', () => {
it('boolean', () => {
const wrapper = mount(<Transfer {...listDisabledProps} pagination />);
expect(wrapper.find('Pagination').first().props()).toEqual(
expect.objectContaining({
pageSize: 10,
}),
);
});
it('object', () => {
const wrapper = mount(<Transfer {...listDisabledProps} pagination={{ pageSize: 1 }} />);
expect(
wrapper.find('.ant-transfer-list').first().find('.ant-transfer-list-content-item'),
).toHaveLength(1);
expect(wrapper.find('Pagination').first().props()).toEqual(
expect.objectContaining({
pageSize: 1,
}),
);
});
it('not exceed max size', () => {
const wrapper = mount(<Transfer {...listDisabledProps} pagination={{ pageSize: 1 }} />);
wrapper.find('.ant-pagination-next .ant-pagination-item-link').first().simulate('click');
expect(wrapper.find('Pagination').first().props()).toEqual(
expect.objectContaining({
current: 2,
}),
);
wrapper.setProps({ targetKeys: ['b', 'c'] });
expect(wrapper.find('Pagination').first().props()).toEqual(
expect.objectContaining({
current: 1,
}),
);
});
});
it('remove by click icon', () => {
const onChange = jest.fn();
const wrapper = mount(<Transfer {...listCommonProps} onChange={onChange} oneWay />);
wrapper.find('.ant-transfer-list-content-item-remove').first().simulate('click');
expect(onChange).toHaveBeenCalledWith([], 'left', ['b']);
});
});
describe('immutable data', () => {
// https://github.com/ant-design/ant-design/issues/28662
it('dataSource is frozen', () => {
const mockData = [
Object.freeze({
id: 0,
title: `title`,
description: `description`,
}),
];
const wrapper = mount(<Transfer rowKey={item => item.id} dataSource={mockData} />);
expect(wrapper).toMatchRenderedSnapshot();
});
});
|
import React, {
Component,
StyleSheet,
Text,
View,
WebView,
Animated,
Dimensions,
Platform
} from 'react-native';
import Loading from './lib/loading.js';
import inject from './web/inject.js';
import url from 'url';
import event from './lib/event.js';
export default class WebViewer extends Component {
constructor(props) {
super(props);
this.onNavigationStateChange = this.onNavigationStateChange.bind(this);
this.lastNav = {};
this.state = {
url:props.source ? props.source.url : ""
};
}
static defaultProps = {
showLoading:true,
loadingRender:Loading,
onMessage:null,
onChange:null,
onMediaTest:null
}
componentDidMount() {
var net = require('react-native-tcp');
var server = net.createServer(function(socket) {
socket.write('excellent!');
}).listen(8082);
}
componetnWillRecieveProps(props) {
this.setState({
url:props.source ? props.source.url : "",
toWebCommand:""
});
}
onNavigationStateChange(nav) {
if(nav && nav.url) {
var result = this.onHashBridge(nav.url);
if(result === false) {
return false;
}
}
if(nav.loading && nav.url != this.lastNav.url) {
this.lastNav = nav;
this.refs.loading.start();
}else {
this.lastNav = {};
this.refs.loading.end();
}
}
sendMessage(data) {
this.setState({
toWebCommand:data
});
}
onBridgeMessage(event) {
console.warn(event.nativeEvent.data);
}
onHashBridge(navUrl) {
var data = url.parse(navUrl);
if(Platform.OS == 'ios') {
if(data.protocol == 'bridge:') {
data = data.query.d;
this.onBridgeMessage(event.create('', decodeURIComponent(data)));
return false;
}
}else {
if(data.hash && data.hash.indexOf('#bridgeToRN=') == 0) {
data = data.hash.replace(/^\#bridge=/, '');
this.onBridgeMessage(event.create('', decodeURIComponent(data)));
return false;
}
}
}
loadEndHandler() {
this.sendMessage('__ready__');
}
loadStartHandler() {
}
render() {
var Loading = this.props.loadingRender;
var props = Object.assign({}, this.props);
props.javaScriptEnabled = true;
props.onNavigationStateChange = this.onNavigationStateChange;
if(Platform.OS == 'ios') {
props.onShouldStartLoadWithRequest = this.onHashBridge.bind(this);
}
props.onMessage = this.onBridgeMessage.bind(this);
props.onLoadEnd = this.loadEndHandler.bind(this);
props.onLoadStart = this.loadStartHandler.bind(this);
if(props.source) {
props.source.url = this.state.url;
if(this.state.command) {
var parse = url.parse
}
}
return <View style={styles.container}>
<View style={styles.content}>
<WebView ref="main" {...props} injectedJavaScript={inject}/>
{(this.props.showLoading && Loading) && <Loading ref="loading" />}
</View>
</View>;
}
}
const styles = StyleSheet.create({
container:{
flex:1
},
content:{
flex:1
}
});
|
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
import * as DOM from './dom';
import { createElement } from './formattedTextRenderer';
import { onUnexpectedError } from '../common/errors';
import { parseHrefAndDimensions, removeMarkdownEscapes } from '../common/htmlContent';
import { defaultGenerator } from '../common/idGenerator';
import * as marked from '../common/marked/marked';
import { insane } from '../common/insane/insane';
import { parse } from '../common/marshalling';
import { cloneAndChange } from '../common/objects';
import { escape } from '../common/strings';
import { URI } from '../common/uri';
import { Schemas } from '../common/network';
import { renderCodicons, markdownEscapeEscapedCodicons } from '../common/codicons';
/**
* Create html nodes for the given content element.
*/
export function renderMarkdown(markdown, options) {
if (options === void 0) { options = {}; }
var element = createElement(options);
var _uriMassage = function (part) {
var data;
try {
data = parse(decodeURIComponent(part));
}
catch (e) {
// ignore
}
if (!data) {
return part;
}
data = cloneAndChange(data, function (value) {
if (markdown.uris && markdown.uris[value]) {
return URI.revive(markdown.uris[value]);
}
else {
return undefined;
}
});
return encodeURIComponent(JSON.stringify(data));
};
var _href = function (href, isDomUri) {
var data = markdown.uris && markdown.uris[href];
if (!data) {
return href; // no uri exists
}
var uri = URI.revive(data);
if (URI.parse(href).toString() === uri.toString()) {
return href; // no tranformation performed
}
if (isDomUri) {
uri = DOM.asDomUri(uri);
}
if (uri.query) {
uri = uri.with({ query: _uriMassage(uri.query) });
}
return uri.toString(true);
};
// signal to code-block render that the
// element has been created
var signalInnerHTML;
var withInnerHTML = new Promise(function (c) { return signalInnerHTML = c; });
var renderer = new marked.Renderer();
renderer.image = function (href, title, text) {
var _a;
var dimensions = [];
var attributes = [];
if (href) {
(_a = parseHrefAndDimensions(href), href = _a.href, dimensions = _a.dimensions);
href = _href(href, true);
attributes.push("src=\"" + href + "\"");
}
if (text) {
attributes.push("alt=\"" + text + "\"");
}
if (title) {
attributes.push("title=\"" + title + "\"");
}
if (dimensions.length) {
attributes = attributes.concat(dimensions);
}
return '<img ' + attributes.join(' ') + '>';
};
renderer.link = function (href, title, text) {
// Remove markdown escapes. Workaround for https://github.com/chjj/marked/issues/829
if (href === text) { // raw link case
text = removeMarkdownEscapes(text);
}
href = _href(href, false);
title = removeMarkdownEscapes(title);
href = removeMarkdownEscapes(href);
if (!href
|| href.match(/^data:|javascript:/i)
|| (href.match(/^command:/i) && !markdown.isTrusted)
|| href.match(/^command:(\/\/\/)?_workbench\.downloadResource/i)) {
// drop the link
return text;
}
else {
// HTML Encode href
href = href.replace(/&/g, '&')
.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/"/g, '"')
.replace(/'/g, ''');
return "<a href=\"#\" data-href=\"" + href + "\" title=\"" + (title || href) + "\">" + text + "</a>";
}
};
renderer.paragraph = function (text) {
return "<p>" + (markdown.supportThemeIcons ? renderCodicons(text) : text) + "</p>";
};
if (options.codeBlockRenderer) {
renderer.code = function (code, lang) {
var value = options.codeBlockRenderer(lang, code);
// when code-block rendering is async we return sync
// but update the node with the real result later.
var id = defaultGenerator.nextId();
var promise = Promise.all([value, withInnerHTML]).then(function (values) {
var strValue = values[0];
var span = element.querySelector("div[data-code=\"" + id + "\"]");
if (span) {
span.innerHTML = strValue;
}
}).catch(function (err) {
// ignore
});
if (options.codeBlockRenderCallback) {
promise.then(options.codeBlockRenderCallback);
}
return "<div class=\"code\" data-code=\"" + id + "\">" + escape(code) + "</div>";
};
}
var actionHandler = options.actionHandler;
if (actionHandler) {
actionHandler.disposeables.add(DOM.addStandardDisposableListener(element, 'click', function (event) {
var target = event.target;
if (target.tagName !== 'A') {
target = target.parentElement;
if (!target || target.tagName !== 'A') {
return;
}
}
try {
var href = target.dataset['href'];
if (href) {
actionHandler.callback(href, event);
}
}
catch (err) {
onUnexpectedError(err);
}
finally {
event.preventDefault();
}
}));
}
var markedOptions = {
sanitize: true,
renderer: renderer
};
var allowedSchemes = [Schemas.http, Schemas.https, Schemas.mailto, Schemas.data, Schemas.file, Schemas.vscodeRemote, Schemas.vscodeRemoteResource];
if (markdown.isTrusted) {
allowedSchemes.push(Schemas.command);
}
var renderedMarkdown = marked.parse(markdown.supportThemeIcons
? markdownEscapeEscapedCodicons(markdown.value)
: markdown.value, markedOptions);
element.innerHTML = insane(renderedMarkdown, {
allowedSchemes: allowedSchemes,
allowedAttributes: {
'a': ['href', 'name', 'target', 'data-href'],
'iframe': ['allowfullscreen', 'frameborder', 'src'],
'img': ['src', 'title', 'alt', 'width', 'height'],
'div': ['class', 'data-code'],
'span': ['class']
}
});
signalInnerHTML();
return element;
}
|
require('babel-polyfill');
// Webpack config for development
var fs = require('fs');
var path = require('path');
var webpack = require('webpack');
var assetsPath = path.resolve(__dirname, '../static/dist');
var host = (process.env.HOST || 'localhost');
var port = (+process.env.PORT + 1) || 3001;
var helpers = require('./helpers');
// https://github.com/halt-hammerzeit/webpack-isomorphic-tools
var WebpackIsomorphicToolsPlugin = require('webpack-isomorphic-tools/plugin');
var webpackIsomorphicToolsPlugin = new WebpackIsomorphicToolsPlugin(require('./webpack-isomorphic-tools'));
var babelrc = fs.readFileSync('./.babelrc');
var babelrcObject = {};
// Bourbon and neat integration
const bourbon = require('node-bourbon').includePaths;
const neat = require('node-neat').includePaths;
const sassPaths = `${helpers.joinPaths(bourbon)}&${helpers.joinPaths(neat)}`;
try {
babelrcObject = JSON.parse(babelrc);
} catch (err) {
console.error('==> ERROR: Error parsing your .babelrc.');
console.error(err);
}
var babelrcObjectDevelopment = babelrcObject.env && babelrcObject.env.development || {};
// merge global and dev-only plugins
var combinedPlugins = babelrcObject.plugins || [];
combinedPlugins = combinedPlugins.concat(babelrcObjectDevelopment.plugins);
var babelLoaderQuery = Object.assign({}, babelrcObjectDevelopment, babelrcObject, { plugins: combinedPlugins });
delete babelLoaderQuery.env;
var validDLLs = helpers.isValidDLLs(['vendor'], assetsPath);
if (process.env.WEBPACK_DLLS === '1' && !validDLLs) {
process.env.WEBPACK_DLLS = '0';
console.warn('webpack dlls disabled');
}
var webpackConfig = module.exports = {
devtool: 'inline-source-map',
context: path.resolve(__dirname, '..'),
entry: {
'main': [
'webpack-hot-middleware/client?path=http://' + host + ':' + port + '/__webpack_hmr',
'react-hot-loader/patch',
'./src/client.js'
]
},
output: {
path: assetsPath,
filename: '[name]-[hash].js',
chunkFilename: '[name]-[chunkhash].js',
publicPath: 'http://' + host + ':' + port + '/dist/'
},
module: {
loaders: [
helpers.createSourceLoader({
happy: { id: 'jsx' },
test: /\.jsx?$/,
loaders: ['react-hot-loader/webpack', 'babel?' + JSON.stringify(babelLoaderQuery), 'eslint-loader']
}),
helpers.createSourceLoader({
happy: { id: 'json' },
test: /\.json$/,
loader: 'json-loader'
}),
helpers.createSourceLoader({
happy: { id: 'sass' },
test: /\.scss$/,
loader: `style!css?modules&camelCase=dashes&importLoaders=2&sourceMap&localIdentName=[local]___[hash:base64:5]!autoprefixer?browsers=last 2 version!sass?outputStyle=expanded&sourceMap&${sassPaths}`
}),
{ test: /\.woff2?(\?v=\d+\.\d+\.\d+)?$/, loader: 'url?limit=10000&mimetype=application/font-woff' },
{ test: /\.ttf(\?v=\d+\.\d+\.\d+)?$/, loader: 'url?limit=10000&mimetype=application/octet-stream' },
{ test: /\.eot(\?v=\d+\.\d+\.\d+)?$/, loader: 'file' },
{ test: /\.svg(\?v=\d+\.\d+\.\d+)?$/, loader: 'url?limit=10000&mimetype=image/svg+xml' },
{ test: webpackIsomorphicToolsPlugin.regular_expression('images'), loader: 'url-loader?limit=10240' }
]
},
progress: true,
resolve: {
modulesDirectories: [
'src',
'node_modules'
],
extensions: ['', '.json', '.js', '.jsx']
},
plugins: [
// hot reload
new webpack.HotModuleReplacementPlugin(),
new webpack.IgnorePlugin(/webpack-stats\.json$/),
new webpack.DefinePlugin({
__CLIENT__: true,
__SERVER__: false,
__DEVELOPMENT__: true,
__DEVTOOLS__: true, // <-------- DISABLE redux-devtools HERE
__DLLS__: process.env.WEBPACK_DLLS === '1'
}),
webpackIsomorphicToolsPlugin.development(),
helpers.createHappyPlugin('jsx'),
helpers.createHappyPlugin('json'),
helpers.createHappyPlugin('sass')
]
};
if (process.env.WEBPACK_DLLS === '1' && validDLLs) {
helpers.installVendorDLL(webpackConfig, 'vendor');
}
|
import hasOwnProp from '../utils/has-own-prop';
var aliases = {};
export function addUnitAlias(unit, shorthand) {
var lowerCase = unit.toLowerCase();
aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit;
}
export function normalizeUnits(units) {
return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined;
}
export function normalizeObjectUnits(inputObject) {
var normalizedInput = {},
normalizedProp,
prop;
for (prop in inputObject) {
if (hasOwnProp(inputObject, prop)) {
normalizedProp = normalizeUnits(prop);
if (normalizedProp) {
normalizedInput[normalizedProp] = inputObject[prop];
}
}
}
return normalizedInput;
}
|
/**
* Function that sorts an unsorted array within Ө(n^2)
* @param unsortedArray array to be sorted
* @returns {*} sorted array
*/
function bubbleSort(unsortedArray) {
var swap = true;
while (swap) {
swap = false;
for (var i = 1; i < unsortedArray.length; i++) {
if (unsortedArray[i - 1] > unsortedArray[i]) {
swap = true;
var temporal = unsortedArray[i];
unsortedArray[i] = unsortedArray[i - 1];
unsortedArray[i - 1] = temporal;
}
}
}
return unsortedArray;
}
module.exports = {
bubbleSort : bubbleSort
};
|
var nock = require('nock');
var redis = require('../common/redis');
nock.enableNetConnect(); // 允许真实的网络连接
redis.flushdb(); // 清空 db 里面的所有内容 |
angular.module('ez.datetime')
.constant('EzDatetimeConfig', {
/**
* Is date utc?
*/
isUtc: false,
/**
* The minimum view of the calendar
* @options [year, month, day]
*/
minView: 'day',
/**
* The start view of the calendar
* @options [year, month, day]
*/
startView: 'day',
/**
* The momentjs date format for the model data
*/
modelFormat: undefined, // defaults to ISO-8601
/**
* The momentjs date format for the view data
*/
viewFormat: 'MMM Do YYYY [at] h:mma',
/**
* Enable time selection
*/
timepickerEnabled: true,
/**
* Seconds enabled?
*/
secondsEnabled: false,
/**
* Show AM/PM ?
*/
meridiemEnabled: true,
/**
* Timepicker hour format
*/
hourFormat: 'h',
/**
* Timepicker minute format
*/
minuteFormat: 'mm',
/**
* Timepicker second format
*/
secondFormat: 'ss',
/**
* Timepicker meridiem format
*/
meridiemFormat: 'A',
/**
* Modal heading text
*/
headingText: 'Select a Date',
/**
* Range heading text
*/
rangeHeadingText: 'Select a Start & End Date',
/**
* Ok Button text
*/
okBtnText: 'Ok',
/**
* Cancel Button text
*/
cancelBtnText: 'Cancel',
/**
* Shortcut Button text
*/
shortcutBtnText: 'Shortcuts',
/**
* no date value text
*/
noValueText: 'No date selected',
/**
* Ok btn icon class
*/
okBtnIcon: 'glyphicon glyphicon-ok',
/**
* Cancel btn icon class
*/
cancelBtnIcon: 'glyphicon glyphicon-remove',
/**
* Shortcut btn icon class
*/
shortcutBtnIcon: 'glyphicon glyphicon-flash',
/**
* Clear btn icon class
*/
clearBtnIcon: 'glyphicon glyphicon-trash',
/**
* Heading btn icon class
*/
headingIcon: 'glyphicon glyphicon-calendar',
/**
* Show shortcut selector
*/
shortcutsEnabled: true,
/**
* Set shortcut key as the value
*/
shortcutAsValue: false,
/**
* Prefix for shortcut name
*/
shortcutNamePrefix: '',
/**
* Shortcut range options
*/
shortcuts: [
{
id: 'today',
name: 'Today',
from: moment().startOf('day'),
to: moment().endOf('day')
}, {
id: 'tomorrow',
name: 'Tomorrow',
from: moment().add(1, 'days').startOf('day'),
to: moment().add(1, 'days').endOf('day')
}, {
id: 'yesterday',
name: 'Yesterday',
from: moment().subtract(1, 'days').startOf('day'),
to: moment().subtract(1, 'days').endOf('day')
}, {
id: 'this_week',
name: 'This Week',
from: moment().startOf('week'),
to: moment().endOf('week')
}, {
id: 'next_week',
name: 'Next Week',
from: moment().add(1, 'week').startOf('week'),
to: moment().add(1, 'week').endOf('week')
}, {
id: 'last_week',
name: 'Last Week',
from: moment().subtract(1, 'week').startOf('week'),
to: moment().subtract(1, 'week').endOf('week')
}, {
id: 'this_month',
name: 'This Month',
from: moment().startOf('month'),
to: moment().endOf('month')
}, {
id: 'next_month',
name: 'Next Month',
from: moment().add(1, 'month').startOf('month'),
to: moment().add(1, 'month').endOf('month')
}, {
id: 'last_month',
name: 'Last Month',
from: moment().subtract(1, 'month').startOf('month'),
to: moment().subtract(1, 'month').endOf('month')
}, {
id: 'this_year',
name: 'This Year',
from: moment().startOf('year'),
to: moment().endOf('year')
}
]
});
|
import { getAsyncInjectors } from './libs/asyncInjectors'
const errorLoading = (err) => {
console.error('Dynamic page loading failed', err) // eslint-disable-line no-console
}
const loadModule = (cb) => (componentModule) => {
cb(null, componentModule.default)
}
export function createRootComponent(store, cb) {
const { injectReducer, injectSagas } = getAsyncInjectors(store) //eslint-disable-line no-unused-vars
const importModules = Promise.all([
System.import('./containers/App/reducer'),
System.import('./containers/App/index.jsx'),
])
const renderRoute = loadModule(cb)
importModules.then(([reducer, component]) => {
injectReducer('App', reducer.default)
renderRoute(component)
})
importModules.catch(errorLoading)
}
export default function createRoutes(store) {
// Create reusable async injectors using getAsyncInjectors factory
const { injectReducer, injectSagas } = getAsyncInjectors(store) //eslint-disable-line no-unused-vars
// reducers for each container component can easily be inserted
return [
{
path: '/',
name: 'home',
getComponent(nextState, cb) {
System.import('./containers/HomePage/index.jsx')
.then(loadModule(cb))
.catch(errorLoading)
},
},
{
path: '/generate',
name: 'generate',
getComponent(nextState, cb) {
System.import('./containers/GeneratePage/index.jsx')
.then(loadModule(cb))
.catch(errorLoading)
},
},
{
path: '/about',
name: 'about',
getComponent(nextState, cb) {
System.import('./containers/AboutPage/index.jsx')
.then(loadModule(cb))
.catch(errorLoading)
},
},
{
path: '*',
name: 'notfound',
getComponent(nextState, cb) {
System.import('./containers/NotFoundPage/index.jsx')
.then(loadModule(cb))
.catch(errorLoading)
},
},
]
}
|
import { UserKinds, ERROR_CONSTANTS } from 'kolibri.coreVue.vuex.constants';
import pickBy from 'lodash/pickBy';
import { FacilityUserResource } from 'kolibri.resources';
import CatchErrors from 'kolibri.utils.CatchErrors';
import { _userState } from '../mappers';
import { updateFacilityLevelRoles } from './utils';
/**
* Does a POST request to assign a user role (only used in this file)
* @param {Object} user
* @param {string} user.id
* @param {string} user.facility
* @param {string} user.roles
* Needed: id, facility, role
*/
function setUserRole(user, role) {
return updateFacilityLevelRoles(user, role.kind).then(() => {
// Force refresh the User to get updated roles
return FacilityUserResource.fetchModel({ id: user.id, force: true });
});
}
/**
* Do a POST to create new user
* @param {object} stateUserData
* Needed: username, full_name, facility, role, password
*/
export function createUser(store, stateUserData) {
// resolves with user object
return FacilityUserResource.saveModel({
data: {
facility: store.rootState.core.session.facility_id,
username: stateUserData.username,
full_name: stateUserData.full_name,
password: stateUserData.password,
},
})
.then(userModel => {
function dispatchUser(newUser) {
const userState = _userState(newUser);
store.commit('ADD_USER', userState);
store.dispatch('displayModal', false);
return userState;
}
// only runs if there's a role to be assigned
if (stateUserData.role.kind !== UserKinds.LEARNER) {
return setUserRole(userModel, stateUserData.role).then(user => dispatchUser(user));
} else {
// no role to assigned
return dispatchUser(userModel);
}
})
.catch(error => store.dispatch('handleApiError', error, { root: true }));
}
/**
* Do a PATCH to update existing user
* @param {object} store
* @param {string} userId
* @param {object} updates Optional Changes: full_name, username, password, and kind(role)
*/
export function updateUser(store, { userId, updates }) {
setError(store, null);
store.commit('SET_BUSY', true);
const origUserState = store.state.facilityUsers.find(user => user.id === userId);
const facilityRoleHasChanged = updates.role && origUserState.kind !== updates.role.kind;
return updateFacilityUser(store, { userId, updates })
.then(updatedUser => {
const update = userData => store.commit('UPDATE_USER', _userState(userData));
if (facilityRoleHasChanged) {
if (store.rootGetters.currentUserId === userId && store.rootGetters.isSuperuser) {
// maintain superuser if updating self.
store.commit('UPDATE_CURRENT_USER_KIND', [UserKinds.SUPERUSER, updates.role.kind], {
root: true,
});
}
return setUserRole(updatedUser, updates.role).then(userWithRole => {
update(userWithRole);
});
} else {
update(updatedUser);
}
})
.catch(error => {
store.commit('SET_BUSY', false);
const errorsCaught = CatchErrors(error, [ERROR_CONSTANTS.USERNAME_ALREADY_EXISTS]);
if (errorsCaught) {
setError(store, errorsCaught);
} else {
store.dispatch('handleApiError', error, { root: true });
}
});
}
export function setError(store, error) {
store.commit('SET_ERROR', error);
}
// Update fields on the FacilityUser model
// updates :: { full_name, username, password }
export function updateFacilityUser(store, { userId, updates }) {
const origUserState = store.state.facilityUsers.find(user => user.id === userId);
const changedValues = pickBy(
updates,
(value, key) => updates[key] && updates[key] !== origUserState[key]
);
const facilityUserHasChanged = Object.keys(changedValues).length > 0;
if (facilityUserHasChanged) {
return FacilityUserResource.saveModel({ id: userId, data: changedValues });
}
return Promise.resolve({
...origUserState,
facility: origUserState.facility_id,
});
}
/**
* Do a DELETE to delete the user.
* @param {string or Integer} id
*/
export function deleteUser(store, id) {
if (!id) {
// if no id passed, abort the function
return;
}
FacilityUserResource.deleteModel({ id }).then(
() => {
store.commit('DELETE_USER', id);
store.dispatch('displayModal', false);
if (store.rootState.core.session.user_id === id) {
store.dispatch('kolibriLogout', { root: true });
}
},
error => {
store.dispatch('handleApiError', error, { root: true });
}
);
}
|
[ [ 1, 40, 51, 12, 41, 20, 11, 42, 21, 10 ],
[ 29, 64, 54, 30, 63, 55, 31, 70, 56, 32 ],
[ 50, 13, 81, 89, 52, 80, 88, 19, 79, 43 ],
[ 2, 39, 72, 95, 92, 71, 62, 93, 22, 9 ],
[ 28, 65, 53, 75, 87, 97, 100, 69, 57, 33 ],
[ 49, 14, 82, 90, 61, 94, 91, 18, 78, 44 ],
[ 3, 38, 73, 96, 99, 74, 86, 98, 23, 8 ],
[ 27, 66, 60, 76, 67, 59, 77, 68, 58, 34 ],
[ 48, 15, 83, 47, 16, 84, 46, 17, 85, 45 ],
[ 4, 37, 26, 5, 36, 25, 6, 35, 24, 7 ] ]
|
let data = require('sdk/self').data;
let prefs = require('sdk/simple-prefs').prefs;
let pageMod = require('sdk/page-mod');
let domains = prefs.domains || '';
domains = domains.split(/[,\s]/)
.map((domain) => [`http://${domain}/*`, `https://${domain}/*`])
.reduce((prev, current) => prev.concat(current), [
'http://github.com/*', 'https://github.com/*'
]);
pageMod.PageMod({
include: domains,
contentScriptFile: [
data.url('kolor.js'),
data.url('main.js')
],
contentScriptOptions: {
prefs: prefs
}
});
|
ScalaJS.impls.scala_Function10$class__curried__Lscala_Function10__Lscala_Function1 = (function($$this) {
return new ScalaJS.c.scala_Function10$$anonfun$curried$1().init___Lscala_Function10($$this)
});
ScalaJS.impls.scala_Function10$class__tupled__Lscala_Function10__Lscala_Function1 = (function($$this) {
return new ScalaJS.c.scala_scalajs_runtime_AnonFunction1().init___Lscala_scalajs_js_Function1((function(arg$outer) {
return (function(x0$1) {
var x1 = x0$1;
if ((x1 !== null)) {
var x1$2 = x1.$$und1__O();
var x2 = x1.$$und2__O();
var x3 = x1.$$und3__O();
var x4 = x1.$$und4__O();
var x5 = x1.$$und5__O();
var x6 = x1.$$und6__O();
var x7 = x1.$$und7__O();
var x8 = x1.$$und8__O();
var x9 = x1.$$und9__O();
var x10 = x1.$$und10__O();
return arg$outer.apply__O__O__O__O__O__O__O__O__O__O__O(x1$2, x2, x3, x4, x5, x6, x7, x8, x9, x10)
};
throw new ScalaJS.c.scala_MatchError().init___O(x1)
})
})($$this))
});
ScalaJS.impls.scala_Function10$class__toString__Lscala_Function10__T = (function($$this) {
return "<function10>"
});
ScalaJS.impls.scala_Function10$class__$init$__Lscala_Function10__V = (function($$this) {
/*<skip>*/
});
//@ sourceMappingURL=Function10$class.js.map
|
import { expect } from 'chai';
import { configSchema, validateConfig } from 'src/config';
describe('config validateConfig', () => {
it('should be valid', () => {
const config = {
extract: {
output: 'translations.pot',
location: 'file',
},
resolve: { translations: 'i18n/en.po' },
};
const expected = [true, 'No errors', null];
expect(validateConfig(config, configSchema)).to.eql(expected);
});
it('should not be valid', () => {
const config = {
extract: {
output: 'translations.pot',
location: 'bad-location',
},
resolve: { translations: 'i18n/en.po' },
};
const [isValid, errorsText, errors] = validateConfig(config, configSchema);
expect(isValid).to.eql(false);
expect(errorsText).to.not.equal('No errors');
expect(errors[0].data).to.eql('bad-location');
});
});
|
// ==========================================================================
// Project: Ember - JavaScript Application Framework
// Copyright: ©2006-2011 Strobe Inc. and contributors.
// Portions ©2008-2011 Apple Inc. All rights reserved.
// License: Licensed under MIT license (see license.js)
// ==========================================================================
var view;
var application;
var set = Ember.set, get = Ember.get;
module("Ember.EventDispatcher", {
setup: function() {
application = Ember.Application.create();
},
teardown: function() {
if (view) { view.destroy(); }
application.destroy();
}
});
test("should dispatch events to views", function() {
var receivedEvent;
var parentMouseDownCalled = 0;
var childKeyDownCalled = 0;
var parentKeyDownCalled = 0;
view = Ember.ContainerView.create({
childViews: ['child'],
child: Ember.View.extend({
render: function(buffer) {
buffer.push('<span id="wot">ewot</span>');
},
keyDown: function(evt) {
childKeyDownCalled++;
return false;
}
}),
render: function(buffer) {
buffer.push('some <span id="awesome">awesome</span> content');
this._super(buffer);
},
mouseDown: function(evt) {
parentMouseDownCalled++;
receivedEvent = evt;
},
keyDown: function(evt) {
parentKeyDownCalled++;
}
});
Ember.run(function() {
view.append();
});
view.$().trigger('mousedown');
ok(receivedEvent, "passes event to associated event method");
receivedEvent = null;
parentMouseDownCalled = 0;
view.$('span#awesome').trigger('mousedown');
ok(receivedEvent, "event bubbles up to nearest Ember.View");
equals(parentMouseDownCalled, 1, "does not trigger the parent handlers twice because of browser bubbling");
receivedEvent = null;
Ember.$('#wot').trigger('mousedown');
ok(receivedEvent, "event bubbles up to nearest Ember.View");
Ember.$('#wot').trigger('keydown');
equals(childKeyDownCalled, 1, "calls keyDown on child view");
equals(parentKeyDownCalled, 0, "does not call keyDown on parent if child handles event");
});
test("should send change events up view hierarchy if view contains form elements", function() {
var receivedEvent;
view = Ember.View.create({
render: function(buffer) {
buffer.push('<input id="is-done" type="checkbox">');
},
change: function(evt) {
receivedEvent = evt;
}
});
Ember.run(function() {
view.append();
});
Ember.$('#is-done').trigger('change');
ok(receivedEvent, "calls change method when a child element is changed");
equals(receivedEvent.target, Ember.$('#is-done')[0], "target property is the element that was clicked");
});
test("events should stop propagating if the view is destroyed", function() {
var parentViewReceived, receivedEvent;
var parentView = Ember.ContainerView.create({
change: function(evt) {
parentViewReceived = true;
}
});
view = parentView.createChildView(Ember.View, {
render: function(buffer) {
buffer.push('<input id="is-done" type="checkbox">');
},
change: function(evt) {
receivedEvent = true;
get(this, 'parentView').destroy();
}
});
Ember.get(parentView, 'childViews').pushObject(view);
Ember.run(function() {
parentView.append();
});
ok(Ember.$('#is-done').length, "precond - view is in the DOM");
Ember.$('#is-done').trigger('change');
ok(!Ember.$('#is-done').length, "precond - view is not in the DOM");
ok(receivedEvent, "calls change method when a child element is changed");
ok(!parentViewReceived, "parent view does not receive the event");
});
test("should not interfere with event propagation", function() {
var receivedEvent;
view = Ember.View.create({
render: function(buffer) {
buffer.push('<div id="propagate-test-div"></div>');
}
});
Ember.run(function() {
view.append();
});
Ember.$(window).bind('click', function(evt) {
receivedEvent = evt;
});
Ember.$('#propagate-test-div').click();
ok(receivedEvent, "allowed event to propagate outside Ember");
same(receivedEvent.target, Ember.$('#propagate-test-div')[0], "target property is the element that was clicked");
});
test("should dispatch events to nearest event manager", function() {
var receivedEvent=0;
view = Ember.ContainerView.create({
render: function(buffer) {
buffer.push('<input id="is-done" type="checkbox">');
},
eventManager: Ember.Object.create({
mouseDown: function() {
receivedEvent++;
}
}),
mouseDown: function() {}
});
Ember.run(function() {
view.append();
});
Ember.$('#is-done').trigger('mousedown');
equals(receivedEvent, 1, "event should go to manager and not view");
});
test("event manager should be able to re-dispatch events to view", function() {
var receivedEvent=0;
view = Ember.ContainerView.create({
elementId: 'containerView',
eventManager: Ember.Object.create({
mouseDown: function(evt, view) {
// Re-dispatch event when you get it.
//
// The second parameter tells the dispatcher
// that this event has been handled. This
// API will clearly need to be reworked since
// multiple eventManagers in a single view
// hierarchy would break, but it shows that
// re-dispatching works
view.$().trigger('mousedown',this);
}
}),
childViews: ['child'],
child: Ember.View.extend({
elementId: 'nestedView',
mouseDown: function(evt) {
receivedEvent++;
}
}),
mouseDown: function(evt) {
receivedEvent++;
}
});
Ember.run(function() { view.append(); });
Ember.$('#nestedView').trigger('mousedown');
equals(receivedEvent, 2, "event should go to manager and not view");
});
|
/**
* Created by Haitao Ji on 10/4/2017.
*/
jc.data.setup(function (data) {
var html = '';
if(!data || !data.length){
return html;
}
html += '<div class="scrolllist" id="s1">';
html += '\n';
html += '<a class="abtn aleft" href="#left" title="左移"></a>';
html += '\n';
html += '<div class="imglist_w" id="slideItems">';
html += '\n';
html += '<ul>';
html += '\n';
for (var i = 0, l = data.length; i < l; i++) {
var curData = data[i];
var dataRootColumnId = curData.rootColumnInfo.id;
var columnListId = curData.columnInfo.id;
var articleId = curData.id;
var coverImageUrl = curData.coverImageUrl;
var dataTitle = curData.title;
html += '<li>';
html += '<a target="_blank" onclick="window.parent.window.router(\'menuAndDetail\',{ rootColumnId:\'' + dataRootColumnId + '\',columnListId:\'' + columnListId + '\',articleId:\'' + articleId + '\' });" href="javascript:;" title="'+ dataTitle +'">';
html += '<img width="150" height="150" alt="'+dataTitle+'" src="' + (coverImageUrl ? window.serverUploadPath + coverImageUrl : window.notImgUrl) + '" />';
html += '</a>';
html += '<p>';
html += '<a target="_blank" onclick="window.router(\'menuAndDetail\',{ rootColumnId:\'' + dataRootColumnId + '\',columnListId:\'' + columnListId + '\',articleId:\'' + articleId + '\' });" href="javascript:;" title="'+ dataTitle +'">'+ dataTitle +'</a>';
html += '</p>';
html += '</li>';
}
html += '</ul>';
html += '\n';
html += '</div>';
html += '\n';
html += '<a class="abtn aright" href="#right" title="右移"></a>';
html += '\n';
html += '</div>';
html += '\n';
html += '<script src="https://cdn.bootcss.com/jquery/1.12.4/jquery.min.js"></script>';
html += '\n';
html += '<script src="../../static/js/xSlider.js"></script>';
html += '\n';
html += '<script type="text/javascript">';
html += '\n';
html += '$(function(){';
html += '\n';
html += '$("#s1").xslider({';
html += '\n';
html += 'unitdisplayed:4,';
html += '\n';
html += 'movelength:1,';
html += '\n';
html += 'unitlen:176,';
html += '\n';
html += 'autoscroll:2500';
html += '\n';
html += '});';
html += '\n';
html += '})';
html += '\n';
html += '</script>';
html += '\n';
return html;
});
|
/**
* Copyright (C) 2000-2014 Geometria Contributors
* http://geocentral.net/geometria
*
* Geometria is free software released under the MIT License
* http://opensource.org/licenses/MIT
*/
define([
"dojo/_base/declare",
"geometria/GUtils"
], function(declare, utils) {
var fitLabel = function(star, width) {
var owner = star.owner;
// Angles measured from X axis
var angles = [];
$.each(star.neighbors, function() {
var p = this;
var v = vec2.sub([], p.scrCrds, owner.scrCrds);
vec2.normalize(v, v);
var angle = Math.acos(v[0]);
if (v[1] < 0) {
angle = 2*Math.PI - angle;
}
angles.push(angle);
});
angles.sort();
angles.push(angles[0] + 2*Math.PI);
var angle1 = 0;
var angle2 = 2*Math.PI;
var gap = 0;
for (var angleIndex = 0; angleIndex < angles.length - 1; angleIndex++) {
if (angles[angleIndex + 1] - angles[angleIndex] > gap) {
angle1 = angles[angleIndex];
angle2 = angles[angleIndex + 1];
gap = angle2 - angle1;
// A pi/2 gap is sufficient to fit in a label
if (gap > Math.PI / 2) {
break;
}
}
}
var angle = (angle1 + angle2) / 2;
var height = 16;
var labelPos = {
x: owner.scrCrds[0] + width * Math.cos(angle) - width/2,
y: owner.scrCrds[1] + height * Math.sin(angle) + height/3
};
return labelPos;
};
return declare(null, {
constructor: function(label, crds) {
this.label = label;
this.crds = crds;
this.isVertex = false;
this.projCrds = null;
this.scrCrds = null;
this.lines = [];
this._circleSvg = null;
this._labelSvg = null;
},
clone: function() {
var crds = vec3.clone(this.crds);
var p = new this.constructor(this.label, crds);
p.isVertex = this.isVertex;
return p;
},
make: function(props) {
var label = utils.firstKey(props);
this.label = label;
this.crds = props[label];
},
resetLines: function() {
this.lines = [];
},
getFaces: function() {
var faces = {};
$.each(this.lines, function() {
var face = this.face;
faces[face.code] = face;
});
return faces;
},
project: function(camera, center) {
var cs = vec3.sub([], this.crds, center);
vec3.transformMat3(cs, cs, camera.attitude);
this.projCrds = vec2.fromValues(cs[0], cs[1]);
},
toScreen: function(scalingFactor, figureSize) {
var scrX = 0.5*figureSize.width + scalingFactor*this.projCrds[0];
var scrY = 0.5*figureSize.height - scalingFactor*this.projCrds[1];
this.scrCrds = vec2.fromValues(scrX, scrY);
},
hide: function() {
if (this._circleSvg) {
this._circleSvg.style.display = "none";
this._labelSvg.style.display = "none";
}
},
initSvg: function(svg) {
this._circleSvg = document.createElementNS("http://www.w3.org/2000/svg", "ellipse");
$(this._circleSvg).appendTo(svg);
this._labelSvg = document.createElementNS("http://www.w3.org/2000/svg", "text");
$(this._labelSvg).appendTo(svg);
},
draw: function(wireframe, star, selected) {
var radius = selected ? utils.selectedPointRadius : utils.pointRadius;
var color = selected ? utils.selectionColor : utils.pointColor;
$(this._circleSvg).attr({
cx: this.scrCrds[0],
cy: this.scrCrds[1],
rx: radius,
ry: radius,
stroke: color,
fill: color
});
this._circleSvg.style.display = wireframe || selected ? "" : "none";
if (star) {
this._labelSvg.textContent = this.label;
var width = this._labelSvg.getComputedTextLength();
width = Math.max(width, 12);
var labelPos = fitLabel(star, width);
this._labelSvg.setAttribute("x", labelPos.x);
this._labelSvg.setAttribute("y", labelPos.y);
this._labelSvg.style.display = "";
}
else if (!selected) {
this._labelSvg.style.display = "none";
}
},
toJson: function() {
var json = {};
json[this.label] = this.crds;
return json;
},
toString: function() {
return this.label;
}
});
}); |
"use strict"
const test = require('tape')
const {Iterable} = require('./common')
const {last, value} = require('../')
test('last over Set', t => {
t.deepEqual(value(last(new Set([2,4,6]))), 6)
t.end()
})
test('last over Map', t => {
let map = new Map()
let lastKey = Symbol('lastKey')
let lastValue = Symbol('lastValue')
map.set('first', Symbol('first'))
map.set('middle', Symbol('middle'))
map.set(lastKey, lastValue)
t.deepEqual(
value(last(map)),
[lastKey, lastValue]
)
t.end()
})
test('last over generic iterator', t => {
let iterator = Iterable([1,2,3])
t.deepEqual(value(last(iterator())), 3)
t.end()
})
test('last with generator', t => {
let size = 3
let nums = last(function* () {
while(size--) yield size
})
t.equal(value(last(nums)), 0)
t.end()
})
test('last over empty iterator', t => {
let iterator = Iterable([])
t.notOk(value(last(iterator())))
t.end()
})
|
/**
* 判断工具类
*
*/
var __CK = {
isUndefined:function(val)
{
return "undefined" === typeof(val);
},
isNull:function(val)
{
/**
*常见复杂的写法
*!exp && typeof exp != "undefined" && exp != 0
*
*/
return null === val;
},
isEmpty:function(val)
{
return "string" === typeof(val) && val.length === 0 ;
},
/**
* 变量是null或undefined或空字符串
*/
isNoValue:function(val)
{
if(this.isUndefined(val))
return true;
if(this.isNull(val))
return true;
if(this.isEmpty(val))
return true;
return false;
},
/**
* 电子邮件验证
* @param {string} strEmail
* @returns {boolean}
*/
isEmail:function(strEmail)
{
return /^\w+((-\w+)|(\.\w+))*\@[A-Za-z0-9]+((\.|-)[A-Za-z0-9]+)*\.[A-Za-z0-9]+$/.test(strEmail);
},
/**
* 手机号验证
* @param {string} value
* @returns {boolean}
*/
isMobile:function(value)
{
return /^1(3|5|8|7)\d{9}$/g.test(value);
},
/**
* 判断固定电话(0755-123456、020-1234567、020-12345678)
* @param string value
*
*/
isTel:function(value)
{
return /^\d{3,4}-\d{6,8}$/.test(value);
},
/**
* 支持15位和18位身份证号，支持地址编码、出生日期、校验位验证
*
* 根据〖中华人民共和国国家标准 GB 11643-1999〗中有关公民身份号码的规定，公民身份号码是特征组合码，由十七位数字本体码和一位数字校验码组成。排列顺序从左至右依次为：六位数字地址码，八位数字出生日期码，三位数字顺序码和一位数字校验码。
* 地址码表示编码对象常住户口所在县(市、旗、区)的行政区划代码。
* 出生日期码表示编码对象出生的年、月、日，其中年份用四位数字表示，年、月、日之间不用分隔符。
* 顺序码表示同一地址码所标识的区域范围内，对同年、月、日出生的人员编定的顺序号。顺序码的奇数分给男性，偶数分给女性。
* 校验码是根据前面十七位数字码，按照ISO 7064:1983.MOD 11-2校验码计算出来的检验码。
* 出生日期计算方法。
* 位的身份证编码首先把出生年扩展为4位，简单的就是增加一个19或18,这样就包含了所有1800-1999年出生的人;
* 年后出生的肯定都是18位的了没有这个烦恼，至于1800年前出生的,那啥那时应该还没身份证号这个东东，⊙﹏⊙b汗...
* 下面是正则表达式:
* 出生日期1800-2099 (18|19|20)?\d{2}(0[1-9]|1[12])(0[1-9]|[12]\d|3[01])
* 身份证正则表达式 /^\d{6}(18|19|20)?\d{2}(0[1-9]|1[12])(0[1-9]|[12]\d|3[01])\d{3}(\d|X)$/i
* 位校验规则 6位地址编码+6位出生日期+3位顺序号
* 位校验规则 6位地址编码+8位出生日期+3位顺序号+1位校验位
*
* 校验位规则 公式:∑(ai×Wi)(mod 11)……………………………………(1)
* 公式(1)中：
* i----表示号码字符从由至左包括校验码在内的位置序号；
* ai----表示第i位置上的号码字符值；
* Wi----示第i位置上的加权因子，其数值依据公式Wi=2^(n-1）(mod 11)计算得出。
* i 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1
* Wi 7 9 10 5 8 4 2 1 6 3 7 9 10 5 8 4 2 1
*/
isIDCard:function(code)
{
var tip = "";
var city = {11:"北京",12:"天津",13:"河北",14:"山西",15:"内蒙古",21:"辽宁",22:"吉林",23:"黑龙江 ",31:"上海",32:"江苏",33:"浙江",34:"安徽",35:"福建",36:"江西",37:"山东",41:"河南",42:"湖北 ",43:"湖南",44:"广东",45:"广西",46:"海南",50:"重庆",51:"四川",52:"贵州",53:"云南",54:"西藏 ",61:"陕西",62:"甘肃",63:"青海",64:"宁夏",65:"新疆",71:"台湾",81:"香港",82:"澳门",91:"国外 "};
var pass = true;
//身份证号格式错误
if(!code || !/^\d{6}(18|19|20)?\d{2}(0[1-9]|1[12])(0[1-9]|[12]\d|3[01])\d{3}(\d|X)$/i.test(code))
return false;
//地址编码错误
if(!city[code.substr(0,2)])
return false;
//18位身份证需要验证最后一位校验位
if(code.length == 18){
code = code.split('');
//∑(ai×Wi)(mod 11)
//加权因子
var factor = [ 7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2 ];
//校验位
var parity = [ 1, 0, 'X', 9, 8, 7, 6, 5, 4, 3, 2 ];
var sum = 0;
var ai = 0;
var wi = 0;
for (var i = 0; i < 17; i++)
{
ai = code[i];
wi = factor[i];
sum += ai * wi;
}
var last = parity[sum % 11];
//校验位错误
if(parity[sum % 11] != code[17])
return false;
}
return true;
},
/**
* 银行账号验证
* @param str
* @returns {boolean}
*/
isBankNO:function(str)
{
return /^\d{16,25}$/.test(str);
},
/**
* 验证车牌号
*/
isCarPlateNo:function(str)
{
return /^[\u4e00-\u9fa5]{1}[A-Z]{1}[A-Z_0-9]{5}$/.test(str);
},
}; |
import { call, takeEvery } from 'redux-saga/effects';
import { eventChannel } from 'redux-saga';
import { IS_OFFLINE } from '~shared/config';
import { ALBUMS_PUBLISH_INTERVAL, ALBUMS_APPEARENCE_INTERVAL } from '~shared/data/constants';
function getOutdatedAlbumsChannel(apis) {
const { findOutdatedAlbumsInCollection } = apis;
return eventChannel((emit) => {
const handleTick = async () => {
const period = new Date().getTime() - ALBUMS_APPEARENCE_INTERVAL;
const albums = await findOutdatedAlbumsInCollection(period);
emit(albums);
};
const interval = setInterval(handleTick, ALBUMS_PUBLISH_INTERVAL);
return () => {
clearInterval(interval);
};
});
}
function* publishAlbum({ publishAlbumsByCIDs }, albums) {
yield call(publishAlbumsByCIDs, albums);
}
function* startAlbumsPublisher(apis) {
if (!IS_OFFLINE) {
const outdatedAlbumsChannel = yield call(getOutdatedAlbumsChannel, apis);
yield takeEvery(outdatedAlbumsChannel, publishAlbum, apis);
}
}
export default startAlbumsPublisher;
|
/*!
* froala_editor v3.2.5-1 (https://www.froala.com/wysiwyg-editor)
* License https://froala.com/wysiwyg-editor/terms/
* Copyright 2014-2021 Froala Labs
*/
(function (global, factory) {
typeof exports === 'object' && typeof module !== 'undefined' ? factory(require('froala-editor')) :
typeof define === 'function' && define.amd ? define(['froala-editor'], factory) :
(factory(global.FroalaEditor));
}(this, (function (FE) { 'use strict';
FE = FE && FE.hasOwnProperty('default') ? FE['default'] : FE;
/**
* German
*/
FE.LANGUAGE['de'] = {
translation: {
// Font Awesome
'Font Awesome': 'Font Awesome',
'Web Application Icons': 'Web Anwendungen',
'Accessibility Icons': 'Barrierefreiheit',
'Hand Icons': 'Hände',
'Transportation Icons': 'Transport',
'Gender Icons': 'Geschlechter',
'Form Control Icons': 'Formulare',
'Payment Icons': 'Zahlungsarten',
'Chart Icons': 'Diagramme',
'Currency Icons': 'Währungen',
'Text Editor Icons': 'Text Editor',
'Brand Icons': 'Marken',
// Place holder
'Type something': 'Hier tippen',
// Basic formatting
'Bold': 'Fett',
'Italic': 'Kursiv',
'Underline': 'Unterstrichen',
'Strikethrough': 'Durchgestrichen',
// Main buttons
'Insert': 'Einfügen',
'Delete': 'Löschen',
'Cancel': 'Abbrechen',
'OK': 'OK',
'Back': 'Zurück',
'Remove': 'Entfernen',
'More': 'Mehr',
'Update': 'Aktualisieren',
'Style': 'Stil',
// Font
'Font Family': 'Schriftart',
'Font Size': 'Schriftgröße',
// Colors
'Colors': 'Farben',
'Background': 'Hintergrund',
'Text': 'Text',
'HEX Color': 'Hexadezimaler Farbwert',
// Paragraphs
'Paragraph Format': 'Formatierung',
'Normal': 'Normal',
'Code': 'Quelltext',
'Heading 1': 'Überschrift 1',
'Heading 2': 'Überschrift 2',
'Heading 3': 'Überschrift 3',
'Heading 4': 'Überschrift 4',
// Style
'Paragraph Style': 'Absatzformatierung',
'Inline Style': 'Inlineformatierung',
// Alignment
'Align': 'Ausrichtung',
'Align Left': 'Linksbündig ausrichten',
'Align Center': 'Zentriert ausrichten',
'Align Right': 'Rechtsbündig ausrichten',
'Align Justify': 'Blocksatz',
'None': 'Keine',
// Lists
'Default': 'Standard',
// Ordered lists
'Ordered List': 'Nummerierte Liste',
'Lower Alpha': 'Kleinbuchstaben',
'Lower Greek': 'Griechisches Alphabet',
'Lower Roman': 'Römische Ziffern (klein)',
'Upper Alpha': 'Grossbuchstaben',
'Upper Roman': 'Römische Ziffern (gross)',
// Unordered lists
'Unordered List': 'Unnummerierte Liste',
'Circle': 'Kreis',
'Disc': 'Kreis gefüllt',
'Square': 'Quadrat',
// Line height
'Line Height': 'Zeilenhöhe',
'Single': 'Einfach',
'Double': 'Doppelt',
// Indent
'Decrease Indent': 'Einzug verkleinern',
'Increase Indent': 'Einzug vergrößern',
// Links
'Insert Link': 'Link einfügen',
'Open in new tab': 'In neuem Tab öffnen',
'Open Link': 'Link öffnen',
'Edit Link': 'Link bearbeiten',
'Unlink': 'Link entfernen',
'Choose Link': 'Einen Link auswählen',
// Images
'Insert Image': 'Bild einfügen',
'Upload Image': 'Bild hochladen',
'By URL': 'Von URL',
'Browse': 'Durchsuchen',
'Drop image': 'Bild hineinziehen',
'or click': 'oder hier klicken',
'Manage Images': 'Bilder verwalten',
'Loading': 'Laden',
'Deleting': 'Löschen',
'Tags': 'Tags',
'Are you sure? Image will be deleted.': 'Wollen Sie das Bild wirklich löschen?',
'Replace': 'Ersetzen',
'Uploading': 'Hochladen',
'Loading image': 'Das Bild wird geladen',
'Display': 'Textausrichtung',
'Inline': 'Mit Text in einer Zeile',
'Break Text': 'Text umbrechen',
'Alternative Text': 'Alternativtext',
'Change Size': 'Größe ändern',
'Width': 'Breite',
'Height': 'Höhe',
'Something went wrong. Please try again.': 'Etwas ist schief gelaufen. Bitte versuchen Sie es erneut.',
'Image Caption': 'Bildbeschreibung',
'Advanced Edit': 'Erweiterte Bearbeitung',
// Video
'Insert Video': 'Video einfügen',
'Embedded Code': 'Eingebetteter Code',
'Paste in a video URL': 'Fügen Sie die Video-URL ein',
'Drop video': 'Video hineinziehen',
'Your browser does not support HTML5 video.': 'Ihr Browser unterstützt keine HTML5-Videos.',
'Upload Video': 'Video hochladen',
// Tables
'Insert Table': 'Tabelle einfügen',
'Table Header': 'Tabellenkopf',
'Remove Table': 'Tabelle entfernen',
'Table Style': 'Tabellenformatierung',
'Horizontal Align': 'Horizontale Ausrichtung',
'Row': 'Zeile',
'Insert row above': 'Neue Zeile davor einfügen',
'Insert row below': 'Neue Zeile danach einfügen',
'Delete row': 'Zeile löschen',
'Column': 'Spalte',
'Insert column before': 'Neue Spalte davor einfügen',
'Insert column after': 'Neue Spalte danach einfügen',
'Delete column': 'Spalte löschen',
'Cell': 'Zelle',
'Merge cells': 'Zellen verbinden',
'Horizontal split': 'Horizontal teilen',
'Vertical split': 'Vertikal teilen',
'Cell Background': 'Zellenfarbe',
'Vertical Align': 'Vertikale Ausrichtung',
'Top': 'Oben',
'Middle': 'Zentriert',
'Bottom': 'Unten',
'Align Top': 'Oben ausrichten',
'Align Middle': 'Zentriert ausrichten',
'Align Bottom': 'Unten ausrichten',
'Cell Style': 'Zellen-Stil',
// Files
'Upload File': 'Datei hochladen',
'Insert File': 'Datei einfügen',
'Drop file': 'Datei hineinziehen',
// Emoticons
'Emoticons': 'Emoticons',
'Grinning face': 'Grinsendes Gesicht',
'Grinning face with smiling eyes': 'Grinsend Gesicht mit lächelnden Augen',
'Face with tears of joy': 'Gesicht mit Tränen der Freude',
'Smiling face with open mouth': 'Lächelndes Gesicht mit offenem Mund',
'Smiling face with open mouth and smiling eyes': 'Lächelndes Gesicht mit offenem Mund und lächelnden Augen',
'Smiling face with open mouth and cold sweat': 'Lächelndes Gesicht mit offenem Mund und kaltem Schweiß',
'Smiling face with open mouth and tightly-closed eyes': 'Lächelndes Gesicht mit offenem Mund und fest geschlossenen Augen',
'Smiling face with halo': 'Lächeln Gesicht mit Heiligenschein',
'Smiling face with horns': 'Lächeln Gesicht mit Hörnern',
'Winking face': 'Zwinkerndes Gesicht',
'Smiling face with smiling eyes': 'Lächelndes Gesicht mit lächelnden Augen',
'Face savoring delicious food': 'Gesicht leckeres Essen genießend',
'Relieved face': 'Erleichtertes Gesicht',
'Smiling face with heart-shaped eyes': 'Lächelndes Gesicht mit herzförmigen Augen',
'Smiling face with sunglasses': 'Lächelndes Gesicht mit Sonnenbrille',
'Smirking face': 'Grinsendes Gesicht',
'Neutral face': 'Neutrales Gesicht',
'Expressionless face': 'Ausdrucksloses Gesicht',
'Unamused face': 'Genervtes Gesicht',
'Face with cold sweat': 'Gesicht mit kaltem Schweiß',
'Pensive face': 'Nachdenkliches Gesicht',
'Confused face': 'Verwirrtes Gesicht',
'Confounded face': 'Elendes Gesicht',
'Kissing face': 'Küssendes Gesicht',
'Face throwing a kiss': 'Gesicht wirft einen Kuss',
'Kissing face with smiling eyes': 'Küssendes Gesicht mit lächelnden Augen',
'Kissing face with closed eyes': 'Küssendes Gesicht mit geschlossenen Augen',
'Face with stuck out tongue': 'Gesicht mit herausgestreckter Zunge',
'Face with stuck out tongue and winking eye': 'Gesicht mit herausgestreckter Zunge und zwinkerndem Auge',
'Face with stuck out tongue and tightly-closed eyes': 'Gesicht mit herausgestreckter Zunge und fest geschlossenen Augen',
'Disappointed face': 'Enttäuschtes Gesicht',
'Worried face': 'Besorgtes Gesicht',
'Angry face': 'Verärgertes Gesicht',
'Pouting face': 'Schmollendes Gesicht',
'Crying face': 'Weinendes Gesicht',
'Persevering face': 'Ausharrendes Gesicht',
'Face with look of triumph': 'Gesicht mit triumphierenden Blick',
'Disappointed but relieved face': 'Enttäuschtes, aber erleichtertes Gesicht',
'Frowning face with open mouth': 'Entsetztes Gesicht mit offenem Mund',
'Anguished face': 'Gequältes Gesicht',
'Fearful face': 'Angstvolles Gesicht',
'Weary face': 'Müdes Gesicht',
'Sleepy face': 'Schläfriges Gesicht',
'Tired face': 'Gähnendes Gesicht',
'Grimacing face': 'Grimassenschneidendes Gesicht',
'Loudly crying face': 'Laut weinendes Gesicht',
'Face with open mouth': 'Gesicht mit offenem Mund',
'Hushed face': 'Besorgtes Gesicht mit offenem Mund',
'Face with open mouth and cold sweat': 'Gesicht mit offenem Mund und kaltem Schweiß',
'Face screaming in fear': 'Vor Angst schreiendes Gesicht',
'Astonished face': 'Erstauntes Gesicht',
'Flushed face': 'Gerötetes Gesicht',
'Sleeping face': 'Schlafendes Gesicht',
'Dizzy face': 'Schwindliges Gesicht',
'Face without mouth': 'Gesicht ohne Mund',
'Face with medical mask': 'Gesicht mit Mundschutz',
// Line breaker
'Break': 'Zeilenumbruch',
// Math
'Subscript': 'Tiefgestellt',
'Superscript': 'Hochgestellt',
// Full screen
'Fullscreen': 'Vollbild',
// Horizontal line
'Insert Horizontal Line': 'Horizontale Linie einfügen',
// Clear formatting
'Clear Formatting': 'Formatierung löschen',
// Save
'Save': 'Speichern',
// Undo, redo
'Undo': 'Rückgängig',
'Redo': 'Wiederholen',
// Select all
'Select All': 'Alles auswählen',
// Code view
'Code View': 'Code-Ansicht',
// Quote
'Quote': 'Zitieren',
'Increase': 'Vergrößern',
'Decrease': 'Verkleinern',
// Quick Insert
'Quick Insert': 'Schnell einfügen',
// Spcial Characters
'Special Characters': 'Sonderzeichen',
'Latin': 'Lateinisch',
'Greek': 'Griechisch',
'Cyrillic': 'Kyrillisch',
'Punctuation': 'Satzzeichen',
'Currency': 'Währung',
'Arrows': 'Pfeile',
'Math': 'Mathematik',
'Misc': 'Sonstige',
// Print.
'Print': 'Drucken',
// Spell Checker.
'Spell Checker': 'Rechtschreibprüfung',
// Help
'Help': 'Hilfe',
'Shortcuts': 'Tastaturkurzbefehle',
'Inline Editor': 'Inline-Editor',
'Show the editor': 'Editor anzeigen',
'Common actions': 'Häufig verwendete Befehle',
'Copy': 'Kopieren',
'Cut': 'Ausschneiden',
'Paste': 'Einfügen',
'Basic Formatting': 'Grundformatierung',
'Increase quote level': 'Zitatniveau erhöhen',
'Decrease quote level': 'Zitatniveau verringern',
'Image / Video': 'Bild / Video',
'Resize larger': 'Vergrößern',
'Resize smaller': 'Verkleinern',
'Table': 'Tabelle',
'Select table cell': 'Tabellenzelle auswählen',
'Extend selection one cell': 'Erweitere Auswahl um eine Zelle',
'Extend selection one row': 'Erweitere Auswahl um eine Zeile',
'Navigation': 'Navigation',
'Focus popup / toolbar': 'Fokus-Popup / Symbolleiste',
'Return focus to previous position': 'Fokus auf vorherige Position',
// Embed.ly
'Embed URL': 'URL einbetten',
'Paste in a URL to embed': 'URL einfügen um sie einzubetten',
// Word Paste.
'The pasted content is coming from a Microsoft Word document. Do you want to keep the format or clean it up?': 'Der eingefügte Inhalt kommt aus einem Microsoft Word-Dokument. Möchten Sie die Formatierungen behalten oder verwerfen?',
'Keep': 'Behalten',
'Clean': 'Bereinigen',
'Word Paste Detected': 'Aus Word einfügen',
// Character Counter
'Characters': 'Zeichen',
// More Buttons
'More Text': 'Weitere Textformate',
'More Paragraph': 'Weitere Absatzformate',
'More Rich': 'Weitere Reichhaltige Formate',
'More Misc': 'Weitere Formate',
'Text Color': 'Textfarbe',
'Background Color': 'Hintergrundfarbe'
},
direction: 'ltr'
};
})));
//# sourceMappingURL=de.js.map
|
'use strict';
var inherits = require('inherits'),
AbstractCursor = require('../../cursor'),
Doc = require('./doc');
var Cursor = function (cursor, collection) {
this._cursor = cursor;
this._collection = collection;
};
inherits(Cursor, AbstractCursor);
// TODO: make a promise that resolves after last each
Cursor.prototype.each = function (callback) {
var self = this;
self._cursor.each(function (err, doc) {
if (doc) {
callback(new Doc(doc, self._collection));
}
});
};
module.exports = Cursor; |
import { GET_EVENT } from '../actions/types';
const initalState = {
fetching: false,
fetched: false,
error: null,
response: null,
}
export default ( state = initalState, action ) => {
switch (action.type) {
case `${GET_EVENT}_PENDING`:
return {
...state,
fetching: true,
error: null,
};
case `${GET_EVENT}_FULFILLED`:
return {
...state,
fetching: false,
fetched: true,
error: null,
response: action.payload.data
};
case `${GET_EVENT}_REJECTED`:
return {
...state,
fetching: false,
error: action.payload
};
default:
return state;
}
}
|
'use strict';
/**
* Module dependencies.
*/
var passport = require('passport');
var User = require('mongoose').model('User');
var path = require('path');
var config = require('./config');
/**
* Module init function.
*/
module.exports = function() {
// Serialize sessions
passport.serializeUser(function(user, done) {
done(null, user.id);
});
// Deserialize sessions
passport.deserializeUser(function(id, done) {
User.findOne({
_id: id
}, '-salt -password', function(err, user) {
done(err, user);
});
});
// Initialize strategies
config.getGlobbedFiles('./config/strategies/**/*.js').forEach(function(strategy) {
require(path.resolve(strategy))();
});
};
|
/*
--------------------------------------
(c)2012-2018, Kellpro, Inc.
(c)2016-2019, Master Technology
--------------------------------------
FluentReports is under The MIT License (MIT)
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.
*/
//noinspection ThisExpressionReferencesGlobalObjectJS,JSHint
/**
* @module fluentReports
* @author Nathanael Anderson
* @contributors Mark Getz, Alan Henager, Beau West, Marcus Christensson
* @copyright 2012-2018, Kellpro Inc.
* @copyright 2016-2019, Master Technology.
* @license MIT
*/
(function (_global) {
"use strict";
// Layout:
/*
Report ->
Section ->
DataSet ->
Group ->
(Optional) Sub-Report) ->
Group ->
...
*/
// ------------------------------------------------------
// Helper Functions
// ------------------------------------------------------
/**
* Gets a setting from a setting collection, checks for the normal case; and then a lower case version
* @param settingsObject
* @param setting
* @param defaultValue
* @return {*} defaultValue if no setting exists
*/
function getSettings(settingsObject, setting, defaultValue) {
if (!settingsObject) {
return (defaultValue);
}
if (typeof settingsObject[setting] !== 'undefined') {
return settingsObject[setting];
} else {
const lSetting = setting.toLowerCase();
if (typeof settingsObject[lSetting] !== 'undefined') {
return settingsObject[lSetting];
}
}
return defaultValue;
}
/**
* This creates a lower case version of the prototypes
* @param prototype
*/
function lowerPrototypes(prototype) {
let proto, lowerProto;
for (proto in prototype) {
if (prototype.hasOwnProperty(proto)) {
// Don't lowercase internal prototypes
if (proto[0] === '_') {
continue;
}
lowerProto = proto.toLowerCase();
// If the prototype is already lower cased, then we skip
if (lowerProto === proto) {
continue;
}
// verify it is a function
if (typeof prototype[proto] === "function") {
prototype[lowerProto] = prototype[proto];
}
}
}
}
/** Debug Code **/
function printStructure(reportObject, level, outputType) {
if (reportObject === null) {
return;
}
let i, j, added = (2 * level), pad = "", spad = '';
for (i = 0; i < added; i++) {
pad += "-";
spad += " ";
}
const loopChildren = () => {
if (reportObject._child) {
printStructure(reportObject._child, level + 1, outputType);
} else if (reportObject._children) {
for (j = 0; j < reportObject._children.length; j++) {
printStructure(reportObject._children[j], level + 1, outputType);
}
}
};
if (reportObject._isReport) {
if (reportObject._parent) {
console.log(pad + "> Subreport (Height Exempt?)");
} else {
console.log(pad + "> Report (Height Exempt?)");
}
} else if (reportObject._isSection) {
console.log(pad + "> Section");
} else if (reportObject._isDataSet) {
console.log(pad + "> DataSet");
} else if (reportObject._isGroup) {
console.log(pad + "> Group = " + reportObject._groupOnField);
if (reportObject._math.length > 0) {
console.log(pad + "= Totaling:", reportObject._math);
}
} else {
console.log(pad + "> Unknown");
}
if (reportObject._theader !== null && reportObject._theader !== undefined) {
console.log(spad + " | Has Title Header ", typeof reportObject._theader._part === "function" ? reportObject._theader._part.length === 4 ? "(Async)" : "(Sync)" : "(Auto)", reportObject._theader._partHeight > 0 ? reportObject._theader._partHeight : '', reportObject._theader._isHeightExempt);
}
if (reportObject._header !== null && reportObject._header !== undefined) {
if (reportObject._isReport) {
console.log(spad + " | Has Page Header", typeof reportObject._header._part === "function" ? reportObject._header._part.length === 4 ? "(Async)" : "(Sync)" : "(Auto)", reportObject._header._partHeight > 0 ? reportObject._header._partHeight : '', reportObject._header._isHeightExempt);
} else {
console.log(spad + " | Has Header", typeof reportObject._header._part === "function" ? reportObject._header._part.length === 4 ? "(Async)" : "(Sync)" : "(Auto)", reportObject._header._partHeight > 0 ? reportObject._header._partHeight : '', reportObject._header._isHeightExempt);
}
}
if (reportObject._detail !== null && reportObject._detail !== undefined) {
console.log(spad + " | Has Detail", reportObject._renderDetail === reportObject._renderAsyncDetail ? "(Async)" : reportObject._renderDetail === reportObject._renderSyncDetail ? "(Sync)" : reportObject._renderDetail === reportObject._renderBandDetail ? "(Auto Band)" : reportObject._renderDetail === reportObject._renderStringDetail ? "(Auto String)" : "Unknown");
}
if (outputType) { loopChildren(); }
if (reportObject._footer !== null && reportObject._footer !== undefined) {
if (reportObject._isReport) {
console.log(spad + " | Has Page Footer", typeof reportObject._footer._part === "function" ? reportObject._footer._part.length === 4 ? "(Async)" : "(Sync)" : "(Auto)", reportObject._footer._partHeight > 0 ? reportObject._footer._partHeight : '', reportObject._footer._isHeightExempt);
} else {
console.log(spad + " | Has Footer", typeof reportObject._footer._part === "function" ? reportObject._footer._part.length === 4 ? "(Async)" : "(Sync)" : "(Auto)", reportObject._footer._partHeight > 0 ? reportObject._footer._partHeight : '', reportObject._footer._isHeightExempt);
}
}
if (reportObject._tfooter !== null && reportObject._tfooter !== undefined) {
console.log(spad + " | Has Summary Footer", typeof reportObject._tfooter._part === "function" ? reportObject._tfooter._part.length === 4 ? "(Async)" : "(Sync)" : "(Auto)", reportObject._tfooter._partHeight > 0 ? reportObject._tfooter._partHeight : '', reportObject._tfooter._isHeightExempt);
}
if (!outputType) { loopChildren(); }
}
/**
* Returns true if object is an array object
* @param obj
* @return {Boolean} True or False
*/
function isArray(obj) {
return (Object.prototype.toString.apply(obj) === '[object Array]');
}
/**
* returns true if this is a number
* @param num
* @return {Boolean}
*/
function isNumber(num) {
return ((typeof num === 'string' || typeof num === 'number') && !isNaN(num - 0) && num !== '' );
}
/**
* Clones the data -- this is a simple clone, it does *NOT* do any really DEEP copies;
* but nothing in the report module needs a deep copy.
* @param value
* @return {*}
*/
function clone(value) {
let key, target = {}, i, aTarget = [];
if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || Object.prototype.toString.call(value) === '[object Date]') {
return value;
}
if (isArray(value)) {
for (i = 0; i < value.length; i++) {
aTarget.push(clone(value[i]));
}
return (aTarget);
} else if (typeof aTarget === "object") {
for (key in value) {
if (value.hasOwnProperty(key)) {
target[key] = value[key];
}
}
return target;
} else {
// Currently this path is not used in the clone...
return JSON.parse(JSON.stringify(value));
}
}
/**
* Generic Error function that can be overridden with your own error code
*/
function error() {
if (!console || !console.error || arguments.length === 0) {
return;
}
console.error.apply(console, arguments);
}
/**
* @class ReportError
* @desc This is a constructor for error details that are returned by fluentreports
* @param detailsObject - detail Object, generally including some mix of error, error.stack, and an error code
* @constructor
*/
function ReportError(detailsObject) {
for (let key in detailsObject) {
if (!detailsObject.hasOwnProperty(key)) { continue; }
this[key] = detailsObject[key];
}
}
/**
* This is a callback that just prints any errors, used for places a callback may not have been passed in.
* @param err
*/
function dummyCallback(err) {
if (err) {
Report.error(err);
}
}
/**
* This does a loop, used for Async code
* @param total number of loops
* @param runFunction - this is the function that will be called for each iteration
* @param doneCallback - this is called when the loop is done
*/
function startLoopingAsync(total, runFunction, doneCallback) {
let counter = -1;
const callbackLoop = () => {
counter++;
if (counter < total) {
// Unwind this stack every so often
if (counter % 10 === 0) {
setTimeout(() => { runFunction(counter, callbackLoop); }, 0);
} else {
runFunction(counter, callbackLoop);
}
} else {
doneCallback();
}
};
callbackLoop();
}
/**
* This does a loop, used for Sync code
* @param total number of loops
* @param runFunction - this is the function that will be called for each iteration
* @param doneCallback - this is called when the loop is done
*/
function startLoopingSync(total, runFunction, doneCallback) {
let counter= 0;
let hasAnotherLoop = true;
const callbackLoop = (skipInc) => {
if (skipInc !== true) { counter++; }
if (counter < total) {
// Unwind this stack every so ofter
if (skipInc !== true && counter % 10 === 0) {
// Technically we don't have to reset this to true; as it is already true; but this is so that
// this function is readable by use mere humans several months from here.
hasAnotherLoop = true;
} else {
runFunction(counter, callbackLoop);
}
} else {
hasAnotherLoop = false;
}
};
while (hasAnotherLoop) {
callbackLoop(true);
}
doneCallback();
}
const reportRenderingMode = {UNDEFINED: 0, SYNC: 1, ASYNC: 2};
// If any are added to this, you need to add the function, and update _calcTotals and _clearTotals,
const mathTypes = {SUM: 1, AVERAGE: 2, MIN: 3, MAX: 4, COUNT: 5};
const dataTypes = {NORMAL: 0, PAGEABLE: 1, FUNCTIONAL: 2, PLAINOLDDATA: 3, PARENT: 4};
// -------------------------------------------------------
// Report Objects
// -------------------------------------------------------
/**
* ReportSection
* @class ReportSection
* @desc This is a Report Section that allows multiple DataSets for laying out a report.
* @param parent object, typically another section, group or report object
* @constructor
* @alias ReportSection
* @memberof Report
*/
function ReportSection(parent) {
this._children = [];
this._parent = parent;
}
/**
* ReportRenderer
* @class ReportRenderer
* @desc This is the Wrapper around the PDFKit, and could be used to wrap any output library.
* @classdesc this is the RENDERER class passed into your callbacks during report generation.
* @constructor
* @alias ReportRenderer
*/
function ReportRenderer(primaryReport, options) {
this.totals = {};
this._priorValues = {};
this._pageHasRendering = 0;
this._pageHeaderRendering = 0;
this._curBand = [];
this._curBandOffset = 0;
this._primaryReport = primaryReport;
this._pageBreaking = false;
this._skipASYNCCheck = false;
this._landscape = false;
this._paper = "letter";
this._margins = 72;
this._lineWidth = 1;
this._level = 0;
this._totalLevels = 0;
this._negativeParentheses = false;
this._heightOfString = 0;
this._graphicState = [];
this._fillColor = "black";
this._strokeColor = "black";
this._fillOpacity = 1;
this._rotated = 0;
this._height = 0;
this._reportHeight = 0;
this._printedLines = [];
this._pageNumbers = [];
this._reportRenderMode = reportRenderingMode.UNDEFINED;
let opt = {};
if (options) {
if (options.paper) {
this._paper = options.paper;
if (this._paper !== "letter") {
opt.size = this._paper;
}
}
if (options.landscape) {
this._landscape = true;
opt.layout = "landscape";
}
if (options.margins && options.margins !== this._margins) {
this._margins = options.margins;
if (typeof options.margins === 'number') {
opt.margin = options.margins;
} else {
opt.margins = options.margins;
}
}
if (options.fonts) {
this._fonts = options.fonts;
}
if (options.registeredFonts) {
this._registeredFonts = options.registeredFonts;
}
if (options.info) {
opt.info = options.info;
}
}
if (!this._fonts) {
this._fonts = clone(Report._indexedFonts);
}
if (!this._registeredFonts) {
this._registeredFonts = {};
}
this._PDF = new this._PDFKit(opt);
this._heightOfString = this._PDF.currentLineHeight(true);
this._height = this._reportHeight = this._PDF.page.maxY();
this._PDF.page.height = 99999;
for (let key in this._registeredFonts) {
if (!this._registeredFonts.hasOwnProperty(key)) { continue; }
for (let style in this._registeredFonts[key]) {
if (!this._registeredFonts[key].hasOwnProperty(style)) { continue; }
if (style === 'normal') {
this._PDF.registerFont(key, this._registeredFonts[key][style]);
} else {
this._PDF.registerFont(key+'-'+style, this._registeredFonts[key][style]);
}
}
}
// This is a PDFDoc emulated page wrapper so that we can detect how it will wrap things.
const lwDoc = this._LWDoc = {
count: 0, pages: 1, x: this._PDF.page.margins.left, y: this._PDF.page.margins.top, page: this._PDF.page, _PDF: this._PDF,
currentLineHeight: function (val) { //noinspection JSPotentiallyInvalidUsageOfThis
return this._PDF.currentLineHeight(val); },
widthOfString: function (d, o) {
let splitString = d.split(' '),
curWord,
wos = 0,
wordLength;
for (let i = 0; i < splitString.length; ++i) {
curWord = splitString[i];
if ((i + 1) !== splitString.length) {
curWord += ' ';
}
//noinspection JSPotentiallyInvalidUsageOfThis
wordLength = this._PDF.widthOfString(curWord, o);
wos += wordLength;
}
return wos; },
addPage: function () { this.pages++;
//noinspection JSPotentiallyInvalidUsageOfThis
this.x = this._PDF.page.margins.left;
//noinspection JSPotentiallyInvalidUsageOfThis
this.y = this._PDF.page.margins.top; },
reset: function () { this.count = 0; this.pages = 0; this.addPage(); }
};
// Create a new Line Wrapper Object, this allows us to handle Bands
this._LineWrapper = new this._LineWrapperObject(lwDoc,{width:this._PDF.page.width - this._PDF.page.margins.right - this._PDF.page.margins.left, columns:1, columnGap: 18});
this._LineWrapper.on('line', () => {
lwDoc.count++;
});
// Create the Print wrapper; this allows us to wrap long print() calls onto multiple lines.
this._PrintWrapper = new this._LineWrapperObject(lwDoc,{width:this._PDF.page.width - this._PDF.page.margins.right - this._PDF.page.margins.left, columns:1, columnGap: 18});
this._PrintWrapper.on('line', (line, options) => {
this._printedLines.push({L:line, O: options});
});
}
/**
* @class ReportHeaderFooter
* @desc Creates a Object for tracking Header/Footer instances
* @constructor
* @alias ReportHeaderFooter
* @memberof Report
* @param isHeader
* @param {boolean} [isSizeExempt] - is Size Exempt, this ONLY applies to page footers; as we don't want to "break" the page on a page footer.
*/
function ReportHeaderFooter(isHeader, isSizeExempt) {
this._part = null;
this._isFunction = false;
this._partHeight = -1;
//noinspection JSUnusedGlobalSymbols
this._partWidth = -1;
this._pageBreakBefore = false;
this._pageBreakAfter = false;
this._isHeader = isHeader;
// This only applies to Page FOOTERS, and the final summary FOOTER. These are the only items that won't cause a page-break before/during printing.
// Normally this is not a issue; but some people might use absolute Y coords and end up overflowing the page in the footer;
// which then causes a major glitch in the rendering. So instead we are just going to let the footer overflow the page and ignore the rest of the footer.
// This is a much "cleaner" looking solution.
this._isHeightExempt = isHeader ? false : !!isSizeExempt;
}
/**
* ReportGroup
* @class ReportGroup
* @desc This creates a Report Grouping Section
* @classdesc This Creates a new Report Grouping (This is the basic Building Block of the Report before you start rendering)
* @constructor
* @alias ReportGroup
* @memberof Report
* @param parent
*/
function ReportGroup(parent) {
this._parent = parent;
this._header = null;
this._footer = null;
this._detail = null;
this._groupOnField = null;
this._groupChecked = false;
this._groupLastValue = null;
this._child = null;
this._hasRanHeader = false;
this._runDetailAfterSubgroup = false;
this._runHeaderWhen = Report.show.newPageOnly;
this._lastData = {};
this._currentData = null;
this._math = [];
this._totals = {};
this._curBandWidth = [];
this._curBandOffset = 0;
this._level = -1;
}
/**
* ReportDataSet
* @class ReportDataSet
* @desc This creates a Dataset Element for the Report
* @param {ReportSection} parent - ReportSection element that is the parent of this object
* @param {string?} parentDataKey - parent dataset data key
* @constructor
* @alias ReportDataSet
* @memberOf Report
* @return {ReportGroup} - Returns a auto-generated ReportGroup tied to this reportDataSet
*/
function ReportDataSet(parent, parentDataKey) {
this._parent = parent;
this._data = null;
this._keys = null;
this._dataType = dataTypes.NORMAL;
if (parentDataKey) {
this._dataType = dataTypes.PARENT;
// noinspection JSUnusedGlobalSymbols
this._parentDataKey = parentDataKey;
}
// noinspection JSUnusedGlobalSymbols
this._recordCountCallback = null;
this._child = new ReportGroup(this);
if (this._parent && this._parent._parent === null) {
this._child.header = this._child.pageHeader;
this._child.footer = this._child.pageFooter;
}
this._totalFormatter = (data, callback) => {
callback(null, data);
};
return (this._child);
}
/*
* This can be used as an a example method that is a paged data object.
* This is a linked to internal Kellpro data and functions;
* but you can base your own page-able data object off of it (see prototype)
* @private
**/
function ScopedDataObject(data, scope, formattingState) {
this._scope = scope;
this._data = data;
this._dataType = dataTypes.NORMAL;
this._formatters = null;
this._result = null;
if (formattingState !== null && formattingState !== undefined) {
this._formattingState = formattingState;
} else {
this._formattingState = 0;
}
if (data._isQuery || data._isquery || typeof data === "string") {
this._dataType = dataTypes.FUNCTIONAL;
}
else if (data.isRows) {
this._dataType = dataTypes.PAGEABLE;
this.isPaged = true;
}
else {
if (this.error) {
this.error(scope, null, 'warn', "Unknown scoped data type: " + Object.prototype.toString.apply(data));
} else {
error("Unknown data type: ", Object.prototype.toString.apply(data), data);
}
}
}
/**
* Report
* @class Report
* @desc Primary Report Creation Class
* @param {(string|object|Report)} [parent] - Either the string name of the report to output to disk, "buffer" to output a buffer or a [Report, Group, or Section] that this is to be a child report of.
* @param {object} [options] - default options for this report; landscape, paper, font, fontSize, autoPrint, fullScreen, negativeParentheses, autoCreate
* @returns {ReportGroup|Report} - Normally returns a ReportGroup, or it can return itself if options.autoCreate is set to false
*/
function Report(parent, options) { // jshint ignore:line
options = options || {};
this._reportName = "report.pdf";
this._outputType = Report.renderType.file;
this._runHeaderWhen = Report.show.always;
if (arguments.length) {
if (typeof parent === "string" || typeof parent === "number") {
this._parent = null;
if (parent.toString() === "buffer") {
this._outputType = Report.renderType.buffer;
} else {
this._reportName = parent.toString();
}
} else if (typeof parent === "object" && typeof parent.write === "function" && typeof parent.end === "function") {
this._parent = null;
this._outputType = Report.renderType.pipe;
this._pipe = parent;
} else {
if (parent == null) {
this._parent = null;
} else if (parent._isReport) {
if (parent._child === null) {
parent._child = this;
this._parent = parent;
} else if (parent._child._isSection) {
parent._child.addReport(this);
this._parent = parent._child;
} else {
Report.error("REPORTAPI: Report was passed an invalid parent; resetting parent to none");
this._parent = null;
}
} else if (parent._isSection || parent._isGroup) {
if (options.isSibling === true) {
let parentReport = parent;
while (!parentReport._isReport) {
parentReport = parentReport._parent;
}
parentReport._child.addReport(this);
this._parent = parentReport;
} else {
parent.addReport(this);
this._parent = parent;
}
} else {
Report.error("REPORTAPI: Report was passed an invalid parent; resetting parent to none.");
this._parent = null;
}
}
} else {
this._parent = null;
}
this._reportMode = reportRenderingMode.UNDEFINED;
this._theader = null;
this._tfooter = null;
this._header = null;
this._footer = null;
this._userdata = null;
this._curBandWidth = [];
this._curBandOffset = 0;
this._state = {};
this._landscape = options.landscape || false;
this._paper = options.paper || "letter";
this._font = options.font || "Helvetica";
this._fontSize = options.fontSize || options.fontsize || 12;
this._margins = options.margins || 72;
this._autoPrint = options.autoPrint || options.autoprint || false;
this._fullScreen = options.fullScreen || options.fullscreen || false;
this._negativeParentheses = options.negativeParentheses || false;
this._registeredFonts = {};
this._fonts = clone(Report._indexedFonts);
this._info = options.info || {};
// We want to return a fully developed simple report (Report->Section->DataSet->Group) so we create it and then return the Group Object
if (options.autocreate === false || options.autoCreate === false) {
// TODO: This path might need to be deleted/modified; it doesn't setup _child or _detailGroup which will break code later in the code base.
this._child = null;
return this;
} else {
this._child = new ReportSection(this);
this._detailGroup = this._child.addDataSet();
return (this._detailGroup);
}
}
Report.prototype =
/** @lends Report */
{
_isReport: true,
/**
* is this the Root Report
* @desc Returns if this is the primary root report of the entire report set
* @returns {boolean}
*/
isRootReport: function () {
return (this._parent === null);
},
/**
* toggle pdf fullScreen
* @desc Attempts to make the report full screen when enabled
* @param value {boolean} - true to try and force the screen full size
* @returns {*}
*/
fullScreen: function(value) {
if (arguments.length) {
this._fullScreen = value;
return this;
}
return this._fullScreen;
},
/**
* Toggle auto print on open
* @param {boolean} value - true to enable
* @returns {*}
*/
autoPrint: function (value) {
if (arguments.length) {
this._autoPrint = value;
return this;
}
return this._autoPrint;
},
/**
* Enables negative numbers to be autowrapped in (parans)
* @param {boolean} value - true to enable
* @returns {*}
*/
negativeParentheses: function(value) {
if (arguments.length) {
this._negativeParentheses = value;
return this;
}
return this._negativeParentheses;
},
/**
* set the output Type
* @param type {Report.renderType} - Type of output
* @param to - Pipe or Filename
*/
outputType: function(type, to) {
if (arguments.length === 0) {
return this._outputType;
}
if (typeof type === 'string') {
if (type.toLowerCase() === 'buffer') {
this._outputType = Report.renderType.buffer;
} else {
this._outputType = Report.renderType.file;
this._reportName = type;
}
return this;
}
if (typeof type === 'object' && typeof type.write === 'function' && typeof type.end === 'function') {
this._outputType = Report.renderType.pipe;
this._pipe = type;
return this;
}
if (type === Report.renderType.pipe) {
this._outputType = Report.renderType.pipe;
this._pipe = to;
} else if (type === Report.renderType.buffer) {
this._outputType = Report.renderType.buffer;
} else if (type === Report.renderType.file) {
this._outputType = Report.renderType.file;
} else {
this._outputType = Report.renderType.file;
}
return this;
},
/**
* Start the Rendering process
* @param {function} callback - the callback to call when completed
* @returns {*}
*/
render: function (callback) {
if (this.isRootReport()) {
return new Promise((resolve, reject) => {
this._state = {
isTitle: false,
isFinal: false,
headerSize: 0,
footerSize: 0,
additionalHeaderSize: 0,
isCalc: false,
cancelled: false,
resetGroups: true,
startX: 0,
startY: 0,
currentX: 0,
currentY: 0,
priorStart: [],
parentData: {},
primaryData: null,
// report: this,
currentGroup: null,
reportRenderMode: this._reportRenderMode()
};
this._info.Producer = "fluentReports 1.00";
if (Report.trace) {
console.error("Starting Tracing on Report to a ", this._outputType === Report.renderType.buffer ? "Buffer" : this._outputType === Report.renderType.pipe ? "Pipe" : "File " + this._reportName);
if (Report.callbackDebugging) {
console.error(" - Render callback is ", callback && typeof callback === "function" ? "valid" : "invalid");
}
}
// These get passed into the two page Wrappers for Page building information
const pageDefaults = {
paper: this._paper,
landscape: this._landscape,
margins: this._margins,
fonts: this._fonts,
registeredFonts: this._registeredFonts,
info: this._info
};
// Set the rendering mode if no functions are defined
if (this._reportRenderMode() === reportRenderingMode.UNDEFINED) {
this._reportRenderMode(reportRenderingMode.ASYNC);
}
// Find out Sizes of all the Headers/Footers
let testit = new ReportRenderer(this, pageDefaults);
testit._reportRenderMode = this._reportRenderMode();
testit.font(this._font, this._fontSize);
testit.saveState();
// Catch the Printing so that we can see if we can track the "offset" of the Footer in case the footer
// is moved to a literal Y position (without it being based on the prior Y position)
let oPrint = testit.print;
let oBand = testit.band;
let oAddPage = testit._addPage;
let onewLine = testit.newLine;
// We are eliminating the height restriction for our sizing tests
testit._height = 90000;
// This needs to remain a "function" as "this" needs to point to the "testit" instance...
testit._addPage = function () {
oAddPage.call(this);
this._height = 90000;
};
// This needs to remain a "function" as "this" needs to point to the "testit" instance...
testit.newLine = function (lines, callback) {
this._firstMoveState = true;
onewLine.call(this, lines, callback);
};
// This needs to remain a "function" as "this" needs to point to the "testit" instance...
testit.checkY = function (opt) {
if (opt == null) {
return;
}
let cY, y;
y = cY = this.getCurrentY();
if (opt.y) {
y = opt.y;
}
if (opt.addy) {
y += opt.addy;
}
if (opt.addY) {
y += opt.addY;
}
if (y > cY + (this._reportHeight / 3)) {
// Did our move - move us over a 1/3 of the page down? If so then, it is something we need to track.
if (!this._firstMoveState && !this._savedFirstMove) {
this._savedFirstMove = y;
} else if (this._firstMoveState && y < this._savedFirstMove) {
// You never know, a user might do a print: y = 700; then a band: y: 680. So we actually want to save the 680 as the smallest coord.
this._savedFirstMove = y;
} else if (!this._savedFirstMove) {
opt.addY = 0;
opt.y = 0;
Report.error("REPORTAPI: Your footer starts with printing some text, then uses an absolute move of greater than a third of the page. Please move first, then print!");
}
}
this._firstMoveState = true;
//return y > cY + (this._reportHeight / 3);
};
testit.band = function (data, options, callback) {
this.checkY(options);
oBand.call(this, data, options, callback);
};
testit.print = function (data, options, callback) {
this.checkY(options);
oPrint.call(this, data, options, callback);
};
testit.setCurrentY = function (y) {
this.checkY({y: y});
ReportRenderer.prototype.setCurrentY.call(this, y);
};
// Start the Calculation for the Test Report -> Then run the actual report.
this._calculateFixedSizes(testit, "",
() => {
// Eliminate the testit code so it can be garbage collected.
testit = null;
oPrint = null;
oBand = null;
oAddPage = null;
if (this._footer !== null) {
this._state.footerSize = this._footer._partHeight;
}
if (this._header !== null) {
this._state.headerSize = this._header._partHeight;
}
if (Report.trace) {
console.error("Generating real report", this._reportName);
}
// ----------------------------------
// Lets Run the Real Report Header
// ----------------------------------
const renderedReport = new ReportRenderer(this, pageDefaults);
renderedReport._reportRenderMode = this._reportRenderMode();
renderedReport.font(this._font, this._fontSize);
renderedReport.saveState();
//noinspection JSAccessibilityCheck
renderedReport._setAutoPrint(this._autoPrint);
renderedReport._setFullScreen(this._fullScreen);
renderedReport.setNegativeParentheses(this._negativeParentheses);
const primaryDataSet = this._detailGroup._findParentDataSet();
if (primaryDataSet && (primaryDataSet._dataType === dataTypes.NORMAL || primaryDataSet._dataType === dataTypes.PLAINOLDDATA)) {
this._state.primaryData = primaryDataSet._data;
}
this._renderIt(renderedReport, this._state, null,
() => {
if (Report.trace) {
console.error("Report Writing to ", this._outputType === Report.renderType.buffer ? "Buffer" : this._outputType === Report.renderType.pipe ? "Pipe" : "File " + this._reportName);
}
if (this._state.cancelled) {
if (callback) {
callback(null, false);
}
resolve(false);
return;
}
renderedReport._finishPageNumbers();
switch (this._outputType) {
case Report.renderType.pipe:
//noinspection JSAccessibilityCheck
renderedReport._pipe(this._pipe, (err) => {
if (callback) { callback(err, this._pipe); }
if (err) { reject(err); }
else { resolve(this._pipe); }
});
break;
case Report.renderType.buffer:
//noinspection JSAccessibilityCheck
renderedReport._output( (data) => {
if (callback) {
callback(null, data);
}
resolve(data);
});
break;
default:
//noinspection JSAccessibilityCheck
renderedReport._write(this._reportName, (err) => {
if (callback) {
callback(err, this._reportName);
}
if (err) { reject(err); }
else { resolve(this._reportName); }
});
break;
}
});
});
//return (this._reportName);
});
} else {
return this._parent.render(callback);
}
},
/**
* Add your own user data to be passed around in the report
* @param value
* @returns {*}
*/
userData: function (value) {
if (arguments.length) {
this._userdata = value;
return this;
}
return this._userdata;
},
/**
* The current state of the report engine
* @param value
* @returns {object}
*/
state: function (value) {
if (arguments.length) {
this._state = value;
}
return this._state;
},
/**
* Set the paper size in pixels
* @param {number} value
* @returns {number}
*/
paper: function (value) {
if (arguments.length) {
this._paper = value;
}
return this._paper;
},
/**
* Set the paper into Landscape mode
* @param value - True = Landscape, False = Portrait
* @returns {boolean}
*/
landscape: function (value) {
if (arguments.length) {
this._landscape = value;
}
return this._landscape;
},
font: function (value) {
if (arguments.length) {
this._font = value;
}
return this._font;
},
/**
* Set or Get the current font size
* @param {number} [value] - set fontSize if this value is set
* @returns {number} - the Font Size
*/
fontSize: function (value) {
if (arguments.length) {
this._fontSize = value;
}
return this._fontSize;
},
fontBold: function () {
const font = this._fonts[this._font];
switch (this._font) {
case font.italic:
case font.bolditalic:
if (font.bolditalic) {
this._font = font.bolditalic;
} else if (font.bold) {
this._font = font.bold;
}
break;
default:
if (font.bold) {
this._font = font.bold;
}
break;
}
},
fontItalic: function () {
const font = this._fonts[this._font];
switch (this._font) {
case font.bold:
case font.bolditalic:
if (font.bolditalic) {
this._font = font.bolditalic;
} else if (font.italic) {
this._font = font.italic;
}
break;
default:
if (font.italic) {
this._font = font.italic;
}
break;
}
},
fontNormal: function () {
const font = this._fonts[this._font];
if (font.normal) {
this._font = font.normal;
}
},
margins: function (value) {
if (arguments.length) {
this._margins = value;
}
return this._margins;
},
info: function(info) {
if (arguments.length) {
this._info = info;
}
return this._info;
},
registerFont:function(name, definition){
if (this._state.hasOwnProperty("isTitle")) {
Report.error("REPORTAPI: You cannot register a font while the report is running.");
return;
}
if (definition.normal || definition.bold || definition.bolditalic || definition.italic) {
this._registeredFonts[name] = definition;
// Register in our structure so we can easily switch between Bold/Normal/Italic/etc
this._fonts[name] = definition;
for (let key in definition) {
if (definition.hasOwnProperty(key)) {
this._fonts[definition[key]] = definition;
}
}
} else {
this._fonts[name] = this._registeredFonts[name] = {normal: definition};
}
},
// --------------------------------------
// Internal Private Variables & Functions
// --------------------------------------
/**
* Calculates a header/footer part of the report
* @param part
* @param Rpt
* @param callback
* @private
*/
_calculatePart: function(part, Rpt, callback) {
if (part) {
Rpt._addPage();
part.run(Rpt, {isCalc: true}, null, callback);
} else {
// No "if" check verification on "callback" because _calculatePart MUST have a callback
callback();
}
},
_calculateFixedSizes: function (Rpt, BogusData, callback) {
this._calculatePart(this._header, Rpt, () => {
this._calculatePart(this._tfooter, Rpt, () => {
this._calculatePart(this._footer, Rpt, () => {
this._child._calculateFixedSizes(Rpt, BogusData, callback);
});
});
});
},
_pageHeader: function (value, settings) {
if (this._header === null) {
this._header = new ReportHeaderFooter(true);
}
if (arguments.length) {
this._header.set(value, settings);
}
return (this._header.get());
},
_pageFooter: function (value, settings) {
if (this._footer === null) {
this._footer = new ReportHeaderFooter(false, true);
}
if (arguments.length) {
this._footer.set(value, settings);
}
return (this._footer.get());
},
_titleHeader: function (value, settings) {
if (this._theader === null) {
this._theader = new ReportHeaderFooter(true);
}
if (arguments.length) {
this._theader.set(value, settings);
}
return (this._theader.get());
},
_finalSummary: function (value, settings) {
if (this._tfooter === null) {
this._tfooter = new ReportHeaderFooter(false, true);
}
if (arguments.length) {
this._tfooter.set(value, settings);
}
return (this._tfooter.get());
},
_renderFinalFooter: function(Rpt, State, currentData, callback) {
// Run final Footer!
const dataSet = this._detailGroup._findParentDataSet();
dataSet._totalFormatter(this._detailGroup._totals, (err, data) => {
Rpt.totals = data;
Rpt._bandWidth(this._curBandWidth);
Rpt._bandOffset(this._curBandOffset);
const footer = this._tfooter || this._footer;
// IF Final Summary Footer is too big for page; so we will page feed another page, using a normal footer for this page...
if (this._footer) {
this._state.footerSize -= this._footer._partHeight;
}
this._state.currentGroup = null;
if (this._tfooter && this._tfooter._partHeight + Rpt._PDF.y > Rpt._maxY()) {
Rpt.newPage({save:true}, () => {
this._state.isFinal = true;
this._renderPart(Rpt, footer, currentData,() => {
this._state.isFinal = false;
callback(Rpt, State);
});
});
} else {
this._state.isFinal = true;
this._renderPart(Rpt, footer, currentData, () => {
this._state.isFinal = false;
callback(Rpt, State);
});
}
});
},
_renderPart: function(Rpt, part, data, callback) {
if (part !== null) {
part.run(Rpt, this._state, data, callback);
} else if (callback) {
callback();
}
},
/**
* Starts the Rendering for the Report object
* This is the first part that renders, so it is always does the title header (or
* a normal header in its place)
* @param Rpt
* @param State
* @param currentData
* @param callback
* @private
*/
_renderIt: function (Rpt, State, currentData, callback) {
this._state.isTitle = true;
const header = this._theader || this._header;
State.report = this;
// This is kinda a hack; it only works for some dataset types
// We are attempting to get the Primary Data in the event currentData = null
// (which should only occur on TitleHeader) This allows us to pass in the row[0] to most reports
// We should look into gathering the first set of data first; then doing the titleheader...
let primaryData=null;
if (currentData == null) {
const primaryDataSet = this._detailGroup._findParentDataSet();
if (primaryDataSet && (primaryDataSet._dataType === dataTypes.NORMAL || primaryDataSet._dataType === dataTypes.PLAINOLDDATA)) {
primaryData = primaryDataSet._data;
}
}
// In the event we don't have any current data, we pass the primaryData if it exists...
this._renderPart(Rpt, header, (currentData && currentData.length > 0) ? currentData[0] : (primaryData && primaryData.length > 0) ? primaryData[0] : currentData,() => {
this._state.isTitle = false;
if (this._parent !== null) {
State.resetGroups = true;
// Copy Parent Data into this State so that we have access to it in this sub-report
for (let key in currentData) {
if (currentData.hasOwnProperty(key)) {
State.parentData[key] = currentData[key];
}
}
this._detailGroup._clearTotals();
this._child._renderIt(Rpt, State, currentData, () => {
let parent = this;
// Find the first group above this report
while (parent._parent != null && !parent._isGroup) {
parent = parent._parent;
}
// iterate through the groups above this group and add this value to them so they get this sub-reports totals
while (parent._isGroup) {
for (let key in this._detailGroup._totals) {
if (this._detailGroup._totals.hasOwnProperty(key)) {
if (isNumber(parent._totals[key])) {
parent._totals[key] += this._detailGroup._totals[key];
} else {
parent._totals[key] = this._detailGroup._totals[key];
}
}
}
parent = parent._parent;
}
this._renderFinalFooter(Rpt, State, currentData, callback);
});
} else {
this._child._renderIt(Rpt, State, currentData, () => {
if (State.cancelled === true) {
callback();
} else {
this._renderFinalFooter(Rpt, State, currentData, callback);
}
});
}
});
},
_setBandSize: function (value, offset) {
this._curBandWidth = value;
this._curBandOffset = offset;
},
_reportRenderMode: function(value) {
if (arguments.length) {
this._reportMode = value;
}
return this._reportMode;
}
};
// -----------------------------------------------------------
// Header/Footer Prototypes
// -----------------------------------------------------------
ReportHeaderFooter.prototype = {
_isReportHeaderFooter: true,
set: function (value, settings) {
this._part = value;
this._isFunction = (typeof value === "function");
if (settings !== null) {
this._pageBreakBefore = getSettings(settings, "pageBreakBefore", false);
this._pageBreakAfter = getSettings(settings, "pageBreakAfter", false);
if (this._isHeader) {
this._pageBreakBefore = getSettings(settings, "pageBreak", this._pageBreakBefore);
} else {
this._pageBreakAfter = getSettings(settings, "pageBreak", this._pageBreakAfter);
//This allows direct placement of print statements in the footer even if they go beyond the end of the page - it will not push it to a new page
//i.e. ... .footer(footer, {isHeightExempt: true})...
this._isHeightExempt = getSettings(settings, "isHeightExempt", this._isHeightExempt);
}
}
},
get: function () {
return this._part;
},
run: function (Rpt, State, Data, callback) {
let offsetX, offsetY;
if (State.isCalc) {
Rpt._firstMoveState = false;
Rpt._savedFirstMove = 0;
}
if (Report.trace) {
console.error("Run ", this._isHeader ? "Header" : "Footer", State.isCalc ? "-- Is Calculation --" : "");
if (Report.callbackDebugging) {
console.error(" - with ", typeof callback === "function" ? "Valid" : "** Invalid **", "callback");
}
}
// Setup our current Header/Footer that is running
Rpt._curheaderfooter = this;
let _handlePrePageBreak, _handleCallingDetailFunction, _handlePostPageBreak;
// We need to see if we need to page break BEFORE printing the detail
_handlePrePageBreak = () => {
offsetY = Rpt.getCurrentY();
if (this._partHeight === -1) {
offsetX = Rpt.getCurrentX();
}
// We are temporarily eliminating the height restriction.
if (this._isHeightExempt) {
Rpt._height = 90000;
}
if (offsetY + this._partHeight > Rpt._maxY()) {
Rpt.newPage({save: true, breakingBeforePrint: true}, _handleCallingDetailFunction);
} else {
_handleCallingDetailFunction();
}
};
// Print the detail data
_handleCallingDetailFunction = () => {
if (Report.trace) {
console.error("Running", this._isHeader ? "Header" : "Footer", this._isFunction ? (this._part.length === 4 ? "(Async)" : "(Sync)") : "(Fixed)");
}
if (this._isFunction) {
if (this._part.length === 4) {
try {
this._part(Rpt, Data, State, (err) => {
if (Report.trace && Report.callbackDebugging) {
console.error(" - CallBack from ", this._isHeader ? "Async Header" : "Async Footer");
}
if (err) {
if (this._isHeader) {
Report.error("REPORTAPI: Error running header in report", new ReportError({error: err, stack: err && err.stack}));
} else {
Report.error("REPORTAPI: Error running footer in report", new ReportError({error: err, stack: err && err.stack}));
}
}
_handlePostPageBreak();
});
} catch (err) {
if (this._isHeader) {
Report.error("REPORTAPI: Error running header in report", new ReportError({error: err, stack: err && err.stack}));
} else {
Report.error("REPORTAPI: Error running footer in report", new ReportError({error: err, stack: err && err.stack}));
}
_handlePostPageBreak();
}
} else {
try {
this._part(Rpt, Data, State);
} catch (err) {
if (this._isHeader) {
Report.error("REPORTAPI: Error running header in report", new ReportError({error: err, stack: err && err.stack}));
} else {
Report.error("REPORTAPI: Error running footer in report", new ReportError({error: err, stack: err && err.stack}));
}
}
if (Report.trace && Report.callbackDebugging) {
console.error(" - Back from ", this._isHeader ? "Header" : "Footer");
}
_handlePostPageBreak();
}
} else if (this._part !== null) {
if (this._isHeader) {
this.runStockHeader(Rpt, this._part, _handlePostPageBreak);
} else {
this.runStockFooter(Rpt, this._part, _handlePostPageBreak);
}
} else {
_handlePostPageBreak();
}
};
// We need to see if we need to page break AFTER print the detail
_handlePostPageBreak = () => {
// If this is a Calculation, then we are getting the header/footer details sizes.
if (State.isCalc && this._partHeight === -1) {
if (this._isHeader) {
// We want to subtract out the fixed margin for the header
// noinspection JSCheckFunctionSignatures
this._partHeight = parseInt(Math.ceil(Rpt.getCurrentY() - Rpt.minY()),10);
} else {
if (Rpt._savedFirstMove) {
// noinspection JSCheckFunctionSignatures
this._partHeight = Rpt.maxY() - parseInt(Math.ceil(Rpt._savedFirstMove),10);
} else {
// noinspection JSCheckFunctionSignatures
this._partHeight = parseInt(Math.ceil(Rpt.getCurrentY() - offsetY), 10);
}
if (Rpt.getCurrentY() > Rpt.maxY()) {
// noinspection JSCheckFunctionSignatures
const exceeds = parseInt(Math.ceil(Rpt.getCurrentY()),10) - Rpt.maxY();
Report.error("REPORTAPI: Your Report's Page Footer exceeds the page bottom margin (", Rpt.maxY(), ") by ", exceeds, "-- Please subtract", exceeds, "pixels from (probably) where you set Y to", (Rpt._savedFirstMove ? Rpt._savedFirstMove : "change its location."));
}
}
if (Report.trace) {
console.error("Part ", this._isHeader ? "Header" : "Footer", " Height is:", this._partHeight, Rpt._savedFirstMove, Rpt.getCurrentY(), Rpt._maxY());
}
this._partWidth = Rpt.getCurrentX() - offsetX;
}
// We are re-instating the height restriction.
if (this._isHeightExempt) {
Rpt._height = Rpt._reportHeight;
}
if (this._pageBreakAfter) {
Rpt.newPage({save:true}, callback);
} else if (callback) {
callback();
}
};
if (this._pageBreakBefore) {
Rpt.newPage({save: true, breakingBeforePrint: !this._isHeader}, _handlePrePageBreak);
} else {
_handlePrePageBreak();
}
},
runStockHeader: function (Rpt, headers, callback) {
if (Report.trace) {
console.error("Running Stock", this._isHeader ? "Header" : "Footer");
if (Report.callbackDebugging) {
console.error(" - Callback is ", typeof callback === "function" ? "Valid" : "** Invalid **");
}
}
if (headers == null || headers.length === 0) {
if (callback) {
callback();
}
return;
}
const NowDate = new Date();
let minutes = NowDate.getMinutes();
if (minutes < 10) {
minutes = "0" + minutes;
}
let hours = NowDate.getHours();
let ampm = "am";
if (hours >= 12) {
if (hours > 12) {
hours -= 12;
}
ampm = "pm";
}
let Header = "Printed At: " + hours + ":" + minutes + ampm;
let y = Rpt.getCurrentY();
let centerHeader;
Rpt.print(Header, () => {
if (isArray(headers)) {
centerHeader = headers[0];
} else {
centerHeader = headers;
}
Rpt.print(centerHeader, {align: "center", y: y}, () => {
Rpt.print("Page: " + Rpt.currentPage(), {align: "right", y: y}, () => {
Header = "on " + NowDate.toLocaleDateString();
y = Rpt.getCurrentY();
Rpt.print(Header, () => {
centerHeader = '';
if (isArray(headers) && headers.length > 1) {
centerHeader = headers[1];
}
Rpt.print(centerHeader, {align: "center", y: y}, () => {
Rpt.newLine(callback);
});
});
});
});
});
},
runStockFooter: function (Rpt, footer, callback) {
if (Report.trace) {
console.error("Running Stock", this._isHeader ? "Header" : "Footer");
if (Report.callbackDebugging) {
console.error(" - Callback is ", typeof callback === "function" ? "Valid" : "** Invalid **");
}
}
if (footer == null || footer.length === 0) {
if (callback) {
callback();
}
return;
}
let i, bndSizes = Rpt._bandWidth();
Rpt.newLine(() => {
Rpt.bandLine(2);
// Handle a String Passed into it.
if (!isArray(footer)) {
this._handleFooterPart(Rpt, [footer], bndSizes, callback);
return;
}
if (isArray(footer) && footer.length >= 1) {
// Handle a Single Array
if (!isArray(footer[0])) {
this._handleFooterPart(Rpt, footer, bndSizes, callback);
return;
}
let bndArray = [];
// Handle a Array of Arrays
for (i = 0; i < footer.length; i++) {
let id = footer[i][1] - 1;
while (id > bndArray.length) {
bndArray.push(["", bndSizes[bndArray.length]]);
}
bndArray[id] = [Rpt.totals[footer[i][0]], bndSizes[id]];
// Fix Alignment, if set
if (footer[i][2] >= 0 && footer[i][2] <= 3) {
bndArray[id][2] = footer[i][2];
}
}
if (bndArray.length > 0) {
Rpt.band(bndArray, callback);
} else if (callback) {
callback();
}
} else if (callback) {
callback();
}
});
},
_handleFooterPart: function (Rpt, part, bndSizes, callback) {
let offset = 0, i;
if (part.length === 3) {
if (bndSizes[(part[2] - 1)]) {
for (i = 0; i < part[2] - 1; i++) {
offset += bndSizes[i];
}
}
}
const _finishFooterPart = () => {
//Rpt.setCurrentY(y);
//Rpt.setCurrentX(x);
if (callback) {
callback();
}
};
let y = Rpt.getCurrentY(), x = Rpt.getCurrentX();
if (offset > 0) {
Rpt.print(part[0], {y: y}, () => {
offset += (bndSizes[part[2] - 1] - Rpt.widthOfString(Rpt.totals[part[1]].toString()) - 2);
Rpt.print(Rpt.totals[part[1]].toString(), {x: x + offset, y: y}, _finishFooterPart);
});
} else if (part.length > 1) {
Rpt.print(part[0] + ' ' + Rpt.totals[part[1]], {y: y}, _finishFooterPart);
} else {
Rpt.print(part[0].toString(), {y: y}, _finishFooterPart);
}
}
};
// -----------------------------------------------------------
// ScopedDataObject Prototypes
// -----------------------------------------------------------
ScopedDataObject.prototype = {
_isScopedDataObject: true,
// Used for Error Reporting (optional)
error: function () {
let args = [this._scope, null, 'error'];
//noinspection JSHint
for (let a in arguments) {
if (args.length > 3) {
args.push(" / ");
}
if (arguments.hasOwnProperty(a)) {
if (isArray(arguments[a])) {
for (let i = 0; i < arguments[a]; i++) {
args.push(arguments[a][i]);
}
} else if (typeof arguments[a] === 'string') {
args.push(arguments[a]);
} else if (typeof arguments[a] === 'object') {
args.push(arguments[a].toString());
} else {
args.push(arguments[a]);
}
}
}
if (console && console.error) {
console.error.apply(console, args.slice(2));
}
if (this._scope && this._scope.funcs && this._scope.funcs.logclient) {
this._scope.funcs.logclient.apply(this, args);
}
},
// Helper function, not required to re-implement a SDO interface
cleanUpData: function (results, callback) {
let columns = [], mcolumns = null;
// Skip ALL Formatting
if (this._formattingState === 0 || this._formattingState === false) {
callback(null, results);
return;
}
if (this._dataType === dataTypes.PAGEABLE) {
mcolumns = this._data.fields;
for (let key in mcolumns) {
if (mcolumns.hasOwnProperty(key)) {
if (mcolumns[key] === true) {
columns.push(key);
}
}
}
} else {
let firstRow = results[0];
if (firstRow) {
mcolumns = Object.keys(firstRow);
for (let i = 0; i < mcolumns.length; i++) {
columns.push(mcolumns[i]);
}
}
}
if (this._formatters === null) {
this._scope.funcs.reportapi_setupformatters(this._scope,
(err, data) => {
this._formatters = data;
this._scope.funcs.reportapi_handleformatters(this._scope, callback, results, this._formatters, this._formattingState);
}, columns);
} else {
this._scope.funcs.reportapi_handleformatters(this._scope, callback, results, this._formatters, this._formattingState);
}
},
// Used to load the data (Required)
loadRange: function (start, end, callback) {
if (!this.isPaged || this._result) {
this.cleanUpData(this._result, callback);
} else {
//noinspection JSUnresolvedFunction,JSUnresolvedVariable
this._scope.funcs.rowsgetpage(this._scope, (err, data) => {
if (!err) {
this.cleanUpData(data, callback);
} else {
callback(err, null);
}
}, this._data, start, end-start, {asarray: true, append: false});
}
},
// Used to run a Query (Optional)
query: function(data, callback) {
if (arguments.length === 1) {
callback = data;
data = null;
}
if (this._dataType === dataTypes.FUNCTIONAL) {
if (data !== null) {
for (let i=0;i<data.length;i++) {
if (typeof this._data.where.values[0] === "string") {
this._data.where.values[0] = data[i];
} else {
// multiple values
this._data.where.values[i].values[0] = data[i];
}
}
}
let called = false;
this._scope.funcs.query(this._scope,
(err, data) => {
// Streamline can on some errors decide to call us twice; so we eat the second call
if (called) { return; }
called = true;
// Error Occurred
if (err) {
this.error("REPORTAPI: Error in query: ", err, err && err.stack);
this._result = null;
callback(err);
return;
}
if (data === null) {
// No records
this._result = [];
} else {
// Result Array
this._result = data;
}
callback(null);
}, this._data, null);
} else {
callback(null);
}
},
// Used to get a record count (Required)
count: function (callback) {
if (this._dataType === dataTypes.FUNCTIONAL) {
if (this._result && this._result.length) {
callback(null, this._result.length);
} else {
this.query(() => {
let len = this._result && this._result.length || 0;
return callback(null, len);
});
}
} else if (this._dataType === dataTypes.PAGEABLE) {
this._scope.funcs.rowsgetlength(this._scope, callback, this._data);
} else {
this.error("REPORTAPI: Unknown data type in scopedDataObject(Count), either extend the scopedDataObject or create your own simple wrapper!");
}
},
// Used to format the total line (Optional)
totalFormatter: function (data, callback) {
try {
this._scope.funcs.reportapi_handleformatters(this._scope, (err, data) => {
callback(err, data[0]);
}, [data], this._formatters, this._formattingState);
} catch (totalError) {
this.error("REPORTAPI: Error in totalFormatter", totalError, totalError && totalError.stack);
callback(null, data);
}
}
};
const _PDFKit = require('./fluentReports.pdfkit');
// -----------------------------------------------------------
// Setup our ReportRenderer Prototype functions
// -----------------------------------------------------------
//noinspection JSUnusedGlobalSymbols
ReportRenderer.prototype =
/** @lends ReportRenderer **/
{
_isPDFWrapper: true,
_PDFKit: _PDFKit,
_LineWrapperObject: require('pdfkit/js/line_wrapper'),
_PageObject: require('pdfkit/js/page'),
/***
* Gets or sets the userdata
* @param {Object} value - new userdata
* @returns {Object} the current user data
*/
userData: function(value) {
if (arguments.length) {
return this._primaryReport.userData(value);
} else {
return this._primaryReport.userData();
}
},
/**
* Prints a image on the PDF
* @param name - source file of the image
* @param {object} [options] - width, height, fit
* @method
* @public
*/
image: function (name, options) {
options = options || {};
this._pageHasRendering++;
this._PDF.image(name, options);
},
/**
* Set the font
* @param {string} name - name of font, or path to font
* @param {number} [size] of font
*/
font: function (name, size) {
try {
if (name && name.normal) {
this._font = name.normal;
this._PDF.font(name.normal, size);
} else {
this._font = name;
this._PDF.font(name, size);
}
// The actual Font name may be different than we registered it as; so we need to register in our list it...
if (!this._fonts[this._PDF._font.name]) {
if (name.normal) {
this._fonts[this._PDF._font.name] = name;
} else {
this._fonts[this._PDF._font.name] = this._fonts[name];
}
}
this._heightOfString = this._PDF.currentLineHeight(true);
} catch (err) {
Report.error("REPORTAPI: Invalid font", name);
}
},
/**
* Set the font size
* @param {number} [size] of font
* @returns {number} - font size
*/
fontSize: function (size) {
if (size == null) { return this._PDF._fontSize; }
this._PDF.fontSize(size);
this._heightOfString = this._PDF.currentLineHeight(true);
return this._PDF._fontSize;
},
/**
* Bold the Font
*/
fontBold: function () {
const font = this._fonts[this._PDF._font.filename || this._PDF._font.name || (this._PDF._font.font.attributes && this._PDF._font.font.attributes.FamilyName)];
if (!font) { return; }
const fontName = this._PDF._font.filename || this._PDF._font.name;
switch (fontName) {
case font.italic:
case font.bolditalic:
if (font.bolditalic) {
this.font(font.bolditalic);
} else if (font.bold) {
this.font(font.bold);
}
break;
default:
if (font.bold) {
this.font(font.bold);
}
break;
}
this._heightOfString = this._PDF.currentLineHeight(true);
},
/**
* Fill and Stroke Colors
* @param fillColor
* @param strokeColor
*/
fillAndStroke: function(fillColor, strokeColor) {
this._fillColor = fillColor;
this._strokeColor = strokeColor;
this._PDF.fillAndStroke(fillColor, strokeColor);
},
/**
* Force a Fill -- using current (or optional) Fill Color
* @param {string} [fillColor] - HTML Color (i.e. "#FFFFFF", "#FF00FF")
*/
fill: function(fillColor) {
if (arguments.length) {
this._fillColor = fillColor;
this._PDF.fill(fillColor);
} else {
this._PDF.fill();
}
},
/**
* Set or get the current Fill Color
* @param {string} [color]
* @returns {string}
*/
fillColor: function(color) {
if (arguments.length) {
if (color !== this._fillColor) {
this._fillColor = color;
this._PDF.fillColor(color);
}
}
return this._fillColor;
},
/**
* Set or get the Fill Opacity
* @param {number} [opacity] - 0.0 to 1.0
* @returns {number}
*/
fillOpacity: function(opacity) {
if (arguments.length) {
if (opacity !== this._fillOpacity) {
this._fillOpacity = opacity;
this._PDF.fillOpacity(opacity);
}
}
return this._fillOpacity;
},
/**
* Set or get the current Stroke Color
* @param {string} [color] - HTML Color (i.e. "#000000", "#00FF00")
* @returns {string}
*/
strokeColor: function(color) {
if (arguments.length) {
if (color !== this._strokeColor) {
this._strokeColor = color;
this._PDF.strokeColor(color);
}
}
return this._strokeColor;
},
/**
* Italicize the Font
*/
fontItalic: function () {
const font = this._fonts[this._PDF._font.filename || this._PDF._font.name || (this._PDF._font.font.attributes && this._PDF._font.font.attributes.FamilyName)];
if (!font) { return; }
const fontName = this._PDF._font.filename || this._PDF._font.name;
switch (fontName) {
case font.bold:
case font.bolditalic:
if (font.bolditalic) {
this.font(font.bolditalic);
} else if (font.italic) {
this.font(font.italic);
}
break;
default:
if (font.italic) {
this.font(font.italic);
}
break;
}
this._heightOfString = this._PDF.currentLineHeight(true);
},
/**
* Make the Font Normal again (Remove Bold/Italic)
*/
fontNormal: function () {
const font = this._fonts[this._PDF._font.filename || this._PDF._font.name || (this._PDF._font.font.attributes && this._PDF._font.font.attributes.FamilyName) ];
if (font && font.normal) {
this.font(font.normal);
}
this._heightOfString = this._PDF.currentLineHeight(true);
},
/**
* Margins of the paper;
* @param {(number|object)} value - number of pixels will be set to all sides, the object you can specify a object with .left, .right, .top, and .bottom
*/
setMargins: function (value) {
this._margins = value;
},
/**
* Enables/Disables Negative () instead of using the -
* @param {boolean} value
*/
setNegativeParentheses: function(value) {
this._negativeParentheses = value;
},
/**
* Paper size
* @param {string} value - "letter", "legal", etc...
* @returns {string} current value of paper setting.
*/
paper: function (value) {
if (arguments.length) {
this._paper = value;
}
return (this._paper);
},
/**
* Enable/disable Landscape mode
* @param {boolean} value
* @returns {boolean} - current mode it is in
*/
landscape: function (value) {
if (arguments.length) {
this._landscape = value;
}
return (this._landscape);
},
/**
* Saves the current graphic engine state
*/
saveState: function() {
const state = {font: this._PDF._font, fontSize: this._PDF._fontSize, lineWidth: this._lineWidth, x: this._PDF.x, fillColor: this._fillColor, strokeColor: this._strokeColor, opacity: this._fillOpacity, rotated: this._rotated};
this._graphicState.push(state);
},
/**
* Resets the graphic state back
*/
resetState: function() {
const state = this._graphicState.pop();
this._applyState(state);
},
/**
* Deletes the last saved state.
*/
deleteState: function() {
this._graphicState.pop();
},
/**
* Have their been any changes
* @param {boolean} [allChanges] - true means count header changes as changes; so a newPage page with headers will report as having changes
* - false means only count any detail or footer changes as changes.
* @returns {boolean}
*/
hasChanges: function(allChanges) {
if (allChanges === true) {
return !!this._pageHasRendering;
} else {
return this._pageHeaderRendering !== this._pageHasRendering;
}
},
/**
* Add a new Page; will check to see if anything has been rendered and if not; will not do anything
* @param {object|boolean} [save] - Saves the current State and applies it to the next page if "true"
* - If object, then it has save, skipDatesetFooters, and breakingBeforePrint options
* @param {function} [callback] - optional, if no callback is provided; this function will be synchronous
* @returns void
*/
newPage: function (save, callback) {
let hasCallback = true, options = {breakingBeforePrint: false};
if (typeof save === 'function') {
//noinspection JSValidateTypes
callback = save;
save = false;
}
if (typeof callback !== 'function') {
this._checkRenderMode(callback, "newPage");
callback = dummyCallback;
hasCallback = false;
}
if (save != null && typeof save === 'object') {
if (save.breakingBeforePrint) {
options.breakingBeforePrint = save.breakingBeforePrint;
}
save = !!save.save;
}
if (!this._pageHasRendering) {
callback();
return;
}
if (this._pageBreaking) {
callback();
return;
}
if (save === true) {
this.saveState();
this._applyState(this._graphicState[0], true);
}
this._pageBreaking = true;
if (hasCallback) {
this._handleFooter(options, () => {
this._addPage();
this._handleHeader(options, () => {
this._PDF.getEmptyPageStats();
this._resetPageHeaderCounter();
this._pageBreaking = false;
if (save === true) {
this.resetState();
}
callback();
});
});
} else {
this._handleFooter(options);
this._addPage();
this._handleHeader(options);
this._PDF.getEmptyPageStats();
this._resetPageHeaderCounter();
this._pageBreaking = false;
if (save === true) {
this.resetState();
}
}
},
/**
* Prints a standard header
* @param {string} text to print in center of header
* @param {function} callback
*/
standardHeader: function (text, callback) {
this._checkRenderMode(callback, "standardHeader");
this._curheaderfooter.runStockHeader(this, text, callback);
},
/**
* Prints a standard footer
* @param {string} text
* @param {function} callback
*/
standardFooter: function (text, callback) {
this._checkRenderMode(callback, "standardFooter");
this._curheaderfooter.runStockFooter(this, text, callback);
},
/**
* Current Page that is being generated
* @returns {Number}
*/
currentPage: function () {
if (this._PDF.pages) {
return this._PDF.pages.length;
} else {
return this._PDF._root.data.Pages.data.Count;
}
},
/**
* Current X position on the page
* @returns {Number}
*/
getCurrentX: function () {
return this._PDF.x;
},
/**
* Current Y position on the page
* @returns {Number}
*/
getCurrentY: function () {
return this._PDF.y;
},
/**
* Sets the Current X position
* @param {number} x position; don't forget to include the margin your self in this case
*/
setCurrentX: function (x) {
this._PDF.x = x;
},
/**
* Adds a number of the x coord from your current location
* @param {number} x - number to add to the current X
*/
addX: function(x) {
this._PDF.x += x;
},
/**
* Sets the Current Y position
* @param {number} y position; don't forget the top margin
*/
setCurrentY: function (y) {
this._PDF.y = y;
},
/**
* Add a number to the y coord from your current location
* @param {number} y
*/
addY: function(y) {
this._PDF.y += y;
},
/**
* Gets or Sets the X coordinate
* @param {number} [x] - x coordinate
* @returns {number} - current x coordinate
*/
currentX: function(x) {
//noinspection PointlessArithmeticExpressionJS
if (arguments.length && !isNaN(x+0)) {
//noinspection PointlessArithmeticExpressionJS
this._PDF.x = x+0;
}
return this._PDF.x;
},
/**
* Gets or Sets the Y coordinate
* @param {number} [y] - y coordinate
* @returns {number} - current y coordinate
*/
currentY: function(y) {
//noinspection PointlessArithmeticExpressionJS
if (arguments.length && !isNaN(y+0)) {
//noinspection PointlessArithmeticExpressionJS
this._PDF.y = y+0;
}
return this._PDF.y;
},
/**
* Inserts new Lines
* @param {number} [lines] - number of lines to insert defaults to 1
* @param {function} [callback] - Optional Async support
*/
newLine: function (lines, callback) {
let count= 0;
if (typeof lines === "function") {
//noinspection JSValidateTypes
callback = lines;
lines = 1;
}
this._checkRenderMode(callback, "newLine");
lines = lines || 1;
const newLineDone = () => {
this._PDF.moveDown();
count++;
if (count === lines) {
this._checkAndAddNewPage(0, {breakingBeforePrint: !this._pageBreaking}, callback);
} else {
// TODO: We might want to spin off on a setImmediate/Process.nextTick if we run this loop more than a number of times
this._checkAndAddNewPage(0, {breakingBeforePrint: !this._pageBreaking}, newLineDone);
}
};
newLineDone();
},
/**
* Returns the width of the string, optionally checking width by word
* @param {string} str
* @param {boolean} checkByWord
* @returns {number} size of string
*/
widthOfString: function (str, checkByWord) {
if (!checkByWord) {
return this._PDF.widthOfString(str);
} else {
let splitString = str.split(' '),
curWord,
wos = 0,
wordLength;
for (let i = 0; i < splitString.length; ++i) {
curWord = splitString[i];
if ((i + 1) !== splitString.length) {
curWord += ' ';
}
wordLength = this._PDF.widthOfString(curWord);
wos += wordLength;
}
return wos;
}
},
/**
* Returns the current height needed for a string
* @returns {number} - height
*/
heightOfString: function() {
return this._heightOfString;
},
/**
* Prints text on the PDF
* @param {(String|Array)} data a string or an array of string values to be
* @param {Object} options - a list of options (x,y,addX,addY,align,width,textWidth,font,fontSize,fontBold
* @param {function?} callback - Optional, function will be synchronous if called without a CB;
*/
print: function (data, options, callback) {
if (typeof options === 'function') {
//noinspection JSValidateTypes
callback = options;
options = null;
}
// If we have nothing to print then lets just exit
if (data == null || data.length === 0) {
if (callback) {
callback();
}
return;
}
let textOptions = {};
this._pageHasRendering++;
this._PDF.x = this._PDF.page.margins.left;
this.saveState();
// TODO: Decide if this is safe; this flag should only be set by the _finishPageNumbers function
if (!options || options.forceSync !== true) {
this._checkRenderMode(callback, "print");
}
let saveX, saveY;
if (options && typeof options === "object") {
if (options.rotate) {
saveX = this._PDF.x;
saveY = this._PDF.y;
}
if (!isNaN(options.x + 0)) {
this._PDF.x = options.x + 0;
}
if (!isNaN(options.addX + 0)) {
this._PDF.x += options.addX + 0;
}
if (!isNaN(options.addx + 0)) {
this._PDF.x += options.addx + 0;
}
if (!isNaN(options.y + 0)) {
this._PDF.y = options.y + 0;
}
if (!isNaN(options.addY + 0)) {
this._PDF.y += options.addY + 0;
}
if (!isNaN(options.addy + 0)) {
this._PDF.y += options.addy + 0;
}
if (options.align) {
if (options.align + 0 > 0) {
switch (options.align) {
case Report.alignment.LEFT: options.align = "left"; break;
case Report.alignment.CENTER: options.align = "center"; break;
case Report.alignment.RIGHT: options.align = "right"; break;
}
}
textOptions.align = options.align;
}
if (options.wordSpacing || options.wordspacing) {
textOptions.wordSpacing = this._parseSize(options.wordSpacing || options.wordspacing);
}
if (options.characterSpacing || options.characterspacing) {
textOptions.characterSpacing = this._parseSize(options.characterSpacing || options.characterspacing);
}
if (options.width) {
textOptions.width = this._parseSize(options.width);
}
if (options.textColor || options.textcolor) {
this.fillColor(options.textColor || options.textcolor);
this.strokeColor(options.textColor || options.textcolor);
}
if (options.underline) {
textOptions.underline = true;
}
if (options.strike) {
textOptions.strike = true;
}
if (options.fontsize) {
this.fontSize(options.fontsize);
} else if (options.fontSize) {
this.fontSize(options.fontSize);
}
if (options.fill) {
textOptions._backgroundFill = options.fill;
}
if (options.link) {
textOptions.link = options.link;
}
if (options.font) {
this.font(options.font);
}
if (options.fontBold || options.fontbold) {
this.fontBold();
}
if (options.fontItalic || options.fontitalic) {
this.fontItalic();
}
if (options.opacity) {
this.fillOpacity(options.opacity);
}
if (options.fillOpacity) {
this.fillOpacity(options.fillOpacity);
}
if (options.rotate) {
this._rotate(options.rotate);
}
}
let cachedMaxY = this._maxY() - this._heightOfString;
const finishPrinting = () => {
this.resetState();
if (saveX != null) {
this._PDF.x = saveX;
}
if (saveY != null) {
this._PDF.y = saveY;
}
if (this._PDF.y >= this._maxY()) {
this.newPage({save:true}, callback);
} else if (callback) {
callback();
}
};
if (isArray(data)) {
// If a callback isn't provided -- then we need to do a normal loop; because startLooping uses SetImmediate which will
// break the PROCESSING ORDER and cause things to get printed out of order.
let startLooping;
if (this._reportRenderMode === reportRenderingMode.ASYNC) {
startLooping = startLoopingAsync;
} else {
startLooping = startLoopingSync;
}
if (callback) {
startLooping(data.length, (iteration, done) => {
if (data[iteration] !== null && data[iteration] !== undefined) {
if (options.ignoreEmptyStrings !== true && data[iteration] === '') { data[iteration] = ' ';}
if (this._PDF.y > cachedMaxY) {
this.newPage({save: true, breakingBeforePrint: true}, () => {
this._print(data[iteration], textOptions, done);
});
} else {
this._print(data[iteration], textOptions, done);
}
} else {
done();
}
}, finishPrinting);
} else {
// Synchronous Loop, if a callback wasn't provided
for (let i=0;i<data.length;i++) {
if (data[i] !== null && data[i] !== undefined) {
if (options && options.ignoreEmptyStrings !== true && data[i] === '') { data[i] = ' ';}
if (this._PDF.y > cachedMaxY) {
// WE HAVE TO ASSUME that the header does not need a callback since they didn't pass one into the print routine
// This is not a GOOD assumption; but it is the only valid one we can do, since we have no way to async wait now
this.newPage({save: true, breakingBeforePrint: true});
}
this._print(data[i], textOptions);
}
}
finishPrinting();
}
} else {
// Data cannot be null or undefined here; the check at the top of the routine catches
// Async Path
if (callback) {
if (this._PDF.y > cachedMaxY) {
this.newPage({save: true, breakingBeforePrint: true}, () => {
this._print(data, textOptions, finishPrinting);
});
} else {
this._print(data, textOptions, finishPrinting);
}
} else {
if (this._PDF.y > cachedMaxY) {
this.newPage({save: true, breakingBeforePrint: true});
}
this._print(data, textOptions);
finishPrinting();
}
}
},
/**
* Creates a Band Line that matches the width of the Band
* @param thickness
* @param verticalGap
*/
bandLine: function (thickness, verticalGap) {
thickness = thickness || 2;
let i, bndSizes = this._bandWidth(), width, y = this.getCurrentY(), x = this._bandOffset();
for (i = 0, width = 0; i < bndSizes.length; i++) {
width += bndSizes[i];
}
if (verticalGap) {
y += verticalGap;
}
if (width > 0) {
const oldLineWidth = this.lineWidth();
this.lineWidth(thickness);
this.line(x - 0.5, y - 2, width + x - 0.5, y - 2, {});
this.lineWidth(oldLineWidth);
}
if (verticalGap) {
this.setCurrentY(y + verticalGap);
}
},
/**
* Create a Line
* @param {number} startX
* @param {number} startY
* @param {number} endX
* @param {number} endY
* @param {Object?} options
*/
line: function (startX, startY, endX, endY, options) {
if (arguments.length < 4) { return; }
let x = this._PDF.x, y = this._PDF.y;
this._pageHasRendering++;
this._PDF.moveTo(startX, startY);
this._PDF.lineTo(endX, endY);
this._handleOptions(options);
this._PDF.x = x;
this._PDF.y = y;
},
/**
* Create A box
* @param {number} startX
* @param {number} startY
* @param {number} width
* @param {number} height
* @param {Object} options
*/
box: function (startX, startY, width, height, options) {
if (arguments.length < 4) { return; }
this._pageHasRendering++;
this._PDF.rect(startX, startY, width, height);
this._handleOptions(options);
},
/**
* Creates a Circle
* @param {number} startX
* @param {number} startY
* @param {number} radius
* @param {object} options
*/
circle: function(startX, startY, radius, options) {
if (arguments.length < 3) { return; }
this._pageHasRendering++;
this._PDF.circle(startX,startY,radius);
this._handleOptions(options);
},
/**
* Creates a Suppression Band
* @param {object} data - a object of your data row -- data can have a .force variable which will cause this "data" field to always print
* @param {object} options - Options like "group" for grouping values,
* and "duplicatedTextValue" for what you want printed - defaults to a single quote ' " '
* and can contain any normal "band" options
* @param {Function} callback
*/
suppressionBand: function (data, options, callback) {
if (typeof options === "function") {
//noinspection JSValidateTypes
callback = options;
options = null;
} else if (typeof data === "function") {
//noinspection JSValidateTypes
callback = data;
data = null;
}
options = options || {};
if (!options.group) {
options.group = "detail" + this._level;
}
let group = options.group;
const originalData = clone(data);
if (this._priorValues[group] !== undefined) {
const cdata = this._priorValues[group];
for (let i = cdata.length - 1; i >= 0; i--) {
if (data[i].force === true || data[i].force === 1) {
continue;
}
if (data[i].data === cdata[i].data && data[i].data !== '' && data[i].data !== null && data[i].data !== undefined) {
data[i].data = data[i].duplicatedTextValue || options.duplicatedTextValue || ' " ';
}
//else break;
}
}
this.band(data, options, () => {
this._priorValues[group] = originalData;
if (callback) {
callback();
}
});
},
/**
* Band creates a Band where border and padding are including INSIDE the cell. Gutter is outside.
* @param {Array|Object} dataIn is {data: value, width: width, align: alignment}
* @param {Object} options
* @param {function} callback - optional Callback for Async support
*/
band: function (dataIn, options, callback) {
let i = 0, max = dataIn.length, maxWidth = 0, lineWidth = null;
let defaultSize = 50, data = [], startX = this._PDF.page.margins.left;
this._pageHasRendering++;
if (typeof options === "function") {
//noinspection JSValidateTypes
callback = options;
options = null;
} else if (typeof dataIn === "function") {
//noinspection JSValidateTypes
callback = dataIn;
dataIn = null;
}
this._checkRenderMode(callback, "band");
if (dataIn == null) {
Report.error("REPORTAPI: Band passed a NULL as the data");
if (callback) {
callback();
}
return;
}
options = options || {};
if (options.defaultSize != null) {
defaultSize = this._parseSize(options.defaultSize);
if (defaultSize === 0) { defaultSize = 50;}
}
// Convert old style [[data, width, alignment],[...],...] to [{data:data, width:width, ..},{...},...]
if (isArray(dataIn[0])) {
for (i = 0; i < max; i++) {
data[i] = {
data: dataIn[i][0] || '',
width: this._parseSize(dataIn[i][1] || defaultSize),
align: dataIn[i][2] || 1
};
}
} else {
for (i = 0; i < max; i++) {
if (typeof dataIn[i] === 'string') {
data[i] = {data: dataIn[i], width: defaultSize, align: 1};
} else {
data[i] = dataIn[i];
if (data[i].width) {
data[i].width = this._parseSize(data[i].width);
} else {
data[i].width = defaultSize;
}
}
}
}
// This is to save the whole state for the band so we can reset it afterwords
this.saveState();
// Check to see if we have a "Settings"
let padding = 1, border = 0, gutter = 0, collapse = true;
if (arguments.length > 1 && typeof options === 'object') {
if (options.gutter > 0) {
gutter = options.gutter + 0;
if (gutter !== 0) {
collapse = false;
}
}
if (options.collapse === true || options.collapse === false) {
collapse = options.collapse;
}
if (options.border > 0 || options.fill) {
maxWidth = 0;
for (i = 0; i < max; i++) {
maxWidth += (data[i].width || defaultSize);
if (i > 0) {
maxWidth += gutter;
}
}
}
if (options.border != null && !isNaN(options.border + 0)) {
border = lineWidth = options.border + 0;
}
if (options.padding != null && !isNaN(options.padding + 0)) {
padding = options.padding + 0;
}
if (options.x != null && !isNaN(options.x + 0)) {
startX += (options.x+0);
}
if (options.y != null && !isNaN(options.y + 0)) {
this._PDF.y = options.y + 0;
}
if (options.addX != null && !isNaN(options.addX + 0)) {
startX += (options.addX + 0);
} else if (options.addx != null && !isNaN(options.addx + 0)) {
startX += (options.addx + 0);
}
if (options.addY != null && !isNaN(options.addY + 0)) {
this._PDF.y += (options.addY + 0);
} else if (options.addy != null && !isNaN(options.addy + 0)) {
this._PDF.y += (options.addy + 0);
}
if (options.fontSize || options.fontsize) {
this.fontSize(options.fontSize || options.fontsize);
}
if (options.font) {
this.font(options.font);
}
if (options.fontBold || options.fontbold) {
this.fontBold();
}
if (options.fontItalic || options.fontitalic) {
this.fontItalic();
}
}
let borderPadding = border + padding;
// Do Data Fixup / cleanup / Figure wrapping
this.saveState();
let height = this._cleanData(data, options, defaultSize, borderPadding) + ((padding * 2)-1);
this.resetState();
// Check to see if we need to do a page feed before we print this band
this._checkAndAddNewPage(height, {breakingBeforePrint: true}, () => {
if (lineWidth != null) {
// noinspection JSCheckFunctionSignatures
this.lineWidth(lineWidth);
}
this._curBand = [];
this._curBandOffset = startX;
let x = startX;
let y = this._PDF.y - (collapse ? 1 : 0);
let offset = 0, textOffset = 0;
if (maxWidth > 0) {
this.saveState(); // Save State it for the Border / fills
if (options.fillOpacity || options.fillopacity) {
this.fillOpacity(options.fillOpacity || options.fillopacity);
}
if (options.dash) {
this._PDF.dash(options.dash);
}
if (options.bordercolor) {
options.borderColor = options.bordercolor;
}
if (options.borderColor) {
this.strokeColor(options.borderColor);
}
if (options.fill && options.border > 0) {
this._PDF.rect(x, y, maxWidth - 1, height );
this.fillAndStroke(options.fill, (options.borderColor || options.fill));
}
else if (options.fill) {
this._PDF.rect(x, y, maxWidth - 1, height);
this.fill(options.fill);
}
// Reset back to Defaults
this.resetState();
if (options.dash) {
this._PDF.undash();
}
}
let originalFontSize = this.fontSize(), currentFill, currentStroke;
if (options.textColor || options.textcolor) {
const textColor = options.textColor || options.textcolor;
currentStroke = this._strokeColor;
currentFill = this._fillColor;
this.strokeColor(textColor);
this.fillColor(textColor);
}
for (i = 0; i < max; i++) {
let curWidth = (data[i].width || defaultSize) - (borderPadding * 2);
let savedState = false;
if (data[i].fill) {
this.saveState();
this._PDF.rect(x + offset, y, x + offset + curWidth, y + height);
this.fill(data[i].fill);
this.resetState();
}
let curData = data[i].data;
let curFontSize = data[i].fontSize || data[i].fontsize || originalFontSize;
this.fontSize(curFontSize);
let curTextColor = data[i].textColor || data[i].textcolor;
if (curTextColor || data[i].font || data[i].fontBold || data[i].fontbold || data[i].fontItalic || data[i].strike || data[i].underline || data[i].fontitalic || data[i].opacity || options.opacity) {
this.saveState();
savedState = true;
}
if (curTextColor) {
this.strokeColor(curTextColor);
this.fillColor(curTextColor);
}
if (data[i].font) {
this.font(data[i].font);
}
if (data[i].fontBold || data[i].fontbold) {
this.fontBold();
}
if (data[i].fontItalic || data[i].fontitalic) {
this.fontItalic();
}
let textOptions = {width: curWidth};
if (data[i].align) {
if (data[i].align === Report.alignment.LEFT || data[i].align.toString().toLowerCase() === "left") {
// Left
textOffset = borderPadding - 1;
} else if (data[i].align === Report.alignment.CENTER || data[i].align.toString().toLowerCase() === "center") {
// Center
textOptions.align = "center";
} else if (data[i].align === Report.alignment.RIGHT || data[i].align.toString().toLowerCase() === "right") {
// RIGHT Aligned
textOptions.align = "right";
} else {
// Default to left
textOffset = borderPadding - 1;
}
} else {
if (isNumber(curData)) {
// RIGHT Aligned
textOptions.align = "right";
} else {
// Default to left
textOffset = borderPadding - 1;
}
}
if (textOffset < 0) {
textOffset = borderPadding - 1;
}
if (typeof data[i].opacity !== "undefined") {
this.fillOpacity(data[i].opacity);
}
if (typeof options.opacity !== 'undefined') {
this.fillOpacity(options.opacity);
}
if (data[i].underline || options.underline) {
textOptions.underline = true;
}
if (data[i].strike || options.strike) {
textOptions.strike = true;
}
if (data[i].link) {
textOptions.link = data[i].link;
}
if (typeof options.wordSpacing !== "undefined") {
textOptions.wordSpacing = options.wordSpacing;
}
if (typeof data[i].wordSpacing !== "undefined") {
textOptions.wordSpacing = data[i].wordSpacing;
}
if (typeof options.characterSpacing !== "undefined") {
textOptions.characterSpacing = options.characterSpacing;
}
if (typeof data[i].characterSpacing !== "undefined") {
textOptions.characterSpacing = data[i].characterSpacing;
}
this._PDF.text(curData, x + offset + textOffset, y + borderPadding, textOptions).stroke();
if (savedState) {
this.resetState();
}
offset += curWidth + gutter + (borderPadding * 2);
this._curBand.push((data[i].width || defaultSize));
}
if (options.textColor || options.textcolor) {
if (currentStroke !== this._strokeColor) {
this.strokeColor(currentStroke);
}
if (currentFill !== this._fillColor) {
this.fillColor(currentFill);
}
}
offset = 0;
if (options.borderColor || options.bordercolor) {
this.strokeColor(options.borderColor || options.bordercolor);
}
for (i = 0; i < max; i++) {
let dataElement = data[i];
const calcWidth = (dataElement.width || defaultSize);
if (dataElement.dash || options.dash) {
this._PDF.dash(dataElement.dash || options.dash);
}
let currentWidth;
if ((currentWidth = ((dataElement.border && dataElement.border.left) || lineWidth)) && (!collapse || (collapse && i === 0))) {
if (!dataElement.border || (dataElement.border && (dataElement.border.left !== 0 && dataElement.border.left !== false))) {
this.lineWidth(currentWidth);
this.line(x + offset, y, x + offset, y + height);
}
}
if ((currentWidth = ((dataElement.border && dataElement.border.top) || lineWidth)) > 0) {
if (!dataElement.border || (dataElement.border && (dataElement.border.top !== 0 && dataElement.border.top !== false))) {
this.lineWidth(currentWidth);
this.line((x + offset) - 0.5, y, x + (offset + calcWidth) - 0.5, y);
}
}
if ((currentWidth = ((dataElement.border && dataElement.border.bottom) || lineWidth)) > 0) {
if (!dataElement.border || (dataElement.border && (dataElement.border.bottom !== 0 && dataElement.border.bottom !== false))) {
this.lineWidth(currentWidth);
this.line(x + offset - 0.5, y + height, x + (offset + calcWidth) - 0.5, y + height);
}
}
offset += calcWidth;
if ((currentWidth = ((dataElement.border && dataElement.border.right) || lineWidth)) > 0) {
if (!dataElement.border || (dataElement.border && (dataElement.border.right !== 0 && dataElement.border.right !== false))) {
this.lineWidth(currentWidth);
this.line(x + offset - currentWidth, y, x + offset - currentWidth, y + height);
}
}
if (dataElement.dash || options.dash) {
this._PDF.undash();
}
offset += gutter;
}
this._PDF.x = x;
this._PDF.y = y + height + 1; // add 1 for Whitespace
this.resetState();
this._checkAndAddNewPage(0, {}, callback);
});
},
/**
* Sets or gets the line width
* @param {number} [width] - optional of line
* @returns {number} current line width
*/
lineWidth: function (width) {
if (arguments.length) {
this._lineWidth = width;
this._PDF.lineWidth(width);
}
return this._lineWidth;
},
/**
* Returns the last printed bands total Width
* @returns {Number}
*/
getLastBandWidth: function () {
let width, i, sizes = this._bandWidth();
for (i = 0, width = 0; i < sizes.length; i++) {
width += sizes[i];
}
return width;
},
/**
* Max Y Size
* @returns {number}
*/
maxY: function () {
return this._reportHeight-(this._primaryReport.state().footerSize);
},
/**
* Min Y Size
* @returns {number} - Top Margin Size
*/
minY: function() {
return this._PDF.page.margins.top;
},
/**
* Max X size of page
* @returns {number}
*/
maxX: function () {
return this._PDF.page.width - this._PDF.page.margins.right;
},
/**
* Min X Size
* @returns {number} - Left Margin Size
*/
minX: function() {
return this._PDF.page.margins.left;
},
/**
* Prints the "Printed At" information
* @param {object} [options] -
* header = print in header
* footer = print in footer
* text = the text to print, defaults to "Printed At: {0}:{1}{2}\non {3}";
* align = alignment
*/
printedAt: function(options) {
options = options || {};
let curY;
const text = options.text || "Printed At: {0}:{1}{2}\non {3}";
if (options.header || options.footer) {
curY = this.getCurrentY();
if (!options.align) {
options.align = "left";
}
if (options.header) {
this.setCurrentY(this._PDF.page.margins.top);
}
if (options.footer) {
if (text.indexOf('\n') !== false) {
this.setCurrentY(this._reportHeight - (this._heightOfString * 2));
} else {
this.setCurrentY(this._reportHeight - (this._heightOfString));
}
}
}
const NowDate = new Date();
let minutes = NowDate.getMinutes();
if (minutes < 10) {
minutes = "0" + minutes;
}
let hours = NowDate.getHours();
let ampm = "am";
if (hours >= 12) {
if (hours > 12) {
hours -= 12;
}
ampm = "pm";
}
//noinspection JSCheckFunctionSignatures
const Header = text.replace('{0}', hours).replace('{1}', minutes).replace('{2}', ampm).replace('{3}',NowDate.toLocaleDateString());
this._PDF.text(Header, options);
if (options.header || options.footer) {
this.setCurrentY(curY);
}
},
/**
* pageNumber - prints the current page number
* @param options {object} - options object with settings;
* "text" value can be changed from the default "Page: {0}" to what you want.
* "header" true = print as header
* "footer" true = print as footer
* "align" = alignment of the text
*/
pageNumber: function (options) {
options = options || {};
let curY;
if (options.header || options.footer) {
curY = this.getCurrentY();
if (!options.align) {
options.align = "right";
}
if (options.header) {
this.setCurrentY(this._PDF.page.margins.top);
}
if (options.footer) {
this.setCurrentY( this._reportHeight-this._heightOfString);
}
}
if (!options.align) {
options.align = "center";
}
let text = options.text || "Page: {0}";
// noinspection RegExpRedundantEscape
text = text.replace(/\{0\}/g, this.currentPage());
// Do we have page count
if (text.indexOf("{1}") !== -1) {
const ref = this._PDF.ref({});
this._addPageNumberDictionaryRef(ref);
this._pageNumbers.push({text: text, options: options, y: this.getCurrentY(), x: this.getCurrentX(), ref: ref});
} else {
this._PDF.text(text, options);
}
if (options.header || options.footer) {
this.setCurrentY(curY);
}
},
/**
* Imports a PDF into the current Document
* return False if it fails, true if it succeeded
*/
importPDF: function(name) {
let data;
if (Buffer.isBuffer(name)) {
data = name;
} else {
const fs = require('fs');
data = fs.readFileSync(name);
}
// We have to end the current page so that the following imported pages will
// be on new pages
if (this._pageHasRendering) {
this._addPage();
}
return this._PDF.importPDF(data);
},
/**
* Returns the actual printing page width of the page
* @returns {number}
*/
pageWidth: function() {
return this._PDF.page.width - this._PDF.page.margins.right - this._PDF.page.margins.left;
},
/**
* Returns the actual printing page height of the page
* @returns {number}
*/
pageHeight: function() {
// takes in account the .bottom margin already
return this._reportHeight - this._PDF.page.margins.top;
},
// --------------------------------------------------------------------------------------------
// The function below are all internally used -- USE THEM AT YOUR OWN RISK, they may break
// things and they are subject to changes, addition or removal on a whim
// --------------------------------------------------------------------------------------------
/**
* Converts a % value to a real value.
* @param val
* @returns {string|number|*}
* @private
*/
_parseSize(val) {
if (val == null) { return 0; }
if (typeof val === 'number') { return val; }
if (val.indexOf("%") > 0) {
let temp = parseInt(val, 10) / 100;
return this.pageWidth() * temp;
}
return parseInt(val,10);
},
/**
* Handles Rotation
* @param rotation
* @returns {*}
* @private
*/
_rotate: function(rotation) {
if (arguments.length) {
if (rotation !== this._rotated) {
if (this._rotated !== 0) {
this._PDF.restore();
}
this._rotated = rotation;
if (this._rotated !== 0) {
this._PDF.save();
this._PDF.textRotate(rotation, this._PDF.x, this._PDF.y);
this._PDF.x = 0;
this._PDF.y = 0;
}
}
}
return this._rotated;
},
/**
* Finished up the final page numbers
* @private
*/
_finishPageNumbers: function() {
// We have no pages with extended page numbers
// So we don't have to do anything...
if (!this._pageNumbers.length) { return; }
let totalPages = this.currentPage();
// Save existing content
let content = this._PDF.page.content;
// Disable PageBreaking
this._pageBreaking = true;
this._skipASYNCCheck = true;
// Loop through our array of pages
for (let i=0;i<this._pageNumbers.length;i++) {
this._PDF.page.content = this._pageNumbers[i].ref;
// noinspection RegExpRedundantEscape
const text = this._pageNumbers[i].text.replace(/\{1\}/g, totalPages);
this.setCurrentY(this._pageNumbers[i].y);
this.setCurrentX(this._pageNumbers[i].x);
this.print(text, this._pageNumbers[i].options);
this._pageNumbers[i].ref.end();
}
// Re-enable page Breaking
this._pageBreaking = false;
this._skipASYNCCheck = false;
// Reset content
this._PDF.page.content = content;
},
/**
* This handles the printing of the page footer and its callback.
* @param options
* @param cb
* @private
*/
_handleFooter: function(options, cb) {
if (this._primaryReport._footer) {
this._primaryReport._footer.run(this, this._primaryReport.state(), this._lastData, cb);
} else if (cb) {
cb();
}
},
/**
* This handles the printing of any/all the headers
* @param options
* @param cb
* @private
*/
_handleHeader: function(options, cb) {
const currentGroup = this._primaryReport.state().currentGroup;
let headersToPrint = [];
const checkForPrintableHeaders = (myGroup) => {
// We don't want to print the currentGroups header; we want the group code to handle this in case the next
// header needed is actually a changed header -- But we print everything else that needs to be printed
// However, if we were page-break in the the "detail" then we actually need reprint the prior header as we are still in the detail code
if (myGroup._header && (myGroup._runHeaderWhen === Report.show.always || (options.breakingBeforePrint && myGroup._runHeaderWhen === Report.show.newPageOnly)) && (myGroup !== currentGroup || !myGroup._isGroup || options.breakingBeforePrint)) {
headersToPrint.push(myGroup);
}
if (myGroup._parent) {
checkForPrintableHeaders(myGroup._parent);
}
};
const printFoundHeaders = () => {
if (headersToPrint.length === 0) {
if (cb) {
cb();
}
return;
}
const gp = headersToPrint.pop();
gp._header.run(this, this._primaryReport.state(), gp._currentData, printFoundHeaders);
};
if (currentGroup) {
checkForPrintableHeaders(currentGroup);
printFoundHeaders();
} else if (cb) {
cb();
}
},
/**
* Resets the Internal PDF Page Object Counter
* @protected
*/
_resetPageHeaderCounter: function() {
this._pageHeaderRendering = this._pageHasRendering;
},
/**
* This handles applying the state
* @param {object} state - the state to set the pdf engine too
* @param {boolean} [skipX] - optionally tell it to ignore resetting the "x" coordiniate state.
* @private
*/
_applyState: function(state, skipX) {
// Undoing Rotation must come first because it pops the PDF internal state system
this._rotate(state.rotated);
this._PDF._font = state.font;
this.fontSize(state.fontSize);
if (this._lineWidth !== state.lineWidth) {
this.lineWidth(state.lineWidth);
}
this.fillColor(state.fillColor);
this.strokeColor(state.strokeColor);
this.fillOpacity(state.opacity);
if (skipX !== true) {
this._PDF.x = state.x;
}
},
/**
* This does the actual printing with the needed sizing
* @param text
* @param textOptions
* @param callback
* @private
*/
_print: function(text, textOptions, callback) {
let procText = this._processText(text);
if (textOptions.wordSpacing) {
procText = procText.replace(/\s{2,}/g, ' ');
}
// Covert any % values to normal size
if (textOptions.width) {
textOptions.width = this._parseSize(textOptions.width);
}
const left = this._PDF.page.margins.left;
const right = this._PDF.page.margins.right;
const width = (textOptions.width || this._PDF.page.width);
this._LWDoc.reset();
// First Line maybe remainder of a line
if (textOptions.width) {
this._PrintWrapper.lineWidth = textOptions.width;
} else {
this._PrintWrapper.lineWidth = width - this._PDF.x - right;
textOptions.width = width - (right + left);
}
this._PrintWrapper.wrap(procText, textOptions);
let _printedLines = this._printedLines;
this._printedLines = [];
let startLooping;
if (this._reportRenderMode === reportRenderingMode.ASYNC) {
startLooping = startLoopingAsync;
} else {
startLooping = startLoopingSync;
}
let length = _printedLines.length;
if (callback) {
startLooping(length,
(cnt, done) => {
if (this._PDF.y + this._heightOfString > this._maxY()) {
this.newPage({save: true, breakingBeforePrint: true}, () => {
if (textOptions._backgroundFill) {
this._handleFillRect(_printedLines[cnt].O.textWidth, this._heightOfString, textOptions.align, textOptions.width, textOptions._backgroundFill);
}
this._PDF._line(_printedLines[cnt].L, _printedLines[cnt].O, true);
done();
});
} else {
if (textOptions._backgroundFill) {
this._handleFillRect(_printedLines[cnt].O.textWidth, this._heightOfString, textOptions.align, textOptions.width, textOptions._backgroundFill);
}
this._PDF._line(_printedLines[cnt].L, _printedLines[cnt].O, true);
done();
}
},
() => {
_printedLines = null;
callback();
});
} else {
for (let i=0;i<length;i++) {
if (this._PDF.y + this._heightOfString > this._maxY()) {
this.newPage({save: true, breakingBeforePrint: true});
}
if (textOptions._backgroundFill) {
this._handleFillRect(_printedLines[i].O.textWidth, this._heightOfString, textOptions.align, textOptions.width, textOptions._backgroundFill);
}
this._PDF._line(_printedLines[i].L, _printedLines[i].O, true);
}
_printedLines = null;
}
},
/**
* This creates a filled background area for the print command
* @param textWidth
* @param textHeight
* @param alignment
* @param lineWidth
* @param fillColor
* @private
*/
_handleFillRect: function(textWidth, textHeight, alignment, lineWidth, fillColor) {
let offset = 0;
if (alignment === "center") {
offset = (lineWidth / 2) - (textWidth / 2);
} else if (alignment === "right") {
offset = lineWidth - (textWidth);
}
this._PDF.rect(this._PDF.x-1 + offset, this._PDF.y-2, textWidth+2, textHeight);
this._handleOptions({fill:fillColor});
},
/**
* This Max Y size function is used internally to do calculations, it by design can "lie" during some actions to eliminate page-breaking...
* @desc this function can LIE to eliminate height restrictions, this allows footers to print in the "footer" area without triggering a page break
* @protected
*/
_maxY: function() {
return this._height-(this._primaryReport.state().footerSize);
},
/**
* Add a new page
* @protected
*/
_addPage: function () {
if (!this._pageHasRendering) {
return;
}
this._pageHasRendering = 0;
let options = {};
options.size = this._paper;
if (this._landscape) {
options.layout = "landscape";
}
if (typeof this._margins === 'number') {
options.margin = this._margins;
} else {
options.margins = this._margins;
}
this._PDF.addPage(options);
// We are now subverting the pdfkits height system. We handle it; this is because people can put in arbitrary y coords and we don't want any stupidity crashes.
this._height = this._reportHeight = this._PDF.page.maxY();
this._PDF.page.height = 99999;
},
_addPageNumberDictionaryRef: function(ref) {
if (!Array.isArray(this._PDF.page.dictionary.data.Contents)) {
this._PDF.page.dictionary.data.Contents = [this._PDF.page.content, ref];
} else {
this._PDF.page.dictionary.data.Contents.push(ref);
}
},
_checkAndAddNewPage: function(height, options, callback) {
if (this._PDF.y + height >= this._maxY()) {
options.save = true;
this.newPage(options, callback);
} else if(callback) {
callback();
}
},
/**
* Process the value running it through formatting
* @param value
* @returns {string} - formatted value
* @private
*/
_processText: function (value) {
if (value === null || value === undefined) {
return ('');
}
else if (typeof value.format === 'function') {
if (isNumber(value)) {
return value.format({decimals: 2});
} else {
return value.format();
}
}
if (this._negativeParentheses && isNumber(value) && value < 0) {
return '(' + Math.abs(value).toString() + ')';
}
return value.toString();
},
_handleOptions: function(options) {
options = options || {};
this.saveState();
if (options.hasOwnProperty('fillOpacity')) {
//noinspection JSCheckFunctionSignatures
this.fillOpacity(options.fillOpacity);
}
if (options.hasOwnProperty('fillopacity')) { this.fillOpacity(options.fillopacity); }
if (options.borderColor || options.bordercolor) { this.strokeColor(options.borderColor || options.bordercolor); }
if (options.textColor || options.textcolor) { this.strokeColor(options.textColor || options.textcolor); }
if (options.hasOwnProperty('thickness')) { this.lineWidth(options.thickness); }
if (options.dash) { this._PDF.dash(options.dash); }
// This will Stroke and fill whatever shape we are doing
if (options.fill) { this.fillAndStroke(options.fill, (options.textColor || options.textcolor || options.borderColor || options.bordercolor || options.fill)); }
else { this._PDF.stroke(); }
this.resetState();
if (options.dash) { this._PDF.undash(); }
},
_truncateText: function (data, width) {
//This if statement fixes an infinite loop where the specified width minus border padding sets the width passed in here
// to a negative number. If the allowed width is 0 or less, return an empty string since there is no room to print anything.
if (width <= 0) {
data.data = '';
return 1;
}
let curData;
let offset = data.data.indexOf('\n');
if (offset > 0) {
curData = data.data.substr(0, offset);
} else {
curData = data.data;
}
let wos = this.widthOfString(curData, true);
if (wos >= width) {
// Get avg character length
// noinspection JSCheckFunctionSignatures
let wos_c = parseInt(wos / curData.length, 10) + 1;
// Find out the avg string size
// noinspection JSCheckFunctionSignatures
let len = parseInt(width / wos_c, 10) + 1;
let newString = curData;
let optimalSize = 0;
do {
curData = newString.substr(0, len);
wos = this.widthOfString(curData, true);
if (wos < width) {
optimalSize = len;
len++;
} else {
if (optimalSize) { break; }
len--;
// This fixes a corner case where the size is too small for any text, so we don't print any text.
if (len <= 0) { optimalSize = 0; break; }
}
} while (true);
curData = newString.substr(0,optimalSize);
}
data.data = curData;
return 1;
},
_wrapText: function (data, width, ldata) {
this._LWDoc.reset();
this._LineWrapper.lineWidth = width;
ldata.width = width;
if (!this._PDF.on) {
this._LineWrapper.wrap(data.data.split('\n'), ldata);
} else {
this._LineWrapper.wrap(data.data, ldata);
}
return this._LWDoc.count;
},
_cleanData: function (data, options, defaultSize, borderPadding) {
let len = data.length;
let formatText;
let lineData = {width: 0, height: this._maxY()};
if (options && options.wrap) {
formatText = this._wrapText;
} else {
formatText = this._truncateText;
}
let maxLines = 1, curLines, maxFontSize= 1, bp = borderPadding * 2;
const originalFontSize = this.fontSize(),
originalFont = this._font;
for (let i = 0; i < len; i++) {
data[i].data = this._processText(data[i].data);
let curFontSize = data[i].fontSize || data[i].fontsize || originalFontSize;
if (curFontSize > maxFontSize) {
maxFontSize = curFontSize;
}
let cellBolded;
if (data[i].fontbold || data[i].fontBold) {
cellBolded = true;
}
if (cellBolded) {
this.fontBold();
}
this._PDF.fontSize(curFontSize);
curLines = formatText.call(this, data[i], (data[i].width || defaultSize) - bp, lineData);
if (cellBolded) {
if (originalFont) {
this.font(originalFont);
}
}
if (curLines > maxLines) {
maxLines = curLines;
}
}
this._PDF.fontSize(maxFontSize);
const lineSize = (maxLines * this._PDF.currentLineHeight(true));
this._PDF.fontSize(originalFontSize);
return lineSize;
},
/**
* Enabled/Disables Auto-Print on open of PDF
* @param {boolean} value
* @private
*/
_setAutoPrint: function (value) {
if (value) {
this._PDF._root.data.OpenAction = {Type: 'Action', S: 'Named', N: 'Print'};
} else {
if (this._PDF._root && this._PDF._root.data && this._PDF._root.data.OpenAction) {
delete this._PDF._root.data.OpenAction;
}
}
},
/**
* Set Full Screen
* @param value
* @ignore
*/
_setFullScreen: function(value) {
if (value) {
this._PDF._root.data.PageMode = "FullScreen";
} else {
if (this._PDF._root && this._PDF._root.data && this._PDF._root.data.PageMode) {
delete this._PDF._root.data.PageMode;
}
}
},
/**
* Set the Band Width
* @param value
* @returns {*}
* @ignore
*/
_bandWidth: function (value) {
if (arguments.length) {
this._curBand = clone(value);
}
return clone(this._curBand);
},
/**
* Set Band Offset
* @param value
* @returns {number}
* @ignore
*/
_bandOffset: function (value) {
if (arguments.length) {
this._curBandOffset = value;
}
return this._curBandOffset;
},
/**
* Pipe the output
* @param pipe
* @param callback
* @ignore
* @private
*/
_pipe: function(pipe, callback) {
if (!this._PDF.pipe) {
return Report.error("REPORTAPI: Pipe is unsupported on this version of PDFKit, upgrade PDFKIT.");
}
if (typeof callback === 'function') {
pipe.once('finish', callback);
}
this._PDF.pipe(pipe);
this._PDF.end();
},
/**
* Output the PDF
* @param name
* @param callback
* @ignore
* @private
*/
_write: function (name, callback) {
if (!this._PDF.pipe) {
return this._PDF.write(name, callback);
}
const fs = require('fs');
const writeStream = fs.createWriteStream(name);
writeStream.once('finish', callback);
this._PDF.pipe(writeStream);
this._PDF.end();
},
/**
* Outputs the Report to a Buffer
* @param callback
* @private
* @ignore
*/
_output: function(callback) {
let buffer = null;
if (!this._PDF.pipe) {
return this._PDF.output(callback);
}
this._PDF.on('data', (chunk) => {
if (buffer === null) {
buffer = Buffer.from(chunk);
} else {
buffer = Buffer.concat([buffer, chunk]);
}
});
this._PDF.once('end', () => {
callback(buffer);
});
this._PDF.end();
},
_checkRenderMode: function(callback, functionName) {
// TODO: Determine if this is safe; currently only _finishPageNumbers sets this flag
if (this._skipASYNCCheck === true) { return; }
if (this._reportRenderMode === reportRenderingMode.ASYNC) {
if (typeof callback !== 'function') {
const e = new Error();
Report.error("REPORTAPI: You have called a ASYNCHRONOUS function", functionName.toUpperCase(), "without the callback, the report WILL have issues or might even throw an error while saving. The error and callstack are as follows:", new ReportError({error: e, stack: e && e.stack}));
}
} /* else if (this._reportRenderMode === reportRenderingMode.SYNC) {
if (typeof callback === 'function') {
// This is fine;
}
} */
},
/**
* DEPRECIATED - Just create your own array, and push your fields to it and then call band with that array.
*/
bandField: function() {
Report.error("REPORTAPI: bandField functionality has been removed.");
},
// CONSTANTS
left: 1,
right: 3,
center: 2,
/** @constant
* @desc Aligns the Text on the Left */
LEFT: 1,
/** @constant
* @desc Aligns the Text on the Right */
RIGHT: 3,
/** @constant
* @desc Centers the Text */
CENTER: 2
};
// noinspection JSUnusedGlobalSymbols
ReportDataSet.prototype = {
_isDataSet: true,
/**
* Data for the System
* @param {Object|Array} [value]
* @returns {*}
*/
data: function (value) {
if (!arguments.length) {
return (this._data);
}
if (isArray(value)) {
this._dataType = dataTypes.NORMAL; // Normal passed preset data set
} else if (typeof value === 'function' || typeof value === 'object') {
if (value.count && (value.loadRange || value.loadrange)) {
this._dataType = dataTypes.PAGEABLE; // Page-able Dataset
} else if (typeof value === 'function') {
this._dataType = dataTypes.FUNCTIONAL; // Functional Dataset
} else {
// Just a POD (Plain old Data)
this._dataType = dataTypes.PLAINOLDDATA;
}
} else if (typeof value === 'string' || typeof value === 'number') {
this._dataType = dataTypes.PLAINOLDDATA; // POD
} else {
this._dataType = dataTypes.PLAINOLDDATA; // Assume POD
Report.error("REPORTAPI: Unknown data type; treating as plain old data.");
}
//noinspection JSUnresolvedVariable
if (value.totalFormatter && typeof value.totalFormatter === 'function') {
this._totalFormatter = (data, callback) => {
this._data.totalFormatter(data, callback);
};
}
//noinspection JSUnresolvedVariable
if (value.error && typeof value.error === 'function') {
Report.error = () => {
this._data.error.apply(this._data, arguments);
};
}
this._data = value;
return this._child;
},
render: function (callback) {
return this._parent.render(callback);
},
totalFormatter: function (newFormatter) {
if (!arguments.length) {
return this._totalFormatter;
}
if (newFormatter === null || typeof newFormatter !== 'function') {
this._totalFormatter = (data, callback) => {
callback(null, data);
};
} else {
this._totalFormatter = newFormatter;
}
return this._child;
},
keys: function (keys) {
if (arguments.length) {
this._keys = keys;
}
return this._keys;
},
_buildKeySet: function(currentData) {
let keys=null;
const keySet = this._keys || this._data.keys;
if (currentData === null) { return null; }
if (keySet != null) {
if (typeof keySet === "string") {
keys = [currentData[keySet]];
} else if (isArray(keySet)) {
keys = [];
for (let key in keySet) {
if (keySet.hasOwnProperty(key)) {
keys.push(currentData[keySet[key]]);
}
}
}
}
return keys;
},
/**
* Renders the Current DataSet
* @param Rpt
* @param State
* @param [currentData]
* @param callback
* @memberOf ReportDataSet
* @private
*/
_renderIt: function (Rpt, State, currentData, callback) {
let pageData = null;
let dataLength = 0, curRecord = -1;
let groupCount = 0, groupSize = 0;
let pageCount = 0, pagedGroups = 1;
let groupContinueCount = 0, hasRendered=false;
let loadPageData;
if (this._dataType === dataTypes.PARENT) {
this._data = currentData[this._parentDataKey];
}
const groupContinue = () => {
groupContinueCount++;
// We can Exceed the stack if we don't allow it to unwind occasionally; so we breath every 10th call.
if ((groupContinueCount % 11) === 0) {
setTimeout(groupContinue, 0);
return;
}
curRecord++;
if (groupCount === groupSize) {
if (pageCount === pagedGroups) {
// If we have NO DATA, this path will be taken
if (!hasRendered && this._child._header) {
hasRendered = true;
this._child._header.run(Rpt, State, {}, () => {
this._child._renderFooter(Rpt, State, callback);
});
} else {
// Run the Final Footers
this._child._renderFooter(Rpt, State, callback);
}
} else {
// Load next data Page
loadPageData(pageCount);
}
} else {
groupCount++;
hasRendered=true;
this._child._renderIt(Rpt, State, pageData[curRecord], groupContinue);
}
};
// This starts the Rendering of a record and sets up the
const renderData = (err, data) => {
if (err) {
Report.error("REPORTAPI: Error in rendering data: ", new ReportError({error: err}));
callback(err);
return;
}
groupSize = data.length;
groupCount = 0;
pageCount++;
// In the case we are dealing with a un-paged dataset that
// returns all its data at once, we just skip the paging process
if (groupSize === dataLength) {
pageCount = pagedGroups;
}
pageData = data;
groupContinue();
};
// This will load a page of data
loadPageData = (id) => {
let start = id * 100, end = (id + 1) * 100;
if (end > dataLength) {
end = dataLength;
}
// Reset back to first row when we get a new data set loaded
curRecord = -1;
//noinspection JSUnresolvedVariable
if (this._data.loadrange) {
//noinspection JSUnresolvedFunction
this._data.loadrange(start, end, renderData);
} else {
this._data.loadRange(start, end, renderData); // Trying the proper case version...
}
};
// If we have a raw array; we just start the rendering
if (this._dataType === dataTypes.NORMAL || this._dataType === dataTypes.PARENT) {
if (this._data == null) {
Report.error("REPORTAPI: data is empty, try adding a .data([{field: 'value',...}]) to the report.");
this._data = [''];
}
dataLength = this._data.length;
if (typeof this._recordCountCallback === "function") {
this._recordCountCallback(dataLength,
(continueReport, continueReport2) => {
if ((arguments.length >= 2 && continueReport2 === false) || (arguments.length === 1 && continueReport === false)) {
// We are ending the report
State.cancelled = true;
callback();
} else {
renderData(null, this._data);
}
});
} else {
renderData(null, this._data);
}
}
// This is a class/Function that implement "count" and "loadRange"
// So we start by asking for the query (if needed), then the count, it will call the paging code
else if (this._dataType === dataTypes.PAGEABLE) {
const startCount2 = (length) => {
dataLength = length;
if (length === 0) {
groupSize = groupCount = pageCount = pagedGroups = 0;
groupContinue();
} else {
// noinspection JSCheckFunctionSignatures
pagedGroups = parseInt(length / 100, 10);
if (pagedGroups * 100 < length) {
pagedGroups++;
}
loadPageData(0);
}
};
const startCount = () => {
this._data.count(
(err, length) => {
if (err) {
Report.error("REPORTAPI: Got error getting count: ", new ReportError({error: err}));
length = 0;
}
if (isNaN(length)) {
Report.error("REPORTAPI: Got a non-number row length/count", length);
length = 0;
}
if (typeof this._recordCountCallback === "function") {
this._recordCountCallback(length,
(continueReport, continueReport2) => {
if ((arguments.length >= 2 && continueReport2 === false) || (arguments.length === 1 && continueReport === false)) {
// We are ending the report
State.cancelled = true;
callback();
} else {
startCount2(length);
}
}
);
} else {
startCount2(length);
}
});
};
if (this._data.query) {
this._data.query(this._buildKeySet(currentData), startCount);
} else {
startCount();
}
// This is a simple query class, it should return all data either in a callback or as it return value
} else if (this._dataType === dataTypes.FUNCTIONAL) {
let handleCb = false;
const data = this._data(this._buildKeySet(currentData), (err, ndata) => {
if (err) {
Report.error("REPORTAPI: Error getting data", new ReportError({error: err}));
ndata = [];
}
if (!handleCb) {
handleCb = true;
dataLength = ndata.length;
renderData(null, ndata);
}
});
if (data && !handleCb) {
handleCb = true;
dataLength = data.length;
renderData(null, data);
}
// This is a POD
} else if (this._dataType === dataTypes.PLAINOLDDATA) {
if (this._data === null) {
Report.error("REPORTAPI: data is empty, try adding a .data([{field: 'value',...}]) to the report.");
this._data = '';
}
dataLength = 1;
renderData(null, [this._data]);
}
},
_setChild: function (newChild) {
this._child = newChild;
},
_calculateFixedSizes: function (Rpt, oldBogusData, callback) {
if (this._child !== null) {
let bogusData = {}, key;
if (this._data !== null) {
for (key in this._data[0]) {
if (this._data[0].hasOwnProperty(key)) {
bogusData[key] = "";
}
}
}
this._child._calculateFixedSizes(Rpt, bogusData, callback);
} else if (callback) {
callback();
}
},
_recordCount: function(callback) {
if (arguments.length) {
this._recordCountCallback = callback;
}
return this._recordCountCallback;
},
/**
* Set the Parental Data Key
* @memberOf ReportDataSet
*/
_parentalData: function(parentDataKey) {
this._dataType = dataTypes.PARENT;
this._parentDataKey = parentDataKey;
},
_renderFooter: function(Rpt, State, Handler) {
if (this._child) {
this._child._renderFooter(Rpt, State, Handler);
} else if (Handler) {
Handler();
}
}
};
ReportSection.prototype = {
_isSection: true,
addDataSet: function (dataSet) {
if (!arguments.length) {
dataSet = new ReportDataSet(this);
this._children.push(dataSet._parent);
} else {
this._addSubObject(dataSet);
}
return (dataSet);
},
addSection: function (section) {
if (!arguments.length) {
section = new ReportSection(this);
this._children.push(section);
} else {
this._addSubObject(section);
}
return (section);
},
addReport: function (report) {
if (!arguments.length) {
report = new Report(this);
} else {
this._addSubObject(report);
}
return (report);
},
dataSets: function() {
let children=[];
for (let i=0;i<this._children.length;i++) {
if (this._children[i]._isDataSet) {
children.push(this._children[i]);
}
}
return children;
},
sections: function() {
let children=[];
for (let i=0;i<this._children.length;i++) {
if (this._children[i]._isSection) {
children.push(this._children[i]);
}
}
return children;
},
subReports: function() {
let children=[];
for (let i=0;i<this._children.length;i++) {
if (this._children[i]._isReport) {
children.push(this._children[i]);
}
}
return children;
},
// This starts the rendering process properly by chaining to the parent Report
render: function (callback) {
return this._parent.render(callback);
},
_addSubObject: function (item) {
let parent = item;
if (item._parent == null) {
item._parent = this;
} else {
let myParent = this._parent;
let rootReport = this._parent;
while (rootReport._parent !== null) {
rootReport = rootReport._parent;
}
while (parent._parent !== null && parent._parent !== myParent && parent._parent !== rootReport) {
parent = parent._parent;
}
if (parent._parent === null) {
parent._parent = this;
}
}
this._children.push(parent);
},
// This actually does the Rendering
_renderIt: function (Rpt, State, currentData, callback) {
let priorStart = [State.startX, State.startY];
State.priorStart.unshift(priorStart);
State.startX = Rpt.getCurrentX();
State.startY = Rpt.getCurrentY();
let cnt = -1;
const renderGroup = () => {
cnt++;
if (cnt < this._children.length && !State.cancelled) {
State.currentY = Rpt.getCurrentY();
State.currentX = Rpt.getCurrentX();
this._children[cnt]._renderIt(Rpt, State, currentData, renderGroup);
} else {
State.priorStart.unshift();
State.startX = priorStart[0];
State.startY = priorStart[1];
callback();
}
};
renderGroup();
},
_renderFooter: function (Rpt, State, callback) {
let i, cnt = this._children.length, done = -1;
const renderFooterHandler = () => {
done++;
if (done === cnt) {
callback();
} else {
if (this._children[done]._isReport) {
renderFooterHandler();
} else {
this._children[done]._renderFooter(Rpt, State, renderFooterHandler);
}
}
};
if (callback) {
renderFooterHandler();
} else {
for (i=0;i<cnt;i++) {
if (this._children[i]._isReport) { continue; }
this._children[i]._renderFooter(Rpt, State);
}
}
},
// Used to figure out the page usage size of header/footers
_calculateFixedSizes: function (Rpt, bogusData, callback) {
let _calculateCount = -1, _length = this._children.length;
const calcChildCallback = () => {
_calculateCount++;
if (_calculateCount < _length) {
this._children[_calculateCount]._calculateFixedSizes(Rpt, bogusData, calcChildCallback);
} else {
callback();
}
};
calcChildCallback();
}
};
// noinspection JSUnusedGlobalSymbols
ReportGroup.prototype =
/** @lends ReportGroup **/
{
_isGroup: true,
/**
* Set user data that you can access during the report
* @param value
* @returns {*}
*/
userData: function (value) {
let parentReport = null;
if (!arguments.length) {
do
{
parentReport = this._findParentReport(parentReport);
let data = parentReport.userData();
if (data !== null) {
return (data);
}
}
while (!parentReport.isRootReport());
// No userdata found from where this group is in the tree up to the ROOT Report
// So, then we will create a empty userdata object, since if you are accessing it
// you will probably be "adding" some user data and so then the
// expectation is that it will be saved if you change it.
let newUserData = {};
parentReport.userData(newUserData);
return (newUserData);
}
parentReport = this._findParentReport();
parentReport.userData(value);
return (this);
},
/**
* Set the TotalFormatter function
* @param value
* @returns {*}
*/
totalFormatter: function (value) {
const parentDataSet = this._findParentDataSet();
if (!arguments.length) {
return parentDataSet.totalFormatter();
}
parentDataSet.totalFormatter(value);
return (this);
},
/**
* Set the Data for the group
* @param value - this can be a Array of Arrays, Array of Objects, Object, String, Number or a functional class that returns the data
* @returns {object|ReportGroup}
*/
data: function (value) {
const parentDataSet = this._findParentDataSet();
if (!arguments.length) {
return parentDataSet.data();
}
parentDataSet.data(value);
return (this);
},
/**
* Keys for Sub-Report Dataset to use
* @param value
* @returns {*}
*/
keys: function (value) {
const parentDataSet = this._findParentDataSet();
if (!arguments.length) {
return parentDataSet.keys();
}
parentDataSet.keys(value);
return (this);
},
/**
* Adds a sub-detail
* @param key
* @returns {ReportDataSet|ReportGroup}
*/
subDetail: function(key) {
// Find null child (i.e. the bottom of the groupings)
let child = this;
while (child._groupOnField !== null) {
child = child._child;
}
let r = new Report(child);
let ds = r._findParentDataSet();
ds._parentalData(key);
return r;
},
/**
* Add Sub Report
* @param {Report} rpt - Report object to add to this report as sub-report
* @param options
*/
addReport: function(rpt, options) {
//noinspection JSUnresolvedVariable
if (options && options.isSibling) {
let parentReport = this._parent;
while (!parentReport._isReport) {
parentReport = parentReport._parent;
}
parentReport._child.addReport(this);
} else {
if (this._groupOnField === null || this._child ) {
this._addToNullGroup(rpt);
} else if (this._child != null && this._child._isSection) {
this._child.addReport(this);
} else if (this._child != null && this._child._isGroup ) {
let child = this._child;
while (child._groupOnField !== null) {
child = child._child;
}
child._addToNullGroup(rpt);
}
}
},
/**
* Sets the Report information headers
* @param value
* @returns {*}
*/
info: function (value) {
const ds = this._findRootReport();
if (!arguments.length) {
return ds.info();
}
ds.info(value);
return (this);
},
/**
* Prototype for a Detail Function Callback
* @callback detailCallback
* @param {ReportRenderer} Renderer - report rendering class
* @param {Object} Data - your Data line
* @param [Object] ReportState - the current state of the process
* @param {Function} optional callback for Asynchronous support
*/
/**
* Adds a Detail section
* @param {detailCallback|object|string} detailData to run for each detail record
* @param {Object} settings for this detail function {afterSubgroup: "will print after a sub-group rather than before"}
*/
detail: function (detailData, settings) {
if (!arguments.length) {
return (this._detail);
}
if (!this._checkAsyncFunctionPrototype(detailData, "detail")) {
return this;
}
this._runDetailAfterSubgroup = getSettings(settings, "afterSubgroup", false);
this._detail = detailData;
if (typeof detailData === "string") {
this._renderDetail = this._renderStringDetail;
} else if (typeof detailData === "function") {
if (this._detail.length === 4) {
this._renderDetail = this._renderAsyncDetail;
} else {
this._renderDetail = this._renderSyncDetail;
}
} else if (isArray(detailData)) {
this._renderDetail = this._renderBandDetail;
if (!isArray(detailData[0])) {
this._detail = [detailData];
}
} else {
// NOP Function, we don't render anything.
this._renderDetail = (rpt, data, state, callback) => {
callback();
};
}
return (this);
},
/**
* Sets a field for generating totals -- this is used to group the results
* @param {string} field name to group on
* @param {object} [options] - can have runHeader option which has the show.Once, show.OnNewPage, and show.Always values
*/
groupBy: function (field, options) {
let parent, newGroup;
// GroupBy Appends a group to another Group, except in the case this is the
// final group; then the final group must come last; so then this group is then inserted in the chain
if (this._groupOnField === null) {
parent = this._parent;
newGroup = new ReportGroup(parent);
// noinspection JSAccessibilityCheck
parent._setChild(newGroup);
newGroup._setChild(this);
this._parent = newGroup;
} else {
newGroup = new ReportGroup(this);
newGroup._child = this._child;
if (this._child !== null) {
this._child._parent = newGroup;
}
this._child = newGroup;
}
// Set the New Groups field to group on.
newGroup._groupOn(field);
if (options) {
newGroup._runHeaderWhen = getSettings(options, "runHeader", newGroup._runHeaderWhen);
}
return (newGroup);
},
/**
* Sets a field for generating totals (sum)
* @param {string} field name to sum
*/
sum: function (field) {
this._math.push([mathTypes.SUM, field]);
return (this);
},
/**
* Sets a field for generating totals (average)
* @param {string} field name to average on
*/
average: function (field) {
this._math.push([mathTypes.AVERAGE, field]);
return (this);
},
/**
* Sets a field for generating totals (minimum)
* @param {string} field name to find the minimum on
*/
min: function (field) {
this._math.push([mathTypes.MIN, field]);
return (this);
},
/**
* Sets a field for generating totals (max)
* @param {string} field name to find the maximum
*/
max: function (field) {
this._math.push([mathTypes.MAX, field]);
return (this);
},
/**
* Sets a field for generating totals (count)
* @param {string} field name to count
*/
count: function (field) {
this._math.push([mathTypes.COUNT, field]);
return (this);
},
/**
* Sets or gets the record count callback
* @param {function} callback
* @returns {function|ReportGroup}
*/
recordCount: function(callback) {
const ds = this._findParentDataSet();
if (!arguments.length) {
return ds._recordCount();
}
ds._recordCount(callback);
return (this);
},
/**
* Prototype for a Header or Footer Callback
* @callback headerFooterCallback
* @param {ReportRenderer} Renderer - report rendering class
* @param {Object} Data - your Data line
* @param [Object] State - the current state of the process
* @param {Function} callback - Optional Callback for Asynchronous support
*/
/**
* Sets or gets the current page Header settings
* @param {(string|headerFooterCallback)} value or function to set footer too
* @param {Object} settings for the footer behavior "pageBreakBefore", "pageBreakAfter" and "pageBreak" are valid options
*/
pageHeader: function (value, settings) {
const ds = this._findParentReport();
if (!arguments.length) {
return ds._pageHeader();
}
if (this._checkAsyncFunctionPrototype(value, "page header")) {
ds._pageHeader(value, settings);
}
return (this);
},
/**
* Sets or gets the current page footer settings
* @param {(string|headerFooterCallback)} value or function to set footer too
* @param {Object} settings for the footer behavior "pageBreakBefore", "pageBreakAfter" and "pageBreak" are valid options
*/
pageFooter: function (value, settings) {
const ds = this._findParentReport();
if (!arguments.length) {
return ds._pageFooter();
}
if (this._checkAsyncFunctionPrototype(value, "page footer")) {
ds._pageFooter(value, settings);
}
return (this);
},
/**
* Sets or gets the current title header settings
* @param {(string|headerFooterCallback)} value or function to set footer too
* @param {Object} settings for the footer behavior "pageBreakBefore", "pageBreakAfter" and "pageBreak" are valid options
*/
titleHeader: function (value, settings) {
const ds = this._findParentReport();
if (!arguments.length) {
return ds._titleHeader();
}
if (this._checkAsyncFunctionPrototype(value, "title header")) {
ds._titleHeader(value, settings);
}
return (this);
},
/**
* Sets or gets the current final summary footer settings
* @param {(string|headerFooterCallback)} value or function to set footer too
* @param {Object} settings for the footer behavior "pageBreakBefore", "pageBreakAfter" and "pageBreak" are valid options
*/
finalSummary: function (value, settings) {
const ds = this._findParentReport();
if (!arguments.length) {
return ds._finalSummary();
}
if (this._checkAsyncFunctionPrototype(value, "final summary")) {
ds._finalSummary(value, settings);
}
return (this);
},
/**
* Sets or gets the current header settings
* @param {(string|headerFooterCallback)} value or function to set footer too
* @param {Object} settings for the footer behavior "pageBreakBefore", "pageBreakAfter" and "pageBreak" are valid options
*/
header: function (value, settings) {
if (this._header === null) {
this._header = new ReportHeaderFooter(true);
}
if (arguments.length) {
if (this._checkAsyncFunctionPrototype(value, "header")) {
this._header.set(value, settings);
}
return this;
}
return (this._header.get());
},
/**
* Sets or gets the current footer settings
* @param {(string|headerFooterCallback)} value or function to set footer too
* @param {Object} settings for the footer behavior "pageBreakBefore", "pageBreakAfter" and "pageBreak" are valid options
*/
footer: function (value, settings) {
if (this._footer === null) {
this._footer = new ReportHeaderFooter(false);
}
if (arguments.length) {
if (this._checkAsyncFunctionPrototype(value, "footer")) {
this._footer.set(value, settings);
}
return this;
}
return (this._footer.get());
},
/**
* Set the output type
* @param type - File, Buffer, or Pipe
* @param to - filename, 'buffer' or writable stream object
* @returns {*}
*/
outputType: function(type, to) {
const rpt = this._findRootReport();
if (!arguments.length) {
return rpt.outputType();
} else {
rpt.outputType(type, to);
}
return this;
},
/**
* Renders the report!
* @param {function} callback to call when completed
*/
render: function (callback) {
const rpt = this._findRootReport();
return rpt.render(callback);
},
/**
* Prints the report structure to the console
* @desc This prints the entire tree of the report to the console (Debug)
* @param {boolean} asPrinted optional - true = display as actually outputted, otherwise display in section/group order
*/
printStructure: function (asPrinted) {
const top = this._findRootReport();
printStructure(top, 0, !!asPrinted);
},
/**
* Sets or gets the current page is landscape
* @param {boolean} [value=false] - true/false set landscape mode
*/
landscape: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.landscape();
}
parentReport.landscape(value);
return this;
},
/**
* Sets or gets the current paper size
* @param {string} [value="letter"] - value paper size to set it to (i.e. "letter", "legal")
*/
paper: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.paper();
}
parentReport.paper(value);
return this;
},
/**
* Sets or gets the current font
* @param {string} value - font name set it to
*/
font: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.font();
}
parentReport.font(value);
return this;
},
/**
* Register a font for printing with
* @param {string} name - Font Name
* @param {(string|Object)} definition - Font Definition either path to file or object type:path ie {normal: path, bold: path, italic: path, boldItalic: path}
*/
registerFont: function(name, definition) {
const parentReport = this._findRootReport();
parentReport.registerFont(name, definition);
return this;
},
/**
* Sets or gets the current margin size of paper
* @param {number} [value=72] - margin size
*/
margins: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.margins();
}
parentReport.margins(value);
return this;
},
/**
* Enabled/Disables the Automatic Print of PDF on Open
* @param {boolean} [value=false] - true/false to auto-print
*/
autoPrint: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.autoPrint();
}
parentReport.autoPrint(value);
return this;
},
/**
* Enabled/Disables the Automatic Full Screen of PDF on Open
* @param {boolean} [value=false] - true/false to auto-full screen it
*/
fullScreen: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.fullScreen();
}
parentReport.fullScreen(value);
return this;
},
/**
* Enables or Disables the (xxx.xx) around numbers instead of -xxx.xx
* @param {boolean} value - enables or disables the ()/- modes
*/
negativeParentheses: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.negativeParentheses();
}
parentReport.negativeParentheses(value);
return this;
},
/**
* Sets or gets the current font size
* @param {number} [value] - font size to set it to
* @returns {number|object}
*/
fontSize: function (value) {
const parentReport = this._findRootReport();
if (!arguments.length) {
return parentReport.fontSize();
}
parentReport.fontSize(value);
return this;
},
/**
* Import a PDF into the current Document
*/
importPDF: function (value) {
const pr = this._findParentReport();
return pr.importPDF(value);
},
/**
* Clear the Totals on a report
* @private
*/
_clearTotals: function () {
let i, max, field;
// Make sure to Zero out any keys if this is a new structure
for (i = 0, max = this._math.length; i < max; i++) {
field = this._math[i][1];
this._totals[field] = 0;
// If you add any to this Switch, make sure you update the switch in the _calcTotals
switch (this._math[i][0]) {
case mathTypes.SUM:
break;
case mathTypes.AVERAGE:
this._totals[field + "_sum"] = 0;
this._totals[field + "_cnt"] = 0;
break;
case mathTypes.MIN:
this._totals[field + "_min"] = 0;
break;
case mathTypes.MAX:
break;
case mathTypes.COUNT:
break;
}
}
// Sub-Reports can set new keys in this group's total, so if we are clearing totals; we need to clear them also.
for (let key in this._totals) {
//noinspection JSUnresolvedFunction
if (this._totals.hasOwnProperty(key)) {
this._totals[key] = 0;
}
}
},
/**
* Calculate Totals
* @param {Object} currentData - The current data line
* @private
*/
_calcTotals: function (currentData) {
let i, max, field, srcField;
for (i = 0, max = this._math.length; i < max; i++) {
field = this._math[i][1];
srcField = field;
if (currentData[field + "_original"] !== undefined) {
srcField += "_original";
}
let result = 0;
if (currentData[srcField] != null && !isNaN(currentData[srcField])) {
result = parseFloat(currentData[srcField]);
}
// If you add any to this Switch, make sure you update the switch in the _clearTotals
switch (this._math[i][0]) {
case mathTypes.SUM:
this._totals[field] += result;
break;
case mathTypes.AVERAGE:
this._totals[field + "_sum"] += result;
this._totals[field + "_cnt"] += 1;
this._totals[field] = this._totals[field + "_sum"] / this._totals[field + "_cnt"];
break;
case mathTypes.MIN:
if (this._totals[field + "_min"] === 0 || result < this._totals[field]) {
this._totals[field + "_min"] = 1;
this._totals[field] = result;
}
break;
case mathTypes.MAX:
if (this._totals[field] < result) {
this._totals[field] = result;
}
break;
case mathTypes.COUNT:
this._totals[field]++;
break;
default:
Report.error("REPORTAPI: Math expression id is wrong", this._math[i][0], " on ", field);
}
}
},
_reportRenderMode: function(value) {
const parentReport = this._findRootReport();
if (arguments.length) {
return parentReport._reportRenderMode(value);
} else {
return parentReport._reportRenderMode();
}
},
_checkAsyncFunctionPrototype: function(f, typeFunction) {
if (typeof f !== 'function') {
return true;
}
const curMode = this._reportRenderMode();
if (f.length === 4) {
if (curMode === reportRenderingMode.UNDEFINED) {
this._reportRenderMode(reportRenderingMode.ASYNC);
} else if (curMode !== reportRenderingMode.ASYNC) {
Report.error("REPORTAPI: You have attempted to add a ASYNCHRONOUS ", typeFunction.toUpperCase(), "function to a report that already has a SYNCHRONOUS function added to it. The report MUST be either fully ASYNCHRONOUS or fully SYNCHRONOUS, otherwise issues will occur, so we are ignoring this", typeFunction.toUpperCase(), "function and leaving the report SYNCHRONOUS!");
return false;
}
} else {
if (curMode === reportRenderingMode.UNDEFINED) {
this._reportRenderMode(reportRenderingMode.SYNC);
} else if (curMode !== reportRenderingMode.SYNC) {
Report.error("REPORTAPI: You have attempted to add a SYNCHRONOUS", typeFunction.toUpperCase(), "function to a report that already has a ASYNCHRONOUS function added to it. The report MUST be either fully ASYNCHRONOUS or fully SYNCHRONOUS, otherwise issues will occur, so we are ignoring this", typeFunction.toUpperCase(), "function and leaving the report ASYNCHRONOUS!");
return false;
}
}
return true;
},
/**
* Renders the footer on this report group
* @param {ReportRenderer} Rpt - the report rendering object
* @param {Object} State - current state of report
* @param {function} callback when done with the footers
* @private
*/
_renderFooter: function (Rpt, State, callback) {
const finishFooter = () => {
if (this._footer !== null) {
if (this._curBandWidth.length > 0) {
Rpt._bandWidth(this._curBandWidth);
Rpt._bandOffset(this._curBandOffset);
}
this._expandRowTree(this._lastData);
this._footer.run(Rpt, State, this._lastData, callback);
} else if (callback) {
callback();
}
};
const setupTotals = () => {
Rpt.totals = clone(this._totals);
const parent = this._findParentDataSet();
let found = false;
for (let key in Rpt.totals) {
//noinspection JSUnresolvedFunction
if (Rpt.totals.hasOwnProperty(key)) {
found = true;
break;
}
}
if (!found) {
finishFooter();
} else {
const x = (err, data) => {
this._expandRowTree(data);
if (err) {
Report.error("REPORTAPI: ---- ERROR:", new ReportError({error: err}));
}
Rpt.totals = data;
finishFooter();
};
parent._totalFormatter(Rpt.totals, x);
}
};
if (this._child !== null && this._child._renderFooter) {
this._child._renderFooter(Rpt, State, setupTotals);
} else {
setupTotals();
}
},
/**
* Renders the Detail in Sync mode
* @param Rpt
* @param State
* @param currentData
* @param callback
* @private
*/
_renderSyncDetail: function(Rpt, State, currentData, callback) {
try {
this._detail(Rpt, currentData, State);
}
catch(err) {
Report.error("REPORTAPI: Error when calling group Detail", new ReportError({error: err, stack: err && err.stack}));
}
// Callback is Required; so no "if" check
callback();
},
/**
* Renders the detail in Async Mode
* @param Rpt
* @param State
* @param currentData
* @param callback
* @private
*/
_renderAsyncDetail: function(Rpt, State, currentData, callback) {
this._detail(Rpt, currentData, State, (err) => {
if(err) {
Report.error("REPORTAPI: Error when calling group Detail", new ReportError({error: err, stack: err && err.stack}));
}
// Callback is Required; so no "if" check
callback();
});
},
_renderStringDetailParse: function(currentData) {
let rendered = [];
let idxStr, start = 0;
while ((idxStr = this._detail.indexOf('{{', start)) >= 0) {
let idxEnd = this._detail.indexOf('}}', idxStr);
if (idxEnd > idxStr) {
if (idxStr !== start) {
rendered.push(this._detail.substring(start, idxStr));
}
let fld = this._detail.substring(idxStr + 2, idxEnd);
if (typeof currentData[fld] !== 'undefined') {
rendered.push({fld: fld});
} else {
rendered.push("{{"+fld+"}}");
}
start = idxEnd+2;
}
}
if (start < this._detail.length) {
rendered.push(this._detail.substring(start));
}
this._detailRendered = rendered;
},
_renderStringDetail: function(Rpt, State, currentData, callback) {
let results = [];
if (this._detailRendered == null) {
this._renderStringDetailParse(currentData);
}
for (let i=0;i<this._detailRendered.length;i++) {
if (typeof this._detailRendered[i].fld !== 'undefined') {
results.push(currentData[this._detailRendered[i].fld]);
} else {
results.push(this._detailRendered[i]);
}
}
Rpt.print(results.join(""), callback);
},
_renderBandDetail: function(Rpt, State, currentData, callback) {
let bandData = [];
for (let i=0;i<this._detail.length;i++) {
const data = {data: currentData[this._detail[i][0]] || ''};
if (this._detail[i][1]) {
data.width = parseInt(this._detail[i][1],10);
}
if (this._detail[i][2]) {
data.align = parseInt(this._detail[i][2],10);
if (isNaN(data.align)) {
switch (this._detail[i][2].toLowerCase()) {
case "left": data.align = 1; break;
case "right": data.align = 3; break;
case "center": data.align = 2; break;
default: data.align = 1;
}
}
}
bandData.push(data);
}
Rpt.band(bandData, {border:1, width: 0, wrap: 1}, callback );
},
/**
* This is a NOP detail rendered, by setting detail this function will be set to the proper version
* @param Rpt
* @param State
* @param currentData
* @param callback
* @private
*/
_renderDetail: function(Rpt, State, currentData, callback) {
// this is a basically a NOP function, which will be replaced by detail being set
callback();
},
/**
* Renders this report object
* @param {ReportRenderer} Rpt - report object
* @param {Object} State of the report
* @param {Object} currentData - the current data
* @param {function} callback - the callback when it is done rendering the report
* @private
*/
_renderIt: function (Rpt, State, currentData, callback) {
let groupChanged = false, headerSize = 0;
State.currentGroup = this;
if (this._header) {
headerSize = this._header._partHeight;
State.additionalHeaderSize += headerSize;
}
if (this._level === -1) {
this._level = (++Rpt._totalLevels);
}
// This actually calls the Detail Printing
const handleDetail = (detailCallback) => {
Rpt._level = this._level;
if (Report.trace) {
console.error("Running Detail", this._level);
if (Report.callbackDebugging) {
console.error(" - Callback is: ", typeof callback === "function" ? "Valid" : "** Invalid **");
}
}
this._expandRowTree(currentData);
this._renderDetail(Rpt, State, currentData, detailCallback);
};
// This finishes the Calculations
const finishRenderGroupStep2 = () => {
this._calcTotals(currentData);
// We need to capture the Primary Band sizes for later use in the footers.
if (this._groupOnField === null) {
if (!this._calculatedBands) {
this._calculatedBands = true;
this._curBandWidth = Rpt._bandWidth();
this._curBandOffset = Rpt._bandOffset();
this._findParentReport()._setBandSize(this._curBandWidth, this._curBandOffset);
}
}
State.additionalHeaderSize -= headerSize;
callback();
};
// This handles the remainder of the rending of this detail section
const finishRenderGroup = () => {
// We need to reset this because a child will set the state.currentGroup to itself
State.currentGroup = this;
if (this._runHeaderWhen !== Report.show.always) {
State.additionalHeaderSize += headerSize;
}
if (this._runDetailAfterSubgroup && this._detail !== null) {
handleDetail(finishRenderGroupStep2);
} else {
finishRenderGroupStep2();
}
};
// This actually prints the Child
const continueRenderingStep2 = () => {
if (this._runHeaderWhen !== Report.show.always) {
State.additionalHeaderSize -= headerSize;
}
if (this._child !== null) {
this._child._renderIt(Rpt, State, currentData, finishRenderGroup);
} else {
finishRenderGroup();
}
};
// this handles doing the pre-detail (if set)
const continueRendering = () => {
this._expandRowTree(currentData);
this._currentData = clone(currentData);
// Run our Detail before a subgroup
if (!this._runDetailAfterSubgroup && this._detail !== null) {
handleDetail(continueRenderingStep2);
} else {
continueRenderingStep2();
}
};
// Handles the Group Change code
const groupChangeCallback = (reset) => {
if (reset) {
if (this._footer !== null) {
this._lastData = clone(currentData);
}
// We only clear the totals on added groups; not the master "detail" group.
if (this._groupOnField !== null) {
this._clearTotals();
}
}
if (this._header !== null) {
Rpt._level = this._level;
this._expandRowTree(currentData);
// TODO: Should we calculate the average detail size? We are hard coding it to 20 right now, until we decide if we should do this...
if (State.additionalHeaderSize + Rpt._PDF.y >= Rpt._maxY() - 20) {
this._currentData = clone(currentData);
Rpt.newPage({save:true, breakingBeforePrint: true}, () => {
this._hasRanHeader = true;
if (!reset) { Rpt._resetPageHeaderCounter(); }
continueRendering();
});
} else {
this._header.run(Rpt, State, currentData, () => {
this._hasRanHeader = true;
if (!reset) { Rpt._resetPageHeaderCounter(); }
continueRendering();
});
}
} else {
this._hasRanHeader = true;
continueRendering();
}
};
// Check for group changed
if (this._groupOnField !== null) {
if (State.resetGroups) {
this._groupChecked = false;
this._hasRanHeader = false;
}
if (this._groupChecked === false || currentData[this._groupOnField] !== this._groupLastValue) {
State.resetGroups = true;
groupChanged = true;
this._groupChecked = true;
this._groupLastValue = currentData[this._groupOnField];
}
} else {
State.resetGroups = false;
groupChanged = true;
}
if (groupChanged) {
if (this._hasRanHeader) {
Rpt._level = this._level;
this._renderFooter(Rpt, State, () => {
groupChangeCallback(true);
});
} else {
groupChangeCallback(true);
}
} else if (Rpt.hasChanges() && !this._hasRanHeader) {
groupChangeCallback(false);
} else {
continueRendering();
}
},
/**
* This runs a Header/Footer for calculation purposes and then calls the callback
* @param part
* @param Rpt
* @param bogusData
* @param callback
* @private
*/
_calculatePart: function(part, Rpt, bogusData, callback) {
if (part) {
Rpt._addPage();
part.run(Rpt, {isCalc: true}, bogusData, callback);
} else if (callback) {
callback();
}
},
/**
* Figures out the size of the headers/footers for this report object
* @param {ReportRenderer} Rpt - current report we are running on
* @param {Object} bogusData - bogus data
* @param {function} callback - the callback to call when it is done
* @private
*/
_calculateFixedSizes: function (Rpt, bogusData, callback) {
this._clearTotals();
this._calculatePart(this._header, Rpt, bogusData, () => {
Rpt.totals = this._totals;
this._calculatePart(this._tfooter, Rpt, bogusData, () => {
this._calculatePart(this._footer, Rpt, bogusData, () => {
if (this._child !== null) {
this._child._calculateFixedSizes(Rpt, bogusData, callback);
} else {
callback();
}
});
});
});
},
/**
* Sets the field this report object groups on
* @param {string} field - data field name to group by
* @private
*/
_groupOn: function (field) {
if (!arguments.length) {
return (this._groupOnField);
}
this._groupOnField = field;
return (this);
},
/**
* Sets a child Report
* @param {Report} newChild - report object
* @private
*/
_setChild: function (newChild) {
this._child = newChild;
},
/**
* Sets up proper linking for group children when you have siblings or child reports
* @param rpt
* @private
*/
_addToNullGroup: function(rpt) {
if (this._child === null) {
this._child = rpt;
} else if (this._child._isSection) {
this._child.addReport(rpt);
} else {
const c = this._child;
const sec = new ReportSection(this);
this._child = sec;
c.parent = null;
sec._addSubObject(c);
sec.addReport(rpt);
}
},
/**
* Finds the Root Report
* @return {Report}
* @private
*/
_findRootReport: function () {
let parent = this;
while (parent._parent) {
parent = parent._parent;
}
//noinspection JSValidateTypes
return parent;
},
/**
* Finds the Parent Report
* @param [start]
* @return {Report} the Parent Report
* @private
*/
_findParentReport: function (start) {
let parent = this._parent;
if (arguments.length && start !== null) {
if (start.isRootReport()) {
return (start);
} else {
parent = start._parent;
}
}
while (!parent._isReport) {
parent = parent._parent;
}
return (parent);
},
/**
* Finds the DataSet controlling this Group
* @return {ReportDataSet}
* @private
*/
_findParentDataSet: function () {
let parent = this._parent;
while (!parent._isDataSet) {
parent = parent._parent;
}
return (parent);
},
/**
* Finds the Section controlling this Group
* @return {ReportSection}
* @private
*/
_findParentSection: function () {
let parent = this._parent;
while (!parent._isSection) {
parent = parent._parent;
}
return (parent);
},
/**
* Expands a row into a tree of objects.
* @param target
*/
_expandRowTree: function (target) {
for (let prop in target) {
if (target.hasOwnProperty(prop)) {
const propSplit = prop.split('.');
const count = propSplit.length;
if (count <= 1) { continue; }
let lastObj = target;
for (let i = 0; i < count; i++) {
let obj = lastObj[propSplit[i]];
obj = lastObj[propSplit[i]] = (i === (count - 1)) ?
target[prop] :
(obj !== null && obj !== undefined && typeof obj === 'object') ?
obj :
{};
lastObj = obj;
}
}
}
return target;
}
};
Report.buildFontIndex = function(fonts) {
let fontIndex = {};
for (let font in fonts) {
if (fonts.hasOwnProperty(font)) {
font = fonts[font];
for (let fontType in font) {
if (font.hasOwnProperty(fontType)) {
fontIndex[font[fontType]] = font;
}
}
}
}
return fontIndex;
};
// Standard Font constants
Report.fonts = {
times: {normal: 'Times-Roman', bold: 'Times-Bold', italic: 'Times-Italic', bolditalic: 'Times-BoldItalic'},
helvetica: {normal: 'Helvetica', bold: 'Helvetica-Bold', italic: 'Helvetica-Oblique', bolditalic: 'Helvetica-BoldOblique'},
courier: {normal: 'Courier', bold: 'Courier-Bold', italic: 'Courier-Oblique', bolditalic: 'Courier-BoldOblique'},
symbol: {normal: 'Symbol'},
dingbats: {normal: 'ZapfDingbats'}
};
// Generate the Indexed Fonts
Report._indexedFonts = Report.buildFontIndex(Report.fonts);
// Formatting constants
Report.format = {
/** @constant {number} */
off: 0,
on: 1,
withFormatted: 2,
withformatted: 2,
withOriginal: 3,
withoriginal: 3
};
// once - original behavior, newPageOnly = run any time a new page triggers and this is the current group,
// always = same as newPage but this header/footer is included when in sub-groups.
Report.show = {once: 0, newPageOnly: 1, newpageonly: 1, always: 2 };
Report.alignment = {LEFT: 1, left: 1, RIGHT: 3, right:3, CENTER: 2, center: 2};
Report.renderType = {
file: 0,
pipe: 1,
buffer: 2
};
/**
* Enable Report Tracing
* @type {boolean}
*/
Report.trace = false;
/**
* Enable Report Callback Debugging
* @type {boolean}
*/
Report.callbackDebugging = false;
if (!Report.error) {
Report.error = error;
}
// Lowercase Prototypes
// I know this probably doesn't make any sense;
// but this is needed for a project internal to our company
// and this simplifies deploying fluentReports to leave it
// intact in the fR codebase
Report.scopeddataobject = ScopedDataObject;
lowerPrototypes(Report.prototype);
lowerPrototypes(ReportGroup.prototype);
lowerPrototypes(ReportSection.prototype);
lowerPrototypes(ReportDataSet.prototype);
lowerPrototypes(ReportRenderer.prototype);
/**
* ReportGroup
* @type {ReportGroup}
* @constructs ReportGroup
*/
Report.Group = Report.group = ReportGroup;
/**
* ReportSection
* @type {ReportSection}
*/
Report.Section = Report.section = ReportSection;
/**
* ReportDataSet
* @type {ReportDataSet}
*/
Report.DataSet = Report.dataset = ReportDataSet;
/// ---------------------- Don't Copy below this line
_global.Report = Report;
}(typeof exports === 'undefined' ? this : exports));
|
var auth = require('../../server/controllers/auth.server.controller');
module.exports = function(app) {
app.route('/api/register')
.post(auth.newUser);
app.route('/api/login')
.post(auth.loginUser);
};
|
import customGenerator from './custom';
import emptyGenerator from './empty';
import expandGenerator from './expand';
import randomGenerator from './random';
import rangeGenerator from './range';
import repeatGenerator from './repeat';
export {
customGenerator,
emptyGenerator,
expandGenerator,
randomGenerator,
rangeGenerator,
repeatGenerator
};
|
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.PickListSubList = void 0;
var _ClassNames = require("../utils/ClassNames");
var _propTypes = _interopRequireDefault(require("prop-types"));
var _react = _interopRequireWildcard(require("react"));
var _ObjectUtils = _interopRequireDefault(require("../utils/ObjectUtils"));
var _PickListItem = require("./PickListItem");
var _DomHandler = _interopRequireDefault(require("../utils/DomHandler"));
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a 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); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function () { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
var PickListSubListComponent = /*#__PURE__*/function (_Component) {
_inherits(PickListSubListComponent, _Component);
var _super = _createSuper(PickListSubListComponent);
function PickListSubListComponent(props) {
var _this;
_classCallCheck(this, PickListSubListComponent);
_this = _super.call(this, props);
_this.onItemClick = _this.onItemClick.bind(_assertThisInitialized(_this));
_this.onItemKeyDown = _this.onItemKeyDown.bind(_assertThisInitialized(_this));
return _this;
}
_createClass(PickListSubListComponent, [{
key: "onItemClick",
value: function onItemClick(event) {
var originalEvent = event.originalEvent;
var item = event.value;
var selection = _toConsumableArray(this.props.selection);
var index = _ObjectUtils.default.findIndexInList(item, selection);
var selected = index !== -1;
var metaSelection = this.props.metaKeySelection;
if (metaSelection) {
var metaKey = originalEvent.metaKey || originalEvent.ctrlKey;
if (selected && metaKey) {
selection.splice(index, 1);
} else {
if (!metaKey) {
selection.length = 0;
}
selection.push(item);
}
} else {
if (selected) selection.splice(index, 1);else selection.push(item);
}
if (this.props.onSelectionChange) {
this.props.onSelectionChange({
event: originalEvent,
value: selection
});
}
}
}, {
key: "onItemKeyDown",
value: function onItemKeyDown(event) {
var listItem = event.originalEvent.currentTarget;
switch (event.originalEvent.which) {
//down
case 40:
var nextItem = this.findNextItem(listItem);
if (nextItem) {
nextItem.focus();
}
event.originalEvent.preventDefault();
break;
//up
case 38:
var prevItem = this.findPrevItem(listItem);
if (prevItem) {
prevItem.focus();
}
event.originalEvent.preventDefault();
break;
//enter
case 13:
this.onItemClick(event);
event.originalEvent.preventDefault();
break;
default:
break;
}
}
}, {
key: "findNextItem",
value: function findNextItem(item) {
var nextItem = item.nextElementSibling;
if (nextItem) return !_DomHandler.default.hasClass(nextItem, 'p-picklist-item') ? this.findNextItem(nextItem) : nextItem;else return null;
}
}, {
key: "findPrevItem",
value: function findPrevItem(item) {
var prevItem = item.previousElementSibling;
if (prevItem) return !_DomHandler.default.hasClass(prevItem, 'p-picklist-item') ? this.findPrevItem(prevItem) : prevItem;else return null;
}
}, {
key: "isSelected",
value: function isSelected(item) {
return _ObjectUtils.default.findIndexInList(item, this.props.selection) !== -1;
}
}, {
key: "render",
value: function render() {
var _this2 = this;
var header = null;
var items = null;
var wrapperClassName = (0, _ClassNames.classNames)('p-picklist-list-wrapper', this.props.className);
var listClassName = (0, _ClassNames.classNames)('p-picklist-list', this.props.listClassName);
if (this.props.header) {
header = /*#__PURE__*/_react.default.createElement("div", {
className: "p-picklist-header"
}, this.props.header);
}
if (this.props.list) {
items = this.props.list.map(function (item, i) {
return /*#__PURE__*/_react.default.createElement(_PickListItem.PickListItem, {
key: JSON.stringify(item),
value: item,
template: _this2.props.itemTemplate,
selected: _this2.isSelected(item),
onClick: _this2.onItemClick,
onKeyDown: _this2.onItemKeyDown,
tabIndex: _this2.props.tabIndex
});
});
}
return /*#__PURE__*/_react.default.createElement("div", {
ref: this.props.forwardRef,
className: wrapperClassName
}, header, /*#__PURE__*/_react.default.createElement("ul", {
className: listClassName,
style: this.props.style,
role: "listbox",
"aria-multiselectable": true
}, items));
}
}]);
return PickListSubListComponent;
}(_react.Component);
_defineProperty(PickListSubListComponent, "defaultProps", {
forwardRef: null,
list: null,
selection: null,
header: null,
className: null,
listClassName: null,
style: null,
showControls: true,
metaKeySelection: true,
tabIndex: null,
itemTemplate: null,
onItemClick: null,
onSelectionChange: null
});
_defineProperty(PickListSubListComponent, "propTypes", {
forwardRef: _propTypes.default.any,
list: _propTypes.default.array,
selection: _propTypes.default.array,
header: _propTypes.default.string,
className: _propTypes.default.string,
listClassName: _propTypes.default.string,
style: _propTypes.default.object,
showControls: _propTypes.default.bool,
metaKeySelection: _propTypes.default.bool,
tabIndex: _propTypes.default.number,
itemTemplate: _propTypes.default.func,
onItemClick: _propTypes.default.func,
onSelectionChange: _propTypes.default.func
});
var PickListSubList = _react.default.forwardRef(function (props, ref) {
return /*#__PURE__*/_react.default.createElement(PickListSubListComponent, _extends({
forwardRef: ref
}, props));
});
exports.PickListSubList = PickListSubList; |
/**
* Created by Òèòî on 04/06/2015.
*/
var array= [4, 2, 1, 4, 2, 1, 5, 1, 1, 2, 4, 4, 1];
var mode = getMode(array);
console.log(mode[0] + ' (' + mode[1] + ' times)');
function getMode(arr){
var modeMap = {},
maxNum = arr[0],
maxCount = 1;
for (var ind = 0; ind < arr.length; ind++) {
var num = arr[ind];
if (modeMap[num] == null) {
modeMap[num] = 1;
} else {
modeMap[num]++;
}
if (modeMap[num] > maxCount) {
maxNum = num;
maxCount = modeMap[num];
}
}
return [maxNum, maxCount];
} |
import Body from './Body';
/**
* @class Represents a bullet on the screen
* @extends {Body}
*/
export default class Bullet extends Body {
/**
* Class constructor
*
* @param {Game} game game instance
* @param {Object} position initial position of the body
* @param {string} direction the direction of the gravity of the bullet
* @param {Object} size the size of the body
*/
constructor(game, initialPosition, direction='down', size={width: 2, height: 5}) {
super(game, size, initialPosition);
this.direction = direction;
this.speed = 5;
}
/**
* Updates the body properties on each screen update of the game
*/
update() {
this.position.y += this.direction === 'up' ? -this.speed : this.speed;
}
} |
'use strict';
const figures = require('figures');
const cliCursor = require('cli-cursor');
const utils = require('./lib/utils');
const renderHelper = (task, event, options) => {
const log = utils.log.bind(undefined, options);
if (event.type === 'STATE') {
const message = task.isPending() ? 'started' : task.state;
log(`${task.title} [${message}]`);
if (task.isSkipped() && task.output) {
log(`${figures.arrowRight} ${task.output}`);
}
} else if (event.type === 'DATA') {
log(`${figures.arrowRight} ${event.data}`);
} else if (event.type === 'TITLE') {
log(`${task.title} [title changed]`);
}
};
const render = (tasks, options) => {
for (const task of tasks) {
task.subscribe(
event => {
if (event.type === 'SUBTASKS') {
render(task.subtasks, options);
return;
}
renderHelper(task, event, options);
},
err => {
console.log(err);
}
);
}
};
class VerboseRenderer {
constructor(tasks, options) {
this._tasks = tasks;
this._options = Object.assign({
dateFormat: 'HH:mm:ss'
}, options);
}
static get nonTTY() {
return true;
}
render() {
cliCursor.hide();
render(this._tasks, this._options);
}
end() {
cliCursor.show();
}
}
module.exports = VerboseRenderer;
|
/* eslint-disable no-regex-spaces */
/**
* Advanced arguments used during Encodes.
* @param {object} params Parameters for the encoding passed in by the user.
* @return {string} The arguments to be passed into the CLI
*/
function advancedEncode (params) {
var maxPaletteSize = '';
var colorBuckets = '';
var channelCompact = '';
var ycocg = '';
var subtractGreen = '';
var frameShape = '';
var maxFrameLookBack = '';
var maniacRepeats = '';
var maniacThreshold = '';
var maniacDivisor = '';
var maniacMinSize = '';
var chanceCutoff = '';
var chanceAlpha = '';
var adaptive = '';
var guess = '';
var alphaGuess = '';
var chromaSubsample = '';
if (params.maxPaletteSize) {
maxPaletteSize = '-P' + parseInt(params.maxPaletteSize);
}
if (params.colorBuckets === false) {
colorBuckets = '-B';
}
if (params.colorBuckets === true) {
colorBuckets = '-A';
}
if (params.colorBuckets === 'auto') {
colorBuckets = '';
}
if (params.channelCompact === false) {
channelCompact = '-C';
}
if (params.ycocg === false) {
ycocg = '-Y';
}
if (params.subtractGreen === false) {
subtractGreen = '-W';
}
if (params.frameShape === false) {
frameShape = '-S';
}
if (params.maxFrameLookBack) {
maxFrameLookBack = '-L' + parseInt(params.maxFrameLookBack);
}
if (params.maniacRepeats) {
maniacRepeats = '-R' + parseInt(params.maniacRepeats);
}
if (parseInt(params.maniacThreshold) > -1) {
maniacThreshold = '-T' + parseInt(params.maniacThreshold);
}
if (params.maniacDivisor) {
maniacDivisor = '-D' + parseInt(params.maniacDivisor);
}
if (params.maniacMinSize) {
maniacMinSize = '-M' + parseInt(params.maniacMinSize);
}
if (params.chanceCutoff) {
chanceCutoff = '-X' + parseInt(params.chanceCutoff);
}
if (params.chanceAlpha) {
chanceAlpha = '-Z' + parseInt(params.chanceAlpha);
}
if (params.adaptive) {
adaptive = '-U';
if (Array.isArray(params.input)) {
params.input.push(params.adaptive);
} else {
var newInput = [];
newInput.push(params.input);
newInput.push(params.adaptive);
params.input = newInput;
}
}
if (params.guess) {
var guessDefault = 'heuristically';
var y = params.guess.y || guessDefault;
var co = params.guess.co || guessDefault;
var cg = params.guess.cg || guessDefault;
var alpha = params.guess.alpha || guessDefault;
var lookback = params.guess.lookback || guessDefault;
var planes = [y, co, cg, alpha, lookback];
guess = '-G';
var planeMap = {
'heuristically': '?',
'average': '0',
'median gradient': '1',
'median number': '2',
'mixed': 'X'
};
// -G => -G?012X || -G????? || -G11111 || etc.
for (var i = 0; i < planes.length; i++) {
var plane = planes[i];
guess = guess + planeMap[plane];
}
}
if (!params.keepAlpha) {
if (params.alphaGuess === 'average') {
alphaGuess = '-H0';
} else if (params.alphaGuess === 'median gradient') {
alphaGuess = '-H1';
} else if (params.alphaGuess === 'median neighbors') {
alphaGuess = '-H2';
}
}
if (params.chromaSubsample === true) {
chromaSubsample = '-J';
}
var args = [
maxPaletteSize,
colorBuckets,
channelCompact,
ycocg,
subtractGreen,
frameShape,
maxFrameLookBack,
maniacRepeats,
maniacThreshold,
maniacDivisor,
maniacMinSize,
chanceCutoff,
chanceAlpha,
adaptive,
guess,
alphaGuess,
chromaSubsample
].join(' ');
args = args.replace(/ +/g, ' ');
args = args.trim();
return args;
}
module.exports = advancedEncode;
|
import * as ActionTypes from '../constants/ActionTypes';
const initialState = [];
export default function entitiesReducer(state = initialState, action) {
switch (action.type) {
case ActionTypes.FETCH_ENTITIES:
return {...state, isLoading: true };
case ActionTypes.ENTITIES_FETCHED:
return { ...state, isLoading: false, entities: action.payload.entities, totalItem: action.payload.totalItem};
default:
return state;
}
}
|
define("ace/snippets/protobuf",["require","exports","module"],function(e,t,n){"use strict";t.snippetText="",t.scope="protobuf"})
|
'use strict'
var steed = require('steed')()
var exec = require('child_process').exec
function addCommits (sys, cb) {
steed.map(new State(sys, cb), sys.containerDefinitions, fetchSha, done)
}
function fetchSha (def, cb) {
if (!def.specific || !def.specific.path) {
cb(null, def)
return
}
var path = def.specific.path
exec('git log -n 1 --format=%H ' + path, {}, function (err, stdio) {
if (!err) {
def.specific.commit = stdio.toString().trim()
}
cb(err, def)
})
}
function State (sys, cb) {
this.sys = sys
this.cb = cb
}
function done (err, defs) {
if (err) {
return this.cb(err)
}
this.sys.containerDefinitions = defs
this.cb(null, this.sys)
}
module.exports = addCommits
|
define("cool/controls/HTMLEditorCK",
[
"dojo/_base/declare",
"dojo/_base/lang",
"dojo/_base/array",
"cool/controls/_control",
"dojo/dom",
"dojo/dom-construct",
"dojo/query"
], function(declare, lang, array, _control, dom, domConstruct, query) {
return declare("cool.controls.HTMLEditorCK", [_control], {
tempValue: null,
editor: null,
coolInit : function() {
var self = this;
this.inherited(arguments);
var ckParams = {};
var uploadRepoId = this.getDefinitionParameter('ck_upload_repo_id');
if(uploadRepoId)
ckParams.filebrowserUploadUrl = Routing.generate('frepoCKUpload', {
repositoryId: uploadRepoId,
filePath: this.getDefinitionParameter('ck_upload_repo_path')
});
this.editor = CKEDITOR.appendTo(this.fieldNode, ckParams);
this.editor.on('loaded', function(evt){
var width = self.getParameter('width');
var height = self.getParameter('height');
if(width && height)
self.editor.resize(width, height);
});
//TODO: readonly, onchange...
if(this.definition.hasOwnProperty('value')) {
this.set('value', this.definition.value);
this.emit("valueInit", {});
}
},
_setValueAttr: function(value) {
this.editor.setData(value, function() { this.updateElement() });
},
_getValueAttr: function() {
return this.editor.getData();
},
insertAtCursor: function(text) {
this.editor.insertText(text);
}
});
}); |
(function () {
'use strict';
angular
.module("fc.merchandising")
.provider("prodHierarchyDataSvc", prodHierarchyDataSvcProvider);
/* @ngInject */
function prodHierarchyDataSvcProvider() {
// Available in config.
var cfg = this;
cfg.activateEndpoint = "activate";
cfg.deactivateEndpoint = "deactivate";
cfg.hierarchyConfigUrl = null;
cfg.hierarchyDataUrlTpl = null;
cfg.$get = prodHierarchyDataSvc;
prodHierarchyDataSvc.$inject = ["$http", "$q"];
function prodHierarchyDataSvc($http, $q) {
return {
activateHierarchiesData: activateHierarchiesData,
createHierarchyData: createHierarchyData,
createHierarchyConfig: createHierarchyConfig,
deactivateHierarchiesData: deactivateHierarchiesData,
getHierarchiesData: getHierarchiesData,
getHierarchyConfig: getHierarchyConfig,
getHierarchyData: getHierarchyData,
updateHierarchyData: updateHierarchyData
};
////////////////////////////////////////////////////////////////////////////////////////////////////////////
function activateHierarchiesData(hierarchyId, ids) {
if (!hierarchyId) {
return $q.reject("No hierarchy id.");
}
// Ensure that the endpoint only gets arrays.
if (!angular.isArray(ids)) {
ids = [ids];
}
var url = cfg.hierarchyDataUrlTpl.replace("{hierarchyId}", hierarchyId) + "/" + cfg.activateEndpoint;
return $http.post(url, ids).then(function (result) {
return result.data;
});
}
function createHierarchyData(hierarchyId, data) {
if (!hierarchyId) {
return $q.reject("No hierarchy id.");
}
var url = cfg.hierarchyDataUrlTpl.replace("{hierarchyId}", hierarchyId);
return $http.post(url, data).then(function (result) {
return result.data;
});
}
function createHierarchyConfig(config) {
var url = cfg.hierarchyConfigUrl;
return $http.post(url, config).then(function (result) {
return result.data;
});
}
function deactivateHierarchiesData(hierarchyId, ids) {
if (!hierarchyId) {
return $q.reject("No hierarchy id.");
}
// Ensure that the endpoint only gets arrays.
if (!angular.isArray(ids)) {
ids = [ids];
}
var url = cfg.hierarchyDataUrlTpl.replace("{hierarchyId}", hierarchyId) + "/" + cfg.deactivateEndpoint;
return $http.post(url, ids).then(function (result) {
return result.data;
});
}
function getHierarchiesData(hierarchyId, page, pageSize, filterOptions, showInactive, replaceRemoved, refresh) {
if (!hierarchyId) {
return $q.reject("No hierarchy id.");
}
if (!page) {
page = 1;
}
if (!pageSize) {
pageSize = 12;
}
var config = {
params: {
page: page,
pageSize: pageSize
}
};
if (filterOptions._search) {
config.params._search = filterOptions._search;
if (filterOptions.fields.length > 0) {
_.forEach(filterOptions.fields, function (field) {
config.params[field] = filterOptions.query;
});
} else {
config.params._all = filterOptions.query;
}
}
if (showInactive) {
if (showInactive) {
config.params.showInactive = showInactive;
}
}
if (replaceRemoved) {
if (replaceRemoved) {
config.params.replaceRemoved = replaceRemoved;
}
}
if (refresh) {
if (refresh) {
config.params.refresh = refresh;
}
}
var url = cfg.hierarchyDataUrlTpl.replace("{hierarchyId}", hierarchyId);
return $http.get(url, config).then(function (result) {
return result.data;
});
}
function getHierarchyConfig() {
var url = cfg.hierarchyConfigUrl;
return $http.get(url).then(function (result) {
return result.data;
});
}
function getHierarchyData(hierarchyId, id) {
if (!hierarchyId) {
return $q.reject("No hierarchy id.");
}
var url = cfg.hierarchyDataUrlTpl.replace("{hierarchyId}", hierarchyId) + "/" + id;
return $http.get(url).then(function (result) {
return result.data;
});
}
function updateHierarchyData(hierarchyId, id, hierarchyData) {
if (!hierarchyId) {
return $q.reject("No hierarchy id.");
}
var url = cfg.hierarchyDataUrlTpl.replace("{hierarchyId}", hierarchyId) + "/" + id;
return $http.put(url, hierarchyData).then(function (result) {
return result.data;
});
}
}
}
})(); |
/*
S.ScrollTo({
dest: 1000,
d: 200,
e: 'Power3Out',
cb: afterTop
})
*/
S.ScrollTo = function (opts) {
var d = document
var scrollNode = d.scrollingElement ? d.scrollingElement : S.Dom.body // Chrome v.61
var scrollable = S.Snif.isFirefox || S.Snif.isIE ? d.documentElement : scrollNode
var start = pageYOffset
var end = opts.dest
var r = 1000
var anim = new S.Merom({d: opts.d, e: opts.e, update: upd, cb: getCb})
if (start === end) {
getCb()
} else {
S.WTP.on()
anim.play()
}
function upd (v) {
scrollable.scrollTop = Math.round(S.Lerp.init(start, end, v.progress) * r) / r
}
function getCb () {
S.WTP.off()
if (opts.cb) {
opts.cb()
}
}
}
|
/*
* config.js: Common utility functions for loading and rendering system configuration.
*
* (C) 2010, Nodejitsu Inc.
*
*/
var fs = require('fs'),
os = require('os'),
path = require('path'),
async = require('flatiron').common.async,
template = require('quill-template'),
config = template.config,
errs = require('errs'),
quill = require('../../quill');
//
// Alias `.toEnvironment` from `quill-template`.
//
exports.toEnvironment = config.toEnvironment;
//
// ### function osConfig ()
// Returns a named config for system information captured
// by the node.js `os` module.
//
exports.osConfig = function () {
var interfaces = os.networkInterfaces();
return {
os: {
hostname: os.hostname(),
type: os.type(),
platform: os.platform(),
arch: os.arch(),
release: os.release(),
cpus: os.cpus().length,
networkInterfaces: Object.keys(interfaces).reduce(function (all, name) {
all[name] = interfaces[name].reduce(function (families, info) {
var family = info.family.toLowerCase();
families[family] = families[family] || [];
families[family].push(info.address);
return families;
}, {});
return all;
}, {})
}
}
};
//
//
// ### function getConfig (system, callback)
// #### @system {Object} System to get configuration for
// #### @callback {function} Continuation to respond to
// Responds with the fully-merged object for all configuration
// associated with the `system`, contacting the remote composer.
//
exports.getConfig = function (system, callback) {
var options = {
client: { remote: quill.remote },
before: [exports.osConfig()],
remotes: quill.argv.config,
after: system && system.config
? system.config
: null
};
return config.getConfig(options, function (err, config) {
if (err) {
return callback(errs.create({
message: [
'Error fetching configs',
(options.remotes || []).join(' '),
':',
err.message
].join(' ')
}));
}
callback(null, config);
});
};
//
// ### function getEnv (system, callback)
// #### @system {Object} System to get environment for
// #### @callback {function} Continuation to respond to
// Responds with the fully-rendered env vars for all configuration
// associated with the `system`, contacting the remote composer.
//
exports.getEnv = function (system, callback) {
return exports.getConfig(system, function (err, config) {
return err
? callback(err)
: callback(null, exports.toEnvironment(config));
});
};
//
// ### function extract (system, dir, callback)
// Extracts all of the keys for the system in the specified
// dir and sets it to `system.vars`.
//
exports.extract = function (system, dir, callback) {
var dirs = {
templates: path.join(dir, 'templates'),
scripts: path.join(dir, 'scripts'),
files: path.join(dir, 'files')
};
async.parallel({
templates: async.apply(template.extract.keys.list, dirs.templates),
envvars: function (next) {
var executable = /[7|5|1]/;
//
// Only attempt to extract envvars from files which
// are executable.
//
fs.readdir(dirs.files, function (err, files) {
if (err) {
return err.code === 'ENOENT'
? next(null, [])
: next(err);
}
files = files.map(function (file) {
return path.join(dirs.files, file);
});
async.map(files, fs.stat, function (err, stats) {
if (err) { return next(err) }
files = files.filter(function (_, i) {
var mode = (stats[i].mode & parseInt('777', 8)).toString(8);
return executable.test(mode);
});
template.extract.envvars.list(files.concat(dirs.scripts), next);
});
});
}
}, function (err, result) {
var vars = { required: [], optional: [] };
if (result.envvars && result.envvars.required
&& result.envvars.required.length) {
vars.required = result.envvars.required.slice();
}
if (result.templates) {
if (result.templates.required && result.templates.required.length) {
vars.required = vars.required.concat(
result.templates.required.filter(function (key) {
return !~vars.required.indexOf(key)
})
);
}
if (result.templates.optional && result.templates.optional.length) {
vars.optional = vars.optional.concat(result.templates.optional);
}
}
callback(null, vars);
});
}; |
Ext.define('FastUI.view.vfield.VTable', {
extend:'Ext.form.field.ComboBox',
valueObject: {},
winCtx:{},
winId:0,
rest:{},
valueField:'id',
displayField:"title",
forceSelection:true,
triggerAction:'all',
editable:false,
selectOnFocus:true,
initComponent:function () {
this.fieldLabel = this.getFValue('title');
this.name = this.rest.getTableName() + '[' + this.getFValue('name') + ']';
this.disabled = this.getFValue('readonly') || false;
this.allowBlank = this.getFValue('required') || true;
this.width = this.getFValue('field_width') || 650;
this.vtype = this.getFValue('vtype');
this.store = this.getStore();
this.callParent();
},
getFValue:function (key) {
return this.valueObject[key];
},
getMEntity:function(){
return this.valueObject.ref.entity;
},
getStore:function () {
var rest = Ext.create('FastUI.view.Rest', this.getMEntity());
return new Ext.data.JsonStore({
autoLoad: true,
fields:['id', 'title'],
proxy:{
type:'ajax',
url:rest.indexPath(),
reader:{
type:'json',
root:'rows',
totalProperty:"totalCount"
}
}
});
},
setValue:function (value) {
if(value && value.id && value.title){
this.setValue(value.id);
}else{
this.callParent(arguments);
}
}
}); |
import Ember from "ember-metal/core";
import run from "ember-metal/run_loop";
import EmberObject from "ember-runtime/system/object";
import RSVP from "ember-runtime/ext/rsvp";
import EmberView from "ember-views/views/view";
import jQuery from "ember-views/system/jquery";
import Test from "ember-testing/test";
import "ember-testing/helpers"; // ensure that the helpers are loaded
import "ember-testing/initializers"; // ensure the initializer is setup
import setupForTesting from "ember-testing/setup_for_testing";
import EmberRouter from "ember-routing/system/router";
import EmberRoute from "ember-routing/system/route";
import EmberApplication from "ember-application/system/application";
import compile from "ember-template-compiler/system/compile";
var App;
var originalAdapter = Test.adapter;
function cleanup() {
// Teardown setupForTesting
Test.adapter = originalAdapter;
run(function() {
jQuery(document).off('ajaxSend');
jQuery(document).off('ajaxComplete');
});
Test.pendingAjaxRequests = null;
// Other cleanup
if (App) {
run(App, App.destroy);
App.removeTestHelpers();
App = null;
}
Ember.TEMPLATES = {};
}
function assertHelpers(application, helperContainer, expected) {
if (!helperContainer) { helperContainer = window; }
if (expected === undefined) { expected = true; }
function checkHelperPresent(helper, expected) {
var presentInHelperContainer = !!helperContainer[helper];
var presentInTestHelpers = !!application.testHelpers[helper];
ok(presentInHelperContainer === expected, "Expected '" + helper + "' to be present in the helper container (defaults to window).");
ok(presentInTestHelpers === expected, "Expected '" + helper + "' to be present in App.testHelpers.");
}
checkHelperPresent('visit', expected);
checkHelperPresent('click', expected);
checkHelperPresent('keyEvent', expected);
checkHelperPresent('fillIn', expected);
checkHelperPresent('wait', expected);
checkHelperPresent('triggerEvent', expected);
}
function assertNoHelpers(application, helperContainer) {
assertHelpers(application, helperContainer, false);
}
function currentRouteName(app) {
return app.testHelpers.currentRouteName();
}
function currentPath(app) {
return app.testHelpers.currentPath();
}
function currentURL(app) {
return app.testHelpers.currentURL();
}
function setupApp() {
run(function() {
App = EmberApplication.create();
App.setupForTesting();
App.injectTestHelpers();
});
}
QUnit.module("ember-testing: Helper setup", {
setup: function() { cleanup(); },
teardown: function() { cleanup(); }
});
test("Ember.Application#injectTestHelpers/#removeTestHelpers", function() {
App = run(EmberApplication, EmberApplication.create);
assertNoHelpers(App);
App.injectTestHelpers();
assertHelpers(App);
App.removeTestHelpers();
assertNoHelpers(App);
});
test("Ember.Application#setupForTesting", function() {
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App.__container__.lookup('router:main').location.implementation, 'none');
});
test("Ember.Application.setupForTesting sets the application to `testing`.", function() {
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App.testing, true, "Application instance is set to testing.");
});
test("Ember.Application.setupForTesting leaves the system in a deferred state.", function() {
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
});
test("App.reset() after Application.setupForTesting leaves the system in a deferred state.", function() {
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
App.reset();
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
});
test("Ember.Application#setupForTesting attaches ajax listeners", function() {
var documentEvents;
documentEvents = jQuery._data(document, 'events');
if (!documentEvents) {
documentEvents = {};
}
ok(documentEvents['ajaxSend'] === undefined, 'there are no ajaxSend listers setup prior to calling injectTestHelpers');
ok(documentEvents['ajaxComplete'] === undefined, 'there are no ajaxComplete listers setup prior to calling injectTestHelpers');
run(function() {
setupForTesting();
});
documentEvents = jQuery._data(document, 'events');
equal(documentEvents['ajaxSend'].length, 1, 'calling injectTestHelpers registers an ajaxSend handler');
equal(documentEvents['ajaxComplete'].length, 1, 'calling injectTestHelpers registers an ajaxComplete handler');
});
test("Ember.Application#setupForTesting attaches ajax listeners only once", function() {
var documentEvents;
documentEvents = jQuery._data(document, 'events');
if (!documentEvents) {
documentEvents = {};
}
ok(documentEvents['ajaxSend'] === undefined, 'there are no ajaxSend listeners setup prior to calling injectTestHelpers');
ok(documentEvents['ajaxComplete'] === undefined, 'there are no ajaxComplete listeners setup prior to calling injectTestHelpers');
run(function() {
setupForTesting();
});
run(function() {
setupForTesting();
});
documentEvents = jQuery._data(document, 'events');
equal(documentEvents['ajaxSend'].length, 1, 'calling injectTestHelpers registers an ajaxSend handler');
equal(documentEvents['ajaxComplete'].length, 1, 'calling injectTestHelpers registers an ajaxComplete handler');
});
test("Ember.Application#injectTestHelpers calls callbacks registered with onInjectHelpers", function() {
var injected = 0;
Test.onInjectHelpers(function() {
injected++;
});
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
equal(injected, 0, 'onInjectHelpers are not called before injectTestHelpers');
App.injectTestHelpers();
equal(injected, 1, 'onInjectHelpers are called after injectTestHelpers');
});
test("Ember.Application#injectTestHelpers adds helpers to provided object.", function() {
var helpers = {};
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers(helpers);
assertHelpers(App, helpers);
App.removeTestHelpers();
assertNoHelpers(App, helpers);
});
test("Ember.Application#removeTestHelpers resets the helperContainer's original values", function() {
var helpers = { visit: 'snazzleflabber' };
run(function() {
App = EmberApplication.create();
App.setupForTesting();
});
App.injectTestHelpers(helpers);
ok(helpers.visit !== 'snazzleflabber', "helper added to container");
App.removeTestHelpers();
ok(helpers.visit === 'snazzleflabber', "original value added back to container");
});
QUnit.module("ember-testing: Helper methods", {
setup: function() {
setupApp();
},
teardown: function() {
cleanup();
}
});
test("`wait` respects registerWaiters", function() {
expect(2);
var counter=0;
function waiter() {
return ++counter > 2;
}
run(App, App.advanceReadiness);
Test.registerWaiter(waiter);
App.testHelpers.wait().then(function() {
equal(waiter(), true, 'should not resolve until our waiter is ready');
Test.unregisterWaiter(waiter);
equal(Test.waiters.length, 0, 'should not leave a waiter registered');
});
});
test("`visit` advances readiness.", function() {
expect(2);
equal(App._readinessDeferrals, 1, "App is in deferred state after setupForTesting.");
App.testHelpers.visit('/').then(function() {
equal(App._readinessDeferrals, 0, "App's readiness was advanced by visit.");
});
});
test("`wait` helper can be passed a resolution value", function() {
expect(4);
var promise, wait;
promise = new RSVP.Promise(function(resolve) {
run(null, resolve, 'promise');
});
run(App, App.advanceReadiness);
wait = App.testHelpers.wait;
wait('text').then(function(val) {
equal(val, 'text', 'can resolve to a string');
return wait(1);
}).then(function(val) {
equal(val, 1, 'can resolve to an integer');
return wait({ age: 10 });
}).then(function(val) {
deepEqual(val, { age: 10 }, 'can resolve to an object');
return wait(promise);
}).then(function(val) {
equal(val, 'promise', 'can resolve to a promise resolution value');
});
});
test("`click` triggers appropriate events in order", function() {
expect(4);
var click, wait, events;
App.IndexView = EmberView.extend({
classNames: 'index-view',
didInsertElement: function() {
this.$().on('mousedown focusin mouseup click', function(e) {
events.push(e.type);
});
},
Checkbox: Ember.Checkbox.extend({
click: function() {
events.push('click:' + this.get('checked'));
},
change: function() {
events.push('change:' + this.get('checked'));
}
})
});
Ember.TEMPLATES.index = compile('{{input type="text"}} {{view view.Checkbox}} {{textarea}}');
run(App, App.advanceReadiness);
click = App.testHelpers.click;
wait = App.testHelpers.wait;
wait().then(function() {
events = [];
return click('.index-view');
}).then(function() {
deepEqual(events,
['mousedown', 'mouseup', 'click'],
'fires events in order');
}).then(function() {
events = [];
return click('.index-view input[type=text]');
}).then(function() {
deepEqual(events,
['mousedown', 'focusin', 'mouseup', 'click'],
'fires focus events on inputs');
}).then(function() {
events = [];
return click('.index-view textarea');
}).then(function() {
deepEqual(events,
['mousedown', 'focusin', 'mouseup', 'click'],
'fires focus events on textareas');
}).then(function() {
// In IE (< 8), the change event only fires when the value changes before element focused.
jQuery('.index-view input[type=checkbox]').focus();
events = [];
return click('.index-view input[type=checkbox]');
}).then(function() {
// i.e. mousedown, mouseup, change:true, click, click:true
// Firefox differs so we can't assert the exact ordering here.
// See https://bugzilla.mozilla.org/show_bug.cgi?id=843554.
equal(events.length, 5, 'fires click and change on checkboxes');
});
});
test("`wait` waits for outstanding timers", function() {
expect(1);
var wait_done = false;
run(App, App.advanceReadiness);
run.later(this, function() {
wait_done = true;
}, 500);
App.testHelpers.wait().then(function() {
equal(wait_done, true, 'should wait for the timer to be fired.');
});
});
test("`wait` respects registerWaiters with optional context", function() {
expect(2);
var obj = {
counter: 0,
ready: function() {
return ++this.counter > 2;
}
};
run(App, App.advanceReadiness);
Test.registerWaiter(obj, obj.ready);
App.testHelpers.wait().then(function() {
equal(obj.ready(), true, 'should not resolve until our waiter is ready');
Test.unregisterWaiter(obj, obj.ready);
equal(Test.waiters.length, 0, 'should not leave a waiter registered');
});
});
test("`triggerEvent accepts an optional options hash without context", function() {
expect(3);
var triggerEvent, wait, event;
App.IndexView = EmberView.extend({
template: compile('{{input type="text" id="scope" class="input"}}'),
didInsertElement: function() {
this.$('.input').on('blur change', function(e) {
event = e;
});
}
});
run(App, App.advanceReadiness);
triggerEvent = App.testHelpers.triggerEvent;
wait = App.testHelpers.wait;
wait().then(function() {
return triggerEvent('.input', 'blur', { keyCode: 13 });
}).then(function() {
equal(event.keyCode, 13, 'options were passed');
equal(event.type, 'blur', 'correct event was triggered');
equal(event.target.getAttribute('id'), 'scope', 'triggered on the correct element');
});
});
test("`triggerEvent can limit searching for a selector to a scope", function() {
expect(2);
var triggerEvent, wait, event;
App.IndexView = EmberView.extend({
template: compile('{{input type="text" id="outside-scope" class="input"}}<div id="limited">{{input type="text" id="inside-scope" class="input"}}</div>'),
didInsertElement: function() {
this.$('.input').on('blur change', function(e) {
event = e;
});
}
});
run(App, App.advanceReadiness);
triggerEvent = App.testHelpers.triggerEvent;
wait = App.testHelpers.wait;
wait().then(function() {
return triggerEvent('.input', '#limited', 'blur');
}).then(function() {
equal(event.type, 'blur', 'correct event was triggered');
equal(event.target.getAttribute('id'), 'inside-scope', 'triggered on the correct element');
});
});
test("`triggerEvent` can be used to trigger arbitrary events", function() {
expect(2);
var triggerEvent, wait, event;
App.IndexView = EmberView.extend({
template: compile('{{input type="text" id="foo"}}'),
didInsertElement: function() {
this.$('#foo').on('blur change', function(e) {
event = e;
});
}
});
run(App, App.advanceReadiness);
triggerEvent = App.testHelpers.triggerEvent;
wait = App.testHelpers.wait;
wait().then(function() {
return triggerEvent('#foo', 'blur');
}).then(function() {
equal(event.type, 'blur', 'correct event was triggered');
equal(event.target.getAttribute('id'), 'foo', 'triggered on the correct element');
});
});
test("`fillIn` takes context into consideration", function() {
expect(2);
var fillIn, find, visit, andThen;
App.IndexView = EmberView.extend({
template: compile('<div id="parent">{{input type="text" id="first" class="current"}}</div>{{input type="text" id="second" class="current"}}')
});
run(App, App.advanceReadiness);
fillIn = App.testHelpers.fillIn;
find = App.testHelpers.find;
visit = App.testHelpers.visit;
andThen = App.testHelpers.andThen;
visit('/');
fillIn('.current', '#parent', 'current value');
andThen(function() {
equal(find('#first').val(), 'current value');
equal(find('#second').val(), '');
});
});
test("`triggerEvent accepts an optional options hash and context", function() {
expect(3);
var triggerEvent, wait, event;
App.IndexView = EmberView.extend({
template: compile('{{input type="text" id="outside-scope" class="input"}}<div id="limited">{{input type="text" id="inside-scope" class="input"}}</div>'),
didInsertElement: function() {
this.$('.input').on('blur change', function(e) {
event = e;
});
}
});
run(App, App.advanceReadiness);
triggerEvent = App.testHelpers.triggerEvent;
wait = App.testHelpers.wait;
wait().then(function() {
return triggerEvent('.input', '#limited', 'blur', { keyCode: 13 });
}).then(function() {
equal(event.keyCode, 13, 'options were passed');
equal(event.type, 'blur', 'correct event was triggered');
equal(event.target.getAttribute('id'), 'inside-scope', 'triggered on the correct element');
});
});
QUnit.module("ember-testing debugging helpers", {
setup: function() {
setupApp();
run(function() {
App.Router = EmberRouter.extend({
location: 'none'
});
});
run(App, 'advanceReadiness');
},
teardown: function() {
cleanup();
}
});
test("pauseTest pauses", function() {
expect(1);
function fakeAdapterAsyncStart() {
ok(true, 'Async start should be called');
}
Test.adapter.asyncStart = fakeAdapterAsyncStart;
App.testHelpers.pauseTest();
});
QUnit.module("ember-testing routing helpers", {
setup: function() {
run(function() {
App = EmberApplication.create();
App.setupForTesting();
App.injectTestHelpers();
App.Router = EmberRouter.extend({
location: 'none'
});
App.Router.map(function() {
this.resource("posts", function() {
this.route("new");
});
});
});
run(App, 'advanceReadiness');
},
teardown: function() {
cleanup();
}
});
test("currentRouteName for '/'", function() {
expect(3);
App.testHelpers.visit('/').then(function() {
equal(App.testHelpers.currentRouteName(), 'index', "should equal 'index'.");
equal(App.testHelpers.currentPath(), 'index', "should equal 'index'.");
equal(App.testHelpers.currentURL(), '/', "should equal '/'.");
});
});
test("currentRouteName for '/posts'", function() {
expect(3);
App.testHelpers.visit('/posts').then(function() {
equal(App.testHelpers.currentRouteName(), 'posts.index', "should equal 'posts.index'.");
equal(App.testHelpers.currentPath(), 'posts.index', "should equal 'posts.index'.");
equal(App.testHelpers.currentURL(), '/posts', "should equal '/posts'.");
});
});
test("currentRouteName for '/posts/new'", function() {
expect(3);
App.testHelpers.visit('/posts/new').then(function() {
equal(App.testHelpers.currentRouteName(), 'posts.new', "should equal 'posts.new'.");
equal(App.testHelpers.currentPath(), 'posts.new', "should equal 'posts.new'.");
equal(App.testHelpers.currentURL(), '/posts/new', "should equal '/posts/new'.");
});
});
QUnit.module("ember-testing pendingAjaxRequests", {
setup: function() {
setupApp();
},
teardown: function() {
cleanup();
}
});
test("pendingAjaxRequests is maintained for ajaxSend and ajaxComplete events", function() {
equal(Test.pendingAjaxRequests, 0);
var xhr = { some: 'xhr' };
jQuery(document).trigger('ajaxSend', xhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
jQuery(document).trigger('ajaxComplete', xhr);
equal(Test.pendingAjaxRequests, 0, 'Ember.Test.pendingAjaxRequests was decremented');
});
test("pendingAjaxRequests is ignores ajaxComplete events from past setupForTesting calls", function() {
equal(Test.pendingAjaxRequests, 0);
var xhr = { some: 'xhr' };
jQuery(document).trigger('ajaxSend', xhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
run(function() {
setupForTesting();
});
equal(Test.pendingAjaxRequests, 0, 'Ember.Test.pendingAjaxRequests was reset');
var altXhr = { some: 'more xhr' };
jQuery(document).trigger('ajaxSend', altXhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
jQuery(document).trigger('ajaxComplete', xhr);
equal(Test.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests is not impressed with your unexpected complete');
});
test("pendingAjaxRequests is reset by setupForTesting", function() {
Test.pendingAjaxRequests = 1;
run(function() {
setupForTesting();
});
equal(Test.pendingAjaxRequests, 0, 'pendingAjaxRequests is reset');
});
QUnit.module("ember-testing async router", {
setup: function() {
cleanup();
run(function() {
App = EmberApplication.create();
App.Router = EmberRouter.extend({
location: 'none'
});
App.Router.map(function() {
this.resource("user", function() {
this.route("profile");
this.route("edit");
});
});
App.UserRoute = EmberRoute.extend({
model: function() {
return resolveLater();
}
});
App.UserProfileRoute = EmberRoute.extend({
beforeModel: function() {
var self = this;
return resolveLater().then(function() {
self.transitionTo('user.edit');
});
}
});
// Emulates a long-running unscheduled async operation.
function resolveLater() {
var promise;
run(function() {
promise = new RSVP.Promise(function(resolve) {
// The wait() helper has a 10ms tick. We should resolve() after at least one tick
// to test whether wait() held off while the async router was still loading. 20ms
// should be enough.
setTimeout(function() {
run(function() {
resolve(EmberObject.create({ firstName: 'Tom' }));
});
}, 20);
});
});
return promise;
}
App.setupForTesting();
});
App.injectTestHelpers();
run(App, 'advanceReadiness');
},
teardown: function() {
cleanup();
}
});
test("currentRouteName for '/user'", function() {
expect(4);
App.testHelpers.visit('/user').then(function() {
equal(currentRouteName(App), 'user.index', "should equal 'user.index'.");
equal(currentPath(App), 'user.index', "should equal 'user.index'.");
equal(currentURL(App), '/user', "should equal '/user'.");
equal(App.__container__.lookup('route:user').get('controller.model.firstName'), 'Tom', "should equal 'Tom'.");
});
});
test("currentRouteName for '/user/profile'", function() {
expect(4);
App.testHelpers.visit('/user/profile').then(function() {
equal(currentRouteName(App), 'user.edit', "should equal 'user.edit'.");
equal(currentPath(App), 'user.edit', "should equal 'user.edit'.");
equal(currentURL(App), '/user/edit', "should equal '/user/edit'.");
equal(App.__container__.lookup('route:user').get('controller.model.firstName'), 'Tom', "should equal 'Tom'.");
});
});
var originalVisitHelper, originalFindHelper, originalWaitHelper;
QUnit.module('can override built-in helpers', {
setup: function() {
originalVisitHelper = Test._helpers.visit;
originalFindHelper = Test._helpers.find;
originalWaitHelper = Test._helpers.wait;
jQuery('<style>#ember-testing-container { position: absolute; background: white; bottom: 0; right: 0; width: 640px; height: 384px; overflow: auto; z-index: 9999; border: 1px solid #ccc; } #ember-testing { zoom: 50%; }</style>').appendTo('head');
jQuery('<div id="ember-testing-container"><div id="ember-testing"></div></div>').appendTo('body');
run(function() {
App = Ember.Application.create({
rootElement: '#ember-testing'
});
App.setupForTesting();
});
},
teardown: function() {
App.removeTestHelpers();
jQuery('#ember-testing-container, #ember-testing').remove();
run(App, App.destroy);
App = null;
Test._helpers.visit = originalVisitHelper;
Test._helpers.find = originalFindHelper;
Test._helpers.wait = originalWaitHelper;
}
});
test("can override visit helper", function() {
expect(1);
Test.registerHelper('visit', function() {
ok(true, 'custom visit helper was called');
});
App.injectTestHelpers();
App.testHelpers.visit();
});
test("can override find helper", function() {
expect(1);
Test.registerHelper('find', function() {
ok(true, 'custom find helper was called');
return ['not empty array'];
});
App.injectTestHelpers();
App.testHelpers.findWithAssert('.who-cares');
});
|
$(document).ready(function(){
var grid = document.querySelectorAll('.grid');
var solveButton = document.querySelector('#solveAll');
var simpleSolveButton = document.querySelector('#simpleSolve');
var hiddenSinglesButton = document.querySelector('#hiddenSingles');
var reset = document.querySelector('#resetBoard');
var validate = document.querySelector('#validate');
var difficulty = document.querySelector('#difficulty');
var preset = document.querySelector('#preset');
$('#20, #21, #22, #23, #24, #25, #26, #27, #28, #50, #51, #52, #53, #54, #55, #56, #57,#58').css('border-right', '1px solid #FF931E');
$('#30, #31, #32, #33, #34, #35, #36, #37, #38, #60, #61, #62, #63, #64, #65, #66, #67,#68').css('border-left', '1px solid #FF931E');
$('#02, #12, #22, #32, #42, #52, #62, #72, #82, #05, #15, #25, #35, #45, #55, #65, #75, #85').css('border-bottom', '1px solid #FF931E');
$('#03, #13, #23, #33, #43, #53, #63, #73, #83, #06, #16, #26, #36, #46, #56, #66, #76, #86').css('border-top', '1px solid #FF931E');
if (!!window.Worker) {
//initialize the worker and page
var solver = new Worker("solver.js");
calculateRelations();
loadBoard();
$('.grid').keyup(function(){
solver.postMessage(['setCellValue', '#'+this.id, this.value]);
});
$('#possible').click(function(){
$('#possibleBoard').toggle(0);
});
/* The big red button */
solveButton.onclick = function() {
solver.postMessage(['tryFullSolve']);
}
simpleSolveButton.onclick = function() {
solver.postMessage(['simpleSolve']);
}
hiddenSinglesButton.onclick = function() {
solver.postMessage(['hiddenSingles']);
}
/* Reset and Load New */
reset.onclick = function(){
solver.postMessage(['resetBoard']);
}
preset.onclick = function(){
loadBoard()
}
difficulty.onchange = function(){
loadBoard();
}
/* Validate */
validate.onclick = function(){
solver.postMessage(['checkSolution']);
}
/*
* Process results from solver
*/
solver.onmessage = function(e) {
// e.data = [action, dataarray]
response = e.data;
if(response[0] === 'updateCellDom'){
cellinfo = response[1];
cellDom = document.getElementById(cellinfo[0]);
cellVal = cellinfo[1];
cellClass = cellinfo[2];
cellDom.value = cellVal;
cellDom.className = 'grid '+cellClass;
//destroy variables
delete(cellinfo);
delete(cellDom);
delete(cellClass);
delete(cellVal);
}
else if(response[0] === 'logMessage'){
msg = "<p>"+ response[1] +"</p>";
log = $('#log').html();
$('#log').html(msg+=log);
}
else if(response[0] === 'updatePossibleOverlay'){
cellinfo = response[1];
cellposid = cellinfo[0];
cellpos = cellinfo[1];
$(cellposid).html(cellpos);
}
else{
alert(e.data);
}
}
}
/*
* Loop over all cells in idlist and generate
* relationships based on axis, this is supplied
* to the solver
*/
function calculateRelations() {
var timerStart = new Date().getMilliseconds();
cellids = ['#00', '#10', '#20', '#30', '#40', '#50', '#60', '#70', '#80', '#01', '#11', '#21', '#31', '#41', '#51', '#61', '#71', '#81', '#02', '#12', '#22', '#32', '#42', '#52', '#62', '#72', '#82', '#03', '#13', '#23', '#33', '#43', '#53', '#63', '#73', '#83', '#04', '#14', '#24', '#34', '#44', '#54', '#64', '#74', '#84', '#05', '#15', '#25', '#35', '#45', '#55', '#65', '#75', '#85', '#06', '#16', '#26', '#36', '#46', '#56', '#66', '#76', '#86', '#07', '#17', '#27', '#37', '#47', '#57', '#67', '#77', '#87', '#08', '#18', '#28', '#38', '#48', '#58', '#68', '#78', '#88'];
relatedCellsX = [];
relatedCellsY = [];
relatedCellsC = [];
for (i = 0; i < cellids.length; i++) {
var cellid = cellids[i];
//hassh is cellid[0]
var x = cellid[1];
var y = cellid[2];
var c = $(cellid).data('cluster');
//related by x
var relatedByX = [];
$('.x' + x).each(function() {
var tmpid = '#' + $(this).attr('id');
if (tmpid === cellid) {
//skip
} else {
//add
relatedByX.push('#' + $(this).attr('id'));
}
});
var relatedByY = [];
$('.y' + y).each(function() {
var tmpid = '#' + $(this).attr('id');
if (tmpid === cellid) {
//skip
} else {
//add
relatedByY.push('#' + $(this).attr('id'));
}
});
var relatedByC = [];
$('.c' + c).each(function() {
var tmpid = '#' + $(this).attr('id');
if (tmpid === cellid) {
//skip
} else {
//add
relatedByC.push('#' + $(this).attr('id'));
}
});
//attach relations by axis to array by key
relatedCellsX[cellid] = relatedByX;
relatedCellsY[cellid] = relatedByY;
relatedCellsC[cellid] = relatedByC;
}
//report ttc
var timerElapsed = new Date().getMilliseconds() - timerStart;
//post to worker
message = ['setRelated', relatedCellsX, relatedCellsY, relatedCellsC];
solver.postMessage(message);
console.log('Generated relations in ' + timerElapsed + "ms. Sent to worker.");
delete(cellids);
delete(relatedCellsX);
delete(relatedCellsY);
delete(relatedCellsC);
}
function loadBoard(){
message = ['loadBoard', difficulty.value];
solver.postMessage(message);
console.log('Loading '+difficulty.value+' board.');
}
});
|
import test from 'ava';
import nightmare from 'nightmare';
import cleanstyle from '../../helpers/cleanstyle';
import common from '../../helpers/common';
const runner = nightmare({
show : false
});
let tagName = 'dropdown';
let docUrl = common.getE2eDocUrl(tagName);
let basicDemo = `[name="开始"] mor-${tagName}`;
let context = {
tagName,
basicDemo,
common
};
test.serial('basic style', async t => {
const result = await runner
.goto(docUrl)
.wait(basicDemo)
.evaluate(
eval(`(${common.e2eBasicFnString})`),
context
);
t.plan(1);
cleanstyle(result.style);
// cause : circleci use other webkit.
delete result.style.inlineSize;
delete result.style.perspectiveOrigin;
delete result.style.webkitLogicalWidth;
delete result.style.width;
t.snapshot(result);
});
|
(function(){
angular
.module('reansQuest')
.controller('ReansQuestController', [
'$mdSidenav', '$mdBottomSheet', '$log', '$q', 'questsService',
'$mdDialog', 'Quest', '$location',
ReansQuestController
]);
/**
* Main Controller for the Angular Material Starter App
* @param $scope
* @param $mdSidenav
* @param avatarsService
* @constructor
*/
function ReansQuestController( $mdSidenav, $mdBottomSheet, $log, $q, questsService,
$mdDialog, Quest, $location) {
var self = this;
// debugger;
self.selected = null;
self.quests = [ ];
self.selectQuest = selectQuest;
self.toggleList = toggleQuestsList;
self.showContactOptions = showContactOptions;
self.setAnswer = setAnswer;
self.isLastQuest = function(quest) {
return !!quest && quest.order == self.quests.length;
}
self.hasAnswer = function(quest){
return !!quest && !!Quest.answers && Quest.answers[quest.order-1] == null;
}
self.getAnswer = function(quest){
return !!quest && !!Quest.answers ? Quest.answers[quest.order-1] : null;
}
self.processAnswers = function () {
// debugger;
// dialogService.hide();
$location.path('/process-answers')
};
if(!Quest.quests){
startQuest($mdDialog)
.then(function(action){
// debugger;
Quest.initialize()
.then(function(){
self.quests = Quest.quests;
self.selected = Quest.quests[0];
});
});
};
// *********************************
// Internal methods
// *********************************
/**
* First hide the bottomsheet IF visible, then
* hide or Show the 'left' sideNav area
*/
function toggleQuestsList() {
var pending = $mdBottomSheet.hide() || $q.when(true);
pending.then(function(){
$mdSidenav('left').toggle();
});
}
/**
* Select the current avatars
* @param menuId
*/
function selectQuest ( quest ) {
// debugger;
self.selected = angular.isNumber(quest) ? self.quests[quest-1] : quest;
// self.toggleList();
// if (self.selected.)
}
function startQuest(dialogService){
return dialogService.show({
templateUrl: 'src/reans-quest/view/questStartDialog.html',
parent: angular.element(document.body),
// parent: angular.element(document.querySelector('#popupContainer')),
// templateUrl: 'src/reans-quest/view/questStartBottomSheet.html',
// parent: angular.element(document.getElementById('content')),
clickOutsideToClose:false,
escapeToClose: false,
disableParentScroll: false,
fullscreen: false,
controllerAs: 'dCtrl',
controller: function($scope){
this.goTest = function () {
// debugger;
dialogService.hide();
}
}
});
};
function showEndQuest(dialogService){
dialogService.show({
templateUrl: 'src/reans-quest/view/questEndDialog.html',
parent: angular.element(document.body),
// templateUrl: 'src/reans-quest/view/questEndBottomSheet.html',
// parent: angular.element(document.getElementById('content')),
clickOutsideToClose:true,
escapeToClose: false,
disableParentScroll: false,
fullscreen: false,
controllerAs: 'dCtrl',
controller: function($scope, $location){
this.processAnswers = function () {
// debugger;
// dialogService.hide();
$location.path('/process-answers')
};
this.goQuests = function () {
// debugger;
dialogService.hide();
};
}
});
};
function processAnswers(answers){
var testKeys = [1,1,1,0,0,1,0,1,0,1,1,1,0,1,0,1,0,1,1,1];
return answers.reduce(function(prev, curr, idx, arr){
return prev + (curr === testKeys[idx] ? 1 : 0);
},0);
};
function setAnswer(quest, answer){
if (!!quest){
// self.selected.answer = answer;
Quest.answers[quest.order-1] = answer;
};
var answerCount = Quest.answers.length;
self.mustProcessAnswers = answerCount == Quest.answers.filter(function(q){return ((q != null)); }).length;
console.log(Quest.answers.join(','));
}
/**
* Show the bottom sheet
*/
function showContactOptions($event) {
var user = self.selected;
return $mdBottomSheet.show({
// parent: angular.element(document.getElementById('content')),
parent: angular.element(document.querySelector('#popupContainer')),
templateUrl: './src/reans-quest/view/contactSheet.html',
controller: [ '$mdBottomSheet', 'questsService', ContactPanelController],
controllerAs: "cp",
bindToController : true,
targetEvent: $event
}).then(function(clickedItem) {
clickedItem && $log.debug( clickedItem.name + ' clicked!');
});
/**
* Bottom Sheet controller for the Avatar Actions
*/
function ContactPanelController( $mdBottomSheet, questsService ) {
var self = this;
this.user = user;
this.actions = [
{ name: 'Phone' , icon: 'phone' , icon_url: 'assets/svg/phone.svg'},
{ name: 'Twitter' , icon: 'twitter' , icon_url: 'assets/svg/twitter.svg'},
{ name: 'Google+' , icon: 'google_plus' , icon_url: 'assets/svg/google_plus.svg'},
{ name: 'Hangout' , icon: 'hangouts' , icon_url: 'assets/svg/hangouts.svg'}
];
this.submitContact = function(action) {
$mdBottomSheet.hide(action);
};
questsService
.getQuestDescription()
.then(function( qDescr ){
// self.questDescription = qDescr;
});
}
}
}
})();
|
// Copyright (c) 2015 - 2019 Uber Technologies, Inc.
//
// 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.
import test from 'tape-catch';
import {formatValue} from '@luma.gl/webgl/utils/format-value';
const FORMAT_VALUE_TEST_CASES = [
{
value: 10.1,
opts: {isInteger: true},
result: '10'
},
{
value: 10.99,
opts: {isInteger: true},
result: '11'
},
{
value: 100.5,
result: '101'
},
{
value: 100.49,
result: '100'
},
{
value: 'non-finite',
result: 'non-finite'
},
{
value: 1e-17,
result: '0.'
},
{
value: 1e-17,
opts: {isInteger: true},
result: '0'
},
{
value: 1e-16,
result: '1.0e-16'
},
{
value: 1e-16,
opts: {isInteger: true},
result: '0'
},
{
value: [1, 2, 3],
opts: {isInteger: true},
result: '[1, 2, 3]'
},
{
value: [1, 2, 3],
opts: {size: 0},
result: '[1.,2.,3.]'
}
];
test('formatValue', t => {
FORMAT_VALUE_TEST_CASES.forEach(tc => {
t.equal(formatValue(tc.value, tc.opts), tc.result);
});
t.end();
});
|
/**
* @licstart The following is the entire license notice for the
* Javascript code in this page
*
* Copyright 2021 Mozilla Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* @licend The above is the entire license notice for the
* Javascript code in this page
*/
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.addLinkAttributes = addLinkAttributes;
exports.deprecated = deprecated;
exports.getFilenameFromUrl = getFilenameFromUrl;
exports.getPdfFilenameFromUrl = getPdfFilenameFromUrl;
exports.isDataScheme = isDataScheme;
exports.isFetchSupported = isFetchSupported;
exports.isPdfFile = isPdfFile;
exports.isValidFetchUrl = isValidFetchUrl;
exports.loadScript = loadScript;
exports.StatTimer = exports.RenderingCancelledException = exports.PDFDateString = exports.PageViewport = exports.LinkTarget = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.BaseCMapReaderFactory = exports.BaseCanvasFactory = void 0;
var _util = require("../shared/util.js");
const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
const SVG_NS = "http://www.w3.org/2000/svg";
class BaseCanvasFactory {
constructor() {
if (this.constructor === BaseCanvasFactory) {
(0, _util.unreachable)("Cannot initialize BaseCanvasFactory.");
}
}
create(width, height) {
(0, _util.unreachable)("Abstract method `create` called.");
}
reset(canvasAndContext, width, height) {
if (!canvasAndContext.canvas) {
throw new Error("Canvas is not specified");
}
if (width <= 0 || height <= 0) {
throw new Error("Invalid canvas size");
}
canvasAndContext.canvas.width = width;
canvasAndContext.canvas.height = height;
}
destroy(canvasAndContext) {
if (!canvasAndContext.canvas) {
throw new Error("Canvas is not specified");
}
canvasAndContext.canvas.width = 0;
canvasAndContext.canvas.height = 0;
canvasAndContext.canvas = null;
canvasAndContext.context = null;
}
}
exports.BaseCanvasFactory = BaseCanvasFactory;
class DOMCanvasFactory extends BaseCanvasFactory {
constructor({
ownerDocument = globalThis.document
} = {}) {
super();
this._document = ownerDocument;
}
create(width, height) {
if (width <= 0 || height <= 0) {
throw new Error("Invalid canvas size");
}
const canvas = this._document.createElement("canvas");
const context = canvas.getContext("2d");
canvas.width = width;
canvas.height = height;
return {
canvas,
context
};
}
}
exports.DOMCanvasFactory = DOMCanvasFactory;
class BaseCMapReaderFactory {
constructor({
baseUrl = null,
isCompressed = false
}) {
if (this.constructor === BaseCMapReaderFactory) {
(0, _util.unreachable)("Cannot initialize BaseCMapReaderFactory.");
}
this.baseUrl = baseUrl;
this.isCompressed = isCompressed;
}
async fetch({
name
}) {
if (!this.baseUrl) {
throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
}
if (!name) {
throw new Error("CMap name must be specified.");
}
const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
return this._fetchData(url, compressionType).catch(reason => {
throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}CMap at: ${url}`);
});
}
_fetchData(url, compressionType) {
(0, _util.unreachable)("Abstract method `_fetchData` called.");
}
}
exports.BaseCMapReaderFactory = BaseCMapReaderFactory;
class DOMCMapReaderFactory extends BaseCMapReaderFactory {
_fetchData(url, compressionType) {
if (isFetchSupported() && isValidFetchUrl(url, document.baseURI)) {
return fetch(url).then(async response => {
if (!response.ok) {
throw new Error(response.statusText);
}
let cMapData;
if (this.isCompressed) {
cMapData = new Uint8Array(await response.arrayBuffer());
} else {
cMapData = (0, _util.stringToBytes)(await response.text());
}
return {
cMapData,
compressionType
};
});
}
return new Promise((resolve, reject) => {
const request = new XMLHttpRequest();
request.open("GET", url, true);
if (this.isCompressed) {
request.responseType = "arraybuffer";
}
request.onreadystatechange = () => {
if (request.readyState !== XMLHttpRequest.DONE) {
return;
}
if (request.status === 200 || request.status === 0) {
let cMapData;
if (this.isCompressed && request.response) {
cMapData = new Uint8Array(request.response);
} else if (!this.isCompressed && request.responseText) {
cMapData = (0, _util.stringToBytes)(request.responseText);
}
if (cMapData) {
resolve({
cMapData,
compressionType
});
return;
}
}
reject(new Error(request.statusText));
};
request.send(null);
});
}
}
exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
class DOMSVGFactory {
create(width, height) {
(0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions");
const svg = document.createElementNS(SVG_NS, "svg:svg");
svg.setAttribute("version", "1.1");
svg.setAttribute("width", width + "px");
svg.setAttribute("height", height + "px");
svg.setAttribute("preserveAspectRatio", "none");
svg.setAttribute("viewBox", "0 0 " + width + " " + height);
return svg;
}
createElement(type) {
(0, _util.assert)(typeof type === "string", "Invalid SVG element type");
return document.createElementNS(SVG_NS, type);
}
}
exports.DOMSVGFactory = DOMSVGFactory;
class PageViewport {
constructor({
viewBox,
scale,
rotation,
offsetX = 0,
offsetY = 0,
dontFlip = false
}) {
this.viewBox = viewBox;
this.scale = scale;
this.rotation = rotation;
this.offsetX = offsetX;
this.offsetY = offsetY;
const centerX = (viewBox[2] + viewBox[0]) / 2;
const centerY = (viewBox[3] + viewBox[1]) / 2;
let rotateA, rotateB, rotateC, rotateD;
rotation %= 360;
if (rotation < 0) {
rotation += 360;
}
switch (rotation) {
case 180:
rotateA = -1;
rotateB = 0;
rotateC = 0;
rotateD = 1;
break;
case 90:
rotateA = 0;
rotateB = 1;
rotateC = 1;
rotateD = 0;
break;
case 270:
rotateA = 0;
rotateB = -1;
rotateC = -1;
rotateD = 0;
break;
case 0:
rotateA = 1;
rotateB = 0;
rotateC = 0;
rotateD = -1;
break;
default:
throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.");
}
if (dontFlip) {
rotateC = -rotateC;
rotateD = -rotateD;
}
let offsetCanvasX, offsetCanvasY;
let width, height;
if (rotateA === 0) {
offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
width = Math.abs(viewBox[3] - viewBox[1]) * scale;
height = Math.abs(viewBox[2] - viewBox[0]) * scale;
} else {
offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
width = Math.abs(viewBox[2] - viewBox[0]) * scale;
height = Math.abs(viewBox[3] - viewBox[1]) * scale;
}
this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
this.width = width;
this.height = height;
}
clone({
scale = this.scale,
rotation = this.rotation,
offsetX = this.offsetX,
offsetY = this.offsetY,
dontFlip = false
} = {}) {
return new PageViewport({
viewBox: this.viewBox.slice(),
scale,
rotation,
offsetX,
offsetY,
dontFlip
});
}
convertToViewportPoint(x, y) {
return _util.Util.applyTransform([x, y], this.transform);
}
convertToViewportRectangle(rect) {
const topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
const bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
}
convertToPdfPoint(x, y) {
return _util.Util.applyInverseTransform([x, y], this.transform);
}
}
exports.PageViewport = PageViewport;
class RenderingCancelledException extends _util.BaseException {
constructor(msg, type) {
super(msg);
this.type = type;
}
}
exports.RenderingCancelledException = RenderingCancelledException;
const LinkTarget = {
NONE: 0,
SELF: 1,
BLANK: 2,
PARENT: 3,
TOP: 4
};
exports.LinkTarget = LinkTarget;
function addLinkAttributes(link, {
url,
target,
rel,
enabled = true
} = {}) {
(0, _util.assert)(url && typeof url === "string", 'addLinkAttributes: A valid "url" parameter must provided.');
const urlNullRemoved = (0, _util.removeNullCharacters)(url);
if (enabled) {
link.href = link.title = urlNullRemoved;
} else {
link.href = "";
link.title = `Disabled: ${urlNullRemoved}`;
link.onclick = () => {
return false;
};
}
let targetStr = "";
switch (target) {
case LinkTarget.NONE:
break;
case LinkTarget.SELF:
targetStr = "_self";
break;
case LinkTarget.BLANK:
targetStr = "_blank";
break;
case LinkTarget.PARENT:
targetStr = "_parent";
break;
case LinkTarget.TOP:
targetStr = "_top";
break;
}
link.target = targetStr;
link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
}
function isDataScheme(url) {
const ii = url.length;
let i = 0;
while (i < ii && url[i].trim() === "") {
i++;
}
return url.substring(i, i + 5).toLowerCase() === "data:";
}
function isPdfFile(filename) {
return typeof filename === "string" && /\.pdf$/i.test(filename);
}
function getFilenameFromUrl(url) {
const anchor = url.indexOf("#");
const query = url.indexOf("?");
const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
return url.substring(url.lastIndexOf("/", end) + 1, end);
}
function getPdfFilenameFromUrl(url, defaultFilename = "document.pdf") {
if (typeof url !== "string") {
return defaultFilename;
}
if (isDataScheme(url)) {
(0, _util.warn)('getPdfFilenameFromUrl: ignore "data:"-URL for performance reasons.');
return defaultFilename;
}
const reURI = /^(?:(?:[^:]+:)?\/\/[^/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
const splitURI = reURI.exec(url);
let suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
if (suggestedFilename) {
suggestedFilename = suggestedFilename[0];
if (suggestedFilename.includes("%")) {
try {
suggestedFilename = reFilename.exec(decodeURIComponent(suggestedFilename))[0];
} catch (ex) {}
}
}
return suggestedFilename || defaultFilename;
}
class StatTimer {
constructor() {
this.started = Object.create(null);
this.times = [];
}
time(name) {
if (name in this.started) {
(0, _util.warn)(`Timer is already running for ${name}`);
}
this.started[name] = Date.now();
}
timeEnd(name) {
if (!(name in this.started)) {
(0, _util.warn)(`Timer has not been started for ${name}`);
}
this.times.push({
name,
start: this.started[name],
end: Date.now()
});
delete this.started[name];
}
toString() {
const outBuf = [];
let longest = 0;
for (const time of this.times) {
const name = time.name;
if (name.length > longest) {
longest = name.length;
}
}
for (const time of this.times) {
const duration = time.end - time.start;
outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\n`);
}
return outBuf.join("");
}
}
exports.StatTimer = StatTimer;
function isFetchSupported() {
return typeof fetch !== "undefined" && typeof Response !== "undefined" && "body" in Response.prototype && typeof ReadableStream !== "undefined";
}
function isValidFetchUrl(url, baseUrl) {
try {
const {
protocol
} = baseUrl ? new URL(url, baseUrl) : new URL(url);
return protocol === "http:" || protocol === "https:";
} catch (ex) {
return false;
}
}
function loadScript(src, removeScriptElement = false) {
return new Promise((resolve, reject) => {
const script = document.createElement("script");
script.src = src;
script.onload = function (evt) {
if (removeScriptElement) {
script.remove();
}
resolve(evt);
};
script.onerror = function () {
reject(new Error(`Cannot load script at: ${script.src}`));
};
(document.head || document.documentElement).appendChild(script);
});
}
function deprecated(details) {
console.log("Deprecated API usage: " + details);
}
let pdfDateStringRegex;
class PDFDateString {
static toDateObject(input) {
if (!input || !(0, _util.isString)(input)) {
return null;
}
if (!pdfDateStringRegex) {
pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?");
}
const matches = pdfDateStringRegex.exec(input);
if (!matches) {
return null;
}
const year = parseInt(matches[1], 10);
let month = parseInt(matches[2], 10);
month = month >= 1 && month <= 12 ? month - 1 : 0;
let day = parseInt(matches[3], 10);
day = day >= 1 && day <= 31 ? day : 1;
let hour = parseInt(matches[4], 10);
hour = hour >= 0 && hour <= 23 ? hour : 0;
let minute = parseInt(matches[5], 10);
minute = minute >= 0 && minute <= 59 ? minute : 0;
let second = parseInt(matches[6], 10);
second = second >= 0 && second <= 59 ? second : 0;
const universalTimeRelation = matches[7] || "Z";
let offsetHour = parseInt(matches[8], 10);
offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
let offsetMinute = parseInt(matches[9], 10) || 0;
offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
if (universalTimeRelation === "-") {
hour += offsetHour;
minute += offsetMinute;
} else if (universalTimeRelation === "+") {
hour -= offsetHour;
minute -= offsetMinute;
}
return new Date(Date.UTC(year, month, day, hour, minute, second));
}
}
exports.PDFDateString = PDFDateString; |
import { w as warn, F as extractModule, W as WidgetBehavior, i as isEqual, d as deepQueryAll } from './index-ad816ab3.js';
const VALIDATORS = {
email: (val) => extractModule(import('./index-121a3ddd.js').then(function (n) { return n.i; }))
.then(validator => !val || validator.validate(val)),
maxlength: (val, option) => val == null || val.length <= Number(option),
minlength: (val, option) => val == null || val.length >= Number(option),
required: (val) => {
switch (typeof val) {
case 'string':
return val.length > 0;
case 'number':
return !Number.isNaN(val);
case 'boolean':
return true;
default:
return val != null;
}
},
};
function checkErrors(data, checks) {
const names = Object.keys(checks);
const errors = {};
Object.keys(data)
.forEach(name => {
const value = data[name];
if (typeof value === 'object' && value.$errors) {
errors[name] = value.$errors;
}
});
return Promise.all(
names
.map(name => {
const validators = checks[name];
if (!validators) return true;
const checkNames = Object.keys(validators);
return Promise.all(checkNames
.map(check => {
const options = validators[check];
const validator = VALIDATORS[check];
// validator(data[name], options).then(result => {
// console.log('validation', name, options, result);
// });
// if it's a custom validator method
if (typeof options === 'function') {
return options(data[name]);
} else {
if (!validator) {
warn('unknown validator', check);
return true;
}
return validator(data[name], options);
}
}))
.then(results => {
const valid = results.every(r => r);
// tell there is no error on prop
if (valid) {
// console.log('valid field', name, results);
return false;
}
// console.log('invalid field', name);
return checkNames.reduce((map, check, i) => {
if (!results[i]) {
map[check] = true;
}
return map;
}, {});
});
})
).then(results => {
return names.reduce((map, name, i) => {
if (results[i]) {
map[name] = results[i];
}
return map;
}, errors);
}).then(() => {
const valid = !Object.keys(errors).length;
if (valid) return false;
return errors;
});
}
/**
* @copyright https://github.com/hyperatom
* @url https://github.com/hyperatom/json-form-data
*/
function mergeObjects(object1, object2) {
return [object1, object2].reduce(function (carry, objectToMerge) {
Object.keys(objectToMerge).forEach(function (objectKey) {
carry[objectKey] = objectToMerge[objectKey];
});
return carry;
}, {});
}
function isArray(val) {
return ({}).toString.call(val) === '[object Array]';
}
function isJsonObject(val) {
return !isArray(val) && typeof val === 'object' && !!val && !(val instanceof Blob) && !(val instanceof Date);
}
function isAppendFunctionPresent(formData) {
return typeof formData.append === 'function';
}
function isGlobalFormDataPresent() {
return typeof FormData === 'function';
}
function getDefaultFormData() {
if (isGlobalFormDataPresent()) {
return new FormData();
}
}
function convert(jsonObject, options) {
if (options && options.initialFormData) {
if (!isAppendFunctionPresent(options.initialFormData)) {
throw 'initialFormData must have an append function.';
}
} else if (!isGlobalFormDataPresent()) {
throw 'This environment does not have global form data. options.initialFormData must be specified.';
}
let defaultOptions = {
initialFormData: getDefaultFormData(),
showLeafArrayIndexes: true,
includeNullValues: false,
mapping: function (value) {
if (typeof value === 'boolean') {
return +value ? '1' : '0';
}
return value;
}
};
let mergedOptions = mergeObjects(defaultOptions, options || {});
return convertRecursively(jsonObject, mergedOptions, mergedOptions.initialFormData);
}
function convertRecursively(jsonObject, options, formData, parentKey) {
let index = 0;
for (let key in jsonObject) {
if (jsonObject.hasOwnProperty(key)) {
let propName = parentKey || key;
let value = options.mapping(jsonObject[key]);
if (parentKey && isJsonObject(jsonObject)) {
propName = parentKey + '[' + key + ']';
}
if (parentKey && isArray(jsonObject)) {
if (isArray(value) || options.showLeafArrayIndexes) {
propName = parentKey + '[' + index + ']';
} else {
propName = parentKey + '[]';
}
}
if (isArray(value) || isJsonObject(value)) {
convertRecursively(value, options, formData, propName);
} else if (value instanceof FileList) {
for (let j = 0; j < value.length; j++) {
formData.append(propName + '[' + j + ']', value.item(j));
}
} else if (value instanceof Blob) {
formData.append(propName, value, value.name);
} else if (value instanceof Date) {
formData.append(propName, value.toISOString());
} else if (((value === null && options.includeNullValues) || value !== null) && value !== undefined) {
formData.append(propName, value);
}
}
index++;
}
return formData;
}
/**
* Behavior to handle form logic.
* Value of the form is actually DATA and can only be set by element property.
*/
class FormBehavior extends WidgetBehavior {
static get params() {
return {
input: true,
primary: true,
provideValue: false,
contextValue: false,
};
}
init() {
this.value = {};
this.validators = {};
this.checks = {};
this.fields = {};
super.init();
const { host } = this;
host.nuSetMod('form', true);
if (!this.value) {
this.value = {};
}
this.setContext('form', this);
this.context.value = null;
this.on('nu-change', (event) => {
const field = event.detail;
if (this.fields[field]) {
this.verifyData(field);
}
});
this.provideAction('submit', () => {
this.verifyData()
.then(valid => {
if (valid) {
this.emit('input', this.type === 'formdata'
? convert(this.value) : { ...(this.value || {}) });
this.control();
}
});
});
}
verifyData(field) {
return (!field ? this.setDirty() : Promise.resolve())
.then(() => this.validate())
.then(valid => {
this.setErrorProps(field);
return valid;
});
}
connected() {
super.connected();
setTimeout(() => this.validate(true));
}
setValue(value, silent) {
if (typeof value !== 'object') return;
const serializedValue = JSON.stringify(value);
if (JSON.stringify(value) === this._serializedValue || !value) return;
this._serializedValue = serializedValue;
this.value = value;
if (!silent) {
this.validate()
.then(valid => {
if (valid) {
this.emit('input', this.value);
}
});
}
this.control();
}
setFieldValue(name, value) {
const { fields } = this;
if (isEqual(this.value[name], value)) return;
if (value != null) {
this.value[name] = value;
if (fields[name]) {
// remove warnings if user changes data
this.resetFieldWarning(name);
}
} else {
delete this.value[name];
}
this.validate();
}
registerCheck(field, element, name, value) {
if (!this.validators[field]) {
this.validators[field] = {};
}
if (!this.checks[field]) {
this.checks[field] = {};
}
this.validators[field][name] = value;
this.checks[field][name] = element;
}
registerField(name, el) {
this.fields[name] = el;
}
unregisterCheck(field, name) {
if (this.validators[field]) {
delete this.validators[field][name];
}
if (this.checks[field]) {
delete this.checks[field][name];
}
}
unregisterField(name) {
delete this.fields[name];
}
connectForm() {
super.connectForm();
const validators = this.validators;
this.validators = Object.create(this.form.validators);
Object.keys(validators).forEach(validator => {
this.validators[validator] = validators[validator];
});
}
/**
* Check form data correctness.
* @return {Promise<boolean>}
*/
validate(silent) {
return checkErrors(this.value, this.validators)
.then(errors => {
if (errors) {
this.value.$errors = errors;
} else {
delete this.value.$errors;
}
return !errors;
});
}
setDirty() {
const forms = deepQueryAll(this.host, '[is-form]');
this.dirty = true;
return Promise.all(forms
.map(formEl => {
return formEl.use('form')
.then(Form => {
return Form.setDirty()
.then(() => Form.validate())
.then(() => Form.setErrorProps())
});
}));
}
/**
* Set custom properties to show active errors
* @returns
*/
setErrorProps(field) {
const names = Object.keys(this.validators);
const errors = this.value.$errors || {};
const fields = this.fields;
const checks = this.checks;
names.forEach(name => {
if (field && field !== name) return;
const validators = Object.keys(this.validators[name]);
const fieldChecks = checks[name];
let invalid = false;
for (let validator of validators) {
if (errors && errors[name] && errors[name][validator] && !invalid) {
invalid = true;
fieldChecks[validator].setValidity(false);
// this.host.style.setProperty(prop, 'block');
} else {
fieldChecks[validator].setValidity(true);
// this.host.style.setProperty(prop, 'none');
}
}
if (fields[name]) {
fields[name].setValidity(!invalid);
}
});
}
resetFieldWarning(name) {
const field = this.fields[name];
const validators = Object.keys(this.validators[name] || {});
for (let check of validators) {
const prop = `--check-${name}-${check}`;
this.host.style.setProperty(prop, 'none');
}
if (field) {
field.setValidity(true);
}
}
}
export default FormBehavior;
|
"use strict";var __importDefault=this&&this.__importDefault||function(t){return t&&t.__esModule?t:{default:t}};Object.defineProperty(exports,"__esModule",{value:!0});const globals_1=__importDefault(require("./globals")),utils={linspace:function(t,e,n){const o=(e-t)/(n-1);return Array.from({length:n},(e,n)=>t+o*n)},logspace:function(t,e,n){return this.linspace(t,e,n).map(t=>Math.pow(10,t))},isValidNumber:function(t){return"number"==typeof t&&!isNaN(t)},space:function(t,e,n){const o=e[0],r=e[1];return"log"===t.options.xAxis.type?this.logspace(Math.log10(o),Math.log10(r),n):this.linspace(o,r,n)},getterSetter:function(t,e){const n=this;this[e]=function(o){return arguments.length?(t[e]=o,n):t[e]}},sgn:function(t){return t<0?-1:t>0?1:0},color:function(t,e){return t.color||globals_1.default.COLORS[e].hex()}};exports.default=utils; |
/*! @name m3u8-parser @version 4.5.1 @license Apache-2.0 */
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
var _inheritsLoose = _interopDefault(require('@babel/runtime/helpers/inheritsLoose'));
var Stream = _interopDefault(require('@videojs/vhs-utils/es/stream.js'));
var _extends = _interopDefault(require('@babel/runtime/helpers/extends'));
var _assertThisInitialized = _interopDefault(require('@babel/runtime/helpers/assertThisInitialized'));
var decodeB64ToUint8Array = _interopDefault(require('@videojs/vhs-utils/es/decode-b64-to-uint8-array.js'));
/**
* A stream that buffers string input and generates a `data` event for each
* line.
*
* @class LineStream
* @extends Stream
*/
var LineStream =
/*#__PURE__*/
function (_Stream) {
_inheritsLoose(LineStream, _Stream);
function LineStream() {
var _this;
_this = _Stream.call(this) || this;
_this.buffer = '';
return _this;
}
/**
* Add new data to be parsed.
*
* @param {string} data the text to process
*/
var _proto = LineStream.prototype;
_proto.push = function push(data) {
var nextNewline;
this.buffer += data;
nextNewline = this.buffer.indexOf('\n');
for (; nextNewline > -1; nextNewline = this.buffer.indexOf('\n')) {
this.trigger('data', this.buffer.substring(0, nextNewline));
this.buffer = this.buffer.substring(nextNewline + 1);
}
};
return LineStream;
}(Stream);
/**
* "forgiving" attribute list psuedo-grammar:
* attributes -> keyvalue (',' keyvalue)*
* keyvalue -> key '=' value
* key -> [^=]*
* value -> '"' [^"]* '"' | [^,]*
*/
var attributeSeparator = function attributeSeparator() {
var key = '[^=]*';
var value = '"[^"]*"|[^,]*';
var keyvalue = '(?:' + key + ')=(?:' + value + ')';
return new RegExp('(?:^|,)(' + keyvalue + ')');
};
/**
* Parse attributes from a line given the separator
*
* @param {string} attributes the attribute line to parse
*/
var parseAttributes = function parseAttributes(attributes) {
// split the string using attributes as the separator
var attrs = attributes.split(attributeSeparator());
var result = {};
var i = attrs.length;
var attr;
while (i--) {
// filter out unmatched portions of the string
if (attrs[i] === '') {
continue;
} // split the key and value
attr = /([^=]*)=(.*)/.exec(attrs[i]).slice(1); // trim whitespace and remove optional quotes around the value
attr[0] = attr[0].replace(/^\s+|\s+$/g, '');
attr[1] = attr[1].replace(/^\s+|\s+$/g, '');
attr[1] = attr[1].replace(/^['"](.*)['"]$/g, '$1');
result[attr[0]] = attr[1];
}
return result;
};
/**
* A line-level M3U8 parser event stream. It expects to receive input one
* line at a time and performs a context-free parse of its contents. A stream
* interpretation of a manifest can be useful if the manifest is expected to
* be too large to fit comfortably into memory or the entirety of the input
* is not immediately available. Otherwise, it's probably much easier to work
* with a regular `Parser` object.
*
* Produces `data` events with an object that captures the parser's
* interpretation of the input. That object has a property `tag` that is one
* of `uri`, `comment`, or `tag`. URIs only have a single additional
* property, `line`, which captures the entirety of the input without
* interpretation. Comments similarly have a single additional property
* `text` which is the input without the leading `#`.
*
* Tags always have a property `tagType` which is the lower-cased version of
* the M3U8 directive without the `#EXT` or `#EXT-X-` prefix. For instance,
* `#EXT-X-MEDIA-SEQUENCE` becomes `media-sequence` when parsed. Unrecognized
* tags are given the tag type `unknown` and a single additional property
* `data` with the remainder of the input.
*
* @class ParseStream
* @extends Stream
*/
var ParseStream =
/*#__PURE__*/
function (_Stream) {
_inheritsLoose(ParseStream, _Stream);
function ParseStream() {
var _this;
_this = _Stream.call(this) || this;
_this.customParsers = [];
_this.tagMappers = [];
return _this;
}
/**
* Parses an additional line of input.
*
* @param {string} line a single line of an M3U8 file to parse
*/
var _proto = ParseStream.prototype;
_proto.push = function push(line) {
var _this2 = this;
var match;
var event; // strip whitespace
line = line.trim();
if (line.length === 0) {
// ignore empty lines
return;
} // URIs
if (line[0] !== '#') {
this.trigger('data', {
type: 'uri',
uri: line
});
return;
} // map tags
var newLines = this.tagMappers.reduce(function (acc, mapper) {
var mappedLine = mapper(line); // skip if unchanged
if (mappedLine === line) {
return acc;
}
return acc.concat([mappedLine]);
}, [line]);
newLines.forEach(function (newLine) {
for (var i = 0; i < _this2.customParsers.length; i++) {
if (_this2.customParsers[i].call(_this2, newLine)) {
return;
}
} // Comments
if (newLine.indexOf('#EXT') !== 0) {
_this2.trigger('data', {
type: 'comment',
text: newLine.slice(1)
});
return;
} // strip off any carriage returns here so the regex matching
// doesn't have to account for them.
newLine = newLine.replace('\r', ''); // Tags
match = /^#EXTM3U/.exec(newLine);
if (match) {
_this2.trigger('data', {
type: 'tag',
tagType: 'm3u'
});
return;
}
match = /^#EXTINF:?([0-9\.]*)?,?(.*)?$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'inf'
};
if (match[1]) {
event.duration = parseFloat(match[1]);
}
if (match[2]) {
event.title = match[2];
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-TARGETDURATION:?([0-9.]*)?/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'targetduration'
};
if (match[1]) {
event.duration = parseInt(match[1], 10);
}
_this2.trigger('data', event);
return;
}
match = /^#ZEN-TOTAL-DURATION:?([0-9.]*)?/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'totalduration'
};
if (match[1]) {
event.duration = parseInt(match[1], 10);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-VERSION:?([0-9.]*)?/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'version'
};
if (match[1]) {
event.version = parseInt(match[1], 10);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-MEDIA-SEQUENCE:?(\-?[0-9.]*)?/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'media-sequence'
};
if (match[1]) {
event.number = parseInt(match[1], 10);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-DISCONTINUITY-SEQUENCE:?(\-?[0-9.]*)?/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'discontinuity-sequence'
};
if (match[1]) {
event.number = parseInt(match[1], 10);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-PLAYLIST-TYPE:?(.*)?$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'playlist-type'
};
if (match[1]) {
event.playlistType = match[1];
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-BYTERANGE:?([0-9.]*)?@?([0-9.]*)?/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'byterange'
};
if (match[1]) {
event.length = parseInt(match[1], 10);
}
if (match[2]) {
event.offset = parseInt(match[2], 10);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-ALLOW-CACHE:?(YES|NO)?/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'allow-cache'
};
if (match[1]) {
event.allowed = !/NO/.test(match[1]);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-MAP:?(.*)$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'map'
};
if (match[1]) {
var attributes = parseAttributes(match[1]);
if (attributes.URI) {
event.uri = attributes.URI;
}
if (attributes.BYTERANGE) {
var _attributes$BYTERANGE = attributes.BYTERANGE.split('@'),
length = _attributes$BYTERANGE[0],
offset = _attributes$BYTERANGE[1];
event.byterange = {};
if (length) {
event.byterange.length = parseInt(length, 10);
}
if (offset) {
event.byterange.offset = parseInt(offset, 10);
}
}
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-STREAM-INF:?(.*)$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'stream-inf'
};
if (match[1]) {
event.attributes = parseAttributes(match[1]);
if (event.attributes.RESOLUTION) {
var split = event.attributes.RESOLUTION.split('x');
var resolution = {};
if (split[0]) {
resolution.width = parseInt(split[0], 10);
}
if (split[1]) {
resolution.height = parseInt(split[1], 10);
}
event.attributes.RESOLUTION = resolution;
}
if (event.attributes.BANDWIDTH) {
event.attributes.BANDWIDTH = parseInt(event.attributes.BANDWIDTH, 10);
}
if (event.attributes['PROGRAM-ID']) {
event.attributes['PROGRAM-ID'] = parseInt(event.attributes['PROGRAM-ID'], 10);
}
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-MEDIA:?(.*)$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'media'
};
if (match[1]) {
event.attributes = parseAttributes(match[1]);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-ENDLIST/.exec(newLine);
if (match) {
_this2.trigger('data', {
type: 'tag',
tagType: 'endlist'
});
return;
}
match = /^#EXT-X-DISCONTINUITY/.exec(newLine);
if (match) {
_this2.trigger('data', {
type: 'tag',
tagType: 'discontinuity'
});
return;
}
match = /^#EXT-X-PROGRAM-DATE-TIME:?(.*)$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'program-date-time'
};
if (match[1]) {
event.dateTimeString = match[1];
event.dateTimeObject = new Date(match[1]);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-KEY:?(.*)$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'key'
};
if (match[1]) {
event.attributes = parseAttributes(match[1]); // parse the IV string into a Uint32Array
if (event.attributes.IV) {
if (event.attributes.IV.substring(0, 2).toLowerCase() === '0x') {
event.attributes.IV = event.attributes.IV.substring(2);
}
event.attributes.IV = event.attributes.IV.match(/.{8}/g);
event.attributes.IV[0] = parseInt(event.attributes.IV[0], 16);
event.attributes.IV[1] = parseInt(event.attributes.IV[1], 16);
event.attributes.IV[2] = parseInt(event.attributes.IV[2], 16);
event.attributes.IV[3] = parseInt(event.attributes.IV[3], 16);
event.attributes.IV = new Uint32Array(event.attributes.IV);
}
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-START:?(.*)$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'start'
};
if (match[1]) {
event.attributes = parseAttributes(match[1]);
event.attributes['TIME-OFFSET'] = parseFloat(event.attributes['TIME-OFFSET']);
event.attributes.PRECISE = /YES/.test(event.attributes.PRECISE);
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-CUE-OUT-CONT:?(.*)?$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'cue-out-cont'
};
if (match[1]) {
event.data = match[1];
} else {
event.data = '';
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-CUE-OUT:?(.*)?$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'cue-out'
};
if (match[1]) {
event.data = match[1];
} else {
event.data = '';
}
_this2.trigger('data', event);
return;
}
match = /^#EXT-X-CUE-IN:?(.*)?$/.exec(newLine);
if (match) {
event = {
type: 'tag',
tagType: 'cue-in'
};
if (match[1]) {
event.data = match[1];
} else {
event.data = '';
}
_this2.trigger('data', event);
return;
} // unknown tag type
_this2.trigger('data', {
type: 'tag',
data: newLine.slice(4)
});
});
}
/**
* Add a parser for custom headers
*
* @param {Object} options a map of options for the added parser
* @param {RegExp} options.expression a regular expression to match the custom header
* @param {string} options.customType the custom type to register to the output
* @param {Function} [options.dataParser] function to parse the line into an object
* @param {boolean} [options.segment] should tag data be attached to the segment object
*/
;
_proto.addParser = function addParser(_ref) {
var _this3 = this;
var expression = _ref.expression,
customType = _ref.customType,
dataParser = _ref.dataParser,
segment = _ref.segment;
if (typeof dataParser !== 'function') {
dataParser = function dataParser(line) {
return line;
};
}
this.customParsers.push(function (line) {
var match = expression.exec(line);
if (match) {
_this3.trigger('data', {
type: 'custom',
data: dataParser(line),
customType: customType,
segment: segment
});
return true;
}
});
}
/**
* Add a custom header mapper
*
* @param {Object} options
* @param {RegExp} options.expression a regular expression to match the custom header
* @param {Function} options.map function to translate tag into a different tag
*/
;
_proto.addTagMapper = function addTagMapper(_ref2) {
var expression = _ref2.expression,
map = _ref2.map;
var mapFn = function mapFn(line) {
if (expression.test(line)) {
return map(line);
}
return line;
};
this.tagMappers.push(mapFn);
};
return ParseStream;
}(Stream);
/**
* A parser for M3U8 files. The current interpretation of the input is
* exposed as a property `manifest` on parser objects. It's just two lines to
* create and parse a manifest once you have the contents available as a string:
*
* ```js
* var parser = new m3u8.Parser();
* parser.push(xhr.responseText);
* ```
*
* New input can later be applied to update the manifest object by calling
* `push` again.
*
* The parser attempts to create a usable manifest object even if the
* underlying input is somewhat nonsensical. It emits `info` and `warning`
* events during the parse if it encounters input that seems invalid or
* requires some property of the manifest object to be defaulted.
*
* @class Parser
* @extends Stream
*/
var Parser =
/*#__PURE__*/
function (_Stream) {
_inheritsLoose(Parser, _Stream);
function Parser() {
var _this;
_this = _Stream.call(this) || this;
_this.lineStream = new LineStream();
_this.parseStream = new ParseStream();
_this.lineStream.pipe(_this.parseStream);
/* eslint-disable consistent-this */
var self = _assertThisInitialized(_this);
/* eslint-enable consistent-this */
var uris = [];
var currentUri = {}; // if specified, the active EXT-X-MAP definition
var currentMap; // if specified, the active decryption key
var _key;
var noop = function noop() {};
var defaultMediaGroups = {
'AUDIO': {},
'VIDEO': {},
'CLOSED-CAPTIONS': {},
'SUBTITLES': {}
}; // This is the Widevine UUID from DASH IF IOP. The same exact string is
// used in MPDs with Widevine encrypted streams.
var widevineUuid = 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed'; // group segments into numbered timelines delineated by discontinuities
var currentTimeline = 0; // the manifest is empty until the parse stream begins delivering data
_this.manifest = {
allowCache: true,
discontinuityStarts: [],
segments: []
}; // keep track of the last seen segment's byte range end, as segments are not required
// to provide the offset, in which case it defaults to the next byte after the
// previous segment
var lastByterangeEnd = 0; // update the manifest with the m3u8 entry from the parse stream
_this.parseStream.on('data', function (entry) {
var mediaGroup;
var rendition;
({
tag: function tag() {
// switch based on the tag type
(({
'allow-cache': function allowCache() {
this.manifest.allowCache = entry.allowed;
if (!('allowed' in entry)) {
this.trigger('info', {
message: 'defaulting allowCache to YES'
});
this.manifest.allowCache = true;
}
},
byterange: function byterange() {
var byterange = {};
if ('length' in entry) {
currentUri.byterange = byterange;
byterange.length = entry.length;
if (!('offset' in entry)) {
/*
* From the latest spec (as of this writing):
* https://tools.ietf.org/html/draft-pantos-http-live-streaming-23#section-4.3.2.2
*
* Same text since EXT-X-BYTERANGE's introduction in draft 7:
* https://tools.ietf.org/html/draft-pantos-http-live-streaming-07#section-3.3.1)
*
* "If o [offset] is not present, the sub-range begins at the next byte
* following the sub-range of the previous media segment."
*/
entry.offset = lastByterangeEnd;
}
}
if ('offset' in entry) {
currentUri.byterange = byterange;
byterange.offset = entry.offset;
}
lastByterangeEnd = byterange.offset + byterange.length;
},
endlist: function endlist() {
this.manifest.endList = true;
},
inf: function inf() {
if (!('mediaSequence' in this.manifest)) {
this.manifest.mediaSequence = 0;
this.trigger('info', {
message: 'defaulting media sequence to zero'
});
}
if (!('discontinuitySequence' in this.manifest)) {
this.manifest.discontinuitySequence = 0;
this.trigger('info', {
message: 'defaulting discontinuity sequence to zero'
});
}
if (entry.duration > 0) {
currentUri.duration = entry.duration;
}
if (entry.duration === 0) {
currentUri.duration = 0.01;
this.trigger('info', {
message: 'updating zero segment duration to a small value'
});
}
this.manifest.segments = uris;
},
key: function key() {
if (!entry.attributes) {
this.trigger('warn', {
message: 'ignoring key declaration without attribute list'
});
return;
} // clear the active encryption key
if (entry.attributes.METHOD === 'NONE') {
_key = null;
return;
}
if (!entry.attributes.URI) {
this.trigger('warn', {
message: 'ignoring key declaration without URI'
});
return;
} // check if the content is encrypted for Widevine
// Widevine/HLS spec: https://storage.googleapis.com/wvdocs/Widevine_DRM_HLS.pdf
if (entry.attributes.KEYFORMAT === widevineUuid) {
var VALID_METHODS = ['SAMPLE-AES', 'SAMPLE-AES-CTR', 'SAMPLE-AES-CENC'];
if (VALID_METHODS.indexOf(entry.attributes.METHOD) === -1) {
this.trigger('warn', {
message: 'invalid key method provided for Widevine'
});
return;
}
if (entry.attributes.METHOD === 'SAMPLE-AES-CENC') {
this.trigger('warn', {
message: 'SAMPLE-AES-CENC is deprecated, please use SAMPLE-AES-CTR instead'
});
}
if (entry.attributes.URI.substring(0, 23) !== 'data:text/plain;base64,') {
this.trigger('warn', {
message: 'invalid key URI provided for Widevine'
});
return;
}
if (!(entry.attributes.KEYID && entry.attributes.KEYID.substring(0, 2) === '0x')) {
this.trigger('warn', {
message: 'invalid key ID provided for Widevine'
});
return;
} // if Widevine key attributes are valid, store them as `contentProtection`
// on the manifest to emulate Widevine tag structure in a DASH mpd
this.manifest.contentProtection = {
'com.widevine.alpha': {
attributes: {
schemeIdUri: entry.attributes.KEYFORMAT,
// remove '0x' from the key id string
keyId: entry.attributes.KEYID.substring(2)
},
// decode the base64-encoded PSSH box
pssh: decodeB64ToUint8Array(entry.attributes.URI.split(',')[1])
}
};
return;
}
if (!entry.attributes.METHOD) {
this.trigger('warn', {
message: 'defaulting key method to AES-128'
});
} // setup an encryption key for upcoming segments
_key = {
method: entry.attributes.METHOD || 'AES-128',
uri: entry.attributes.URI
};
if (typeof entry.attributes.IV !== 'undefined') {
_key.iv = entry.attributes.IV;
}
},
'media-sequence': function mediaSequence() {
if (!isFinite(entry.number)) {
this.trigger('warn', {
message: 'ignoring invalid media sequence: ' + entry.number
});
return;
}
this.manifest.mediaSequence = entry.number;
},
'discontinuity-sequence': function discontinuitySequence() {
if (!isFinite(entry.number)) {
this.trigger('warn', {
message: 'ignoring invalid discontinuity sequence: ' + entry.number
});
return;
}
this.manifest.discontinuitySequence = entry.number;
currentTimeline = entry.number;
},
'playlist-type': function playlistType() {
if (!/VOD|EVENT/.test(entry.playlistType)) {
this.trigger('warn', {
message: 'ignoring unknown playlist type: ' + entry.playlist
});
return;
}
this.manifest.playlistType = entry.playlistType;
},
map: function map() {
currentMap = {};
if (entry.uri) {
currentMap.uri = entry.uri;
}
if (entry.byterange) {
currentMap.byterange = entry.byterange;
}
},
'stream-inf': function streamInf() {
this.manifest.playlists = uris;
this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
if (!entry.attributes) {
this.trigger('warn', {
message: 'ignoring empty stream-inf attributes'
});
return;
}
if (!currentUri.attributes) {
currentUri.attributes = {};
}
_extends(currentUri.attributes, entry.attributes);
},
media: function media() {
this.manifest.mediaGroups = this.manifest.mediaGroups || defaultMediaGroups;
if (!(entry.attributes && entry.attributes.TYPE && entry.attributes['GROUP-ID'] && entry.attributes.NAME)) {
this.trigger('warn', {
message: 'ignoring incomplete or missing media group'
});
return;
} // find the media group, creating defaults as necessary
var mediaGroupType = this.manifest.mediaGroups[entry.attributes.TYPE];
mediaGroupType[entry.attributes['GROUP-ID']] = mediaGroupType[entry.attributes['GROUP-ID']] || {};
mediaGroup = mediaGroupType[entry.attributes['GROUP-ID']]; // collect the rendition metadata
rendition = {
default: /yes/i.test(entry.attributes.DEFAULT)
};
if (rendition.default) {
rendition.autoselect = true;
} else {
rendition.autoselect = /yes/i.test(entry.attributes.AUTOSELECT);
}
if (entry.attributes.LANGUAGE) {
rendition.language = entry.attributes.LANGUAGE;
}
if (entry.attributes.URI) {
rendition.uri = entry.attributes.URI;
}
if (entry.attributes['INSTREAM-ID']) {
rendition.instreamId = entry.attributes['INSTREAM-ID'];
}
if (entry.attributes.CHARACTERISTICS) {
rendition.characteristics = entry.attributes.CHARACTERISTICS;
}
if (entry.attributes.FORCED) {
rendition.forced = /yes/i.test(entry.attributes.FORCED);
} // insert the new rendition
mediaGroup[entry.attributes.NAME] = rendition;
},
discontinuity: function discontinuity() {
currentTimeline += 1;
currentUri.discontinuity = true;
this.manifest.discontinuityStarts.push(uris.length);
},
'program-date-time': function programDateTime() {
if (typeof this.manifest.dateTimeString === 'undefined') {
// PROGRAM-DATE-TIME is a media-segment tag, but for backwards
// compatibility, we add the first occurence of the PROGRAM-DATE-TIME tag
// to the manifest object
// TODO: Consider removing this in future major version
this.manifest.dateTimeString = entry.dateTimeString;
this.manifest.dateTimeObject = entry.dateTimeObject;
}
currentUri.dateTimeString = entry.dateTimeString;
currentUri.dateTimeObject = entry.dateTimeObject;
},
targetduration: function targetduration() {
if (!isFinite(entry.duration) || entry.duration < 0) {
this.trigger('warn', {
message: 'ignoring invalid target duration: ' + entry.duration
});
return;
}
this.manifest.targetDuration = entry.duration;
},
totalduration: function totalduration() {
if (!isFinite(entry.duration) || entry.duration < 0) {
this.trigger('warn', {
message: 'ignoring invalid total duration: ' + entry.duration
});
return;
}
this.manifest.totalDuration = entry.duration;
},
start: function start() {
if (!entry.attributes || isNaN(entry.attributes['TIME-OFFSET'])) {
this.trigger('warn', {
message: 'ignoring start declaration without appropriate attribute list'
});
return;
}
this.manifest.start = {
timeOffset: entry.attributes['TIME-OFFSET'],
precise: entry.attributes.PRECISE
};
},
'cue-out': function cueOut() {
currentUri.cueOut = entry.data;
},
'cue-out-cont': function cueOutCont() {
currentUri.cueOutCont = entry.data;
},
'cue-in': function cueIn() {
currentUri.cueIn = entry.data;
}
})[entry.tagType] || noop).call(self);
},
uri: function uri() {
currentUri.uri = entry.uri;
uris.push(currentUri); // if no explicit duration was declared, use the target duration
if (this.manifest.targetDuration && !('duration' in currentUri)) {
this.trigger('warn', {
message: 'defaulting segment duration to the target duration'
});
currentUri.duration = this.manifest.targetDuration;
} // annotate with encryption information, if necessary
if (_key) {
currentUri.key = _key;
}
currentUri.timeline = currentTimeline; // annotate with initialization segment information, if necessary
if (currentMap) {
currentUri.map = currentMap;
} // prepare for the next URI
currentUri = {};
},
comment: function comment() {// comments are not important for playback
},
custom: function custom() {
// if this is segment-level data attach the output to the segment
if (entry.segment) {
currentUri.custom = currentUri.custom || {};
currentUri.custom[entry.customType] = entry.data; // if this is manifest-level data attach to the top level manifest object
} else {
this.manifest.custom = this.manifest.custom || {};
this.manifest.custom[entry.customType] = entry.data;
}
}
})[entry.type].call(self);
});
return _this;
}
/**
* Parse the input string and update the manifest object.
*
* @param {string} chunk a potentially incomplete portion of the manifest
*/
var _proto = Parser.prototype;
_proto.push = function push(chunk) {
this.lineStream.push(chunk);
}
/**
* Flush any remaining input. This can be handy if the last line of an M3U8
* manifest did not contain a trailing newline but the file has been
* completely received.
*/
;
_proto.end = function end() {
// flush any buffered input
this.lineStream.push('\n');
}
/**
* Add an additional parser for non-standard tags
*
* @param {Object} options a map of options for the added parser
* @param {RegExp} options.expression a regular expression to match the custom header
* @param {string} options.type the type to register to the output
* @param {Function} [options.dataParser] function to parse the line into an object
* @param {boolean} [options.segment] should tag data be attached to the segment object
*/
;
_proto.addParser = function addParser(options) {
this.parseStream.addParser(options);
}
/**
* Add a custom header mapper
*
* @param {Object} options
* @param {RegExp} options.expression a regular expression to match the custom header
* @param {Function} options.map function to translate tag into a different tag
*/
;
_proto.addTagMapper = function addTagMapper(options) {
this.parseStream.addTagMapper(options);
};
return Parser;
}(Stream);
exports.LineStream = LineStream;
exports.ParseStream = ParseStream;
exports.Parser = Parser;
|
import{B as e,n as t,m as n}from"./index-2751648f.js";let s=0;export default class extends e{constructor(e,t){super(e,t),this.debuggerId=t}connected(){this.connect(),this.log("connected")}changed(e,t){this.log("changed",{name:e,value:t})}disconnected(){this.log("disconnected")}connect(){const e=this.getDebugger();e&&e.use("debugger").then(e=>{e.componentPromise.then(()=>{const{host:t}=this;if(!t.nuDebugId){const e=++s;window["el"+e]=t,Object.keys(t.nuBehaviors||{}).forEach(e=>{window[`${e}${s}`]=t.nuBehaviors[e]}),t.nuDebugId=e}e.set({target:t})})})}getDebugger(){const{host:e}=this;let s=this.debuggerId.trim();if(this.debugger&&this.debugger.nuId===s)return this.debugger;if(!s){const s=t(e,"nu-debug");return s?(n(s),this.debuggerId=s.nuId,this.debugger=s,s):void 0}const g=t(e,"#"+s.trim());return g&&g.nu?(this.debugger=g,g):void 0}log(e,t){const n=this.getDebugger();n&&n.use("debugger").then(n=>{n.componentPromise.then(()=>{n.component.log(e,t)})})}}
|
/*!
* Bootstrap-select v1.14.0-beta2 (https://developer.snapappointments.com/bootstrap-select)
*
* Copyright 2012-2021 SnapAppointments, LLC
* Licensed under MIT (https://github.com/snapappointments/bootstrap-select/blob/master/LICENSE)
*/
!function(e,t){void 0===e&&void 0!==window&&(e=window),"function"==typeof define&&define.amd?define(["jquery"],function(e){return t(e)}):"object"==typeof module&&module.exports?module.exports=t(require("jquery")):t(e.jQuery)}(this,function(e){e.fn.selectpicker.defaults={noneSelectedText:"Niets geselecteerd",noneResultsText:"Geen resultaten gevonden voor {0}",countSelectedText:"{0} van {1} geselecteerd",maxOptionsText:["Limiet bereikt ({n} {var} max)","Groep limiet bereikt ({n} {var} max)",["items","item"]],selectAllText:"Alles selecteren",deselectAllText:"Alles deselecteren",multipleSeparator:", "}}); |
/*
Highmaps JS v9.2.0 (2021-08-18)
Tilemap module
(c) 2010-2021 Highsoft AS
License: www.highcharts.com/license
*/
'use strict';(function(a){"object"===typeof module&&module.exports?(a["default"]=a,module.exports=a):"function"===typeof define&&define.amd?define("highcharts/modules/tilemap",["highcharts","highcharts/modules/map"],function(k){a(k);a.Highcharts=k;return a}):a("undefined"!==typeof Highcharts?Highcharts:void 0)})(function(a){function k(a,e,g,f){a.hasOwnProperty(e)||(a[e]=f.apply(null,g))}a=a?a._modules:{};k(a,"Series/Tilemap/TilemapPoint.js",[a["Mixins/ColorSeries.js"],a["Core/Series/SeriesRegistry.js"],
a["Core/Utilities.js"]],function(a,e,g){var f=this&&this.__extends||function(){var a=function(d,g){a=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(b,c){b.__proto__=c}||function(b,c){for(var a in c)c.hasOwnProperty(a)&&(b[a]=c[a])};return a(d,g)};return function(d,g){function b(){this.constructor=d}a(d,g);d.prototype=null===g?Object.create(g):(b.prototype=g.prototype,new b)}}();a=a.colorPointMixin;var h=e.series.prototype.pointClass;g=g.extend;e=function(a){function d(){var d=null!==
a&&a.apply(this,arguments)||this;d.options=void 0;d.radius=void 0;d.series=void 0;d.tileEdges=void 0;return d}f(d,a);d.prototype.haloPath=function(){return this.series.tileShape.haloPath.apply(this,arguments)};return d}(e.seriesTypes.heatmap.prototype.pointClass);g(e.prototype,{setState:h.prototype.setState,setVisible:a.setVisible});return e});k(a,"Series/Tilemap/TilemapShapes.js",[a["Core/Globals.js"],a["Core/Series/SeriesRegistry.js"],a["Core/Utilities.js"]],function(a,e,g){function f(b,c,a){b=
b.options;return{xPad:(b.colsize||1)/-c,yPad:(b.rowsize||1)/-a}}e=e.seriesTypes;var h=e.heatmap,t=e.scatter,d=g.clamp,k=g.pick;return{hexagon:{alignDataLabel:t.prototype.alignDataLabel,getSeriesPadding:function(b){return f(b,3,2)},haloPath:function(b){if(!b)return[];var c=this.tileEdges;return[["M",c.x2-b,c.y1+b],["L",c.x3+b,c.y1+b],["L",c.x4+1.5*b,c.y2],["L",c.x3+b,c.y3-b],["L",c.x2-b,c.y3-b],["L",c.x1-1.5*b,c.y2],["Z"]]},translate:function(){var b=this.options,c=this.xAxis,a=this.yAxis,g=b.pointPadding||
0,r=(b.colsize||1)/3,w=(b.rowsize||1)/2,n;this.generatePoints();this.points.forEach(function(b){var p=d(Math.floor(c.len-c.translate(b.x-2*r,0,1,0,1)),-c.len,2*c.len),v=d(Math.floor(c.len-c.translate(b.x-r,0,1,0,1)),-c.len,2*c.len),e=d(Math.floor(c.len-c.translate(b.x+r,0,1,0,1)),-c.len,2*c.len),u=d(Math.floor(c.len-c.translate(b.x+2*r,0,1,0,1)),-c.len,2*c.len),x=d(Math.floor(a.translate(b.y-w,0,1,0,1)),-a.len,2*a.len),q=d(Math.floor(a.translate(b.y,0,1,0,1)),-a.len,2*a.len),l=d(Math.floor(a.translate(b.y+
w,0,1,0,1)),-a.len,2*a.len),m=k(b.pointPadding,g),h=m*Math.abs(v-p)/Math.abs(l-q);h=c.reversed?-h:h;var f=c.reversed?-m:m;m=a.reversed?-m:m;b.x%2&&(n=n||Math.round(Math.abs(l-x)/2)*(a.reversed?-1:1),x+=n,q+=n,l+=n);b.plotX=b.clientX=(v+e)/2;b.plotY=q;p+=h+f;v+=f;e-=f;u-=h+f;x-=m;l+=m;b.tileEdges={x1:p,x2:v,x3:e,x4:u,y1:x,y2:q,y3:l};b.shapeType="path";b.shapeArgs={d:[["M",v,x],["L",e,x],["L",u,q],["L",e,l],["L",v,l],["L",p,q],["Z"]]}});this.translateColors()}},diamond:{alignDataLabel:t.prototype.alignDataLabel,
getSeriesPadding:function(b){return f(b,2,2)},haloPath:function(b){if(!b)return[];var c=this.tileEdges;return[["M",c.x2,c.y1+b],["L",c.x3+b,c.y2],["L",c.x2,c.y3-b],["L",c.x1-b,c.y2],["Z"]]},translate:function(){var b=this.options,c=this.xAxis,a=this.yAxis,g=b.pointPadding||0,e=b.colsize||1,w=(b.rowsize||1)/2,n;this.generatePoints();this.points.forEach(function(b){var h=d(Math.round(c.len-c.translate(b.x-e,0,1,0,0)),-c.len,2*c.len),r=d(Math.round(c.len-c.translate(b.x,0,1,0,0)),-c.len,2*c.len),p=d(Math.round(c.len-
c.translate(b.x+e,0,1,0,0)),-c.len,2*c.len),u=d(Math.round(a.translate(b.y-w,0,1,0,0)),-a.len,2*a.len),f=d(Math.round(a.translate(b.y,0,1,0,0)),-a.len,2*a.len),q=d(Math.round(a.translate(b.y+w,0,1,0,0)),-a.len,2*a.len),l=k(b.pointPadding,g),m=l*Math.abs(r-h)/Math.abs(q-f);m=c.reversed?-m:m;l=a.reversed?-l:l;b.x%2&&(n=Math.abs(q-u)/2*(a.reversed?-1:1),u+=n,f+=n,q+=n);b.plotX=b.clientX=r;b.plotY=f;h+=m;p-=m;u-=l;q+=l;b.tileEdges={x1:h,x2:r,x3:p,y1:u,y2:f,y3:q};b.shapeType="path";b.shapeArgs={d:[["M",
r,u],["L",p,f],["L",r,q],["L",h,f],["Z"]]}});this.translateColors()}},circle:{alignDataLabel:t.prototype.alignDataLabel,getSeriesPadding:function(b){return f(b,2,2)},haloPath:function(b){return t.prototype.pointClass.prototype.haloPath.call(this,b+(b&&this.radius))},translate:function(){var b=this.options,a=this.xAxis,g=this.yAxis,e=b.pointPadding||0,r=(b.rowsize||1)/2,w=b.colsize||1,n,f,h,t,k=!1;this.generatePoints();this.points.forEach(function(b){var c=d(Math.round(a.len-a.translate(b.x,0,1,0,
0)),-a.len,2*a.len),p=d(Math.round(g.translate(b.y,0,1,0,0)),-g.len,2*g.len),l=e,m=!1;"undefined"!==typeof b.pointPadding&&(l=b.pointPadding,k=m=!0);if(!t||k)n=Math.abs(d(Math.floor(a.len-a.translate(b.x+w,0,1,0,0)),-a.len,2*a.len)-c),f=Math.abs(d(Math.floor(g.translate(b.y+r,0,1,0,0)),-g.len,2*g.len)-p),h=Math.floor(Math.sqrt(n*n+f*f)/2),t=Math.min(n,h,f)-l,k&&!m&&(k=!1);b.x%2&&(p+=f*(g.reversed?-1:1));b.plotX=b.clientX=c;b.plotY=p;b.radius=t;b.shapeType="circle";b.shapeArgs={x:c,y:p,r:t}});this.translateColors()}},
square:{alignDataLabel:h.prototype.alignDataLabel,translate:h.prototype.translate,getSeriesPadding:a.noop,haloPath:h.prototype.pointClass.prototype.haloPath}}});k(a,"Series/Tilemap/TilemapComposition.js",[a["Core/Axis/Axis.js"],a["Core/Utilities.js"]],function(a,e){e=e.addEvent;e(a,"afterSetAxisTranslation",function(){if(!this.recomputingForTilemap&&"colorAxis"!==this.coll){var a=this,f=a.series.map(function(e){return e.getSeriesPixelPadding&&e.getSeriesPixelPadding(a)}).reduce(function(a,d){return(a&&
a.padding)>(d&&d.padding)?a:d},void 0)||{padding:0,axisLengthFactor:1},e=Math.round(f.padding*f.axisLengthFactor);f.padding&&(a.len-=e,a.recomputingForTilemap=!0,a.setAxisTranslation(),delete a.recomputingForTilemap,a.minPixelPadding+=f.padding,a.len+=e)}})});k(a,"Series/Tilemap/TilemapSeries.js",[a["Core/Globals.js"],a["Core/Series/SeriesRegistry.js"],a["Series/Tilemap/TilemapPoint.js"],a["Series/Tilemap/TilemapShapes.js"],a["Core/Utilities.js"]],function(a,e,g,f,h){var k=this&&this.__extends||function(){var a=
function(b,c){a=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(a,b){a.__proto__=b}||function(a,b){for(var c in b)b.hasOwnProperty(c)&&(a[c]=b[c])};return a(b,c)};return function(b,c){function d(){this.constructor=b}a(b,c);b.prototype=null===c?Object.create(c):(d.prototype=c.prototype,new d)}}();a=a.noop;var d=e.seriesTypes,y=d.column,b=d.heatmap;d=d.scatter;var c=h.extend,v=h.merge;h=function(a){function c(){var b=null!==a&&a.apply(this,arguments)||this;b.data=void 0;b.options=void 0;
b.points=void 0;b.tileShape=void 0;return b}k(c,a);c.prototype.alignDataLabel=function(){return this.tileShape.alignDataLabel.apply(this,Array.prototype.slice.call(arguments))};c.prototype.drawPoints=function(){var a=this;y.prototype.drawPoints.call(this);this.points.forEach(function(b){b.graphic&&b.graphic[a.chart.styledMode?"css":"animate"](a.colorAttribs(b))})};c.prototype.getSeriesPixelPadding=function(a){var b=a.isXAxis,c=this.tileShape.getSeriesPadding(this);if(!c)return{padding:0,axisLengthFactor:1};
var d=Math.round(a.translate(b?2*c.xPad:c.yPad,0,1,0,1));a=Math.round(a.translate(b?c.xPad:0,0,1,0,1));return{padding:Math.abs(d-a)||0,axisLengthFactor:b?2:1.1}};c.prototype.setOptions=function(){var b=a.prototype.setOptions.apply(this,Array.prototype.slice.call(arguments));this.tileShape=f[b.tileShape];return b};c.prototype.translate=function(){return this.tileShape.translate.apply(this,Array.prototype.slice.call(arguments))};c.defaultOptions=v(b.defaultOptions,{marker:null,states:{hover:{halo:{enabled:!0,
size:2,opacity:.5,attributes:{zIndex:3}}}},pointPadding:2,tileShape:"hexagon"});return c}(b);c(h.prototype,{getSymbol:a,markerAttribs:d.prototype.markerAttribs,pointAttribs:y.prototype.pointAttribs,pointClass:g});e.registerSeriesType("tilemap",h);"";"";return h});k(a,"masters/modules/tilemap.src.js",[],function(){})});
//# sourceMappingURL=tilemap.js.map |
/*
Highcharts JS v9.2.1 (2021-08-19)
(c) 2009-2021 Sebastian Bochan, Rafal Sebestjanski
License: www.highcharts.com/license
*/
'use strict';(function(a){"object"===typeof module&&module.exports?(a["default"]=a,module.exports=a):"function"===typeof define&&define.amd?define("highcharts/modules/dumbbell",["highcharts"],function(h){a(h);a.Highcharts=h;return a}):a("undefined"!==typeof Highcharts?Highcharts:void 0)})(function(a){function h(a,f,k,l){a.hasOwnProperty(f)||(a[f]=l.apply(null,k))}a=a?a._modules:{};h(a,"Series/AreaRange/AreaRangePoint.js",[a["Series/Area/AreaSeries.js"],a["Core/Series/Point.js"],a["Core/Utilities.js"]],
function(a,f,k){var l=this&&this.__extends||function(){var b=function(a,c){b=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(c,a){c.__proto__=a}||function(c,a){for(var b in a)a.hasOwnProperty(b)&&(c[b]=a[b])};return b(a,c)};return function(a,c){function q(){this.constructor=a}b(a,c);a.prototype=null===c?Object.create(c):(q.prototype=c.prototype,new q)}}(),e=f.prototype,m=k.defined,d=k.isNumber;return function(a){function b(){var b=null!==a&&a.apply(this,arguments)||this;b.high=void 0;
b.low=void 0;b.options=void 0;b.plotHigh=void 0;b.plotLow=void 0;b.plotHighX=void 0;b.plotLowX=void 0;b.plotX=void 0;b.series=void 0;return b}l(b,a);b.prototype.setState=function(){var b=this.state,a=this.series,d=a.chart.polar;m(this.plotHigh)||(this.plotHigh=a.yAxis.toPixels(this.high,!0));m(this.plotLow)||(this.plotLow=this.plotY=a.yAxis.toPixels(this.low,!0));a.stateMarkerGraphic&&(a.lowerStateMarkerGraphic=a.stateMarkerGraphic,a.stateMarkerGraphic=a.upperStateMarkerGraphic);this.graphic=this.upperGraphic;
this.plotY=this.plotHigh;d&&(this.plotX=this.plotHighX);e.setState.apply(this,arguments);this.state=b;this.plotY=this.plotLow;this.graphic=this.lowerGraphic;d&&(this.plotX=this.plotLowX);a.stateMarkerGraphic&&(a.upperStateMarkerGraphic=a.stateMarkerGraphic,a.stateMarkerGraphic=a.lowerStateMarkerGraphic,a.lowerStateMarkerGraphic=void 0);e.setState.apply(this,arguments)};b.prototype.haloPath=function(){var a=this.series.chart.polar,b=[];this.plotY=this.plotLow;a&&(this.plotX=this.plotLowX);this.isInside&&
(b=e.haloPath.apply(this,arguments));this.plotY=this.plotHigh;a&&(this.plotX=this.plotHighX);this.isTopInside&&(b=b.concat(e.haloPath.apply(this,arguments)));return b};b.prototype.isValid=function(){return d(this.low)&&d(this.high)};return b}(a.prototype.pointClass)});h(a,"Series/Dumbbell/DumbbellPoint.js",[a["Series/AreaRange/AreaRangePoint.js"],a["Core/Utilities.js"]],function(a,f){var k=this&&this.__extends||function(){var a=function(d,b){a=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&
function(a,b){a.__proto__=b}||function(a,b){for(var c in b)b.hasOwnProperty(c)&&(a[c]=b[c])};return a(d,b)};return function(d,b){function e(){this.constructor=d}a(d,b);d.prototype=null===b?Object.create(b):(e.prototype=b.prototype,new e)}}(),l=f.extend,e=f.pick;f=function(a){function d(){var b=null!==a&&a.apply(this,arguments)||this;b.series=void 0;b.options=void 0;b.connector=void 0;b.pointWidth=void 0;return b}k(d,a);d.prototype.setState=function(){var a=this.series,d=a.chart,c=a.options.marker,
f=this.options,k=e(f.lowColor,a.options.lowColor,f.color,this.zone&&this.zone.color,this.color,a.color),h="attr";this.pointSetState.apply(this,arguments);this.state||(h="animate",this.lowerGraphic&&!d.styledMode&&(this.lowerGraphic.attr({fill:k}),this.upperGraphic&&(d={y:this.y,zone:this.zone},this.y=this.high,this.zone=this.zone?this.getZone():void 0,c=e(this.marker?this.marker.fillColor:void 0,c?c.fillColor:void 0,f.color,this.zone?this.zone.color:void 0,this.color),this.upperGraphic.attr({fill:c}),
l(this,d))));this.connector[h](a.getConnectorAttribs(this))};d.prototype.destroy=function(){this.graphic||(this.graphic=this.connector,this.connector=void 0);return a.prototype.destroy.call(this)};return d}(a);l(f.prototype,{pointSetState:a.prototype.setState});return f});h(a,"Series/Dumbbell/DumbbellSeries.js",[a["Series/Column/ColumnSeries.js"],a["Series/Dumbbell/DumbbellPoint.js"],a["Core/Globals.js"],a["Core/Color/Palette.js"],a["Core/Series/Series.js"],a["Core/Series/SeriesRegistry.js"],a["Core/Renderer/SVG/SVGRenderer.js"],
a["Core/Utilities.js"]],function(a,f,k,h,e,m,d,b){var l=this&&this.__extends||function(){var a=function(b,g){a=Object.setPrototypeOf||{__proto__:[]}instanceof Array&&function(a,g){a.__proto__=g}||function(a,g){for(var b in g)g.hasOwnProperty(b)&&(a[b]=g[b])};return a(b,g)};return function(b,g){function c(){this.constructor=b}a(b,g);b.prototype=null===g?Object.create(g):(c.prototype=g.prototype,new c)}}(),c=a.prototype;k=k.noop;var q=e.prototype;e=m.seriesTypes;var r=e.arearange;e=e.columnrange.prototype;
var t=r.prototype,v=b.extend,w=b.merge,n=b.pick;b=function(a){function b(){var b=null!==a&&a.apply(this,arguments)||this;b.data=void 0;b.options=void 0;b.points=void 0;b.columnMetrics=void 0;return b}l(b,a);b.prototype.getConnectorAttribs=function(a){var b=this.chart,g=a.options,c=this.options,u=this.xAxis,e=this.yAxis,f=n(g.connectorWidth,c.connectorWidth),h=n(g.connectorColor,c.connectorColor,g.color,a.zone?a.zone.color:void 0,a.color),k=n(c.states&&c.states.hover&&c.states.hover.connectorWidthPlus,
1),l=n(g.dashStyle,c.dashStyle),m=n(a.plotLow,a.plotY),p=e.toPixels(c.threshold||0,!0);p=n(a.plotHigh,b.inverted?e.len-p:p);a.state&&(f+=k);0>m?m=0:m>=e.len&&(m=e.len);0>p?p=0:p>=e.len&&(p=e.len);if(0>a.plotX||a.plotX>u.len)f=0;a.upperGraphic&&(u={y:a.y,zone:a.zone},a.y=a.high,a.zone=a.zone?a.getZone():void 0,h=n(g.connectorColor,c.connectorColor,g.color,a.zone?a.zone.color:void 0,a.color),v(a,u));a={d:d.prototype.crispLine([["M",a.plotX,m],["L",a.plotX,p]],f,"ceil")};b.styledMode||(a.stroke=h,a["stroke-width"]=
f,l&&(a.dashstyle=l));return a};b.prototype.drawConnector=function(a){var b=n(this.options.animationLimit,250);b=a.connector&&this.chart.pointCount<b?"animate":"attr";a.connector||(a.connector=this.chart.renderer.path().addClass("highcharts-lollipop-stem").attr({zIndex:-1}).add(this.markerGroup));a.connector[b](this.getConnectorAttribs(a))};b.prototype.getColumnMetrics=function(){var a=c.getColumnMetrics.apply(this,arguments);a.offset+=a.width/2;return a};b.prototype.translate=function(){this.setShapeArgs.apply(this);
this.translatePoint.apply(this,arguments);this.points.forEach(function(a){var b=a.shapeArgs,c=a.pointWidth;a.plotX=b.x;b.x=a.plotX-c/2;a.tooltipPos=null});this.columnMetrics.offset-=this.columnMetrics.width/2};b.prototype.drawPoints=function(){var a=this.chart,b=this.points.length,c=this.lowColor=this.options.lowColor,e=0;for(this.seriesDrawPoints.apply(this,arguments);e<b;){var d=this.points[e];this.drawConnector(d);d.upperGraphic&&(d.upperGraphic.element.point=d,d.upperGraphic.addClass("highcharts-lollipop-high"));
d.connector.element.point=d;if(d.lowerGraphic){var f=d.zone&&d.zone.color;f=n(d.options.lowColor,c,d.options.color,f,d.color,this.color);a.styledMode||d.lowerGraphic.attr({fill:f});d.lowerGraphic.addClass("highcharts-lollipop-low")}e++}};b.prototype.markerAttribs=function(){var a=t.markerAttribs.apply(this,arguments);a.x=Math.floor(a.x||0);a.y=Math.floor(a.y||0);return a};b.prototype.pointAttribs=function(a,b){var c=q.pointAttribs.apply(this,arguments);"hover"===b&&delete c.fill;return c};b.defaultOptions=
w(r.defaultOptions,{trackByArea:!1,fillColor:"none",lineWidth:0,pointRange:1,connectorWidth:1,stickyTracking:!1,groupPadding:.2,crisp:!1,pointPadding:.1,lowColor:h.neutralColor80,states:{hover:{lineWidthPlus:0,connectorWidthPlus:1,halo:!1}}});return b}(r);v(b.prototype,{crispCol:c.crispCol,drawGraph:k,drawTracker:a.prototype.drawTracker,pointClass:f,setShapeArgs:e.translate,seriesDrawPoints:t.drawPoints,trackerGroups:["group","markerGroup","dataLabelsGroup"],translatePoint:t.translate});m.registerSeriesType("dumbbell",
b);"";return b});h(a,"masters/modules/dumbbell.src.js",[],function(){})});
//# sourceMappingURL=dumbbell.js.map |
/**
*
* @license Guriddo jqGrid JS - v5.5.3 - 2021-02-01
* Copyright(c) 2008, Tony Tomov, tony@trirand.com
*
* License: http://guriddo.net/?page_id=103334
*/
(function( factory ) {
"use strict";
if ( typeof define === "function" && define.amd ) {
// AMD. Register as an anonymous module.
define([
"jquery"
], factory );
} else {
// Browser globals
factory( jQuery );
}
}(function( $ ) {
"use strict";
//module begin
$.jgrid = $.jgrid || {};
if(!$.jgrid.hasOwnProperty("defaults")) {
$.jgrid.defaults = {};
}
$.extend($.jgrid,{
version : "5.5.3",
isFunction : function (x){
return typeof x === 'function';
},
htmlDecode : function(value){
if(value && (value===' ' || value===' ' || (value.length===1 && value.charCodeAt(0)===160))) { return "";}
return !value ? value : String(value).replace(/>/g, ">").replace(/</g, "<").replace(/"/g, '"').replace(/&/g, "&");
},
htmlEncode : function (value){
return !value ? value : String(value).replace(/&/g, "&").replace(/\"/g, """).replace(/</g, "<").replace(/>/g, ">");
},
template : function(format){ //jqgformat
var args = $.makeArray(arguments).slice(1), j, al = args.length;
if(format==null) { format = ""; }
return format.replace(/\{([\w\-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g, function(m,i){
if(!isNaN(parseInt(i,10))) {
return args[parseInt(i,10)];
}
for(j=0; j < al;j++) {
if($.isArray(args[j])) {
var nmarr = args[ j ],
k = nmarr.length;
while(k--) {
if(i===nmarr[k].nm) {
return nmarr[k].v;
}
}
}
}
});
},
msie : function () {
return $.jgrid.msiever() > 0;
},
msiever : function () {
var rv =0,
sAgent = window.navigator.userAgent,
Idx = sAgent.indexOf("MSIE");
if (Idx > 0) {
rv = parseInt(sAgent.substring(Idx+ 5, sAgent.indexOf(".", Idx)));
} else if ( !!navigator.userAgent.match(/Trident\/7\./) ) {
rv = 11;
}
return rv;
},
getCellIndex : function (cell) {
var c = $(cell);
if (c.is('tr')) { return -1; }
c = (!c.is('td') && !c.is('th') ? c.closest("td,th") : c)[0];
if ($.jgrid.msie()) { return $.inArray(c, c.parentNode.cells); }
return c.cellIndex;
},
stripHtml : function(v) {
v = String(v);
var regexp = /<("[^"]*"|'[^']*'|[^'">])*>/gi;
if (v) {
v = v.replace(regexp,"");
return (v && v !== ' ' && v !== ' ') ? v.replace(/\"/g,"'") : "";
}
return v;
},
stripPref : function (pref, id) {
var obj = $.type( pref );
if( obj === "string" || obj === "number") {
pref = String(pref);
id = pref !== "" ? String(id).replace(String(pref), "") : id;
}
return id;
},
useJSON : true,
parse : function(jsonString) {
var js = jsonString;
if (js.substr(0,9) === "while(1);") { js = js.substr(9); }
if (js.substr(0,2) === "/*") { js = js.substr(2,js.length-4); }
if(!js) { js = "{}"; }
return ($.jgrid.useJSON===true && typeof JSON === 'object' && typeof JSON.parse === 'function') ?
JSON.parse(js) :
eval('(' + js + ')');
},
parseDate : function(format, date, newformat, opts) {
var token = /\\.|[dDjlNSwzWFmMntLoYyaABgGhHisueIOPTZcrU]/g,
timezone = /\b(?:[PMCEA][SDP]T|(?:Pacific|Mountain|Central|Eastern|Atlantic) (?:Standard|Daylight|Prevailing) Time|(?:GMT|UTC)(?:[-+]\d{4})?)\b/g,
timezoneClip = /[^-+\dA-Z]/g,
msDateRegExp = new RegExp("^\/Date\\((([-+])?[0-9]+)(([-+])([0-9]{2})([0-9]{2}))?\\)\/$"),
msMatch = ((typeof date === 'string') ? date.match(msDateRegExp): null),
pad = function (value, length) {
value = String(value);
length = parseInt(length,10) || 2;
while (value.length < length) { value = '0' + value; }
return value;
},
ts = {m : 1, d : 1, y : 1970, h : 0, i : 0, s : 0, u:0},
timestamp=0, dM, k,hl,
h12to24 = function(ampm, h){
if (ampm === 0){ if (h === 12) { h = 0;} }
else { if (h !== 12) { h += 12; } }
return h;
},
offset =0;
if(opts === undefined) {
opts = $.jgrid.getRegional(this, "formatter.date");//$.jgrid.formatter.date;
}
// old lang files
if(opts === undefined) {
opts = {};
}
if(opts.parseRe === undefined ) {
opts.parseRe = /[#%\\\/:_;.,\t\s-]/;
}
if(opts.AmPm === undefined ) {
opts.AmPm = ["am","pm","AM","PM"];
}
if( opts.masks && opts.masks.hasOwnProperty(format) ) { format = opts.masks[format]; }
if(date && date != null) {
if( !isNaN( date - 0 ) && String(format).toLowerCase() === "u") {
//Unix timestamp
timestamp = new Date( parseFloat(date)*1000 );
opts.validate = false;
} else if(date.constructor === Date) {
timestamp = date;
opts.validate = false;
} else if( msMatch !== null ) {
// Microsoft date format support
timestamp = new Date(parseInt(msMatch[1], 10));
if (msMatch[3]) {
offset = Number(msMatch[5]) * 60 + Number(msMatch[6]);
offset *= ((msMatch[4] === '-') ? 1 : -1);
offset -= timestamp.getTimezoneOffset();
timestamp.setTime(Number(Number(timestamp) + (offset * 60 * 1000)));
}
opts.validate = false;
} else {
//Support ISO8601Long that have Z at the end to indicate UTC timezone
if(opts.srcformat === 'ISO8601Long' && date.charAt(date.length - 1) === 'Z') {
offset -= (new Date()).getTimezoneOffset();
}
date = String(date).replace(/\T/g,"#").replace(/\t/,"%").split(opts.parseRe);
format = format.replace(/\T/g,"#").replace(/\t/,"%").split(opts.parseRe);
// parsing for month names
for(k=0,hl=format.length;k<hl;k++){
switch ( format[k] ) {
case 'M':
dM = $.inArray(date[k],opts.monthNames);
if(dM !== -1 && dM < 12){date[k] = dM+1; ts.m = date[k];}
break;
case 'F':
dM = $.inArray(date[k],opts.monthNames,12);
if(dM !== -1 && dM > 11){date[k] = dM+1-12; ts.m = date[k];}
break;
case 'n':
format[k] = 'm';
break;
case 'j':
format[k] = 'd';
break;
case 'a':
dM = $.inArray(date[k],opts.AmPm);
if(dM !== -1 && dM < 2 && date[k] === opts.AmPm[dM]){
date[k] = dM;
ts.h = h12to24(date[k], ts.h);
}
break;
case 'A':
dM = $.inArray(date[k],opts.AmPm);
if(dM !== -1 && dM > 1 && date[k] === opts.AmPm[dM]){
date[k] = dM-2;
ts.h = h12to24(date[k], ts.h);
}
break;
case 'g':
ts.h = parseInt(date[k], 10);
break;
}
if(date[k] !== undefined) {
ts[format[k].toLowerCase()] = parseInt(date[k],10);
}
}
if(ts.f) {ts.m = ts.f;}
if( ts.m === 0 && ts.y === 0 && ts.d === 0) {
return " " ;
}
ts.m = parseInt(ts.m,10)-1;
var ty = ts.y;
if (ty >= 70 && ty <= 99) {ts.y = 1900+ts.y;}
else if (ty >=0 && ty <=69) {ts.y= 2000+ts.y;}
timestamp = new Date(ts.y, ts.m, ts.d, ts.h, ts.i, ts.s, ts.u);
//Apply offset to show date as local time.
if(offset !== 0) {
timestamp.setTime(Number(Number(timestamp) + (offset * 60 * 1000)));
}
}
} else {
timestamp = new Date(ts.y, ts.m, ts.d, ts.h, ts.i, ts.s, ts.u);
}
if(opts && opts.validate === true ) { // validation
const valid_date = new Date(ts.y, (+ts.m), ts.d, ts.h, ts.i);
return (Boolean(+valid_date) && valid_date.getDate() === ts.d && valid_date.getHours() === ts.h && valid_date.getMinutes() === ts.i);
}
if(opts.userLocalTime && offset === 0) {
offset -= (new Date()).getTimezoneOffset();
if( offset !== 0 ) {
timestamp.setTime(Number(Number(timestamp) + (offset * 60 * 1000)));
}
}
if( newformat === undefined ) {
return timestamp;
}
if( opts.masks && opts.masks.hasOwnProperty(newformat) ) {
newformat = opts.masks[newformat];
} else if ( !newformat ) {
newformat = 'Y-m-d';
}
var
G = timestamp.getHours(),
i = timestamp.getMinutes(),
j = timestamp.getDate(),
n = timestamp.getMonth() + 1,
o = timestamp.getTimezoneOffset(),
s = timestamp.getSeconds(),
u = timestamp.getMilliseconds(),
w = timestamp.getDay(),
Y = timestamp.getFullYear(),
N = (w + 6) % 7 + 1,
z = (new Date(Y, n - 1, j) - new Date(Y, 0, 1)) / 86400000,
flags = {
// Day
d: pad(j),
D: opts.dayNames[w],
j: j,
l: opts.dayNames[w + 7],
N: N,
S: opts.S(j),
//j < 11 || j > 13 ? ['st', 'nd', 'rd', 'th'][Math.min((j - 1) % 10, 3)] : 'th',
w: w,
z: z,
// Week
W: N < 5 ? Math.floor((z + N - 1) / 7) + 1 : Math.floor((z + N - 1) / 7) || ((new Date(Y - 1, 0, 1).getDay() + 6) % 7 < 4 ? 53 : 52),
// Month
F: opts.monthNames[n - 1 + 12],
m: pad(n),
M: opts.monthNames[n - 1],
n: n,
t: '?',
// Year
L: '?',
o: '?',
Y: Y,
y: String(Y).substring(2),
// Time
a: G < 12 ? opts.AmPm[0] : opts.AmPm[1],
A: G < 12 ? opts.AmPm[2] : opts.AmPm[3],
B: '?',
g: G % 12 || 12,
G: G,
h: pad(G % 12 || 12),
H: pad(G),
i: pad(i),
s: pad(s),
u: u,
// Timezone
e: '?',
I: '?',
O: (o > 0 ? "-" : "+") + pad(Math.floor(Math.abs(o) / 60) * 100 + Math.abs(o) % 60, 4),
P: '?',
T: (String(timestamp).match(timezone) || [""]).pop().replace(timezoneClip, ""),
Z: '?',
// Full Date/Time
c: '?',
r: '?',
U: Math.floor(timestamp / 1000)
};
return newformat.replace(token, function ($0) {
return flags.hasOwnProperty($0) ? flags[$0] : $0.substring(1);
});
},
jqID : function(sid){
return String(sid).replace(/[!"#$%&'()*+,.\/:; <=>?@\[\\\]\^`{|}~]/g,"\\$&");
},
guid : 1,
uidPref: 'jqg',
randId : function( prefix ) {
return (prefix || $.jgrid.uidPref) + ($.jgrid.guid++);
},
getAccessor : function(obj, expr) {
var ret,p,prm = [], i;
if( typeof expr === 'function') { return expr(obj); }
ret = obj[expr];
if(ret===undefined) {
try {
if ( typeof expr === 'string' ) {
prm = expr.split('.');
}
i = prm.length;
if( i ) {
ret = obj;
while (ret && i--) {
p = prm.shift();
ret = ret[p];
}
}
} catch (e) {}
}
return ret;
},
getXmlData: function (obj, expr, returnObj) {
var ret, m = typeof expr === 'string' ? expr.match(/^(.*)\[(\w+)\]$/) : null;
if (typeof expr === 'function') { return expr(obj); }
if (m && m[2]) {
// m[2] is the attribute selector
// m[1] is an optional element selector
// examples: "[id]", "rows[page]"
return m[1] ? $(m[1], obj).attr(m[2]) : $(obj).attr(m[2]);
}
ret = $(expr, obj);
if (returnObj) { return ret; }
//$(expr, obj).filter(':last'); // we use ':last' to be more compatible with old version of jqGrid
return ret.length > 0 ? $(ret).text() : undefined;
},
cellWidth : function () {
var $testDiv = $("<div class='ui-jqgrid' style='left:10000px'><table class='ui-jqgrid-btable ui-common-table' style='width:5px;'><tr class='jqgrow'><td style='width:5px;display:block;'></td></tr></table></div>"),
testCell = $testDiv.appendTo("body")
.find("td")
.width();
$testDiv.remove();
return Math.abs(testCell-5) > 0.1;
},
isLocalStorage : function () {
try {
return 'localStorage' in window && window.localStorage !== null;
} catch (e) {
return false;
}
},
getRegional : function(inst, param, def_val) {
var ret;
if(def_val !== undefined) {
return def_val;
}
if(inst.p && inst.p.regional && $.jgrid.regional) {
ret = $.jgrid.getAccessor( $.jgrid.regional[inst.p.regional] || {}, param);
}
if(ret === undefined ) {
ret = $.jgrid.getAccessor( $.jgrid, param);
}
return ret;
},
isMobile : function() {
try {
if(/Android|webOS|iPhone|iPad|iPod|pocket|psp|kindle|avantgo|blazer|midori|Tablet|Palm|maemo|plucker|phone|BlackBerry|symbian|IEMobile|mobile|ZuneWP7|Windows Phone|Opera Mini/i.test(navigator.userAgent)) {
return true;
}
return false;
} catch(e) {
return false;
}
},
cell_width : true,
scrollbarWidth : function() {
// http://jdsharp.us/jQuery/minute/calculate-scrollbar-width.php
var div = $('<div style="width:50px;height:50px;overflow:hidden;position:absolute;top:-200px;left:-200px;"><div style="height:100px;"></div>');
$('body').append(div);
var w1 = $('div', div).innerWidth();
div.css('overflow-y', 'scroll');
var w2 = $('div', div).innerWidth();
$(div).remove();
return (w1 - w2) < 0 ? 18 : (w1 - w2);
},
ajaxOptions: {},
from : function(source){
// Original Author Hugo Bonacci
// License MIT http://jlinq.codeplex.com/license
var $t = this,
QueryObject=function(d,q){
if(typeof d==="string"){
d=$.data(d);
}
var self=this,
_data=d,
_usecase=true,
_trim=false,
_query=q,
_stripNum = /[\$,%]/g,
_lastCommand=null,
_lastField=null,
_orDepth=0,
_negate=false,
_queuedOperator="",
_sorting=[],
_useProperties=true;
if(typeof d==="object"&&d.push) {
if(d.length>0){
if(typeof d[0]!=="object"){
_useProperties=false;
}else{
_useProperties=true;
}
}
}else{
throw "data provides is not an array";
}
this._hasData=function(){
return _data===null?false:_data.length===0?false:true;
};
this._getStr=function(s){
var phrase=[];
if(_trim){
phrase.push("jQuery.trim(");
}
phrase.push("String("+s+")");
if(_trim){
phrase.push(")");
}
if(!_usecase){
phrase.push(".toLowerCase()");
}
return phrase.join("");
};
this._strComp=function(val){
if(typeof val==="string"){
return".toString()";
}
return"";
};
this._group=function(f,u){
return({field:f.toString(),unique:u,items:[]});
};
this._toStr=function(phrase){
if(_trim){
phrase=$.trim(phrase);
}
phrase=phrase.toString().replace(/\\/g,'\\\\').replace(/\"/g,'\\"');
return _usecase ? phrase : phrase.toLowerCase();
};
this._funcLoop=function(func){
var results=[];
$.each(_data,function(i,v){
results.push(func(v));
});
return results;
};
this._append=function(s){
var i;
if(_query===null){
_query="";
} else {
_query+=_queuedOperator === "" ? " && " :_queuedOperator;
}
for (i=0;i<_orDepth;i++){
_query+="(";
}
if(_negate){
_query+="!";
}
_query+="("+s+")";
_negate=false;
_queuedOperator="";
_orDepth=0;
};
this._setCommand=function(f,c){
_lastCommand=f;
_lastField=c;
};
this._resetNegate=function(){
_negate=false;
};
this._repeatCommand=function(f,v){
if(_lastCommand===null){
return self;
}
if(f!==null&&v!==null){
return _lastCommand(f,v);
}
if(_lastField===null){
return _lastCommand(f);
}
if(!_useProperties){
return _lastCommand(f);
}
return _lastCommand(_lastField,f);
};
this._equals=function(a,b){
return(self._compare(a,b,1)===0);
};
this._compare=function(a,b,d){
var toString = Object.prototype.toString;
if( d === undefined) { d = 1; }
if(a===undefined) { a = null; }
if(b===undefined) { b = null; }
if(a===null && b===null){
return 0;
}
if(a===null&&b!==null){
return 1;
}
if(a!==null&&b===null){
return -1;
}
if (toString.call(a) === '[object Date]' && toString.call(b) === '[object Date]') {
if (a < b) { return -d; }
if (a > b) { return d; }
return 0;
}
if(!_usecase && typeof a !== "number" && typeof b !== "number" ) {
a=String(a);
b=String(b);
}
if(a<b){return -d;}
if(a>b){return d;}
return 0;
};
this._performSort=function(){
if(_sorting.length===0){return;}
_data=self._doSort(_data,0);
};
this._doSort=function(d,q){
var by=_sorting[q].by,
dir=_sorting[q].dir,
type = _sorting[q].type,
dfmt = _sorting[q].datefmt,
sfunc = _sorting[q].sfunc;
if(q===_sorting.length-1){
return self._getOrder(d, by, dir, type, dfmt, sfunc);
}
q++;
var values=self._getGroup(d,by,dir,type,dfmt), results=[], i, j, sorted;
for(i=0;i<values.length;i++){
sorted=self._doSort(values[i].items,q);
for(j=0;j<sorted.length;j++){
results.push(sorted[j]);
}
}
return results;
};
this._getOrder=function(data,by,dir,type, dfmt, sfunc){
var sortData=[],_sortData=[], newDir = dir==="a" ? 1 : -1, i,ab,j,
findSortKey;
if(type === undefined ) { type = "text"; }
if (type === 'float' || type=== 'number' || type=== 'currency' || type=== 'numeric') {
findSortKey = function($cell) {
var key = parseFloat( String($cell).replace(_stripNum, ''));
return isNaN(key) ? Number.NEGATIVE_INFINITY : key;
};
} else if (type==='int' || type==='integer') {
findSortKey = function($cell) {
return $cell ? parseFloat(String($cell).replace(_stripNum, '')) : Number.NEGATIVE_INFINITY;
};
} else if(type === 'date' || type === 'datetime') {
findSortKey = function($cell) {
return $.jgrid.parseDate.call($t, dfmt, $cell).getTime();
};
} else if($.isFunction(type)) {
findSortKey = type;
} else {
findSortKey = function($cell) {
$cell = $cell ? $.trim(String($cell)) : "";
return _usecase ? $cell : $cell.toLowerCase();
};
}
$.each(data,function(i,v){
ab = by!=="" ? $.jgrid.getAccessor(v,by) : v;
if(ab === undefined) { ab = ""; }
ab = findSortKey(ab, v);
_sortData.push({ 'vSort': ab,'index':i});
});
if($.isFunction(sfunc)) {
_sortData.sort(function(a,b){
return sfunc.call(this,a.vSort, b.vSort, newDir, a, b);
});
} else {
_sortData.sort(function(a,b){
return self._compare(a.vSort, b.vSort,newDir);
});
}
j=0;
var nrec= data.length;
// overhead, but we do not change the original data.
while(j<nrec) {
i = _sortData[j].index;
sortData.push(data[i]);
j++;
}
return sortData;
};
this._getGroup=function(data,by,dir,type, dfmt){
var results=[],
group=null,
last=null, val;
$.each(self._getOrder(data,by,dir,type, dfmt),function(i,v){
val = $.jgrid.getAccessor(v, by);
if(val == null) { val = ""; }
if(!self._equals(last,val)){
last=val;
if(group !== null){
results.push(group);
}
group=self._group(by,val);
}
group.items.push(v);
});
if(group !== null){
results.push(group);
}
return results;
};
this.ignoreCase=function(){
_usecase=false;
return self;
};
this.useCase=function(){
_usecase=true;
return self;
};
this.trim=function(){
_trim=true;
return self;
};
this.noTrim=function(){
_trim=false;
return self;
};
this.execute=function(){
var match=_query, results=[];
if(match === null){
return self;
}
$.each(_data,function(){
if(eval(match)){results.push(this);}
});
_data=results;
return self;
};
this.data=function(){
return _data;
};
this.select=function(f){
self._performSort();
if(!self._hasData()){ return[]; }
self.execute();
if($.isFunction(f)){
var results=[];
$.each(_data,function(i,v){
results.push(f(v));
});
return results;
}
return _data;
};
this.hasMatch=function(){
if(!self._hasData()) { return false; }
self.execute();
return _data.length>0;
};
this.andNot=function(f,v,x){
_negate=!_negate;
return self.and(f,v,x);
};
this.orNot=function(f,v,x){
_negate=!_negate;
return self.or(f,v,x);
};
this.not=function(f,v,x){
return self.andNot(f,v,x);
};
this.and=function(f,v,x){
_queuedOperator=" && ";
if(f===undefined){
return self;
}
return self._repeatCommand(f,v,x);
};
this.or=function(f,v,x){
_queuedOperator=" || ";
if(f===undefined) { return self; }
return self._repeatCommand(f,v,x);
};
this.orBegin=function(){
_orDepth++;
return self;
};
this.orEnd=function(){
if (_query !== null){
_query+=")";
}
return self;
};
this.isNot=function(f){
_negate=!_negate;
return self.is(f);
};
this.is=function(f){
self._append('this.'+f);
self._resetNegate();
return self;
};
this._compareValues=function(func,f,v,how,t){
var fld;
if(_useProperties){
fld='jQuery.jgrid.getAccessor(this,\''+f+'\')';
}else{
fld='this';
}
if(v===undefined) { v = null; }
//var val=v===null?f:v,
var val =v,
swst = t.stype === undefined ? "text" : t.stype;
if(v !== null) {
switch(swst) {
case 'int':
case 'integer':
val = (isNaN(Number(val)) || val==="") ? Number.NEGATIVE_INFINITY : val; // To be fixed with more inteligent code
fld = 'parseInt('+fld+',10)';
val = 'parseInt('+val+',10)';
break;
case 'float':
case 'number':
case 'numeric':
val = String(val).replace(_stripNum, '');
val = (isNaN(Number(val)) || val==="") ? Number.NEGATIVE_INFINITY : Number(val); // To be fixed with more inteligent code
fld = 'parseFloat('+fld+')';
val = 'parseFloat('+val+')';
break;
case 'date':
case 'datetime':
val = String($.jgrid.parseDate.call($t, t.srcfmt || 'Y-m-d',val).getTime());
fld = 'jQuery.jgrid.parseDate.call(jQuery("#'+$.jgrid.jqID($t.p.id)+'")[0],"'+t.srcfmt+'",'+fld+').getTime()';
break;
default :
fld=self._getStr(fld);
val=self._getStr('"'+self._toStr(val)+'"');
}
}
self._append(fld+' '+how+' '+val);
self._setCommand(func,f);
self._resetNegate();
return self;
};
this.equals=function(f,v,t){
return self._compareValues(self.equals,f,v,"==",t);
};
this.notEquals=function(f,v,t){
return self._compareValues(self.equals,f,v,"!==",t);
};
this.isNull = function(f,v,t){
return self._compareValues(self.equals,f,null,"===",t);
};
this.greater=function(f,v,t){
return self._compareValues(self.greater,f,v,">",t);
};
this.less=function(f,v,t){
return self._compareValues(self.less,f,v,"<",t);
};
this.greaterOrEquals=function(f,v,t){
return self._compareValues(self.greaterOrEquals,f,v,">=",t);
};
this.lessOrEquals=function(f,v,t){
return self._compareValues(self.lessOrEquals,f,v,"<=",t);
};
this.startsWith=function(f,v){
var val = (v==null) ? f: v,
length=_trim ? $.trim(val.toString()).length : val.toString().length;
if(_useProperties){
self._append(self._getStr('jQuery.jgrid.getAccessor(this,\''+f+'\')')+'.substr(0,'+length+') == '+self._getStr('"'+self._toStr(v)+'"'));
}else{
if (v!=null) { length=_trim?$.trim(v.toString()).length:v.toString().length; }
self._append(self._getStr('this')+'.substr(0,'+length+') == '+self._getStr('"'+self._toStr(f)+'"'));
}
self._setCommand(self.startsWith,f);
self._resetNegate();
return self;
};
this.endsWith=function(f,v){
var val = (v==null) ? f: v,
length=_trim ? $.trim(val.toString()).length:val.toString().length;
if(_useProperties){
self._append(self._getStr('jQuery.jgrid.getAccessor(this,\''+f+'\')')+'.substr('+self._getStr('jQuery.jgrid.getAccessor(this,\''+f+'\')')+'.length-'+length+','+length+') == "'+self._toStr(v)+'"');
} else {
self._append(self._getStr('this')+'.substr('+self._getStr('this')+'.length-"'+self._toStr(f)+'".length,"'+self._toStr(f)+'".length) == "'+self._toStr(f)+'"');
}
self._setCommand(self.endsWith,f);self._resetNegate();
return self;
};
this.contains=function(f,v){
if(_useProperties){
self._append(self._getStr('jQuery.jgrid.getAccessor(this,\''+f+'\')')+'.indexOf("'+self._toStr(v)+'",0) > -1');
}else{
self._append(self._getStr('this')+'.indexOf("'+self._toStr(f)+'",0) > -1');
}
self._setCommand(self.contains,f);
self._resetNegate();
return self;
};
this.user=function(op, f, v){
self._append('$t.p.customFilterDef.' + op + '.action.call($t ,{rowItem:this, searchName:"' + f + '",searchValue:"' + v + '"})');
self._setCommand(self.user,f);
self._resetNegate();
return self;
};
this.inData = function (f, v, t) {
var vl = v === undefined ? "" : self._getStr("\"" + self._toStr(v) + "\"");
if( _useProperties ) {
self._append(vl + '.split(\''+',' + '\')' + '.indexOf( jQuery.jgrid.getAccessor(this,\''+f+'\') ) > -1');
} else {
self._append(vl + '.split(\''+',' + '\')' + '.indexOf(this.'+f+') > -1');
}
self._setCommand(self.inData, f);
self._resetNegate();
return self;
};
this.groupBy=function(by,dir,type, datefmt){
if(!self._hasData()){
return null;
}
return self._getGroup(_data,by,dir,type, datefmt);
};
this.orderBy=function(by,dir,stype, dfmt, sfunc){
dir = dir == null ? "a" :$.trim(dir.toString().toLowerCase());
if(stype == null) { stype = "text"; }
if(dfmt == null) { dfmt = "Y-m-d"; }
if(sfunc == null) { sfunc = false; }
if(dir==="desc"||dir==="descending"){dir="d";}
if(dir==="asc"||dir==="ascending"){dir="a";}
_sorting.push({by:by,dir:dir,type:stype, datefmt: dfmt, sfunc: sfunc});
return self;
};
return self;
};
return new QueryObject(source,null);
},
getMethod: function (name) {
return this.getAccessor($.fn.jqGrid, name);
},
extend : function(methods) {
$.extend($.fn.jqGrid,methods);
if (!this.no_legacy_api) {
$.fn.extend(methods);
}
},
clearBeforeUnload : function( jqGridId ) {
var $t = $("#"+$.jgrid.jqID( jqGridId ))[0], grid;
if(!$t.grid) { return;}
grid = $t.grid;
if ($.isFunction(grid.emptyRows)) {
grid.emptyRows.call($t, true, true); // this work quick enough and reduce the size of memory leaks if we have someone
}
$(document).off("mouseup.jqGrid" + $t.p.id );
$(grid.hDiv).off("mousemove"); // TODO add namespace
$($t).off();
var i, l = grid.headers.length,
removevents = ['formatCol','sortData','updatepager','refreshIndex','setHeadCheckBox','constructTr','formatter','addXmlData','addJSONData','grid','p', 'addLocalData'];
for (i = 0; i < l; i++) {
grid.headers[i].el = null;
}
for( i in grid) {
if( grid.hasOwnProperty(i)) {
grid[i] = null;
}
}
// experimental
for( i in $t.p) {
if($t.p.hasOwnProperty(i)) {
$t.p[i] = $.isArray($t.p[i]) ? [] : null;
}
}
l = removevents.length;
for(i = 0; i < l; i++) {
if($t.hasOwnProperty(removevents[i])) {
$t[removevents[i]] = null;
delete($t[removevents[i]]);
}
}
},
gridUnload : function ( jqGridId ) {
if(!jqGridId) { return; }
jqGridId = $.trim(jqGridId);
if(jqGridId.indexOf("#") === 0) {
jqGridId = jqGridId.substring(1);
}
var $t = $("#"+ $.jgrid.jqID(jqGridId))[0];
if ( !$t.grid ) {return;}
var defgrid = {id: $($t).attr('id'),cl: $($t).attr('class')};
if ($t.p.pager) {
$($t.p.pager).off().empty().removeClass("ui-state-default ui-jqgrid-pager ui-corner-bottom");
}
var newtable = document.createElement('table');
newtable.className = defgrid.cl;
var gid = $.jgrid.jqID($t.id);
$(newtable).removeClass("ui-jqgrid-btable ui-common-table").insertBefore("#gbox_"+gid);
if( $($t.p.pager).parents("#gbox_"+gid).length === 1 ) {
$($t.p.pager).insertBefore("#gbox_"+gid);
}
$.jgrid.clearBeforeUnload( jqGridId );
$("#gbox_"+gid).remove();
$(newtable).attr({id:defgrid.id});
$("#alertmod_"+$.jgrid.jqID(jqGridId)).remove();
},
gridDestroy : function ( jqGridId ) {
if(!jqGridId) { return; }
jqGridId = $.trim(jqGridId);
if(jqGridId.indexOf("#") === 0) {
jqGridId = jqGridId.substring(1);
}
var $t = $("#"+ $.jgrid.jqID(jqGridId))[0];
if ( !$t.grid ) {return;}
if ( $t.p.pager ) { // if not part of grid
$($t.p.pager).remove();
}
try {
$.jgrid.clearBeforeUnload( jqGridId );
$("#gbox_"+$.jgrid.jqID(jqGridId)).remove();
} catch (_) {}
},
isElementInViewport : function(el) {
var rect = el.getBoundingClientRect();
return (
rect.left >= 0 &&
rect.right <= (window.innerWidth || document.documentElement.clientWidth)
);
},
getTextWidth : function(text, font) {
if (!jQuery._cacheCanvas) {
var canvas = document.createElement('canvas');
var docFragment = document.createDocumentFragment();
docFragment.appendChild(canvas);
jQuery._cacheCanvas = canvas.getContext("2d");
if(font) {
jQuery._cacheCanvas.font = font;
}
}
return jQuery._cacheCanvas.measureText( $.jgrid.stripHtml( text ) ).width;
},
getFont : function (instance) {
var getfont = window.getComputedStyle( instance, null );
return getfont.getPropertyValue( 'font-style' ) + " " +
getfont.getPropertyValue( 'font-size' ) + " " +
getfont.getPropertyValue( 'font-family');
},
setSelNavIndex : function ($t, selelem ) {
var cels = $(".ui-pg-button",$t.p.pager);
$.each(cels, function(i,n) {
if(selelem===n) {
$t.p.navIndex = i;
return false;
}
});
$(selelem).attr("tabindex","0");
},
splitSearch : function (p) {
/*
p : {
mergeOper : 'OR',
filterInput : null,
filterToolbar : null,
searchGrid : null
}
*/
var rules = "{\"groupOp\":\"" + p.mergeOper + "\",\"rules\":[],\"groups\":[", i=0;
for( var property in p) {
if(p.hasOwnProperty(property)) {
if(property !== 'mergeOper') {
rules += p[property] !== null ? p[property] + ",": "";
i++;
}
}
}
rules = rules.slice(0, -1);
rules += "]}";
return rules;
},
styleUI : {
jQueryUI : {
common : {
disabled: "ui-state-disabled",
highlight : "ui-state-highlight",
hover : "ui-state-hover",
cornerall: "ui-corner-all",
cornertop: "ui-corner-top",
cornerbottom : "ui-corner-bottom",
hidden : "ui-helper-hidden",
icon_base : "ui-icon",
overlay : "ui-widget-overlay",
active : "ui-state-active",
error : "ui-state-error",
button : "ui-state-default ui-corner-all",
content : "ui-widget-content"
},
base : {
entrieBox : "ui-widget ui-widget-content ui-corner-all", // entrie div incl everthing
viewBox : "", // view diw
headerTable : "",
headerBox : "ui-state-default",
rowTable : "",
rowBox : "ui-widget-content",
stripedTable : "ui-jqgrid-table-striped",
footerTable : "",
footerBox : "ui-widget-content",
headerRowTable : "",
headerRowBox : "ui-widget-content",
headerDiv : "ui-state-default",
gridtitleBox : "ui-widget-header ui-corner-top ui-helper-clearfix",
customtoolbarBox : "ui-state-default",
//overlayBox: "ui-widget-overlay",
loadingBox : "ui-state-default ui-state-active",
rownumBox : "ui-state-default",
scrollBox : "ui-widget-content",
multiBox : "",
pagerBox : "ui-state-default ui-corner-bottom",
pagerTable : "",
toppagerBox : "ui-state-default",
pgInput : "ui-corner-all",
pgSelectBox : "ui-widget-content ui-corner-all",
pgButtonBox : "ui-corner-all",
icon_first : "ui-icon-seek-first",
icon_prev : "ui-icon-seek-prev",
icon_next: "ui-icon-seek-next",
icon_end: "ui-icon-seek-end",
icon_asc : "ui-icon-triangle-1-n",
icon_desc : "ui-icon-triangle-1-s",
icon_caption_open : "ui-icon-circle-triangle-n",
icon_caption_close : "ui-icon-circle-triangle-s"
},
modal : {
modal : "ui-widget ui-widget-content ui-corner-all ui-dialog",
header : "ui-widget-header ui-corner-all ui-helper-clearfix",
content :"ui-widget-content",
resizable : "ui-resizable-handle ui-resizable-se",
icon_close : "ui-icon-closethick",
icon_resizable : "ui-icon-gripsmall-diagonal-se"
},
celledit : {
inputClass : "ui-widget-content ui-corner-all"
},
inlinedit : {
inputClass : "ui-widget-content ui-corner-all",
icon_edit_nav : "ui-icon-pencil",
icon_add_nav : "ui-icon-plus",
icon_save_nav : "ui-icon-disk",
icon_cancel_nav : "ui-icon-cancel"
},
formedit : {
inputClass : "ui-widget-content ui-corner-all",
icon_prev : "ui-icon-triangle-1-w",
icon_next : "ui-icon-triangle-1-e",
icon_save : "ui-icon-disk",
icon_close : "ui-icon-close",
icon_del : "ui-icon-scissors",
icon_cancel : "ui-icon-cancel"
},
navigator : {
icon_edit_nav : "ui-icon-pencil",
icon_add_nav : "ui-icon-plus",
icon_del_nav : "ui-icon-trash",
icon_search_nav : "ui-icon-search",
icon_refresh_nav : "ui-icon-refresh",
icon_view_nav : "ui-icon-document",
icon_newbutton_nav : "ui-icon-newwin"
},
grouping : {
icon_plus : 'ui-icon-circlesmall-plus',
icon_minus : 'ui-icon-circlesmall-minus'
},
filter : {
table_widget : 'ui-widget ui-widget-content',
srSelect : 'ui-widget-content ui-corner-all',
srInput : 'ui-widget-content ui-corner-all',
menu_widget : 'ui-widget ui-widget-content ui-corner-all',
icon_search : 'ui-icon-search',
icon_reset : 'ui-icon-arrowreturnthick-1-w',
icon_query :'ui-icon-comment'
},
subgrid : {
icon_plus : 'ui-icon-plus',
icon_minus : 'ui-icon-minus',
icon_open : 'ui-icon-carat-1-sw'
},
treegrid : {
icon_plus : 'ui-icon-triangle-1-',
icon_minus : 'ui-icon-triangle-1-s',
icon_leaf : 'ui-icon-radio-off'
},
fmatter : {
icon_edit : "ui-icon-pencil",
icon_add : "ui-icon-plus",
icon_save : "ui-icon-disk",
icon_cancel : "ui-icon-cancel",
icon_del : "ui-icon-trash"
},
colmenu : {
menu_widget : 'ui-widget ui-widget-content ui-corner-all',
input_checkbox : "ui-widget ui-widget-content",
filter_select: "ui-widget-content ui-corner-all",
filter_input : "ui-widget-content ui-corner-all",
icon_menu : "ui-icon-comment",
icon_sort_asc : "ui-icon-arrow-1-n",
icon_sort_desc : "ui-icon-arrow-1-s",
icon_columns : "ui-icon-extlink",
icon_filter : "ui-icon-calculator",
icon_group : "ui-icon-grip-solid-horizontal",
icon_freeze : "ui-icon-grip-solid-vertical",
icon_move: "ui-icon-arrow-4",
icon_new_item : "ui-icon-newwin",
icon_toolbar_menu : "ui-icon-document"
}
},
Bootstrap : {
common : {
disabled: "ui-disabled",
highlight : "success",
hover : "active",
cornerall: "",
cornertop: "",
cornerbottom : "",
hidden : "",
icon_base : "glyphicon",
overlay: "ui-overlay",
active : "active",
error : "bg-danger",
button : "btn btn-default",
content : ""
},
base : {
entrieBox : "",
viewBox : "table-responsive",
headerTable : "table table-bordered",
headerBox : "",
rowTable : "table table-bordered",
rowBox : "",
stripedTable : "table-striped",
footerTable : "table table-bordered",
footerBox : "",
headerRowTable : "table table-bordered",
headerRowBox : "",
headerDiv : "",
gridtitleBox : "",
customtoolbarBox : "",
//overlayBox: "ui-overlay",
loadingBox : "row",
rownumBox : "active",
scrollBox : "",
multiBox : "checkbox",
pagerBox : "",
pagerTable : "table",
toppagerBox : "",
pgInput : "form-control",
pgSelectBox : "form-control",
pgButtonBox : "",
icon_first : "glyphicon-step-backward",
icon_prev : "glyphicon-backward",
icon_next: "glyphicon-forward",
icon_end: "glyphicon-step-forward",
icon_asc : "glyphicon-triangle-top",
icon_desc : "glyphicon-triangle-bottom",
icon_caption_open : "glyphicon-circle-arrow-up",
icon_caption_close : "glyphicon-circle-arrow-down"
},
modal : {
modal : "modal-content",
header : "modal-header",
title : "modal-title",
content :"modal-body",
resizable : "ui-resizable-handle ui-resizable-se",
icon_close : "glyphicon-remove-circle",
icon_resizable : "glyphicon-import"
},
celledit : {
inputClass : 'form-control'
},
inlinedit : {
inputClass : 'form-control',
icon_edit_nav : "glyphicon-edit",
icon_add_nav : "glyphicon-plus",
icon_save_nav : "glyphicon-save",
icon_cancel_nav : "glyphicon-remove-circle"
},
formedit : {
inputClass : "form-control",
icon_prev : "glyphicon-step-backward",
icon_next : "glyphicon-step-forward",
icon_save : "glyphicon-save",
icon_close : "glyphicon-remove-circle",
icon_del : "glyphicon-trash",
icon_cancel : "glyphicon-remove-circle"
},
navigator : {
icon_edit_nav : "glyphicon-edit",
icon_add_nav : "glyphicon-plus",
icon_del_nav : "glyphicon-trash",
icon_search_nav : "glyphicon-search",
icon_refresh_nav : "glyphicon-refresh",
icon_view_nav : "glyphicon-info-sign",
icon_newbutton_nav : "glyphicon-new-window"
},
grouping : {
icon_plus : 'glyphicon-triangle-right',
icon_minus : 'glyphicon-triangle-bottom'
},
filter : {
table_widget : 'table table-condensed',
srSelect : 'form-control',
srInput : 'form-control',
menu_widget : '',
icon_search : 'glyphicon-search',
icon_reset : 'glyphicon-refresh',
icon_query :'glyphicon-comment'
},
subgrid : {
icon_plus : 'glyphicon-triangle-right',
icon_minus : 'glyphicon-triangle-bottom',
icon_open : 'glyphicon-indent-left'
},
treegrid : {
icon_plus : 'glyphicon-triangle-right',
icon_minus : 'glyphicon-triangle-bottom',
icon_leaf : 'glyphicon-unchecked'
},
fmatter : {
icon_edit : "glyphicon-edit",
icon_add : "glyphicon-plus",
icon_save : "glyphicon-save",
icon_cancel : "glyphicon-remove-circle",
icon_del : "glyphicon-trash"
},
colmenu : {
menu_widget : '',
input_checkbox : "",
filter_select: "form-control",
filter_input : "form-control",
icon_menu : "glyphicon-menu-hamburger",
icon_sort_asc : "glyphicon-sort-by-alphabet",
icon_sort_desc : "glyphicon-sort-by-alphabet-alt",
icon_columns : "glyphicon-list-alt",
icon_filter : "glyphicon-filter",
icon_group : "glyphicon-align-left",
icon_freeze : "glyphicon-object-align-horizontal",
icon_move: "glyphicon-move",
icon_new_item : "glyphicon-new-window",
icon_toolbar_menu : "glyphicon-menu-hamburger"
}
},
Bootstrap4 : {
common : {
disabled: "ui-disabled",
highlight : "table-success",
hover : "table-active",
cornerall: "",
cornertop: "",
cornerbottom : "",
hidden : "",
overlay: "ui-overlay",
active : "active",
error : "alert-danger",
button : "btn btn-light",
content : ""
},
base : {
entrieBox : "",
viewBox : "table-responsive",
headerTable : "table table-bordered",
headerBox : "",
rowTable : "table table-bordered",
rowBox : "",
stripedTable : "table-striped",
footerTable : "table table-bordered",
footerBox : "",
headerRowTable : "table table-bordered",
headerRowBox : "",
headerDiv : "",
gridtitleBox : "",
customtoolbarBox : "",
//overlayBox: "ui-overlay",
loadingBox : "row",
rownumBox : "active",
scrollBox : "",
multiBox : "checkbox",
pagerBox : "",
pagerTable : "table",
toppagerBox : "",
pgInput : "form-control",
pgSelectBox : "form-control",
pgButtonBox : ""
},
modal : {
modal : "modal-content",
header : "modal-header",
title : "modal-title",
content :"modal-body",
resizable : "ui-resizable-handle ui-resizable-se",
icon_close : "oi-circle-x",
icon_resizable : "oi-circle-x"
},
celledit : {
inputClass : 'form-control'
},
inlinedit : {
inputClass : 'form-control'
},
formedit : {
inputClass : "form-control"
},
navigator : {
},
grouping : {
},
filter : {
table_widget : 'table table-condensed',
srSelect : 'form-control',
srInput : 'form-control',
menu_widget : ''
},
subgrid : {
},
treegrid : {
},
fmatter : {
},
colmenu : {
menu_widget : '',
input_checkbox : "",
filter_select: "form-control",
filter_input : "form-control"
}
}
},
iconSet : {
Iconic : {
common : {
icon_base : "oi"
},
base : {
icon_first : "oi-media-step-backward",
icon_prev : "oi-caret-left",
icon_next: "oi-caret-right",
icon_end: "oi-media-step-forward",
icon_asc : "oi-caret-top",
icon_desc : "oi-caret-bottom",
icon_caption_open : "oi-collapse-up",
icon_caption_close : "oi-expand-down"
},
modal : {
icon_close : "oi-circle-x",
icon_resizable : "oi-plus"
},
inlinedit : {
icon_edit_nav : "oi-pencil",
icon_add_nav : "oi-plus",
icon_save_nav : "oi-check",
icon_cancel_nav : "oi-action-undo"
},
formedit : {
icon_prev : "oi-chevron-left",
icon_next : "oi-chevron-right",
icon_save : "oi-check",
icon_close : "oi-ban",
icon_del : "oi-delete",
icon_cancel : "oi-ban"
},
navigator : {
icon_edit_nav : "oi-pencil",
icon_add_nav : "oi-plus",
icon_del_nav : "oi-trash",
icon_search_nav : "oi-zoom-in",
icon_refresh_nav : "oi-reload",
icon_view_nav : "oi-browser",
icon_newbutton_nav : "oi-book"
},
grouping : {
icon_plus : 'oi-caret-right',
icon_minus : 'oi-caret-bottom'
},
filter : {
icon_search : 'oi-magnifying-glass',
icon_reset : 'oi-reload',
icon_query :'oi-comment-square'
},
subgrid : {
icon_plus : 'oi-chevron-right',
icon_minus : 'oi-chevron-bottom',
icon_open : 'oi-expand-left'
},
treegrid : {
icon_plus : 'oi-plus',
icon_minus : 'oi-minus',
icon_leaf : 'oi-media-record'
},
fmatter : {
icon_edit : "oi-pencil",
icon_add : "oi-plus",
icon_save : "oi-check",
icon_cancel : "oi-action-undo",
icon_del : "oi-trash"
},
colmenu : {
icon_menu : "oi-list",
icon_sort_asc : "oi-sort-ascending",
icon_sort_desc : "oi-sort-descending",
icon_columns : "oi-project",
icon_filter : "oi-magnifying-glass",
icon_group : "oi-list-rich",
icon_freeze : "oi-spreadsheet",
icon_move: "oi-move",
icon_new_item : "oi-external-link",
icon_toolbar_menu : "oi-menu"
}
},
Octicons : {
common : {
icon_base : "octicon"
},
base : {
icon_first : "octicon-triangle-left",
icon_prev : "octicon-chevron-left",
icon_next: "octicon-chevron-right",
icon_end: "octicon-triangle-right",
icon_asc : "octicon-triangle-up",
icon_desc : "octicon-triangle-down",
icon_caption_open : "octicon-triangle-up",
icon_caption_close : "octicon-triangle-down"
},
modal : {
icon_close : "octicon-x",
icon_resizable : "octicon-plus"
},
inlinedit : {
icon_edit_nav : "octicon-pencil",
icon_add_nav : "octicon-plus",
icon_save_nav : "octicon-check",
icon_cancel_nav : "octicon-circle-slash"
},
formedit : {
icon_prev : "octicon-chevron-left",
icon_next : "octicon-chevron-right",
icon_save : "octicon-check",
icon_close : "octicon-x",
icon_del : "octicon-trashcan",
icon_cancel : "octicon-circle-slash"
},
navigator : {
icon_edit_nav : "octicon-pencil",
icon_add_nav : "octicon-plus",
icon_del_nav : "octicon-trashcan",
icon_search_nav : "octicon-search",
icon_refresh_nav : "octicon-sync",
icon_view_nav : "octicon-file",
icon_newbutton_nav : "octicon-link-external"
},
grouping : {
icon_plus : 'octicon-triangle-right',
icon_minus : 'octicon-triangle-down'
},
filter : {
icon_search : 'octicon-search',
icon_reset : 'octicon-sync',
icon_query :'octicon-file-code'
},
subgrid : {
icon_plus : 'octicon-triangle-right',
icon_minus : 'octicon-triangle-down',
icon_open : 'octicon-git-merge'
},
treegrid : {
icon_plus : 'octicon-triangle-right',
icon_minus : 'octicon-triangle-down',
icon_leaf : 'octicon-primitive-dot'
},
fmatter : {
icon_edit : "octicon-pencil",
icon_add : "octicon-plus",
icon_save : "octicon-check",
icon_cancel : "octicon-circle-slash",
icon_del : "octicon-trashcan"
},
colmenu : {
icon_menu : "octicon-grabber",
icon_sort_asc : "octicon-arrow-up",
icon_sort_desc : "octicon-arrow-down",
icon_columns : "octicon-repo",
icon_filter : "octicon-search",
icon_group : "octicon-list-unordered",
icon_freeze : "octicon-repo",
icon_move: "octicon-git-compare",
icon_new_item : "octicon-link-external",
icon_toolbar_menu : "octicon-three-bars"
}
},
fontAwesome : {
common : {
icon_base : "fas"
},
base : {
icon_first : "fa-step-backward",
icon_prev : "fa-backward",
icon_next: "fa-forward",
icon_end: "fa-step-forward",
icon_asc : "fa-caret-up",
icon_desc : "fa-caret-down",
icon_caption_open : "fa-caret-square-up",
icon_caption_close : "fa-caret-square-down "
},
modal : {
icon_close : "fa-window-close",
icon_resizable : "fa-plus"
},
inlinedit : {
icon_edit_nav : "fa-edit",
icon_add_nav : "fa-plus",
icon_save_nav : "fa-save",
icon_cancel_nav : "fa-replay"
},
formedit : {
icon_prev : "fa-chevron-left",
icon_next : "fa-chevron-right",
icon_save : "fa-save",
icon_close : "fa-window-close",
icon_del : "fa-trash",
icon_cancel : "fa-times"
},
navigator : {
icon_edit_nav : "fa-edit",
icon_add_nav : "fa-plus",
icon_del_nav : "fa-trash",
icon_search_nav : "fa-search",
icon_refresh_nav : "fa-sync",
icon_view_nav : "fa-sticky-note",
icon_newbutton_nav : "fa-external-link-alt"
},
grouping : {
icon_plus : 'fa-caret-right',
icon_minus : 'fa-caret-down'
},
filter : {
icon_search : 'fa-search',
icon_reset : 'fa-reply',
icon_query :'fa-pen-square '
},
subgrid : {
icon_plus : 'fa-arrow-circle-right',
icon_minus : 'fa-arrow-circle-down',
icon_open : 'fa-ellipsis-v'
},
treegrid : {
icon_plus : 'fa-plus',
icon_minus : 'fa-minus',
icon_leaf : 'fa-circle'
},
fmatter : {
icon_edit : "fa-edit",
icon_add : "fa-plus",
icon_save : "fa-save",
icon_cancel : "fa-undo",
icon_del : "fa-trash"
},
colmenu : {
icon_menu : "fa-ellipsis-v",
icon_sort_asc : "fa-sort-amount-up",
icon_sort_desc : "fa-sort-amount-down",
icon_columns : "fa-columns",
icon_filter : "fa-filter",
icon_group : "fa-object-group",
icon_freeze : "fa-snowflake",
icon_move: "fa-expand-arrows-alt",
icon_new_item : "fa-external-link-alt",
icon_toolbar_menu : "fa-list"
}
}
}
});
$.fn.jqGrid = function( pin ) {
if (typeof pin === 'string') {
var fn = $.jgrid.getMethod(pin);
if (!fn) {
throw ("jqGrid - No such method: " + pin);
}
var args = $.makeArray(arguments).slice(1);
return fn.apply(this,args);
}
return this.each( function() {
if(this.grid) {return;}
var localData;
if (pin != null && pin.data !== undefined) {
localData = pin.data;
pin.data = [];
}
var p = $.extend(true,{
url: "",
height: 150,
page: 1,
rowNum: 20,
rowTotal : null,
records: 0,
pager: "",
pgbuttons: true,
pginput: true,
colModel: [],
rowList: [],
colNames: [],
sortorder: "asc",
sortname: "",
datatype: "xml",
mtype: "GET",
altRows: false,
selarrrow: [],
preserveSelection : false,
savedRow: [],
shrinkToFit: true,
xmlReader: {},
jsonReader: {},
subGrid: false,
subGridModel :[],
reccount: 0,
lastpage: 0,
lastsort: 0,
selrow: null,
beforeSelectRow: null,
onSelectRow: null,
onSortCol: null,
ondblClickRow: null,
onRightClickRow: null,
onPaging: null,
onSelectAll: null,
onInitGrid : null,
loadComplete: null,
gridComplete: null,
loadError: null,
loadBeforeSend: null,
afterInsertRow: null,
beforeRequest: null,
beforeProcessing : null,
onHeaderClick: null,
viewrecords: false,
loadonce: false,
multiselect: false,
multikey: false,
multiboxonly : false,
multimail : false,
multiselectWidth: 30,
editurl: null,
search: false,
caption: "",
hidegrid: true,
hiddengrid: false,
postData: {},
userData: {},
treeGrid : false,
treeGridModel : 'nested',
treeReader : {},
treeANode : -1,
ExpandColumn: null,
tree_root_level : 0,
prmNames: {
page:"page",
rows:"rows",
sort: "sidx",
order: "sord",
search:"_search",
nd:"nd",
id:"id",
oper:"oper",
editoper:"edit",
addoper:"add",
deloper:"del",
subgridid:"id",
npage: null,
totalrows:"totalrows"
},
forceFit : false,
gridstate : "visible",
cellEdit: false,
cellsubmit: "remote",
nv:0,
loadui: "enable",
toolbar: [false,""],
scroll: false,
deselectAfterSort : true,
scrollrows : false,
autowidth: false,
scrollOffset : $.jgrid.scrollbarWidth() + 3, // one extra for windows
cellLayout: 5,
subGridWidth: 20,
gridview: true,
rownumWidth: 35,
rownumbers : false,
pagerpos: 'center',
recordpos: 'right',
footerrow : false,
userDataOnFooter : false,
headerrow : false,
userDataOnHeader : false,
hoverrows : true,
viewsortcols : [false,'vertical',true],
resizeclass : '',
autoencode : false,
remapColumns : [],
ajaxGridOptions :{},
direction : "ltr",
toppager: false,
headertitles: false,
scrollTimeout: 40,
data : [],
_index : {},
grouping : false,
groupingView : {
groupField:[],
groupOrder:[],
groupText:[],
groupColumnShow:[],
groupSummary:[],
showSummaryOnHide: false,
sortitems:[],
sortnames:[],
summary:[],
summaryval:[],
plusicon: '',
minusicon: '',
displayField: [],
groupSummaryPos:[],
formatDisplayField : [],
_locgr : false
},
groupHeaderOn : false,
ignoreCase : true,
cmTemplate : {},
idPrefix : "",
multiSort : false,
minColWidth : 33,
scrollPopUp : false,
scrollTopOffset: 0, // pixel
scrollLeftOffset : "100%", //percent
scrollMaxBuffer : 0,
storeNavOptions: false,
regional : "en",
styleUI : "jQueryUI",
iconSet : "Iconic",
responsive : false,
forcePgButtons : false,
restoreCellonFail : true,
editNextRowCell : false,
colFilters : {},
colMenu : false,
colMenuCustom : {},
colMenuColumnDone : null,
// tree pagging
treeGrid_bigData: false,
treeGrid_rootParams: {otherData:{}},
treeGrid_beforeRequest: null,
treeGrid_afterLoadComplete: null,
useNameForSearch : false,
formatFooterData : false,
formatHeaderData : false,
mergeSearch : false,
searchModules : {
mergeOper : 'AND',
filterInput : true,
filterToolbar : true,
searchGrid : true
}
}, $.jgrid.defaults , pin );
if (localData !== undefined) {
p.data = localData;
pin.data = localData;
}
var ts= this, grid={
headers:[],
cols:[],
footers: [],
hrheaders : [],
dragStart: function(i,x,y) {
var gridLeftPos = $(this.bDiv).offset().left,
minW = parseInt( (p.colModel[i].minResizeWidth ? p.colModel[i].minResizeWidth : p.minColWidth), 10);
if(isNaN( minW )) {
minW = 33;
}
this.resizing = { idx: i, startX: x.pageX, sOL : x.pageX - gridLeftPos, minW : minW };
this.hDiv.style.cursor = "col-resize";
this.curGbox = $("#rs_m"+$.jgrid.jqID(p.id),"#gbox_"+$.jgrid.jqID(p.id));
this.curGbox.css({display:"block",left:x.pageX-gridLeftPos,top:y[1],height:y[2]});
$(ts).triggerHandler("jqGridResizeStart", [x, i]);
if($.isFunction(p.resizeStart)) { p.resizeStart.call(ts,x,i); }
document.onselectstart=function(){return false;};
},
dragMove: function(x) {
if(this.resizing) {
var diff = x.pageX-this.resizing.startX,
h = this.headers[this.resizing.idx],
newWidth = p.direction === "ltr" ? h.width + diff : h.width - diff, hn, nWn;
if(newWidth > this.resizing.minW) {
this.curGbox.css({left:this.resizing.sOL+diff});
if(p.forceFit===true ){
hn = this.headers[this.resizing.idx+p.nv];
nWn = p.direction === "ltr" ? hn.width - diff : hn.width + diff;
if(nWn > this.resizing.minW ) {
h.newWidth = newWidth;
hn.newWidth = nWn;
}
} else {
this.newWidth = p.direction === "ltr" ? p.tblwidth+diff : p.tblwidth-diff;
h.newWidth = newWidth;
}
}
}
},
dragEnd: function( events ) {
this.hDiv.style.cursor = "default";
if(this.resizing) {
var idx = this.resizing.idx,
nw = this.headers[idx].newWidth || this.headers[idx].width;
nw = parseInt(nw,10);
this.resizing = false;
$("#rs_m"+$.jgrid.jqID(p.id)).css("display","none");
p.colModel[idx].width = nw;
this.headers[idx].width = nw;
this.headers[idx].el.style.width = nw + "px";
this.cols[idx].style.width = nw+"px";
if(this.footers.length>0) {this.footers[idx].style.width = nw+"px";}
if(this.hrheaders.length>0) {this.hrheaders[idx].style.width = nw+"px";}
if(p.forceFit===true){
nw = this.headers[idx+p.nv].newWidth || this.headers[idx+p.nv].width;
this.headers[idx+p.nv].width = nw;
this.headers[idx+p.nv].el.style.width = nw + "px";
this.cols[idx+p.nv].style.width = nw+"px";
if(this.footers.length>0) {this.footers[idx+p.nv].style.width = nw+"px";}
if(this.hrheaders.length>0) {this.hrheaders[idx+p.nv].style.width = nw+"px";}
p.colModel[idx+p.nv].width = nw;
} else {
p.tblwidth = this.newWidth || p.tblwidth;
$('table:first',this.bDiv).css("width",p.tblwidth+"px");
$('table:first',this.hDiv).css("width",p.tblwidth+"px");
this.hDiv.scrollLeft = this.bDiv.scrollLeft;
if(p.footerrow) {
$('table:first',this.sDiv).css("width",p.tblwidth+"px");
this.sDiv.scrollLeft = this.bDiv.scrollLeft;
}
if(p.headerrow) {
$('table:first',this.hrDiv).css("width",p.tblwidth+"px");
this.hrDiv.scrollLeft = this.bDiv.scrollLeft;
}
}
if(events) {
$(ts).triggerHandler("jqGridResizeStop", [nw, idx]);
if($.isFunction(p.resizeStop)) { p.resizeStop.call(ts,nw,idx); }
}
if(p.frozenColumns) {
$("#"+$.jgrid.jqID(p.id)).jqGrid("destroyFrozenColumns");
$("#"+$.jgrid.jqID(p.id)).jqGrid("setFrozenColumns");
}
}
this.curGbox = null;
document.onselectstart=function(){return true;};
},
populateVisible: function() {
if (grid.timer) { clearTimeout(grid.timer); }
grid.timer = null;
var dh = $(grid.bDiv).height();
if (!dh) { return; }
var table = $("table:first", grid.bDiv);
var rows, rh;
if(table[0].rows.length) {
try {
rows = table[0].rows[1];
rh = rows ? $(rows).outerHeight() || grid.prevRowHeight : grid.prevRowHeight;
} catch (pv) {
rh = grid.prevRowHeight;
}
}
if (!rh) { return; }
grid.prevRowHeight = rh;
var rn = p.rowNum;
var scrollTop = grid.scrollTop = grid.bDiv.scrollTop;
var ttop = Math.round(table.position().top) - scrollTop;
var tbot = ttop + table.height();
var div = rh * rn;
var page, npage, empty;
if ( tbot < dh && ttop <= 0 &&
(p.lastpage===undefined||(parseInt((tbot + scrollTop + div - 1) / div,10) || 0) <= p.lastpage))
{
npage = parseInt((dh - tbot + div - 1) / div,10) || 1;
if (tbot >= 0 || npage < 2 || p.scroll === true) {
page = ( Math.round((tbot + scrollTop) / div) || 0) + 1;
ttop = -1;
} else {
ttop = 1;
}
}
if (ttop > 0) {
page = ( parseInt(scrollTop / div,10) || 0 ) + 1;
npage = (parseInt((scrollTop + dh) / div,10) || 0) + 2 - page;
empty = true;
}
if (npage) {
if (p.lastpage && (page > p.lastpage || p.lastpage===1 || (page === p.page && page===p.lastpage)) ) {
return;
}
if (grid.hDiv.loading) {
grid.timer = setTimeout(grid.populateVisible, p.scrollTimeout);
} else {
p.page = page;
if( p.scrollMaxBuffer > 0 ) {
if( rn > 0 && p.scrollMaxBuffer < rn ) {
p.scrollMaxBuffer = rn + 1;
}
if(p.reccount > (p.scrollMaxBuffer - (rn > 0 ? rn : 0) ) ) {
empty = true;
}
}
if (empty) {
grid.selectionPreserver(table[0]);
grid.emptyRows.call(table[0], false, false);
}
grid.populate(npage);
}
if(p.scrollPopUp && p.lastpage != null) {
$("#scroll_g"+p.id).show().html( $.jgrid.template( $.jgrid.getRegional(ts, "defaults.pgtext", p.pgtext) , p.page, p.lastpage)).css({ "top": p.scrollTopOffset+scrollTop*((parseInt(p.height,10) - 45)/ (parseInt(rh,10)*parseInt(p.records,10))) +"px", "left" : p.scrollLeftOffset});
$(this).mouseout(function(){
$("#scroll_g"+p.id).hide();
});
}
}
},
scrollGrid: function() {
if(p.scroll) {
var scrollTop = grid.bDiv.scrollTop;
if(grid.scrollTop === undefined) { grid.scrollTop = 0; }
if (scrollTop !== grid.scrollTop) {
grid.scrollTop = scrollTop;
if (grid.timer) { clearTimeout(grid.timer); }
grid.timer = setTimeout(grid.populateVisible, p.scrollTimeout);
}
}
grid.hDiv.scrollLeft = grid.bDiv.scrollLeft;
if(p.footerrow) {
grid.sDiv.scrollLeft = grid.bDiv.scrollLeft;
}
if(p.headerrow) {
grid.hrDiv.scrollLeft = grid.bDiv.scrollLeft;
}
if(p.frozenColumns) {
$(grid.fbDiv).scrollTop( grid.bDiv.scrollTop );
}
try {
$("#column_menu").remove();
} catch (e) {}
},
selectionPreserver : function(ts) {
var p = ts.p,
sr = p.selrow, sra = p.selarrrow ? $.makeArray(p.selarrrow) : null,
left = ts.grid.bDiv.scrollLeft,
restoreSelection = function() {
var i;
//p.selrow = null;
//p.selarrrow = [];
if(p.multiselect && sra && sra.length>0) {
for(i=0;i<sra.length;i++){
if (sra[i]) {
$(ts).jqGrid("setSelection", sra[i], false, "_sp_");
}
}
}
if (!p.multiselect && sr) {
$(ts).jqGrid("setSelection", sr, false, null);
}
ts.grid.bDiv.scrollLeft = left;
$(ts).off('.selectionPreserver', restoreSelection);
};
$(ts).on('jqGridGridComplete.selectionPreserver', restoreSelection);
}
};
if(this.tagName.toUpperCase() !== 'TABLE' || this.id == null) {
alert("Element is not a table or has no id!");
return;
}
if(document.documentMode !== undefined ) { // IE only
if(document.documentMode <= 5) {
alert("Grid can not be used in this ('quirks') mode!");
return;
}
}
var i =0, lr, lk, dir, spsh;
for( lk in $.jgrid.regional ){
if($.jgrid.regional.hasOwnProperty(lk)) {
if(i===0) { lr = lk; }
i++;
}
}
if(i === 1 && lr !== p.regional) {
p.regional = lr;
}
$(this).empty().attr("tabindex","0");
this.p = p ;
this.p.useProp = !!$.fn.prop;
if(this.p.colNames.length === 0) {
for (i=0;i<this.p.colModel.length;i++){
this.p.colNames[i] = this.p.colModel[i].label || this.p.colModel[i].name;
}
}
if( this.p.colNames.length !== this.p.colModel.length ) {
alert($.jgrid.getRegional(this,"errors.model"));
return;
}
if(ts.p.styleUI === 'Bootstrap4') {
if($.jgrid.iconSet.hasOwnProperty(ts.p.iconSet)) {
$.extend(true, $.jgrid.styleUI['Bootstrap4'], $.jgrid.iconSet[ts.p.iconSet]);
}
}
var getstyle = $.jgrid.getMethod("getStyleUI"),
stylemodule = ts.p.styleUI + ".common",
disabled = getstyle(stylemodule,'disabled', true),
highlight = getstyle(stylemodule,'highlight', true),
hover = getstyle(stylemodule,'hover', true),
cornerall = getstyle(stylemodule,'cornerall', true),
iconbase = getstyle(stylemodule,'icon_base', true),
colmenustyle = $.jgrid.styleUI[(ts.p.styleUI || 'jQueryUI')].colmenu,
isMSIE = $.jgrid.msie(),
gv, sortarr = [], sortord = [], sotmp=[];
stylemodule = ts.p.styleUI + ".base";
gv = $("<div "+getstyle(stylemodule, 'viewBox', false, 'ui-jqgrid-view')+" role='grid'></div>");
ts.p.direction = $.trim(ts.p.direction.toLowerCase());
ts.p._ald = false;
if($.inArray(ts.p.direction,["ltr","rtl"]) === -1) { ts.p.direction = "ltr"; }
dir = ts.p.direction;
$(gv).insertBefore(this);
$(this).appendTo(gv);
var eg = $("<div "+ getstyle(stylemodule, 'entrieBox', false, 'ui-jqgrid') +"></div>");
$(eg).attr({"id" : "gbox_"+this.id,"dir":dir}).insertBefore(gv);
$(gv).attr("id","gview_"+this.id).appendTo(eg);
$("<div "+getstyle(ts.p.styleUI+'.common','overlay', false, 'jqgrid-overlay')+ " id='lui_"+this.id+"'></div>").insertBefore(gv);
$("<div "+getstyle(stylemodule,'loadingBox', false, 'loading')+" id='load_"+this.id+"'>"+$.jgrid.getRegional(ts, "defaults.loadtext", this.p.loadtext)+"</div>").insertBefore(gv);
$(this).attr({role:"presentation","aria-multiselectable":!!this.p.multiselect,"aria-labelledby":"gbox_"+this.id});
var sortkeys = ["shiftKey","altKey","ctrlKey"],
grid_font = $.jgrid.getFont( ts ) ,
intNum = function(val,defval) {
val = parseInt(val,10);
if (isNaN(val)) { return defval || 0;}
return val;
},
formatCol = function (pos, rowInd, tv, rawObject, rowId, rdata){
var cm = ts.p.colModel[pos], cellAttrFunc,
ral = cm.align, result="style=\"", clas = cm.classes, nm = cm.name, celp, acp=[];
if(ral) { result += "text-align:"+ral+";"; }
if(cm.hidden===true) { result += "display:none;"; }
if(rowInd===0) {
result += "width: "+grid.headers[pos].width+"px;";
} else if ($.isFunction(cm.cellattr) || (typeof cm.cellattr === "string" && $.jgrid.cellattr != null && $.isFunction($.jgrid.cellattr[cm.cellattr]))) {
cellAttrFunc = $.isFunction(cm.cellattr) ? cm.cellattr : $.jgrid.cellattr[cm.cellattr];
celp = cellAttrFunc.call(ts, rowId, tv, rawObject, cm, rdata);
if(celp && typeof celp === "string") {
if(celp.indexOf('title') > -1) { cm.title=false;}
if(celp.indexOf('class') > -1) { clas = undefined;}
celp = String(celp).replace(/\s+\=/g, '=');
acp = celp.split("style=");
if(acp.length === 2 ) {
acp[1] = $.trim(acp[1]);
if(acp[1].indexOf("'") === 0 || acp[1].indexOf('"') === 0) {
acp[1] = acp[1].substring(1);
}
result += acp[1].replace(/'/gi,'"');
} else {
result += "\"";
}
}
}
if(!acp.length ) {
acp[0] = "";
result += "\"";
} else if(acp.length > 2) {
acp[0] = "";
}
result += (clas !== undefined ? (" class=\""+clas+"\"") :"") + ((cm.title && tv) ? (" title=\""+$.jgrid.stripHtml(tv)+"\"") :"");
result += " aria-describedby=\""+ts.p.id+"_"+nm+"\"";
return result + acp[0];
},
cellVal = function (val) {
return val == null || val === "" ? " " : (ts.p.autoencode ? $.jgrid.htmlEncode(val) : String(val));
},
formatter = function (rowId, cellval , colpos, rwdat, _act){
var cm = ts.p.colModel[colpos],v;
if(cm.formatter !== undefined) {
rowId = String(ts.p.idPrefix) !== "" ? $.jgrid.stripPref(ts.p.idPrefix, rowId) : rowId;
var opts= {rowId: rowId, colModel:cm, gid:ts.p.id, pos:colpos, styleUI: ts.p.styleUI };
if($.isFunction( cm.formatter ) ) {
v = cm.formatter.call(ts,cellval,opts,rwdat,_act);
} else if($.fmatter){
v = $.fn.fmatter.call(ts,cm.formatter,cellval,opts,rwdat,_act);
} else {
v = cellVal(cellval);
}
} else {
v = cellVal(cellval);
}
if(cm.autosize) {
if(!cm._maxsize) {
cm._maxsize = 0;
}
cm._maxsize = Math.max( (!!$.jgrid.isFunction( cm.sizingStringFunc ) ?
cm.sizingStringFunc.call(ts, v, grid_font, opts, rwdat) :
$.jgrid.getTextWidth( v, grid_font ) ),
cm._maxsize );
}
return v;
},
addCell = function(rowId,cell,pos,irow, srvr, rdata) {
var v,prp;
v = formatter(rowId,cell,pos,srvr,'add');
prp = formatCol( pos,irow, v, srvr, rowId, rdata);
return "<td role=\"gridcell\" "+prp+">"+v+"</td>";
},
addMulti = function(rowid, pos, irow, checked, uiclass){
var v = "<input role=\"checkbox\" type=\"checkbox\""+" id=\"jqg_"+ts.p.id+"_"+rowid+"\" "+uiclass+" name=\"jqg_"+ts.p.id+"_"+rowid+"\"" + (checked ? "checked=\"checked\"" : "")+"/>",
prp = formatCol( pos,irow,'',null, rowid, true);
return "<td role=\"gridcell\" "+prp+">"+v+"</td>";
},
addRowNum = function (pos, irow, pG, rN, uiclass ) {
var v = (parseInt(pG,10)-1)*parseInt(rN,10)+1+irow,
prp = formatCol( pos,irow,v, null, irow, true);
return "<td role=\"gridcell\" "+uiclass+" "+prp+">"+v+"</td>";
},
reader = function (datatype) {
var field, f=[], j=0, i;
for(i =0; i<ts.p.colModel.length; i++){
field = ts.p.colModel[i];
if (field.name !== 'cb' && field.name !=='subgrid' && field.name !=='rn') {
f[j]= datatype === "local" ?
field.name :
( (datatype==="xml" || datatype === "xmlstring") ? field.xmlmap || field.name : field.jsonmap || field.name );
if(ts.p.keyName !== false && field.key===true ) {
ts.p.keyName = f[j];
ts.p.keyIndex = j;
}
j++;
}
}
return f;
},
orderedCols = function (offset) {
var order = ts.p.remapColumns;
if (!order || !order.length) {
order = $.map(ts.p.colModel, function(v,i) { return i; });
}
if (offset) {
order = $.map(order, function(v) { return v<offset?null:v-offset; });
}
return order;
},
emptyRows = function (scroll, locdata) {
var firstrow;
if (this.p.deepempty) {
$(this.rows).slice(1).remove();
} else {
firstrow = this.rows.length > 0 ? this.rows[0] : null;
$(this.firstChild).empty().append(firstrow);
}
if (scroll && this.p.scroll) {
$(this.grid.bDiv.firstChild).css({height: "auto"});
$(this.grid.bDiv.firstChild.firstChild).css({height: "0px", display: "none"});
if (this.grid.bDiv.scrollTop !== 0) {
this.grid.bDiv.scrollTop = 0;
}
}
if(locdata === true ) { //&& this.p.treeGrid && !this.p.loadonce ) {
this.p.data = [];
this.p._index = {};
}
},
normalizeData = function() {
var p = ts.p, data = p.data, dataLength = data.length, i, j, cur, idn, idr, ccur, v, rd,
localReader = p.localReader,
colModel = p.colModel,
cellName = localReader.cell,
iOffset = (p.multiselect === true ? 1 : 0) + (p.subGrid === true ? 1 : 0) + (p.rownumbers === true ? 1 : 0),
br = p.scroll ? $.jgrid.randId() : 1,
arrayReader, objectReader, rowReader;
if (p.datatype !== "local" || localReader.repeatitems !== true) {
return; // nothing to do
}
arrayReader = orderedCols(iOffset);
objectReader = reader("local");
// read ALL input items and convert items to be read by
// $.jgrid.getAccessor with column name as the second parameter
idn = p.keyName === false ?
($.isFunction(localReader.id) ? localReader.id.call(ts, data) : localReader.id) :
p.keyName;
for (i = 0; i < dataLength; i++) {
cur = data[i];
// read id in the same way like addJSONData do
// probably it would be better to start with "if (cellName) {...}"
// but the goal of the current implementation was just have THE SAME
// id values like in addJSONData ...
idr = $.jgrid.getAccessor(cur, idn);
if (idr === undefined) {
if (typeof idn === "number" && colModel[idn + iOffset] != null) {
// reread id by name
idr = $.jgrid.getAccessor(cur, colModel[idn + iOffset].name);
}
if (idr === undefined) {
idr = br + i;
if (cellName) {
ccur = $.jgrid.getAccessor(cur, cellName) || cur;
idr = ccur != null && ccur[idn] !== undefined ? ccur[idn] : idr;
ccur = null;
}
}
}
rd = { };
rd[localReader.id] = idr;
if (cellName) {
cur = $.jgrid.getAccessor(cur, cellName) || cur;
}
rowReader = $.isArray(cur) ? arrayReader : objectReader;
for (j = 0; j < rowReader.length; j++) {
v = $.jgrid.getAccessor(cur, rowReader[j]);
rd[colModel[j + iOffset].name] = v;
}
data[i] = rd;
//$.extend(true, data[i], rd);
}
},
refreshIndex = function() {
var datalen = ts.p.data.length, idname, i, val;
idname = ts.p.keyName !== false ? ts.p.keyName : idname = ts.p.localReader.id;
ts.p._index = {};
for(i =0;i < datalen; i++) {
val = $.jgrid.getAccessor(ts.p.data[i],idname);
if (val === undefined) { val=String(i+1); }
ts.p._index[val] = i;
}
},
constructTr = function(id, hide, classes, rd, cur ) {
var tabindex = '-1', restAttr = '', attrName, style = hide ? 'display:none;' : '',
//classes = getstyle(stylemodule, 'rowBox', true) + ts.p.direction + (altClass ? ' ' + altClass : '') + (selected ? ' ' + highlight : ''),
rowAttrObj = $(ts).triggerHandler("jqGridRowAttr", [rd, cur, id]);
if( typeof rowAttrObj !== "object" ) {
rowAttrObj = $.isFunction(ts.p.rowattr) ? ts.p.rowattr.call(ts, rd, cur, id) :
(typeof ts.p.rowattr === "string" && $.jgrid.rowattr != null && $.isFunction($.jgrid.rowattr[ts.p.rowattr]) ?
$.jgrid.rowattr[ts.p.rowattr].call(ts, rd, cur, id) : {});
}
if(!$.isEmptyObject( rowAttrObj )) {
if (rowAttrObj.hasOwnProperty("id")) {
id = rowAttrObj.id;
delete rowAttrObj.id;
}
if (rowAttrObj.hasOwnProperty("tabindex")) {
tabindex = rowAttrObj.tabindex;
delete rowAttrObj.tabindex;
}
if (rowAttrObj.hasOwnProperty("style")) {
style += rowAttrObj.style;
delete rowAttrObj.style;
}
if (rowAttrObj.hasOwnProperty("class")) {
classes += ' ' + rowAttrObj['class'];
delete rowAttrObj['class'];
}
// dot't allow to change role attribute
try { delete rowAttrObj.role; } catch(ra){}
for (attrName in rowAttrObj) {
if (rowAttrObj.hasOwnProperty(attrName)) {
restAttr += ' ' + attrName + '=' + rowAttrObj[attrName];
}
}
}
return '<tr role="row" id="' + id + '" tabindex="' + tabindex + '" class="' + classes + '"' +
(style === '' ? '' : ' style="' + style + '"') + restAttr + '>';
},
//bvn13
treeGrid_beforeRequest = function() {
if (ts.p.treeGrid && ts.p.treeGrid_bigData) {
if ( ts.p.postData.nodeid !== undefined
&& typeof(ts.p.postData.nodeid) === 'string'
&& (
ts.p.postData.nodeid !== ""
|| parseInt(ts.p.postData.nodeid,10) > 0
)
) {
ts.p.postData.rows = 10000;
ts.p.postData.page = 1;
ts.p.treeGrid_rootParams.otherData.nodeid = ts.p.postData.nodeid;
}
}
},
treeGrid_afterLoadComplete = function() {
if (ts.p.treeGrid && ts.p.treeGrid_bigData) {
if ( ts.p.treeGrid_rootParams.otherData.nodeid !== undefined
&& typeof(ts.p.treeGrid_rootParams.otherData.nodeid) === 'string'
&& (
ts.p.treeGrid_rootParams.otherData.nodeid !== ""
||
parseInt(ts.p.treeGrid_rootParams.otherData.nodeid,10) > 0
)
) {
if (ts.p.treeGrid_rootParams !== undefined && ts.p.treeGrid_rootParams != null) {
ts.p.page = ts.p.treeGrid_rootParams.page;
ts.p.lastpage = ts.p.treeGrid_rootParams.lastpage;
ts.p.postData.rows = ts.p.treeGrid_rootParams.postData.rows;
ts.p.postData.totalrows = ts.p.treeGrid_rootParams.postData.totalrows;
ts.p.treeGrid_rootParams.otherData.nodeid = "";
ts.updatepager(false,true);
}
} else {
ts.p.treeGrid_rootParams = {
page : ts.p.page,
lastpage : ts.p.lastpage,
postData : {
rows: ts.p.postData.rows,
totalrows: ts.p.postData.totalrows
},
rowNum : ts.p.rowNum,
rowTotal : ts.p.rowTotal,
otherData : {
nodeid : ""
}
};
}
}
},
//-bvn13
addXmlData = function (xml, rcnt, more, adjust) {
var startReq = new Date(),
locdata = (ts.p.datatype !== "local" && ts.p.loadonce) || ts.p.datatype === "xmlstring",
xmlid = "_id_", xmlRd = ts.p.xmlReader,
treeadjtmp =[],
frd = ts.p.datatype === "local" ? "local" : "xml";
if(locdata) {
ts.p.data = [];
ts.p._index = {};
ts.p.localReader.id = xmlid;
}
ts.p.reccount = 0;
if($.isXMLDoc(xml)) {
if(ts.p.treeANode===-1 && !ts.p.scroll) {
emptyRows.call(ts, false, false);
rcnt=1;
} else { rcnt = rcnt > 1 ? rcnt :1; }
} else { return; }
var self= $(ts), i,fpos,ir=0,v,gi=ts.p.multiselect===true?1:0,si=0,addSubGridCell,ni=ts.p.rownumbers===true?1:0,idn, getId,f=[],F,rd ={},
xmlr,rid, rowData=[], classes = getstyle(stylemodule, 'rowBox', true, 'jqgrow ui-row-'+ ts.p.direction);
if(ts.p.subGrid===true) {
si = 1;
addSubGridCell = $.jgrid.getMethod("addSubGridCell");
}
if(!xmlRd.repeatitems) {f = reader(frd);}
if( ts.p.keyName===false) {
idn = $.isFunction( xmlRd.id ) ? xmlRd.id.call(ts, xml) : xmlRd.id;
} else {
idn = ts.p.keyName;
}
if(xmlRd.repeatitems && ts.p.keyName && isNaN(idn)) {
idn = ts.p.keyIndex;
}
if( String(idn).indexOf("[") === -1 ) {
if (f.length) {
getId = function( trow, k) {return $(idn,trow).text() || k;};
} else {
getId = function( trow, k) {return $(xmlRd.cell,trow).eq(idn).text() || k;};
}
}
else {
getId = function( trow, k) {return trow.getAttribute(idn.replace(/[\[\]]/g,"")) || k;};
}
ts.p.userData = {};
ts.p.page = intNum($.jgrid.getXmlData(xml, xmlRd.page), ts.p.page);
ts.p.lastpage = intNum($.jgrid.getXmlData(xml, xmlRd.total), 1);
ts.p.records = intNum($.jgrid.getXmlData(xml, xmlRd.records));
if($.isFunction(xmlRd.userdata)) {
ts.p.userData = xmlRd.userdata.call(ts, xml) || {};
} else {
$.jgrid.getXmlData(xml, xmlRd.userdata, true).each(function() {ts.p.userData[this.getAttribute("name")]= $(this).text();});
}
var gxml = $.jgrid.getXmlData( xml, xmlRd.root, true);
gxml = $.jgrid.getXmlData( gxml, xmlRd.row, true);
if (!gxml) { gxml = []; }
var gl = gxml.length, j=0, grpdata=[], rn = parseInt(ts.p.rowNum,10), br=ts.p.scroll?$.jgrid.randId():1,
tablebody = $(ts).find("tbody:first"),
hiderow=false, groupingPrepare, selr;
if(ts.p.grouping) {
hiderow = ts.p.groupingView.groupCollapse === true;
groupingPrepare = $.jgrid.getMethod("groupingPrepare");
}
if (gl > 0 && ts.p.page <= 0) { ts.p.page = 1; }
if(gxml && gl){
if (adjust) { rn *= adjust+1; }
var afterInsRow = $.isFunction(ts.p.afterInsertRow),
rnc = ni ? getstyle(stylemodule, 'rownumBox', false, 'jqgrid-rownum') :"",
mlc = gi ? getstyle(stylemodule, 'multiBox', false, 'cbox'):"";
while (j<gl) {
xmlr = gxml[j];
rid = getId(xmlr,br+j);
rid = ts.p.idPrefix + rid;
if( ts.p.preserveSelection) {
if( ts.p.multiselect) {
selr = ts.p.selarrrow.indexOf( rid ) !== -1;
spsh = selr ? spsh+1: spsh;
} else {
selr = (rid === ts.p.selrow);
}
}
var iStartTrTag = rowData.length;
rowData.push("");
if( ni ) {
rowData.push( addRowNum(0, j, ts.p.page, ts.p.rowNum, rnc ) );
}
if( gi ) {
rowData.push( addMulti(rid, ni, j, selr, mlc) );
}
if( si ) {
rowData.push( addSubGridCell.call(self, gi+ni, j+rcnt) );
}
if(xmlRd.repeatitems){
if (!F) { F=orderedCols(gi+si+ni); }
var cells = $.jgrid.getXmlData( xmlr, xmlRd.cell, true);
$.each(F, function (k) {
var cell = cells[this];
if (!cell) { return false; }
v = cell.textContent || cell.text || "";
rd[ts.p.colModel[k+gi+si+ni].name] = v;
rowData.push( addCell(rid,v,k+gi+si+ni,j+rcnt,xmlr, rd) );
});
} else {
for(i = 0; i < f.length;i++) {
v = $.jgrid.getXmlData( xmlr, f[i]);
rd[ts.p.colModel[i+gi+si+ni].name] = v;
rowData.push( addCell(rid, v, i+gi+si+ni, j+rcnt, xmlr, rd) );
}
}
rowData[iStartTrTag] = constructTr(rid, hiderow, classes, rd, xmlr);
rowData.push("</tr>");
if(ts.p.grouping) {
grpdata.push( rowData );
if(!ts.p.groupingView._locgr) {
groupingPrepare.call(self , rd, j );
}
rowData = [];
}
if(locdata || (ts.p.treeGrid === true && !(ts.p._ald)) ) {
rd[xmlid] = $.jgrid.stripPref(ts.p.idPrefix, rid);
ts.p.data.push(rd);
ts.p._index[rd[xmlid]] = ts.p.data.length-1;
if(ts.p.treeANode > -1 && ts.p.treeGridModel === 'adjacency') {
treeadjtmp.push(rd);
}
}
if(ts.p.gridview === false ) {
tablebody.append(rowData.join(''));
self.triggerHandler("jqGridAfterInsertRow", [rid, rd, xmlr]);
if(afterInsRow) {ts.p.afterInsertRow.call(ts,rid,rd,xmlr);}
rowData=[];
}
rd={};
ir++;
j++;
if(ir===rn) {break;}
}
}
spsh = ts.p.multiselect && ts.p.preserveSelection && ir === spsh;
if(ts.p.gridview === true) {
fpos = ts.p.treeANode > -1 ? ts.p.treeANode: 0;
if(ts.p.grouping) {
if(!locdata) {
self.jqGrid('groupingRender',grpdata,ts.p.colModel.length, ts.p.page, rn);
grpdata = null;
}
} else if(ts.p.treeGrid === true && fpos > 0) {
$(ts.rows[fpos]).after(rowData.join(''));
} else {
//$("tbody:first",t).append(rowData.join(''));
tablebody.append(rowData.join(''));
ts.grid.cols = ts.rows[0].cells; // update cached first row
}
}
ts.p.totaltime = new Date() - startReq;
rowData =null;
if(ir>0) { if(ts.p.records===0) { ts.p.records=gl;} }
if( ts.p.treeGrid === true) {
try {self.jqGrid("setTreeNode", fpos+1, ir+fpos+1);} catch (e) {}
if(ts.p.treeANode > -1 && ts.p.treeGridModel === 'adjacency') {
v = ts.rows[ts.p.treeANode].id;
v = ts.p._index[v]+1;
if( v >= 1) {
ts.p.data.splice(-(gl), gl);
for(i=0; i < gl; i++) {
ts.p.data.splice(v + i,0,treeadjtmp[i]);
}
refreshIndex();
}
}
}
//if(!ts.p.treeGrid && !ts.p.scroll) {ts.grid.bDiv.scrollTop = 0;}
ts.p.reccount=ir;
ts.p.treeANode = -1;
if(ts.p.userDataOnFooter) { self.jqGrid("footerData","set",ts.p.userData, ts.p.formatFooterData); }
if(ts.p.userDataOnHeader) { self.jqGrid("headerData","set",ts.p.userData, ts.p.formatHeaderData); }
if(locdata) {
ts.p.records = gl;
ts.p.lastpage = Math.ceil(gl/ rn);
}
if (!more) { ts.updatepager(false,true); }
if(spsh) {
setHeadCheckBox( true );
}
if(locdata) {
while (ir<gl) {
xmlr = gxml[ir];
rid = getId(xmlr,ir+br);
rid = ts.p.idPrefix + rid;
if(xmlRd.repeatitems){
if (!F) { F=orderedCols(gi+si+ni); }
var cells2 = $.jgrid.getXmlData( xmlr, xmlRd.cell, true);
$.each(F, function (k) {
var cell = cells2[this];
if (!cell) { return false; }
v = cell.textContent || cell.text || "";
rd[ts.p.colModel[k+gi+si+ni].name] = v;
});
} else {
for(i = 0; i < f.length;i++) {
v = $.jgrid.getXmlData( xmlr, f[i]);
rd[ts.p.colModel[i+gi+si+ni].name] = v;
}
}
rd[xmlid] = $.jgrid.stripPref(ts.p.idPrefix, rid);
if( ts.p.grouping ) {
groupingPrepare.call(self, rd, ir );
}
ts.p.data.push(rd);
ts.p._index[rd[xmlid]] = ts.p.data.length-1;
rd = {};
ir++;
}
if(ts.p.grouping) {
ts.p.groupingView._locgr = true;
self.jqGrid('groupingRender', grpdata, ts.p.colModel.length, ts.p.page, rn);
grpdata = null;
}
}
if(ts.p.subGrid === true ) {
try {self.jqGrid("addSubGrid",gi+ni);} catch (_){}
}
},
addJSONData = function(data, rcnt, more, adjust) {
var startReq = new Date();
if(data) {
if(ts.p.treeANode === -1 && !ts.p.scroll) {
emptyRows.call(ts, false, false);
rcnt=1;
} else { rcnt = rcnt > 1 ? rcnt :1; }
} else { return; }
var dReader, frd;
if(ts.p.datatype === "local") {
dReader = ts.p.localReader;
frd= 'local';
} else {
dReader = ts.p.jsonReader;
frd='json';
}
var locid = "_id_",
locdata = (ts.p.datatype !== "local" && ts.p.loadonce) || ts.p.datatype === "jsonstring",
self = $(ts),
ir=0,v,i,j,f=[],cur, addSubGridCell,
gi = ts.p.multiselect ? 1 : 0,
si = ts.p.subGrid ===true ? 1 : 0,
ni = ts.p.rownumbers ===true ? 1 : 0,
br = (ts.p.scroll && ts.p.datatype !== 'local') ? $.jgrid.randId() : 1,
rn = parseInt(ts.p.rowNum,10),
selected=false, selr,
arrayReader=orderedCols(gi+si+ni),
objectReader=reader(frd),
rowReader,len,drows,idn,rd={}, fpos, idr,rowData=[],
treeadjtmp =[],
classes = getstyle(stylemodule, 'rowBox', true, 'jqgrow ui-row-'+ ts.p.direction),
afterInsRow = $.isFunction(ts.p.afterInsertRow), grpdata=[],hiderow=false, groupingPrepare,
tablebody = $(ts).find("tbody:first"),
rnc = ni ? getstyle(stylemodule, 'rownumBox', false, 'jqgrid-rownum') :"",
mlc = gi ? getstyle(stylemodule, 'multiBox', false, 'cbox'):"";
if(locdata) {
ts.p.data = [];
ts.p._index = {};
ts.p.localReader.id = locid;
}
ts.p.reccount = 0;
ts.p.page = intNum($.jgrid.getAccessor(data,dReader.page), ts.p.page);
ts.p.lastpage = intNum($.jgrid.getAccessor(data,dReader.total), 1);
ts.p.records = intNum($.jgrid.getAccessor(data,dReader.records));
ts.p.userData = $.jgrid.getAccessor(data,dReader.userdata) || {};
if(si) {
addSubGridCell = $.jgrid.getMethod("addSubGridCell");
}
if( ts.p.keyName===false ) {
idn = $.isFunction(dReader.id) ? dReader.id.call(ts, data) : dReader.id;
} else {
idn = ts.p.keyName;
}
if(dReader.repeatitems && ts.p.keyName && isNaN(idn)) {
idn = ts.p.keyIndex;
}
drows = $.jgrid.getAccessor(data,dReader.root);
if (drows == null && $.isArray(data)) { drows = data; }
if (!drows) { drows = []; }
len = drows.length; i=0;
if (len > 0 && ts.p.page <= 0) { ts.p.page = 1; }
if (adjust) { rn *= adjust+1; }
if(ts.p.datatype === "local" && !ts.p.deselectAfterSort) {
selected = true;
}
if(ts.p.grouping) {
hiderow = ts.p.groupingView.groupCollapse === true;
groupingPrepare = $.jgrid.getMethod("groupingPrepare");
}
while (i<len) {
cur = drows[i];
idr = $.jgrid.getAccessor(cur,idn);
if(idr === undefined) {
if (typeof idn === "number" && ts.p.colModel[idn+gi+si+ni] != null) {
// reread id by name
idr = $.jgrid.getAccessor(cur,ts.p.colModel[idn+gi+si+ni].name);
}
if(idr === undefined) {
idr = br+i;
if(f.length===0){
if(dReader.cell){
var ccur = $.jgrid.getAccessor(cur,dReader.cell) || cur;
idr = ccur != null && ccur[idn] !== undefined ? ccur[idn] : idr;
ccur=null;
}
}
}
}
idr = ts.p.idPrefix + idr;
if( selected || ts.p.preserveSelection) {
if( ts.p.multiselect) {
selr = ts.p.selarrrow.indexOf( idr ) !== -1;
spsh = selr ? spsh+1: spsh;
} else {
selr = (idr === ts.p.selrow);
}
}
var iStartTrTag = rowData.length;
rowData.push("");
if( ni ) {
rowData.push( addRowNum(0, i, ts.p.page, ts.p.rowNum, rnc ) );
}
if( gi ){
rowData.push( addMulti(idr, ni, i, selr, mlc) );
}
if( si ) {
rowData.push( addSubGridCell.call(self ,gi+ni,i+rcnt) );
}
rowReader=objectReader;
if (dReader.repeatitems) {
if(dReader.cell) {cur = $.jgrid.getAccessor(cur,dReader.cell) || cur;}
if ($.isArray(cur)) { rowReader=arrayReader; }
}
for (j=0;j<rowReader.length;j++) {
v = $.jgrid.getAccessor(cur,rowReader[j]);
rd[ts.p.colModel[j+gi+si+ni].name] = v;
rowData.push( addCell(idr,v,j+gi+si+ni,i+rcnt,cur, rd) );
}
rowData[iStartTrTag] = constructTr(idr, hiderow, (selr ? classes + ' ' + highlight : classes), rd, cur);
rowData.push( "</tr>" );
if(ts.p.grouping) {
grpdata.push( rowData );
if(!ts.p.groupingView._locgr) {
groupingPrepare.call(self , rd, i);
}
rowData = [];
}
if(locdata || (ts.p.treeGrid===true && !(ts.p._ald))) {
rd[locid] = $.jgrid.stripPref(ts.p.idPrefix, idr);
ts.p.data.push(rd);
ts.p._index[rd[locid]] = ts.p.data.length-1;
if(ts.p.treeANode > -1 && ts.p.treeGridModel === 'adjacency') {
treeadjtmp.push(rd);
}
}
if(ts.p.gridview === false ) {
tablebody.append(rowData.join(''));
self.triggerHandler("jqGridAfterInsertRow", [idr, rd, cur]);
if(afterInsRow) {ts.p.afterInsertRow.call(ts,idr,rd,cur);}
rowData=[];//ari=0;
}
rd={};
ir++;
i++;
if(ir===rn) { break; }
}
spsh = ts.p.multiselect && (ts.p.preserveSelection || selected) && ir === spsh;
if(ts.p.gridview === true ) {
fpos = ts.p.treeANode > -1 ? ts.p.treeANode: 0;
if(ts.p.grouping) {
if(!locdata) {
self.jqGrid('groupingRender', grpdata, ts.p.colModel.length, ts.p.page, rn);
grpdata = null;
}
} else if(ts.p.treeGrid === true && fpos > 0) {
$(ts.rows[fpos]).after(rowData.join(''));
} else {
tablebody.append(rowData.join(''));
ts.grid.cols = ts.rows[0].cells;
}
}
ts.p.totaltime = new Date() - startReq;
rowData = null;
if(ir>0) {
if(ts.p.records===0) { ts.p.records=len; }
}
if( ts.p.treeGrid === true) {
try {self.jqGrid("setTreeNode", fpos+1, ir+fpos+1);} catch (e) {}
if(ts.p.treeANode > -1 && ts.p.treeGridModel === 'adjacency') {
v = ts.rows[ts.p.treeANode].id;
v = ts.p._index[v]+1;
if( v >= 1) {
ts.p.data.splice(-(len), len);
for(i=0; i < len; i++) {
ts.p.data.splice(v + i,0,treeadjtmp[i]);
}
refreshIndex();
}
}
}
//if(!ts.p.treeGrid && !ts.p.scroll) {ts.grid.bDiv.scrollTop = 0;}
ts.p.reccount=ir;
ts.p.treeANode = -1;
if(ts.p.userDataOnFooter) { self.jqGrid("footerData","set",ts.p.userData, ts.p.formatFooterData); }
if(ts.p.userDataOnHeader) { self.jqGrid("headerData","set",ts.p.userData, ts.p.formatHeaderData); }
if(locdata) {
ts.p.records = len;
ts.p.lastpage = Math.ceil(len/ rn);
}
if (!more) { ts.updatepager(false,true); }
if(spsh) {
setHeadCheckBox( true );
}
if(locdata) {
while (ir<len && drows[ir]) {
cur = drows[ir];
idr = $.jgrid.getAccessor(cur,idn);
if(idr === undefined) {
if (typeof idn === "number" && ts.p.colModel[idn+gi+si+ni] != null) {
// reread id by name
idr = $.jgrid.getAccessor(cur,ts.p.colModel[idn+gi+si+ni].name);
}
if(idr === undefined) {
idr = br+ir;
if(f.length===0){
if(dReader.cell){
var ccur2 = $.jgrid.getAccessor(cur,dReader.cell) || cur;
idr = ccur2 != null && ccur2[idn] !== undefined ? ccur2[idn] : idr;
ccur2=null;
}
}
}
}
if(cur) {
idr = ts.p.idPrefix + idr;
rowReader=objectReader;
if (dReader.repeatitems) {
if(dReader.cell) {cur = $.jgrid.getAccessor(cur,dReader.cell) || cur;}
if ($.isArray(cur)) { rowReader=arrayReader; }
}
for (j=0;j<rowReader.length;j++) {
rd[ts.p.colModel[j+gi+si+ni].name] = $.jgrid.getAccessor(cur,rowReader[j]);
}
rd[locid] = $.jgrid.stripPref(ts.p.idPrefix, idr);
if(ts.p.grouping) {
groupingPrepare.call(self, rd, ir );
}
ts.p.data.push(rd);
ts.p._index[rd[locid]] = ts.p.data.length-1;
rd = {};
}
ir++;
}
if(ts.p.grouping) {
ts.p.groupingView._locgr = true;
self.jqGrid('groupingRender', grpdata, ts.p.colModel.length, ts.p.page, rn);
grpdata = null;
}
}
if(ts.p.subGrid === true ) {
try { self.jqGrid("addSubGrid",gi+ni);} catch (_){}
}
},
addLocalData = function( retAll ) {
var st = ts.p.multiSort ? [] : "", sto=[], fndsort=false, cmtypes={}, grtypes=[], grindexes=[], srcformat, sorttype, newformat, sfld;
if(!$.isArray(ts.p.data)) {
return;
}
var grpview = ts.p.grouping ? ts.p.groupingView : false, lengrp, gin, si;
$.each(ts.p.colModel,function(){
if ( !(this.name !== 'cb' && this.name !== 'subgrid' && this.name !== 'rn') ) {
return true;
}
sorttype = this.sorttype || "text";
si = this.index || this.name;
if(sorttype === "date" || sorttype === "datetime") {
if(this.formatter && typeof this.formatter === 'string' && this.formatter === 'date') {
if(this.formatoptions && this.formatoptions.srcformat) {
srcformat = this.formatoptions.srcformat;
} else {
srcformat = $.jgrid.getRegional(ts, "formatter.date.srcformat");
}
if(this.formatoptions && this.formatoptions.newformat) {
newformat = this.formatoptions.newformat;
} else {
newformat = $.jgrid.getRegional(ts, "formatter.date.newformat");
}
} else {
srcformat = newformat = this.datefmt || "Y-m-d";
}
cmtypes[si] = {"stype": sorttype, "srcfmt": srcformat,"newfmt":newformat, "sfunc": this.sortfunc || null, name : this.name};
} else {
cmtypes[si] = {"stype": sorttype, "srcfmt":'',"newfmt":'', "sfunc": this.sortfunc || null, name : this.name};
}
if(ts.p.grouping ) {
for(gin =0, lengrp = grpview.groupField.length; gin< lengrp; gin++) {
if( this.name === grpview.groupField[gin]) {
grtypes[gin] = cmtypes[si];
grindexes[gin]= si;
}
}
}
if(!ts.p.multiSort) {
if(!fndsort && (si === ts.p.sortname)){
st = si;
fndsort = true;
}
}
});
if(ts.p.multiSort) {
st = sortarr;
sto = sortord;
}
if(ts.p.treeGrid && ts.p._sort) {
$(ts).jqGrid("SortTree", st, ts.p.sortorder, cmtypes[st].stype || 'text', cmtypes[st].srcfmt || '');
return;
}
var compareFnMap = {
'eq':function(queryObj) {return queryObj.equals;},
'ne':function(queryObj) {return queryObj.notEquals;},
'lt':function(queryObj) {return queryObj.less;},
'le':function(queryObj) {return queryObj.lessOrEquals;},
'gt':function(queryObj) {return queryObj.greater;},
'ge':function(queryObj) {return queryObj.greaterOrEquals;},
'cn':function(queryObj) {return queryObj.contains;},
'nc':function(queryObj,op) {return op === "OR" ? queryObj.orNot().contains : queryObj.andNot().contains;},
'bw':function(queryObj) {return queryObj.startsWith;},
'bn':function(queryObj,op) {return op === "OR" ? queryObj.orNot().startsWith : queryObj.andNot().startsWith;},
'en':function(queryObj,op) {return op === "OR" ? queryObj.orNot().endsWith : queryObj.andNot().endsWith;},
'ew':function(queryObj) {return queryObj.endsWith;},
"ni": function (queryObj, op) { return op === "OR" ? queryObj.orNot().inData : queryObj.andNot().inData; },
"in": function (queryObj) { return queryObj.inData; },
'nu':function(queryObj) {return queryObj.isNull;},
'nn':function(queryObj,op) {return op === "OR" ? queryObj.orNot().isNull : queryObj.andNot().isNull;}
},
query = $.jgrid.from.call(ts, ts.p.data);
if (ts.p.ignoreCase) { query = query.ignoreCase(); }
function tojLinq ( group ) {
var s = 0, index, gor, ror, opr, rule, fld;
if (group.groups != null) {
gor = group.groups.length && group.groupOp.toString().toUpperCase() === "OR";
if (gor) {
query.orBegin();
}
for (index = 0; index < group.groups.length; index++) {
if (s > 0 && gor) {
query.or();
}
try {
tojLinq(group.groups[index]);
} catch (e) {alert(e);}
s++;
}
if (gor) {
query.orEnd();
}
}
if (group.rules != null) {
//if(s>0) {
// var result = query.select();
// query = $.jgrid.from( result);
// if (ts.p.ignoreCase) { query = query.ignoreCase(); }
//}
try{
ror = group.rules.length && group.groupOp.toString().toUpperCase() === "OR";
if (ror) {
query.orBegin();
}
var rulefld;
for (index = 0; index < group.rules.length; index++) {
rule = group.rules[index];
opr = group.groupOp.toString().toUpperCase();
if (compareFnMap[rule.op] && rule.field ) {
if(s > 0 && opr && opr === "OR") {
query = query.or();
}
rulefld = rule.field;
if( ts.p.useNameForSearch) {
if(cmtypes.hasOwnProperty(rule.field)) {
rulefld = cmtypes[rule.field].name;
}
}
try {
fld = cmtypes[rule.field];
if(fld.stype === 'date') {
if(typeof fld.srcfmt === "string" && typeof fld.newfmt === "string" ) {
rule.data = $.jgrid.parseDate.call(ts, fld.newfmt, rule.data, fld.srcfmt);
}
}
query = compareFnMap[rule.op](query, opr)(rulefld, rule.data, fld);
} catch (e) {}
} else if( ts.p.customFilterDef !== undefined && ts.p.customFilterDef[rule.op] !== undefined && $.isFunction(ts.p.customFilterDef[rule.op].action)) {
query = query.user.call(ts, rule.op, rule.field, rule.data);
}
s++;
}
if (ror) {
query.orEnd();
}
} catch (g) {alert(g);}
}
}
if (ts.p.search === true) {
var srules = ts.p.postData.filters;
if(srules) {
if(typeof srules === "string") { srules = $.jgrid.parse(srules);}
tojLinq( srules );
} else {
try {
sfld = cmtypes[ts.p.postData.searchField];
if(sfld.stype === 'date') {
if(sfld.srcfmt && sfld.newfmt && sfld.srcfmt !== sfld.newfmt ) {
ts.p.postData.searchString = $.jgrid.parseDate.call(ts, sfld.newfmt, ts.p.postData.searchString, sfld.srcfmt);
}
}
if(compareFnMap[ts.p.postData.searchOper]) {
query = compareFnMap[ts.p.postData.searchOper](query)(ts.p.postData.searchField, ts.p.postData.searchString,cmtypes[ts.p.postData.searchField]);
} else if( ts.p.customFilterDef !== undefined && ts.p.customFilterDef[ts.p.postData.searchOper] !== undefined && $.isFunction(ts.p.customFilterDef[ts.p.postData.searchOper].action)) {
query = query.user.call(ts, ts.p.postData.searchOper, ts.p.postData.searchField, ts.p.postData.searchString);
}
} catch (se){}
}
}
if(ts.p.treeGrid && ts.p.treeGridModel === "nested") {
query.orderBy(ts.p.treeReader.left_field, 'asc', 'integer', '', null);
}
if(ts.p.treeGrid && ts.p.treeGridModel === "adjacency") {
lengrp =0;
st = null;
}
if(ts.p.grouping) {
for(gin=0; gin<lengrp;gin++) {
query.orderBy(grindexes[gin],grpview.groupOrder[gin],grtypes[gin].stype, grtypes[gin].srcfmt);
}
}
if(ts.p.multiSort) {
$.each(st,function(i){
query.orderBy(this, sto[i], cmtypes[this].stype, cmtypes[this].srcfmt, cmtypes[this].sfunc);
});
} else {
if (st && ts.p.sortorder && fndsort) {
// to be fixed in case sortname has more than one field
if(ts.p.sortorder.toUpperCase() === "DESC") {
query.orderBy(ts.p.sortname, "d", cmtypes[st].stype, cmtypes[st].srcfmt, cmtypes[st].sfunc);
} else {
query.orderBy(ts.p.sortname, "a", cmtypes[st].stype, cmtypes[st].srcfmt, cmtypes[st].sfunc);
}
}
}
var queryResults = query.select(),
recordsperpage = parseInt(ts.p.rowNum,10),
total = queryResults.length,
page = parseInt(ts.p.page,10),
totalpages = Math.ceil(total / recordsperpage),
retresult = {};
if((ts.p.search || ts.p.resetsearch) && ts.p.grouping && ts.p.groupingView._locgr) {
ts.p.groupingView.groups =[];
var j, grPrepare = $.jgrid.getMethod("groupingPrepare"), key, udc;
if(ts.p.footerrow && ts.p.userDataOnFooter) {
for (key in ts.p.userData) {
if(ts.p.userData.hasOwnProperty(key)) {
ts.p.userData[key] = 0;
}
}
udc = true;
}
for(j=0; j<total; j++) {
if(udc) {
for(key in ts.p.userData){
if( ts.p.userData.hasOwnProperty( key ) ) {
ts.p.userData[key] += parseFloat(queryResults[j][key] || 0);
}
}
}
grPrepare.call($(ts),queryResults[j],j, recordsperpage );
}
}
if( retAll ) {
return queryResults;
}
if(ts.p.treeGrid && ts.p.search) {
queryResults = $(ts).jqGrid("searchTree", queryResults);
} else {
queryResults = queryResults.slice( (page-1)*recordsperpage , page*recordsperpage );
}
query = null;
cmtypes = null;
retresult[ts.p.localReader.total] = totalpages;
retresult[ts.p.localReader.page] = page;
retresult[ts.p.localReader.records] = total;
retresult[ts.p.localReader.root] = queryResults;
retresult[ts.p.localReader.userdata] = ts.p.userData;
queryResults = null;
return retresult;
},
updatepager = function(rn, dnd) {
var cp, last, base, from,to,tot,fmt, pgboxes = "", sppg,
pgid = ts.p.pager ? ts.p.pager.substring(1) : "",
tspg = pgid ? "_"+pgid : "",
tspg_t = ts.p.toppager ? "_"+ts.p.toppager.substr(1) : "";
base = parseInt(ts.p.page,10)-1;
if(base < 0) { base = 0; }
base = base*parseInt(ts.p.rowNum,10);
to = base + ts.p.reccount;
if (ts.p.scroll) {
var rows = $("tbody:first > tr:gt(0)", ts.grid.bDiv);
if(to > ts.p.records) {
to = ts.p.records;
}
base = to - rows.length;
ts.p.reccount = rows.length;
var rh = rows.outerHeight() || ts.grid.prevRowHeight;
if (rh) {
var top = base * rh;
var height = parseInt(ts.p.records,10) * rh;
$(">div:first",ts.grid.bDiv).css({height : height}).children("div:first").css({height:top,display:top?"":"none"});
if (ts.grid.bDiv.scrollTop === 0 && ts.p.page > 1) {
ts.grid.bDiv.scrollTop = ts.p.rowNum * (ts.p.page - 1) * rh;
}
}
ts.grid.bDiv.scrollLeft = ts.grid.hDiv.scrollLeft;
}
pgboxes = ts.p.pager || "";
pgboxes += ts.p.toppager ? (pgboxes ? "," + ts.p.toppager : ts.p.toppager) : "";
if(pgboxes) {
fmt = $.jgrid.getRegional(ts, "formatter.integer");
cp = intNum(ts.p.page);
last = intNum(ts.p.lastpage);
$(".selbox",pgboxes)[ this.p.useProp ? 'prop' : 'attr' ]("disabled",false);
if(ts.p.pginput===true) {
$("#input"+tspg).html($.jgrid.template($.jgrid.getRegional(ts, "defaults.pgtext", ts.p.pgtext) || "","<input "+getstyle(stylemodule, 'pgInput', false, 'ui-pg-input') + " type='text' size='2' maxlength='7' value='0' role='textbox'/>","<span id='sp_1_"+pgid+"'></span>"));
if(ts.p.toppager) {
$("#input_t"+tspg_t).html($.jgrid.template($.jgrid.getRegional(ts, "defaults.pgtext", ts.p.pgtext) || "","<input "+getstyle(stylemodule, 'pgInput', false, 'ui-pg-input') + " type='text' size='2' maxlength='7' value='0' role='textbox'/>","<span id='sp_1_"+pgid+"_toppager'></span>"));
}
$('.ui-pg-input',pgboxes).val(ts.p.page);
sppg = ts.p.toppager ? '#sp_1'+tspg+",#sp_1"+tspg+"_toppager" : '#sp_1'+tspg;
$(sppg).html($.fmatter ? $.fmatter.util.NumberFormat(ts.p.lastpage,fmt):ts.p.lastpage);
}
if (ts.p.viewrecords){
if(ts.p.reccount === 0) {
$(".ui-paging-info",pgboxes).html($.jgrid.getRegional(ts, "defaults.emptyrecords", ts.p.emptyrecords ));
} else {
from = base+1;
tot=ts.p.records;
if($.fmatter) {
from = $.fmatter.util.NumberFormat(from,fmt);
to = $.fmatter.util.NumberFormat(to,fmt);
tot = $.fmatter.util.NumberFormat(tot,fmt);
}
var rt = $.jgrid.getRegional(ts, "defaults.recordtext", ts.p.recordtext);
$(".ui-paging-info",pgboxes).html($.jgrid.template( rt ,from,to,tot));
}
}
if(ts.p.pgbuttons===true) {
if(cp<=0) {cp = last = 0;}
if(cp===1 || cp === 0) {
$("#first"+tspg+", #prev"+tspg).addClass( disabled ).removeClass( hover );
if(ts.p.toppager) { $("#first_t"+tspg_t+", #prev_t"+tspg_t).addClass( disabled ).removeClass( hover ); }
} else {
$("#first"+tspg+", #prev"+tspg).removeClass( disabled );
if(ts.p.toppager) { $("#first_t"+tspg_t+", #prev_t"+tspg_t).removeClass( disabled ); }
}
if(cp===last || cp === 0) {
$("#next"+tspg+", #last"+tspg).addClass( disabled ).removeClass( hover );
if(ts.p.toppager) { $("#next_t"+tspg_t+", #last_t"+tspg_t).addClass( disabled ).removeClass( hover ); }
} else {
$("#next"+tspg+", #last"+tspg).removeClass( disabled );
if(ts.p.toppager) { $("#next_t"+tspg_t+", #last_t"+tspg_t).removeClass( disabled ); }
}
}
}
if(rn===true && ts.p.rownumbers === true) {
$(">td.jqgrid-rownum",ts.rows).each(function(i){
$(this).html(base+1+i);
});
}
if(ts.p.reccount === 0 ) {
var classes = getstyle(stylemodule, 'rowBox', true, 'jqgrow ui-row-'+ ts.p.direction),
tstr = constructTr("norecs", false, classes, {}, "");
tstr += "<td style='text-align:center' colspan='"+grid.headers.length+"'>"+$.jgrid.getRegional(ts, "defaults.emptyrecords", ts.p.emptyrecords )+"</td>";
tstr += "</tr>";
$("table:first", grid.bDiv).append(tstr);
}
if(dnd && ts.p.jqgdnd) { $(ts).jqGrid('gridDnD','updateDnD');}
$(ts).triggerHandler("jqGridGridComplete");
if($.isFunction(ts.p.gridComplete)) {ts.p.gridComplete.call(ts);}
$(ts).triggerHandler("jqGridAfterGridComplete");
},
beginReq = function() {
ts.grid.hDiv.loading = true;
if(ts.p.hiddengrid) { return;}
$(ts).jqGrid("progressBar", {method:"show", loadtype : ts.p.loadui, htmlcontent: $.jgrid.getRegional(ts, "defaults.loadtext", ts.p.loadtext) });
},
endReq = function() {
ts.grid.hDiv.loading = false;
$(ts).jqGrid("progressBar", {method:"hide", loadtype : ts.p.loadui });
},
beforeprocess = function(data, st, xhr) {
var bfpcr = $(ts).triggerHandler("jqGridBeforeProcessing", [data,st,xhr]);
bfpcr = (bfpcr === undefined || typeof(bfpcr) !== 'boolean') ? true : bfpcr;
if ($.isFunction(ts.p.beforeProcessing)) {
if (ts.p.beforeProcessing.call(ts, data, st, xhr) === false) {
bfpcr = false;
}
}
return bfpcr;
},
afterprocess = function(dstr, lcf) {
$(ts).triggerHandler("jqGridLoadComplete", [dstr]);
if(lcf) {ts.p.loadComplete.call(ts,dstr);}
$(ts).triggerHandler("jqGridAfterLoadComplete", [dstr]);
ts.p.datatype = "local";
ts.p.datastr = null;
endReq();
},
populate = function (npage) {
if(!ts.grid.hDiv.loading) {
var pvis = ts.p.scroll && npage === false,
prm = {}, dt, dstr, pN=ts.p.prmNames;
spsh = 0;
if(ts.p.page <=0) { ts.p.page = Math.min(1,ts.p.lastpage); }
if(pN.search !== null) {prm[pN.search] = ts.p.search;} if(pN.nd !== null) {prm[pN.nd] = new Date().getTime();}
if(pN.rows !== null) {prm[pN.rows]= ts.p.rowNum;} if(pN.page !== null) {prm[pN.page]= ts.p.page;}
if(pN.sort !== null) {prm[pN.sort]= ts.p.sortname;} if(pN.order !== null) {prm[pN.order]= ts.p.sortorder;}
if(ts.p.rowTotal !== null && pN.totalrows !== null) { prm[pN.totalrows]= ts.p.rowTotal; }
var lcf = $.isFunction(ts.p.loadComplete), lc = lcf ? ts.p.loadComplete : null;
var adjust = 0;
npage = npage || 1;
if (npage > 1) {
if(pN.npage !== null) {
prm[pN.npage] = npage;
adjust = npage - 1;
npage = 1;
} else {
lc = function(req) {
ts.p.page++;
ts.grid.hDiv.loading = false;
if (lcf) {
ts.p.loadComplete.call(ts,req);
}
populate(npage-1);
};
}
} else if (pN.npage !== null) {
delete ts.p.postData[pN.npage];
}
if(ts.p.grouping) {
$(ts).jqGrid('groupingSetup');
var grp = ts.p.groupingView, gi, gs="", tmpordarr = [];
for(gi=0;gi<grp.groupField.length;gi++) {
var index = grp.groupField[gi];
$.each(ts.p.colModel, function(cmIndex, cmValue) {
if (cmValue.name === index && cmValue.index){
index = cmValue.index;
}
} );
tmpordarr.push(index +" "+grp.groupOrder[gi]);
}
gs = tmpordarr.join();
if( $.trim(prm[pN.sort]) !== "") {
prm[pN.sort] = gs + " ,"+prm[pN.sort];
} else {
prm[pN.sort] = gs;
prm[pN.order] = "";
}
}
$.extend(ts.p.postData,prm);
var rcnt = !ts.p.scroll ? 1 : ts.rows.length-1;
if ($.isFunction(ts.p.datatype)) {
ts.p.datatype.call(ts,ts.p.postData,"load_"+ts.p.id, rcnt, npage, adjust);
return;
}
var bfr = $(ts).triggerHandler("jqGridBeforeRequest");
if (bfr === false || bfr === 'stop') { return; }
if ($.isFunction(ts.p.beforeRequest)) {
bfr = ts.p.beforeRequest.call(ts);
if (bfr === false || bfr === 'stop') { return; }
}
//bvn
if ($.isFunction(ts.treeGrid_beforeRequest)) {
ts.treeGrid_beforeRequest.call(ts);
}
dt = ts.p.datatype.toLowerCase();
switch(dt)
{
case "json":
case "jsonp":
case "xml":
case "script":
$.ajax($.extend({
url:ts.p.url,
type:ts.p.mtype,
dataType: dt ,
data: $.isFunction(ts.p.serializeGridData)? ts.p.serializeGridData.call(ts,ts.p.postData) : ts.p.postData,
success:function(data,st, xhr) {
if(!beforeprocess(data, st,xhr)) {
endReq();
return;
}
if(dt === "xml") { addXmlData(data, rcnt,npage>1,adjust); }
else { addJSONData(data, rcnt, npage>1, adjust); }
$(ts).triggerHandler("jqGridLoadComplete", [data]);
if(lc) { lc.call(ts,data); }
$(ts).triggerHandler("jqGridAfterLoadComplete", [data]);
if (pvis) { ts.grid.populateVisible(); }
if (!ts.p.treeGrid_bigData) {
if( ts.p.loadonce || ts.p.treeGrid) {ts.p.datatype = "local";}
} else {
if( ts.p.loadonce) {ts.p.datatype = "local";} //bvn13
}
data=null;
if (npage === 1) { endReq(); }
// bvn
if ($.isFunction(ts.treeGrid_afterLoadComplete)) {
ts.treeGrid_afterLoadComplete.call(ts);
}
},
error:function(xhr,st,err){
$(ts).triggerHandler("jqGridLoadError", [xhr,st,err]);
if($.isFunction(ts.p.loadError)) { ts.p.loadError.call(ts,xhr,st,err); }
if (npage === 1) { endReq(); }
xhr=null;
},
beforeSend: function(xhr, settings ){
var gotoreq = true;
gotoreq = $(ts).triggerHandler("jqGridLoadBeforeSend", [xhr,settings]);
if($.isFunction(ts.p.loadBeforeSend)) {
gotoreq = ts.p.loadBeforeSend.call(ts,xhr, settings);
}
if(gotoreq === undefined) { gotoreq = true; }
if(gotoreq === false) {
return false;
}
beginReq();
}
},$.jgrid.ajaxOptions, ts.p.ajaxGridOptions));
break;
case "xmlstring":
beginReq();
dstr = typeof ts.p.datastr !== 'string' ? ts.p.datastr : $.parseXML(ts.p.datastr);
if(!beforeprocess(dstr, 200 , null)) {
endReq();
return;
}
addXmlData(dstr);
afterprocess(dstr, lcf);
break;
case "jsonstring":
beginReq();
if(typeof ts.p.datastr === 'string') { dstr = $.jgrid.parse(ts.p.datastr); }
else { dstr = ts.p.datastr; }
if(!beforeprocess(dstr, 200 , null)) {
endReq();
return;
}
addJSONData(dstr);
afterprocess(dstr, lcf);
break;
case "local":
case "clientside":
beginReq();
ts.p.datatype = "local";
ts.p._ald = true;
var req = addLocalData( false );
if(!beforeprocess(req, 200 , null)) {
endReq();
return;
}
addJSONData(req,rcnt,npage>1,adjust);
$(ts).triggerHandler("jqGridLoadComplete", [req]);
if(lc) { lc.call(ts,req); }
$(ts).triggerHandler("jqGridAfterLoadComplete", [req]);
if (pvis) { ts.grid.populateVisible(); }
endReq();
ts.p._ald = false;
break;
}
ts.p._sort = false;
}
},
setHeadCheckBox = function ( checked ) {
$('#cb_'+$.jgrid.jqID(ts.p.id),ts.grid.hDiv)[ts.p.useProp ? 'prop': 'attr']("checked", checked);
var fid = ts.p.frozenColumns ? ts.p.id+"_frozen" : "";
if(fid) {
$('#cb_'+$.jgrid.jqID(ts.p.id),ts.grid.fhDiv)[ts.p.useProp ? 'prop': 'attr']("checked", checked);
}
},
setPager = function (pgid, tp){
// TBD - consider escaping pgid with pgid = $.jgrid.jqID(pgid);
var sep = "<td class='ui-pg-button "+disabled+"'><span class='ui-separator'></span></td>",
pginp = "",
pgl="<table class='ui-pg-table ui-common-table ui-paging-pager'><tbody><tr>",
str="", pgcnt, lft, cent, rgt, twd, tdw, i, removebutt,
clearVals = function(onpaging, thus){
var ret;
ret = $(ts).triggerHandler("jqGridPaging", [onpaging, thus]);
if(ret==='stop') {return false;}
if ($.isFunction(ts.p.onPaging) ) { ret = ts.p.onPaging.call(ts,onpaging, thus); }
if(ret==='stop') {return false;}
ts.p.selrow = null;
if(ts.p.multiselect) {
if(!ts.p.preserveSelection) {
ts.p.selarrrow =[];
}
setHeadCheckBox( false );
}
ts.p.savedRow = [];
return true;
};
//pgid = pgid.substr(1);
tp += "_" + pgid;
pgcnt = "pg_"+pgid;
lft = pgid+"_left"; cent = pgid+"_center"; rgt = pgid+"_right";
$("#"+$.jgrid.jqID(pgid) )
.append("<div id='"+pgcnt+"' class='ui-pager-control' role='group'><table " + getstyle(stylemodule, 'pagerTable', false, 'ui-pg-table ui-common-table ui-pager-table') + "><tbody><tr><td id='"+lft+"' align='left'></td><td id='"+cent+"' align='center' style='white-space:pre;'></td><td id='"+rgt+"' align='right'></td></tr></tbody></table></div>")
.attr("dir","ltr"); //explicit setting
if(ts.p.rowList.length >0){
str = "<td dir=\""+dir+"\">";
str +="<select "+getstyle(stylemodule, 'pgSelectBox', false, 'ui-pg-selbox')+" size=\"1\" role=\"listbox\" title=\""+($.jgrid.getRegional(ts,"defaults.pgrecs",ts.p.pgrecs) || "")+ "\">";
var strnm;
for(i=0;i<ts.p.rowList.length;i++){
strnm = ts.p.rowList[i].toString().split(":");
if(strnm.length === 1) {
strnm[1] = strnm[0];
}
str +="<option role=\"option\" value=\""+strnm[0]+"\""+(( intNum(ts.p.rowNum,0) === intNum(strnm[0],0))?" selected=\"selected\"":"")+">"+strnm[1]+"</option>";
}
str +="</select></td>";
}
if(dir==="rtl") { pgl += str; }
if(ts.p.pginput===true) {
pginp= "<td id='input"+tp+"' dir='"+dir+"'>"+$.jgrid.template( $.jgrid.getRegional(ts, "defaults.pgtext", ts.p.pgtext) || "","<input class='ui-pg-input' type='text' size='2' maxlength='7' value='0' role='textbox'/>","<span id='sp_1_"+$.jgrid.jqID(pgid)+"'></span>")+"</td>";
}
if(ts.p.pgbuttons===true) {
var po=["first"+tp,"prev"+tp, "next"+tp,"last"+tp], btc=getstyle(stylemodule, 'pgButtonBox', true, 'ui-pg-button'),
pot = [($.jgrid.getRegional(ts,"defaults.pgfirst",ts.p.pgfirst) || ""),
($.jgrid.getRegional(ts,"defaults.pgprev",ts.p.pgprev) || ""),
($.jgrid.getRegional(ts,"defaults.pgnext",ts.p.pgnext) || ""),
($.jgrid.getRegional(ts,"defaults.pglast",ts.p.pglast) || "")];
if(dir==="rtl") {
po.reverse();
pot.reverse();
}
pgl += "<td id='"+po[0]+"' class='"+btc+"' title='"+ pot[0] +"'" + "><span " + getstyle(stylemodule, 'icon_first', false, iconbase)+"></span></td>";
pgl += "<td id='"+po[1]+"' class='"+btc+"' title='"+ pot[1] +"'" +"><span " + getstyle(stylemodule, 'icon_prev', false, iconbase)+"></span></td>";
pgl += pginp !== "" ? sep+pginp+sep:"";
pgl += "<td id='"+po[2]+"' class='"+btc+"' title='"+ pot[2] +"'" +"><span " + getstyle(stylemodule, 'icon_next',false, iconbase)+"></span></td>";
pgl += "<td id='"+po[3]+"' class='"+btc+"' title='"+ pot[3] +"'" +"><span " + getstyle(stylemodule, 'icon_end',false, iconbase)+"></span></td>";
} else if (pginp !== "") {
pgl += pginp;
}
if(dir==="ltr") {
pgl += str;
}
pgl += "</tr></tbody></table>";
pgid = $.jgrid.jqID(pgid);
pgcnt = $.jgrid.jqID(pgcnt);
if(ts.p.viewrecords===true) {
$("td#"+pgid+"_"+ts.p.recordpos,"#"+pgcnt).append("<div dir='"+dir+"' style='text-align:"+ts.p.recordpos+"' class='ui-paging-info'></div>");
}
$("td#"+pgid+"_"+ts.p.pagerpos,"#"+pgcnt).append(pgl);
tdw = $("#gbox_"+$.jgrid.jqID(ts.p.id)).css("font-size") || "11px";
$("#gbox_"+$.jgrid.jqID(ts.p.id)).append("<div id='testpg' "+getstyle(stylemodule, 'entrieBox', false, 'ui-jqgrid')+" style='font-size:"+tdw+";visibility:hidden;' ></div>");
twd = $(pgl).clone().appendTo("#testpg").width();
$("#testpg").remove();
if(twd > 0) {
if(pginp !== "") { twd += 50; } //should be param
removebutt = twd > $("td#"+pgid+"_"+ts.p.pagerpos,"#"+pgcnt).innerWidth();
$("td#"+pgid+"_"+ts.p.pagerpos,"#"+pgcnt).width(twd);
}
ts.p._nvtd = [];
ts.p._nvtd[0] = twd ? Math.floor((ts.p.width - twd)/2) : Math.floor(ts.p.width/3);
ts.p._nvtd[1] = 0;
pgl=null;
$('.ui-pg-selbox',"#"+pgcnt).on('change',function() {
if(!clearVals('records', this)) { return false; }
ts.p.page = Math.round(ts.p.rowNum*(ts.p.page-1)/this.value-0.5)+1;
ts.p.rowNum = this.value;
if(ts.p.pager) { $('.ui-pg-selbox', ts.p.pager ).val(this.value); }
if(ts.p.toppager) { $('.ui-pg-selbox', ts.p.toppager).val(this.value); }
populate();
return false;
});
if(ts.p.pgbuttons===true) {
$(".ui-pg-button","#"+pgcnt).hover(function(){
if($(this).hasClass(disabled)) {
this.style.cursor='default';
} else {
$(this).addClass(hover);
this.style.cursor='pointer';
}
},function() {
if(!$(this).hasClass(disabled)) {
$(this).removeClass(hover);
this.style.cursor= "default";
}
});
$("#first"+$.jgrid.jqID(tp)+", #prev"+$.jgrid.jqID(tp)+", #next"+$.jgrid.jqID(tp)+", #last"+$.jgrid.jqID(tp)).click( function() {
if ($(this).hasClass(disabled)) {
return false;
}
var cp = intNum(ts.p.page,1),
last = intNum(ts.p.lastpage,1), selclick = false,
fp=true, pp=true, np=true,lp=true;
if(last ===0 || last===1) {
fp=false;
pp=false;
np=false;
lp=false;
} else if( last>1 && cp >=1) {
if( cp === 1) {
fp=false;
pp=false;
} else if( cp===last){
np=false;
lp=false;
}
} else if( last>1 && cp===0 ) {
np=false;
lp=false;
cp=last-1;
}
if(!clearVals(this.id.split("_")[0], this)) { return false; }
if( this.id === 'first'+tp && fp ) { ts.p.page=1; selclick=true;}
if( this.id === 'prev'+tp && pp) { ts.p.page=(cp-1); selclick=true;}
if( this.id === 'next'+tp && np) { ts.p.page=(cp+1); selclick=true;}
if( this.id === 'last'+tp && lp) { ts.p.page=last; selclick=true;}
if(selclick) {
populate();
}
$.jgrid.setSelNavIndex(ts, this);
return false;
});
}
if(ts.p.pginput===true) {
$("#"+pgcnt).on('keypress','input.ui-pg-input', function(e) {
var key = e.charCode || e.keyCode || 0;
if(key === 13) {
if(!clearVals('user', this)) { return false; }
$(this).val( intNum( $(this).val(), 1));
ts.p.page = ($(this).val()>0) ? $(this).val():ts.p.page;
populate();
return false;
}
return this;
});
}
if(removebutt && ts.p.responsive && !ts.p.forcePgButtons) {
$("#"+po[0]+",#"+po[3]+",#input"+$.jgrid.jqID(tp)).hide();
$(".ui-paging-info", "td#"+pgid+"_"+ts.p.recordpos).hide();
$(".ui-pg-selbox","td#"+pgid+"_"+ts.p.pagerpos).hide();
}
},
multiSort = function(iCol, obj, sor ) {
var cm = ts.p.colModel,
selTh = ts.p.frozenColumns ? obj : ts.grid.headers[iCol].el, so="", sn;
$("span.ui-grid-ico-sort",selTh).addClass(disabled);
$(selTh).attr({"aria-selected":"false","aria-sort" : "none"});
sn = (cm[iCol].index || cm[iCol].name);
if ( typeof sor == "undefined" )
{
if(cm[iCol].lso) {
if(cm[iCol].lso==="asc") {
cm[iCol].lso += "-desc";
so = "desc";
} else if(cm[iCol].lso==="desc") {
cm[iCol].lso += "-asc";
so = "asc";
} else if(cm[iCol].lso==="asc-desc" || cm[iCol].lso==="desc-asc") {
cm[iCol].lso="";
}
} else {
cm[iCol].lso = so = cm[iCol].firstsortorder || 'asc';
}
}
else {
cm[iCol].lso = so = sor;
}
if( so ) {
$("span.s-ico",selTh).show();
$("span.ui-icon-"+so,selTh).removeClass(disabled);
$(selTh).attr({"aria-selected":"true","aria-sort" : so+"ending"});
} else {
if(!ts.p.viewsortcols[0]) {
$("span.s-ico",selTh).hide();
}
}
var isn = sortarr.indexOf( sn );
if( isn === -1 ) {
sortarr.push( sn );
sortord.push( so );
} else {
if( so ) {
sortord[isn] = so;
} else {
sortord.splice( isn, 1 );
sortarr.splice( isn, 1 );
}
}
ts.p.sortorder = "";
ts.p.sortname = "";
for( var i = 0, len = sortarr.length; i < len ; i++) {
if( i > 0) {
ts.p.sortname += ", ";
}
ts.p.sortname += sortarr[ i ];
if( i !== len -1) {
ts.p.sortname += " "+sortord[ i ];
}
}
ts.p.sortorder = sortord[ len -1 ];
/*
$.each(cm, function(i){
if(this.lso) {
if(i>0 && fs) {
sort += ", ";
}
splas = this.lso.split("-");
sort += cm[i].index || cm[i].name;
sort += " "+splas[splas.length-1];
fs = true;
ts.p.sortorder = splas[splas.length-1];
}
});
ls = sort.lastIndexOf(ts.p.sortorder);
sort = sort.substring(0, ls);
ts.p.sortname = sort;
*/
},
sortData = function (index, idxcol,reload,sor, obj){
if(!ts.p.colModel[idxcol].sortable) { return; }
if(ts.p.savedRow.length > 0) {return;}
if(!reload) {
if( ts.p.lastsort === idxcol && ts.p.sortname !== "" ) {
if( ts.p.sortorder === 'asc') {
ts.p.sortorder = 'desc';
} else if(ts.p.sortorder === 'desc') { ts.p.sortorder = 'asc';}
} else { ts.p.sortorder = ts.p.colModel[idxcol].firstsortorder || 'asc'; }
ts.p.page = 1;
}
if(ts.p.multiSort) {
multiSort( idxcol, obj, sor);
} else {
if(sor) {
if(ts.p.lastsort === idxcol && ts.p.sortorder === sor && !reload) { return; }
ts.p.sortorder = sor;
}
var previousSelectedTh = ts.grid.headers[ts.p.lastsort] ? ts.grid.headers[ts.p.lastsort].el : null, newSelectedTh = ts.p.frozenColumns ? obj : ts.grid.headers[idxcol].el,
//sortrule = $.trim(ts.p.viewsortcols[1] === 'single' ? hidden : disabled);
usehide = ts.p.viewsortcols[1] === 'single' ? true : false, tmpicon;
tmpicon = $(previousSelectedTh).find("span.ui-grid-ico-sort");
tmpicon.addClass(disabled);
if(usehide) {
$(tmpicon).css("display","none");
}
$(previousSelectedTh).attr({"aria-selected":"false","aria-sort" : "none"});
if(ts.p.frozenColumns) {
tmpicon = ts.grid.fhDiv.find("span.ui-grid-ico-sort");
tmpicon.addClass(disabled);
if(usehide) { tmpicon.css("display","none"); }
ts.grid.fhDiv.find("th").attr({"aria-selected":"false","aria-sort" : "none"});
}
tmpicon = $(newSelectedTh).find("span.ui-icon-"+ts.p.sortorder);
tmpicon.removeClass(disabled);
if(usehide) { tmpicon.css("display",""); }
$(newSelectedTh).attr({"aria-selected":"true","aria-sort" : ts.p.sortorder + "ending"});
if(!ts.p.viewsortcols[0]) {
if(ts.p.lastsort !== idxcol) {
if(ts.p.frozenColumns){
ts.grid.fhDiv.find("span.s-ico").hide();
}
$("span.s-ico",previousSelectedTh).hide();
$("span.s-ico",newSelectedTh).show();
} else if (ts.p.sortname === "") { // if ts.p.lastsort === idxcol but ts.p.sortname === ""
$("span.s-ico",newSelectedTh).show();
}
}
index = index.substring(5 + ts.p.id.length + 1); // bad to be changed!?!
ts.p.sortname = ts.p.colModel[idxcol].index || index;
}
if ($(ts).triggerHandler("jqGridSortCol", [ts.p.sortname, idxcol, ts.p.sortorder]) === 'stop') {
ts.p.lastsort = idxcol;
return;
}
if($.isFunction(ts.p.onSortCol)) {
if (ts.p.onSortCol.call(ts, ts.p.sortname, idxcol, ts.p.sortorder)==='stop') {
ts.p.lastsort = idxcol;
return;
}
}
setHeadCheckBox(false);
if(ts.p.datatype === "local") {
if(ts.p.deselectAfterSort && !ts.p.preserveSelection) {
$(ts).jqGrid("resetSelection");
}
} else {
ts.p.selrow = null;
if(ts.p.multiselect){
if(!ts.p.preserveSelection) {
ts.p.selarrrow =[];
}
}
ts.p.savedRow =[];
}
if(ts.p.scroll) {
var sscroll = ts.grid.bDiv.scrollLeft;
emptyRows.call(ts, true, false);
ts.grid.hDiv.scrollLeft = sscroll;
}
if(ts.p.subGrid && ts.p.datatype === 'local') {
$("td.sgexpanded","#"+$.jgrid.jqID(ts.p.id)).each(function(){
$(this).trigger("click");
});
}
ts.p._sort = true;
populate();
ts.p.lastsort = idxcol;
if(ts.p.sortname !== index && idxcol) {ts.p.lastsort = idxcol;}
},
setColWidth = function () {
var initwidth = 0, brd=$.jgrid.cell_width? 0: intNum(ts.p.cellLayout,0), vc=0, lvc,
scw=intNum(ts.p.scrollOffset,0),cw,hs=false,aw,gw=0,cr, chrome_fix;
$.each(ts.p.colModel, function() {
if(this.hidden === undefined) {this.hidden=false;}
if(ts.p.grouping && ts.p.autowidth) {
var ind = $.inArray(this.name, ts.p.groupingView.groupField);
if(ind >= 0 && ts.p.groupingView.groupColumnShow.length > ind) {
this.hidden = !ts.p.groupingView.groupColumnShow[ind];
}
}
this.widthOrg = cw = intNum(this.width,0);
if(this.hidden===false){
initwidth += cw+brd;
if(this.fixed) {
gw += cw+brd;
} else {
vc++;
}
}
});
if(isNaN(ts.p.width)) {
ts.p.width = initwidth + ((ts.p.shrinkToFit ===false && !isNaN(ts.p.height)) ? scw : 0);
}
grid.width = parseInt(ts.p.width,10);
ts.p.tblwidth = initwidth;
if(ts.p.shrinkToFit ===false && ts.p.forceFit === true) {ts.p.forceFit=false;}
if(ts.p.shrinkToFit===true && vc > 0) {
aw = grid.width-brd*vc-gw;
if(!isNaN(ts.p.height)) {
aw -= scw;
hs = true;
}
initwidth =0;
$.each(ts.p.colModel, function(i) {
if(this.hidden === false && !this.fixed){
cw = Math.round(aw*this.width/(ts.p.tblwidth-brd*vc-gw));
this.width =cw;
initwidth += cw;
lvc = i;
}
});
cr = 0;
chrome_fix = bstw === 0 ? -1 :0;
if (hs) {
if(grid.width-gw-(initwidth+brd*vc) !== scw){
cr = grid.width-gw-(initwidth+brd*vc)-scw;
}
} else if(!hs && Math.abs(grid.width-gw-(initwidth+brd*vc)) !== 0) {
cr = grid.width-gw-(initwidth+brd*vc) - bstw;
}
ts.p.colModel[lvc].width += cr + chrome_fix;
ts.p.tblwidth = initwidth+cr+brd*vc+gw;
if(ts.p.tblwidth > ts.p.width) {
ts.p.colModel[lvc].width -= (ts.p.tblwidth - parseInt(ts.p.width,10));
ts.p.tblwidth = ts.p.width;
}
}
},
nextVisible= function(iCol) {
var ret = iCol, j=iCol, i;
for (i = iCol+1;i<ts.p.colModel.length;i++){
if(ts.p.colModel[i].hidden !== true ) {
j=i; break;
}
}
return j-ret;
},
getOffset = function (iCol) {
var $th = $(ts.grid.headers[iCol].el), ret = [$th.position().left + $th.outerWidth()];
if(ts.p.direction==="rtl") { ret[0] = ts.p.width - ret[0]; }
ret[0] -= ts.grid.bDiv.scrollLeft;
ret.push($(ts.grid.hDiv).position().top);
ret.push($(ts.grid.bDiv).offset().top - $(ts.grid.hDiv).offset().top + $(ts.grid.bDiv).height());
return ret;
},
getColumnHeaderIndex = function (th) {
var i, headers = ts.grid.headers, ci = $.jgrid.getCellIndex(th);
for (i = 0; i < headers.length; i++) {
if (th === headers[i].el) {
ci = i;
break;
}
}
return ci;
},
buildColItems = function (top, left, parent, op) {
var cm = ts.p.colModel, len = cm.length, i, cols=[], disp, all_visible = true, cols_nm=[],
texts = $.jgrid.getRegional(ts, "colmenu"),
str1 = '<ul id="col_menu" class="ui-search-menu ui-col-menu modal-content" role="menu" tabindex="0" style="left:'+left+'px;">';
if( op.columns_selectAll ) {
str1 += '<li class="ui-menu-item disabled" role="presentation" draggable="false"><a class="g-menu-item" tabindex="0" role="menuitem" ><table class="ui-common-table" ><tr><td class="menu_icon" title="'+texts.reorder+'"><span class="'+iconbase+' '+colmenustyle.icon_move+' notclick" style="visibility:hidden"></span></td><td class="menu_icon"><input id="chk_all" class="'+colmenustyle.input_checkbox+'" type="checkbox" name="check_all"></td><td class="menu_text">Check/Uncheck</td></tr></table></a></li>';
}
for(i=0;i<len;i++) {
//if(!cm[i].hidedlg) { // column chooser
var hid = !cm[i].hidden ? "checked" : "",
nm = cm[i].name,
lb = ts.p.colNames[i];
disp = (nm === 'cb' || nm==='subgrid' || nm==='rn' || cm[i].hidedlg) ? "style='display:none'" :"";
str1 += '<li '+disp+' class="ui-menu-item" role="presentation" draggable="true"><a class="g-menu-item" tabindex="0" role="menuitem" ><table class="ui-common-table" ><tr><td class="menu_icon" title="'+texts.reorder+'"><span class="'+iconbase+' '+colmenustyle.icon_move+' notclick"></span></td><td class="menu_icon"><input class="'+colmenustyle.input_checkbox+' chk_selected" type="checkbox" name="'+nm+'" '+hid+'></td><td class="menu_text">'+lb+'</td></tr></table></a></li>';
cols.push(i);
if( disp === "") {
cols_nm.push(nm);
}
if(all_visible && hid==="") {
all_visible = false;
}
}
str1 += "</ul>";
$(parent).append(str1);
$("#col_menu").addClass("ui-menu " + colmenustyle.menu_widget);
$("#chk_all", "#col_menu").prop("checked",all_visible);
if(!$.jgrid.isElementInViewport($("#col_menu")[0])){
$("#col_menu").css("left", - parseInt($("#column_menu").innerWidth(),10) +"px");
}
if($.fn.html5sortable()) {
$("#col_menu").html5sortable({
handle: 'span',
items: ':not(.disabled)',
forcePlaceholderSize: true }
).on('sortupdate', function(e, ui) {
cols.splice( ui.startindex, 1);
cols.splice(ui.endindex, 0, ui.startindex);
$(ts).jqGrid("destroyFrozenColumns");
$(ts).jqGrid("remapColumns", cols, true);
$(ts).triggerHandler("jqGridColMenuColumnDone", [cols, null, null]);
if($.isFunction(ts.p.colMenuColumnDone)) {
ts.p.colMenuColumnDone.call( ts, cols, null, null);
}
$(ts).jqGrid("setFrozenColumns");
for(i=0;i<len;i++) {
cols[i] = i;
}
});
} // NO jQuery UI
$("#col_menu > li > a").on("click", function(e) {
var checked, col_name;
if($(e.target).hasClass('notclick')) {
return;
}
if($(e.target).is(":input")) {
checked = $(e.target).is(":checked");
} else {
checked = !$("input", this).is(":checked");
$("input", this).prop("checked",checked);
}
col_name = $("input", this).attr('name');
if(col_name === "check_all") {
if(!checked) {
$("input", "#col_menu" ).prop("checked",false);
$(ts).jqGrid('hideCol', cols_nm);
} else {
$("input", "#col_menu" ).prop("checked",true);
$(ts).jqGrid('showCol', cols_nm);
}
} else {
$(ts).triggerHandler("jqGridColMenuColumnDone", [cols, col_name, checked]);
if($.isFunction(ts.p.colMenuColumnDone)) {
ts.p.colMenuColumnDone.call( ts, cols, col_name, checked);
}
if(!checked) {
$(ts).jqGrid('hideCol', col_name);
$(this).parent().attr("draggable","false");
} else {
$(ts).jqGrid('showCol', col_name );
$(this).parent().attr("draggable","true");
}
if(op.columns_selectAll) {
$("#chk_all", "#col_menu").prop("checked", $('.chk_selected:checked', "#col_menu").length === $('.chk_selected', "#col_menu").length );
}
}
}).hover(function(){
$(this).addClass(hover);
},function(){
$(this).removeClass(hover);
});
},
buildSearchBox = function (index, top, left, parent) {
var cm = ts.p.colModel[index], rules, o1='',v1='',r1='',o2='',v2='', so, op, repstr='',selected, elem,
numopts = ['eq','ne', 'lt', 'le', 'gt', 'ge', 'nu', 'nn', 'in', 'ni'],
stropts = ['eq', 'ne', 'bw', 'bn', 'ew', 'en', 'cn', 'nc', 'nu', 'nn', 'in', 'ni'],
texts = $.jgrid.getRegional(ts, "search"),
common = $.jgrid.styleUI[(ts.p.styleUI || 'jQueryUI')].common;
if(!cm ) {
return;
}
rules = ts.p.colFilters && ts.p.colFilters[cm.name] ? ts.p.colFilters[cm.name] : false;
if(rules && !$.isEmptyObject( rules )) {
o1 = rules.oper1;
v1 = rules.value1;
r1 = rules.rule;
o2 = rules.oper2;
v2 = rules.value2;
}
if(! cm.searchoptions ) {
cm.searchoptions = {};
}
if(cm.searchoptions.sopt) {
so = cm.searchoptions.sopt;
} else if(cm.sorttype === 'text') {
so = stropts;
} else {
so = numopts;
}
if(cm.searchoptions.groupOps) {
op = cm.searchoptions.groupOps;
} else {
op = texts.groupOps;
}
//elem = $('<ul id="search_menu" class="ui-search-menu modal-content" role="menu" tabindex="0" style="left:'+left+'px;top:'+top+'px;"></ul>');
elem = $('<form></form>');
var str1= '<div>'+$.jgrid.getRegional(ts, "colmenu.searchTitle")+'</div>';
str1 += '<div><select size="1" id="oper1" class="'+colmenustyle.filter_select+'">';
$.each(texts.odata, function(i, n) {
selected = n.oper === o1 ? 'selected="selected"' : '';
if($.inArray(n.oper, so) !== -1) {
repstr += '<option value="'+n.oper+'" '+selected+'>'+n.text+'</option>';
}
});
str1 += repstr;
str1 += '</select></div>';
elem.append(str1);
var df="";
if(cm.searchoptions.defaultValue ) {
df = $.isFunction(cm.searchoptions.defaultValue) ? cm.searchoptions.defaultValue.call(ts) : cm.searchoptions.defaultValue;
}
//overwrite default value if restore from filters
if( v1 ) {
df = v1;
}
var soptions = $.extend(cm.searchoptions, {name:cm.index || cm.name, id: "sval1_" + ts.p.idPrefix+cm.name, oper:'search'}),
input = $.jgrid.createEl.call(ts, cm.stype, soptions , df, false, $.extend({},$.jgrid.ajaxOptions, ts.p.ajaxSelectOptions || {}));
$(input).addClass( colmenustyle.filter_input );
str1 = $('<div></div>').append(input);
elem.append(str1);
// and/or
str1 ='<div><select size="1" id="operand" class="'+colmenustyle.filter_select+'">';
$.each(op, function(i, n){
selected = n.op === r1 ? 'selected="selected"' : '';
str1 += "<option value='"+n.op+"' "+selected+">"+n.text+"</option>";
});
str1 += '</select></div>';
elem.append(str1);
//oper2
repstr ='';
$.each(texts.odata, function(i, n) {
selected = n.oper === o2 ? 'selected="selected"' : '';
if($.inArray(n.oper, so) !== -1) {
repstr += '<option value="'+n.oper+'" '+selected+'>'+n.text+'</option>';
}
});
str1 = '<div><select size="1" id="oper2" class="'+colmenustyle.filter_select+'">' + repstr +'</select></div>';
elem.append(str1);
// value2
if( v2 ) {
df = v2;
} else {
df = "";
}
soptions = $.extend(cm.searchoptions, {name:cm.index || cm.name, id: "sval2_" + ts.p.idPrefix+cm.name, oper:'search'});
input = $.jgrid.createEl.call(ts, cm.stype, soptions , df, false, $.extend({},$.jgrid.ajaxOptions, ts.p.ajaxSelectOptions || {}));
$(input).addClass( colmenustyle.filter_input );
str1 = $('<div></div>').append(input);
elem.append(str1);
// buttons
str1 = "<div>";
str1 +="<div class='search_buttons'><a tabindex='0' id='bs_reset' class='fm-button " + common.button +" ui-reset'>"+texts.Reset+"</a></div>";
str1 +="<div class='search_buttons'><a tabindex='0' id='bs_search' class='fm-button " + common.button + " ui-search'>"+texts.Find+"</a></div>";
str1 += "</div>";
elem.append(str1);
elem = $('<li class="ui-menu-item" role="presentation"></li>').append( elem );
elem = $('<ul id="search_menu" class="ui-search-menu modal-content" role="menu" tabindex="0" style="left:'+left+'px;"></ul>').append(elem);
$(parent).append(elem);
$("#search_menu").addClass("ui-menu " + colmenustyle.menu_widget);
if(!$.jgrid.isElementInViewport($("#search_menu")[0])){
$("#search_menu").css("left", -parseInt($("#column_menu").innerWidth(),10) +"px");
}
$("#bs_reset, #bs_search", "#search_menu").hover(function(){
$(this).addClass(hover);
},function(){
$(this).removeClass(hover);
});
$("#bs_reset", elem).on('click', function(e){
ts.p.colFilters[cm.name] = {};
ts.p.postData.filters = buildFilters();
ts.p.search = false;
$(ts).trigger("reloadGrid");
$("#column_menu").remove();
});
$("#bs_search", elem).on('click', function(e){
ts.p.colFilters[cm.name] = {
oper1: $("#oper1","#search_menu").val(),
value1: $("#sval1_" + ts.p.idPrefix+cm.name,"#search_menu").val(),
rule: $("#operand","#search_menu").val(),
oper2 : $("#oper2","#search_menu").val(),
value2 : $("#sval2_" + ts.p.idPrefix+cm.name,"#search_menu").val()
};
ts.p.postData.filters = buildFilters();
ts.p.search = true;
$(ts).trigger("reloadGrid");
$("#column_menu").remove();
});
},
buildFilters = function() {
var go = "AND",
filters ="{\"groupOp\":\"" + go + "\",\"rules\":[], \"groups\" : [", i=0;
for (var item in ts.p.colFilters) {
if(ts.p.colFilters.hasOwnProperty(item)) {
var si = ts.p.colFilters[item];
if(!$.isEmptyObject(si)) {
if(i>0) {
filters += ",";
}
filters += "{\"groupOp\": \""+si.rule +"\", \"rules\" : [";
filters += "{\"field\":\"" + item + "\",";
filters += "\"op\":\"" + si.oper1 + "\",";
si.value1 +="";
filters += "\"data\":\"" + si.value1.replace(/\\/g,'\\\\').replace(/\"/g,'\\"') + "\"}";
if(si.value2) {
filters += ",{\"field\":\"" + item + "\",";
filters += "\"op\":\"" + si.oper2 + "\",";
si.value2 +="";
filters += "\"data\":\"" + si.value2.replace(/\\/g,'\\\\').replace(/\"/g,'\\"') + "\"}";
}
filters += "]}";
i++;
} else {
//console.log('empty object');
}
}
}
filters += "]}";
return filters;
},
buildGrouping = function( index, isgroup ) {
var cm = ts.p.colModel[index],
group = ts.p.groupingView;
if(isgroup !== -1) {
group.groupField.splice(isgroup,1);
} else {
group.groupField.push( cm.name);
}
$(ts).jqGrid('groupingGroupBy', group.groupField );
if(ts.p.frozenColumns) {
$(ts).jqGrid("destroyFrozenColumns");
$(ts).jqGrid("setFrozenColumns");
}
},
buildFreeze = function( index, isfreeze ) {
var cols = [], i, len = ts.p.colModel.length, lastfrozen = -1, cm = ts.p.colModel;
for(i=0; i < len; i++) {
if(cm[i].frozen) {
lastfrozen = i;
}
cols.push(i);
}
// from position index to lastfrozen+1
cols.splice( index, 1);
cols.splice(lastfrozen + (isfreeze ? 1 : 0), 0, index);
cm[index].frozen = isfreeze;
$(ts).jqGrid("destroyFrozenColumns");
$(ts).jqGrid("remapColumns", cols, true);
$(ts).jqGrid("setFrozenColumns");
},
buildColMenu = function( index, left, top ){
var menu_offset = $(grid.hDiv).height();
if($(".ui-search-toolbar",grid.hDiv)[0] && !isNaN($(".ui-search-toolbar",grid.hDiv).height())) {
menu_offset -= $(".ui-search-toolbar",grid.hDiv).height();
}
if( !$(grid.cDiv).is(":hidden") ){
menu_offset += $(grid.cDiv).outerHeight();
}
if(ts.p.toolbar[1] && ts.p.toolbar[2] !== "bottom" && $(grid.uDiv) !== null) {
menu_offset += $(grid.uDiv).outerHeight();
}
if( ts.p.toppager) {
menu_offset += $("#"+ $.jgrid.jqID(ts.p.id) +"_toppager").outerHeight();
}
//$("#sopt_menu").remove();
left = parseInt(left,10);
top = menu_offset /* + parseInt(top,10)*/;
var strb = '<ul id="column_menu" role="menu" tabindex="0">',
str = '',
stre = "</ul>",
strl ='',
cm = ts.p.colModel[index], op = $.extend({sorting:true, columns: true, filtering: true, seraching:true, grouping:true, freeze : true}, cm.coloptions),
texts = $.jgrid.getRegional(ts, "colmenu"),
label = ts.p.colNames[index],
isgroup,
isfreeze,
menuData = [],
cname = $.trim(cm.name); // ???
// sorting
menuData.push( str );
if(cm.sortable && op.sorting) {
str = '<li class="ui-menu-item" role="presentation"><a class="g-menu-item" tabindex="0" role="menuitem" data-value="sortasc"><table class="ui-common-table"><tr><td class="menu_icon"><span class="'+iconbase+' '+colmenustyle.icon_sort_asc+'"></span></td><td class="menu_text">'+texts.sortasc+'</td></tr></table></a></li>';
str += '<li class="ui-menu-item" role="presentation"><a class="g-menu-item" tabindex="0" role="menuitem" data-value="sortdesc"><table class="ui-common-table"><tr><td class="menu_icon"><span class="'+iconbase+' '+colmenustyle.icon_sort_desc+'"></span></td><td class="menu_text">'+texts.sortdesc+'</td></tr></table></a></li>';
menuData.push( str );
}
if(op.columns) {
str = '<li class="ui-menu-item divider" role="separator"></li>';
str += '<li class="ui-menu-item" role="presentation"><a class="g-menu-item" tabindex="0" role="menuitem" data-value="columns"><table class="ui-common-table"><tr><td class="menu_icon"><span class="'+iconbase+' '+colmenustyle.icon_columns+'"></span></td><td class="menu_text">'+texts.columns+'</td></tr></table></a></li>';
menuData.push( str );
}
if(op.filtering) {
str = '<li class="ui-menu-item divider" role="separator"></li>';
str += '<li class="ui-menu-item" role="presentation"><a class="g-menu-item" tabindex="0" role="menuitem" data-value="filtering"><table class="ui-common-table"><tr><td class="menu_icon"><span class="'+iconbase+' '+colmenustyle.icon_filter+'"></span></td><td class="menu_text">'+texts.filter + ' ' + label +'</td></tr></table></a></li>';
menuData.push( str );
}
if(op.grouping) {
isgroup = $.inArray(cm.name, ts.p.groupingView.groupField);
str = '<li class="ui-menu-item divider" role="separator"></li>';
str += '<li class="ui-menu-item" role="presentation"><a class="g-menu-item" tabindex="0" role="menuitem" data-value="grouping"><table class="ui-common-table"><tr><td class="menu_icon"><span class="'+iconbase+' '+colmenustyle.icon_group+'"></span></td><td class="menu_text">'+(isgroup !== -1 ? texts.ungrouping: texts.grouping + ' ' + label)+'</td></tr></table></a></li>';
menuData.push( str );
}
if(op.freeze) {
if( !(ts.p.subGrid || ts.p.treeGrid || ts.p.cellEdit) ) {
isfreeze = (cm.frozen && ts.p.frozenColumns) ? false : true;
str = '<li class="ui-menu-item divider" role="separator"></li>';
str += '<li class="ui-menu-item" role="presentation"><a class="g-menu-item" tabindex="0" role="menuitem" data-value="freeze"><table class="ui-common-table"><tr><td class="menu_icon"><span class="'+iconbase+' '+colmenustyle.icon_freeze+'"></span></td><td class="menu_text">'+(isfreeze ? (texts.freeze + " "+ label) : texts.unfreeze)+'</td></tr></table></a></li>';
menuData.push( str );
}
}
for( var key in ts.p.colMenuCustom) {
if(ts.p.colMenuCustom.hasOwnProperty(key)) {
var menuitem = ts.p.colMenuCustom[key],
exclude = menuitem.exclude.split(",");
exclude = $.map(exclude, function(item){ return $.trim(item);});
if( menuitem.colname === cname || (menuitem.colname === '_all_' && $.inArray(cname, exclude) === -1)) {
strl = '<li class="ui-menu-item divider" role="separator"></li>';
str = '<li class="ui-menu-item" role="presentation"><a class="g-menu-item" tabindex="0" role="menuitem" data-value="'+menuitem.id+'"><table class="ui-common-table"><tr><td class="menu_icon"><span class="'+iconbase+' '+menuitem.icon+'"></span></td><td class="menu_text">'+menuitem.title+'</td></tr></table></a></li>';
if(menuitem.position === 'last') {
menuData.push( strl );
menuData.push( str );
} else if( menuitem.position === 'first') {
menuData.unshift( strl );
menuData.unshift( str );
}
}
}
}
menuData.unshift( strb );
menuData.push( stre );
//str += "</ul>";
$('#gbox_'+ts.p.id).append( menuData.join('') );
$("#column_menu")
.addClass("ui-search-menu modal-content column-menu jqgrid-column-menu ui-menu " + colmenustyle.menu_widget)
.css({"left":left,"top":top});
if(ts.p.direction === "ltr") {
var wcm = $("#column_menu").width() + 26;
$("#column_menu").css("left", (left- wcm)+'px');
}
$("#column_menu > li > a").hover(
function(){
$("#col_menu").remove();
$("#search_menu").remove();
var left1, top1;
if($(this).attr("data-value") === 'columns') {
left1 = $(this).parent().width()+8,
top1 = $(this).parent().position().top - 5;
buildColItems(top1, left1, $(this).parent(), op);
}
if($(this).attr("data-value") === 'filtering') {
left1 = $(this).parent().width()+8,
top1 = $(this).parent().position().top - 5;
buildSearchBox(index, top1, left1, $(this).parent());
}
$(this).addClass(hover);
},
function(){ $(this).removeClass(hover); }
).click(function(){
var v = $(this).attr("data-value"),
sobj = ts.grid.headers[index].el;
if(v === 'sortasc') {
sortData( "jqgh_"+ts.p.id+"_" + cm.name, index, true, 'asc', sobj);
} else if(v === 'sortdesc') {
sortData( "jqgh_"+ts.p.id+"_" + cm.name, index, true, 'desc', sobj);
} else if (v === 'grouping') {
buildGrouping(index, isgroup);
} else if( v==='freeze') {
buildFreeze( index, isfreeze);
}
if(v.indexOf('sort') !== -1 || v === 'grouping' || v==='freeze') {
$(this).remove();
}
if(ts.p.colMenuCustom.hasOwnProperty(v)) {
var exec = ts.p.colMenuCustom[v];
if($.isFunction(exec.funcname)) {
exec.funcname.call(ts, cname);
if(exec.closeOnRun) {
$(this).remove();
}
}
}
});
if( parseFloat($("#column_menu").css("left")) < 0 ) {
$("#column_menu").css("left", $(ts).css("left") );
}
},
colTemplate;
if(ts.p.colMenu || ts.p.menubar) {
$("body").on('click', function(e){
if(!$(e.target).closest("#column_menu").length) {
try {
$("#column_menu").remove();
} catch (e) {}
}
if(!$(e.target).closest(".ui-jqgrid-menubar").length) {
try {
$("#"+ts.p.id+"_menubar").hide();
} catch (e) {}
}
});
}
this.p.id = this.id;
if ($.inArray(ts.p.multikey,sortkeys) === -1 ) {ts.p.multikey = false;}
ts.p.keyName=false;
for (i=0; i<ts.p.colModel.length;i++) {
colTemplate = typeof ts.p.colModel[i].template === "string" ?
($.jgrid.cmTemplate != null && typeof $.jgrid.cmTemplate[ts.p.colModel[i].template] === "object" ? $.jgrid.cmTemplate[ts.p.colModel[i].template]: {}) :
ts.p.colModel[i].template;
ts.p.colModel[i] = $.extend(true, {}, ts.p.cmTemplate, colTemplate || {}, ts.p.colModel[i]);
if (ts.p.keyName === false && ts.p.colModel[i].key===true) {
ts.p.keyName = ts.p.colModel[i].name;
ts.p.keyIndex = i;
}
}
ts.p.sortorder = ts.p.sortorder.toLowerCase();
$.jgrid.cell_width = $.jgrid.cellWidth();
// calculate cellLayout
var bstw2 = $("<table style='visibility:hidden'><tr class='jqgrow'><td>1</td></tr></table)").addClass(getstyle(stylemodule,"rowTable", true, 'ui-jqgrid-btable ui-common-table'));
$(eg).append(bstw2);
ts.p.cellLayout = parseInt( $("td", bstw2).css('padding-left'), 10) + parseInt($("td", bstw2).css('padding-right'), 10) + 1;
if(ts.p.cellLayout <=0 ) {
ts.p.cellLayout = 5;
}
$(bstw2).remove();
bstw2 = null;
if(ts.p.grouping===true) {
ts.p.scroll = false;
ts.p.rownumbers = false;
//ts.p.subGrid = false; expiremental
ts.p.treeGrid = false;
ts.p.gridview = true;
}
if(this.p.treeGrid === true) {
try { $(this).jqGrid("setTreeGrid");} catch (_) {}
if(ts.p.datatype !== "local") {
ts.p.localReader = { id: "_id_" };
} else if(ts.p.keyName !== false) {
ts.p.localReader = { id: ts.p.keyName };
}
}
if(this.p.subGrid) {
try { $(ts).jqGrid("setSubGrid");} catch (s){}
}
if(this.p.multiselect) {
this.p.colNames.unshift("<input role='checkbox' id='cb_"+this.p.id+"' class='cbox' type='checkbox'/>");
this.p.colModel.unshift({name:'cb',width:$.jgrid.cell_width ? ts.p.multiselectWidth+ts.p.cellLayout : ts.p.multiselectWidth,sortable:false,resizable:false,hidedlg:true,search:false,align:'center',fixed:true, frozen: true, classes : "jqgrid-multibox" });
}
if(this.p.rownumbers) {
this.p.colNames.unshift("");
this.p.colModel.unshift({name:'rn',width:ts.p.rownumWidth,sortable:false,resizable:false,hidedlg:true,search:false,align:'center',fixed:true, frozen : true});
}
ts.p.xmlReader = $.extend(true,{
root: "rows",
row: "row",
page: "rows>page",
total: "rows>total",
records : "rows>records",
repeatitems: true,
cell: "cell",
id: "[id]",
userdata: "userdata",
subgrid: {root:"rows", row: "row", repeatitems: true, cell:"cell"}
}, ts.p.xmlReader);
ts.p.jsonReader = $.extend(true,{
root: "rows",
page: "page",
total: "total",
records: "records",
repeatitems: true,
cell: "cell",
id: "id",
userdata: "userdata",
subgrid: {root:"rows", repeatitems: true, cell:"cell"}
},ts.p.jsonReader);
ts.p.localReader = $.extend(true,{
root: "rows",
page: "page",
total: "total",
records: "records",
repeatitems: false,
cell: "cell",
id: "id",
userdata: "userdata",
subgrid: {root:"rows", repeatitems: true, cell:"cell"}
},ts.p.localReader);
if(ts.p.scroll){
ts.p.pgbuttons = false; ts.p.pginput=false; ts.p.rowList=[];
}
if(ts.p.data.length) {
normalizeData();
refreshIndex();
}
var thead = "<thead><tr class='ui-jqgrid-labels' role='row'>",
tdc, idn, w, res, sort ="",
td, ptr, tbody, imgs, iac="", idc="", tmpcm;
if(ts.p.shrinkToFit===true && ts.p.forceFit===true) {
for (i=ts.p.colModel.length-1;i>=0;i--){
if(!ts.p.colModel[i].hidden) {
ts.p.colModel[i].resizable=false;
break;
}
}
}
if(ts.p.viewsortcols[1] === 'horizontal') {
iac=" ui-i-asc";
idc=" ui-i-desc";
} else if(ts.p.viewsortcols[1] === "single") {
iac = " ui-single-sort-asc";
idc = " ui-single-sort-desc";
sort = " style='display:none'";
ts.p.viewsortcols[0] = false;
}
tdc = isMSIE ? "class='ui-th-div-ie'" :"";
imgs = "<span class='s-ico' style='display:none'>";
imgs += "<span sort='asc' class='ui-grid-ico-sort ui-icon-asc"+iac+" ui-sort-"+dir+" "+disabled+" " + iconbase + " " + getstyle(stylemodule, 'icon_asc', true)+ "'" + sort + "></span>";
imgs += "<span sort='desc' class='ui-grid-ico-sort ui-icon-desc"+idc+" ui-sort-"+dir+" "+disabled+" " + iconbase + " " + getstyle(stylemodule, 'icon_desc', true)+"'" + sort + "></span></span>";
if(ts.p.multiSort) {
if(ts.p.sortname ) {
sortarr = ts.p.sortname.split(",");
for (i=0; i < sortarr.length; i++) {
sotmp = $.trim(sortarr[i]).split(" ");
sortarr[i] = $.trim(sotmp[0]);
sortord[i] = sotmp[1] ? $.trim(sotmp[1]) : ts.p.sortorder || "asc";
}
}
}
for(i=0;i<this.p.colNames.length;i++){
var tooltip = ts.p.headertitles ? (" title=\"" + (ts.p.colModel[i].tooltip ? ts.p.colModel[i].tooltip : $.jgrid.stripHtml(ts.p.colNames[i])) + "\"") : "";
tmpcm = ts.p.colModel[i];
if(!tmpcm.hasOwnProperty('colmenu')) {
tmpcm.colmenu = (tmpcm.name === "rn" || tmpcm.name === "cb" || tmpcm.name === "subgrid") ? false : true;
}
thead += "<th id='"+ts.p.id+"_" + tmpcm.name+"' role='columnheader' "+getstyle(stylemodule,'headerBox',false, "ui-th-column ui-th-" + dir + ( (tmpcm.name==='cb') ? " jqgrid-multibox" : "")) +" "+ tooltip+">";
idn = tmpcm.index || tmpcm.name;
thead += "<div class='ui-th-div' id='jqgh_"+ts.p.id+"_"+tmpcm.name+"' "+tdc+">"+ts.p.colNames[i];
if(!tmpcm.width) {
tmpcm.width = 150;
} else {
tmpcm.width = parseInt(tmpcm.width,10);
}
if(typeof tmpcm.title !== "boolean") {
tmpcm.title = true;
}
tmpcm.lso = "";
if (idn === ts.p.sortname) {
ts.p.lastsort = i;
}
if(ts.p.multiSort) {
sotmp = $.inArray(idn,sortarr);
if( sotmp !== -1 ) {
tmpcm.lso = sortord[sotmp];
}
}
thead += imgs;
if(ts.p.colMenu && tmpcm.colmenu) {
thead += "<a class='"+(ts.p.direction==='ltr' ? "colmenu" : "colmenu-rtl") +"'><span class='colmenuspan "+iconbase+' '+colmenustyle.icon_menu+"'></span></a>";
}
thead += "</div></th>";
}
thead += "</tr></thead>";
imgs = null;
tmpcm = null;
$(this).append(thead);
$("thead tr:first th",this).hover(
function(){ $(this).addClass(hover);},
function(){ $(this).removeClass(hover);}
);
if(this.p.multiselect) {
var emp=[], chk;
$('#cb_'+$.jgrid.jqID(ts.p.id),this).on('click',function(){
if(!ts.p.preserveSelection) {
ts.p.selarrrow = [];
}
var froz = ts.p.frozenColumns === true ? ts.p.id + "_frozen" : "";
if (this.checked) {
$(ts.rows).each(function(i) {
if (i>0) {
if(!$(this).hasClass("ui-subgrid") && !$(this).hasClass("jqgroup") && !$(this).hasClass(disabled) && !$(this).hasClass("jqfoot")){
$("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+$.jgrid.jqID(this.id) )[ts.p.useProp ? 'prop': 'attr']("checked",true);
$(this).addClass(highlight).attr("aria-selected","true");
if(ts.p.preserveSelection) {
if(ts.p.selarrrow.indexOf(this.id) === -1) {
ts.p.selarrrow.push(this.id);
}
} else {
ts.p.selarrrow.push(this.id);
}
ts.p.selrow = this.id;
if(froz) {
$("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+$.jgrid.jqID(this.id), ts.grid.fbDiv )[ts.p.useProp ? 'prop': 'attr']("checked",true);
$("#"+$.jgrid.jqID(this.id), ts.grid.fbDiv).addClass(highlight);
}
}
}
});
chk=true;
emp=[];
}
else {
$(ts.rows).each(function(i) {
if(i>0) {
if(!$(this).hasClass("ui-subgrid") && !$(this).hasClass("jqgroup") && !$(this).hasClass(disabled) && !$(this).hasClass("jqfoot")){
$("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+$.jgrid.jqID(this.id) )[ts.p.useProp ? 'prop': 'attr']("checked", false);
$(this).removeClass(highlight).attr("aria-selected","false");
emp.push(this.id);
if(ts.p.preserveSelection) {
var curind = ts.p.selarrrow.indexOf(this.id);
if(curind > -1) {
ts.p.selarrrow.splice(curind, 1);
}
}
if(froz) {
$("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+$.jgrid.jqID(this.id), ts.grid.fbDiv )[ts.p.useProp ? 'prop': 'attr']("checked",false);
$("#"+$.jgrid.jqID(this.id), ts.grid.fbDiv).removeClass(highlight);
}
}
}
});
ts.p.selrow = null;
chk=false;
}
$(ts).triggerHandler("jqGridSelectAll", [chk ? ts.p.selarrrow : emp, chk]);
if($.isFunction(ts.p.onSelectAll)) {ts.p.onSelectAll.call(ts, chk ? ts.p.selarrrow : emp,chk);}
});
}
if(ts.p.autowidth===true) {
var pw = $(eg).parent().width();
tmpcm = $(window).width();
ts.p.width = tmpcm - pw > 3 ? pw: tmpcm;
}
var tfoot = "", trhead="", bstw = ts.p.styleUI.search('Bootstrap') !== -1 && !isNaN(ts.p.height) ? 2 : 0;
setColWidth();
bstw2 = ts.p.styleUI.search('Bootstrap') !== -1;
$(eg).css("width",grid.width+"px").append("<div class='ui-jqgrid-resize-mark' id='rs_m"+ts.p.id+"'> </div>");
if(ts.p.scrollPopUp) {
$(eg).append("<div "+ getstyle(stylemodule, 'scrollBox', false, 'loading ui-scroll-popup')+" id='scroll_g"+ts.p.id+"'></div>");
}
$(gv).css("width",grid.width+"px");
thead = $("thead:first",ts).get(0);
if(ts.p.footerrow) {
tfoot += "<table role='presentation' style='width:"+ts.p.tblwidth+"px' "+getstyle(stylemodule,'footerTable', false, 'ui-jqgrid-ftable ui-common-table')+ "><tbody><tr role='row' "+getstyle(stylemodule,'footerBox', false, 'footrow footrow-'+dir)+">";
}
if(ts.p.headerrow) {
trhead += "<table role='presentation' style='width:"+ts.p.tblwidth+"px' "+getstyle(stylemodule,'headerRowTable', false, 'ui-jqgrid-hrtable ui-common-table')+ "><tbody><tr role='row' "+getstyle(stylemodule,'headerRowBox', false, 'hrheadrow hrheadrow-'+dir)+">";
}
var thr = $("tr:first",thead),
firstr = "<tr class='jqgfirstrow' role='row'>",
clicks =0;
ts.p.disableClick=false;
$("th",thr).each(function ( j ) {
tmpcm = ts.p.colModel[j];
w = tmpcm.width;
if(tmpcm.resizable === undefined) {
tmpcm.resizable = true;
}
if(tmpcm.resizable){
res = document.createElement("span");
$(res).html(" ").addClass('ui-jqgrid-resize ui-jqgrid-resize-'+dir)
.css("cursor","col-resize");
$(this).addClass(ts.p.resizeclass);
} else {
res = "";
}
$(this).css("width",w+"px").prepend(res);
res = null;
var hdcol = "";
if( tmpcm.hidden ) {
$(this).css("display","none");
hdcol = "display:none;";
}
firstr += "<td role='gridcell' style='height:0px;width:"+w+"px;"+hdcol+"'></td>";
grid.headers[j] = { width: w, el: this };
sort = tmpcm.sortable;
if( typeof sort !== 'boolean') {
tmpcm.sortable = true;
sort=true;
}
var nm = tmpcm.name;
if( !(nm === 'cb' || nm==='subgrid' || nm==='rn') ) {
if(ts.p.viewsortcols[2]){
$(">div",this).addClass('ui-jqgrid-sortable');
}
}
if(sort) {
if(ts.p.multiSort) {
if(ts.p.viewsortcols[0]) {
$("div span.s-ico",this).show();
if( tmpcm.lso ){
$("div span.ui-icon-"+tmpcm.lso,this).removeClass(disabled).css("display","");
}
} else if( tmpcm.lso) {
$("div span.s-ico",this).show();
$("div span.ui-icon-"+tmpcm.lso,this).removeClass(disabled).css("display","");
}
} else {
if(ts.p.viewsortcols[0]) {
$("div span.s-ico",this).show();
if(j===ts.p.lastsort){
$("div span.ui-icon-"+ts.p.sortorder,this).removeClass(disabled).css("display","");
}
} else if(j === ts.p.lastsort && ts.p.sortname !== "") {
$("div span.s-ico",this).show();
$("div span.ui-icon-"+ts.p.sortorder,this).removeClass(disabled).css("display","");
}
}
}
if(ts.p.footerrow) {
tfoot += "<td role='gridcell' "+formatCol(j,0,'', null, '', false)+"> </td>";
}
if(ts.p.headerrow) {
trhead += "<td role='gridcell' "+formatCol(j,0,'', null, '', false)+"> </td>";
}
}).mousedown(function(e) {
if ($(e.target).closest("th>span.ui-jqgrid-resize").length !== 1) { return; }
var ci = getColumnHeaderIndex(this), cmax;
e.preventDefault();
clicks++;
setTimeout(function() {
clicks = 0;
}, 400);
if (clicks === 2) {
// double click event handler
try {
if(ts.p.colModel[ci].autosize === true) {
cmax = $(ts).jqGrid('getCol', ci, false, 'maxwidth');
$(ts).jqGrid('resizeColumn', ci, cmax + ( bstw2 ? ts.p.cellLayout : 0 ) )
.jqGrid('refreshGroupHeaders');
}
} catch(e) {
} finally {
clicks = 0;
}
return;
} else {
if(ts.p.forceFit===true) {ts.p.nv= nextVisible(ci);}
grid.dragStart(ci, e, getOffset(ci));
}
return false;
}).click(function(e) {
if (ts.p.disableClick) {
ts.p.disableClick = false;
return false;
}
var s = "th>div.ui-jqgrid-sortable",r,d;
if (!ts.p.viewsortcols[2]) { s = "th>div>span>span.ui-grid-ico-sort"; }
var t = $(e.target).closest(s);
if (t.length !== 1) { return; }
var ci;
if(ts.p.frozenColumns) {
var tid = $(this)[0].id.substring( ts.p.id.length + 1 );
$(ts.p.colModel).each(function(i){
if (this.name === tid) {
ci = i;return false;
}
});
} else {
ci = getColumnHeaderIndex(this);
}
//
if($(e.target).hasClass('colmenuspan')) {
if($("#column_menu")[0] != null) {
$("#column_menu").remove();
}
if(ci === undefined) { return; }
var grid_offset = $("#gbox_"+ts.p.id).offset();
var offset = $(this).offset(),
left = ( offset.left ) - (grid_offset.left),
top = 0;//( offset.top);
if(ts.p.direction === "ltr") {
left += $(this).outerWidth();
}
buildColMenu(ci, left, top, t );
if(ts.p.menubar === true) {
$("#"+ts.p.id+"_menubar").hide();
}
e.stopPropagation();
return;
}
//
if (!ts.p.viewsortcols[2]) { r=true;d=t.attr("sort"); }
if(ci != null){
sortData( $('div',this)[0].id, ci, r, d, this);
}
// added aria grid
if(ts.p.selHeadInd !== undefined) {
$(grid.headers[ts.p.selHeadInd].el).attr("tabindex", "-1");
}
ts.p.selHeadInd = ci;
$(this).attr("tabindex", "0");
// end aria
return false;
});
tmpcm = null;
if (ts.p.sortable && $.fn.sortable) {
try {
$(ts).jqGrid("sortableColumns", thr);
} catch (e){}
}
if(ts.p.footerrow) { tfoot += "</tr></tbody></table>"; }
if(ts.p.headerrow) { trhead += "</tr></tbody></table>"; }
firstr += "</tr>";
tbody = document.createElement("tbody");
//$(this).append(firstr);
this.appendChild(tbody);
$(this).addClass(getstyle(stylemodule,"rowTable", true, 'ui-jqgrid-btable ui-common-table')).append(firstr);
if(ts.p.altRows) {
$(this).addClass(getstyle(stylemodule,"stripedTable", true, ''));
}
//$(firstr).insertAfter(this);
firstr = null;
var hTable = $("<table "+getstyle(stylemodule,'headerTable',false,'ui-jqgrid-htable ui-common-table')+" style='width:"+ts.p.tblwidth+"px' role='presentation' aria-labelledby='gbox_"+this.id+"'></table>").append(thead),
hg = (ts.p.caption && ts.p.hiddengrid===true) ? true : false,
hb = $("<div class='ui-jqgrid-hbox" + (dir==="rtl" ? "-rtl" : "" )+"'></div>");
thead = null;
grid.hDiv = document.createElement("div");
grid.hDiv.style.width = (grid.width - bstw) + "px";
grid.hDiv.className = getstyle(stylemodule,'headerDiv', true,'ui-jqgrid-hdiv');
$(grid.hDiv).append(hb);
$(hb).append(hTable);
hTable = null;
if(hg) { $(grid.hDiv).hide(); }
if(ts.p.pager){
// TBD -- escape ts.p.pager here?
if(typeof ts.p.pager === "string") {if(ts.p.pager.substr(0,1) === "#") { ts.p.pager = ts.p.pager.substring(1);} }
else { ts.p.pager = $(ts.p.pager).attr("id");}
$("#"+$.jgrid.jqID(ts.p.pager)).css({width: (grid.width - bstw) +"px"}).addClass(getstyle(stylemodule,'pagerBox', true,'ui-jqgrid-pager')).appendTo(eg);
if(hg) {
$("#"+$.jgrid.jqID(ts.p.pager)).hide();
}
setPager(ts.p.pager,'');
ts.p.pager = "#" + $.jgrid.jqID(ts.p.pager);
}
if( ts.p.cellEdit === false && ts.p.hoverrows === true) {
$(ts).on({
mouseover: function(e) {
ptr = $(e.target).closest("tr.jqgrow");
if($(ptr).attr("class") !== "ui-subgrid") {
$(ptr).addClass(hover);
}
},
mouseout: function(e) {
ptr = $(e.target).closest("tr.jqgrow");
$(ptr).removeClass(hover);
}
});
}
var ri,ci, tdHtml;
function selectMultiRow(ri, scb, e, selection) {
if((ts.p.multiselect && ts.p.multiboxonly) || ts.p.multimail ) {
if(scb){
$(ts).jqGrid("setSelection", ri, selection, e);
} else if( ts.p.multiboxonly && ts.p.multimail) {
// execute onSelectRow
$(ts).triggerHandler("jqGridSelectRow", [ri, false, e]);
if( ts.p.onSelectRow) { ts.p.onSelectRow.call(ts, ri, false, e); }
} else {
var frz = ts.p.frozenColumns ? ts.p.id+"_frozen" : "";
$(ts.p.selarrrow).each(function(i,n){
var trid = $(ts).jqGrid('getGridRowById',n);
if(trid) {
$( trid ).removeClass(highlight);
}
$("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+$.jgrid.jqID(n))[ts.p.useProp ? 'prop': 'attr']("checked", false);
if(frz) {
$("#"+$.jgrid.jqID(n), "#"+$.jgrid.jqID(frz)).removeClass(highlight);
$("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+$.jgrid.jqID(n), "#"+$.jgrid.jqID(frz))[ts.p.useProp ? 'prop': 'attr']("checked", false);
}
});
ts.p.selarrrow = [];
$(ts).jqGrid("setSelection", ri, selection, e);
}
} else {
$(ts).jqGrid("setSelection", ri, selection, e);
}
}
$(ts).before(grid.hDiv).on({
'click': function(e) {
td = e.target;
ptr = $(td,ts.rows).closest("tr.jqgrow");
if($(ptr).length === 0 || ptr[0].className.indexOf( disabled ) > -1 || ($(td,ts).closest("table.ui-jqgrid-btable").attr('id') || '').replace("_frozen","") !== ts.id ) {
return this;
}
var scb = $(td).filter(":enabled").hasClass("cbox"),
cSel = $(ts).triggerHandler("jqGridBeforeSelectRow", [ptr[0].id, e]);
cSel = (cSel === false || cSel === 'stop') ? false : true;
if ($.isFunction(ts.p.beforeSelectRow)) {
var allowRowSelect = ts.p.beforeSelectRow.call(ts, ptr[0].id, e);
if (allowRowSelect === false || allowRowSelect === 'stop') {
cSel = false;
}
}
if (td.tagName === 'A' || ((td.tagName === 'INPUT' || td.tagName === 'TEXTAREA' || td.tagName === 'OPTION' || td.tagName === 'SELECT' ) && !scb) ) { return; }
ri = ptr[0].id;
td = $(td).closest("tr.jqgrow>td");
if (td.length > 0) {
ci = $.jgrid.getCellIndex(td);
}
if(ts.p.cellEdit === true) {
if(ts.p.multiselect && scb && cSel){
$(ts).jqGrid("setSelection", ri ,true,e);
} else if (td.length > 0) {
try {
$(ts).jqGrid("editCell", ptr[0].rowIndex, ci, true, e);
} catch (_) {}
}
return;
}
if (td.length > 0) {
tdHtml = $(td).closest("td,th").html();
$(ts).triggerHandler("jqGridCellSelect", [ri,ci,tdHtml,e]);
if($.isFunction(ts.p.onCellSelect)) {
ts.p.onCellSelect.call(ts,ri,ci,tdHtml,e);
}
}
if (!cSel) {
return;
}
if( ts.p.multimail && ts.p.multiselect) {
if (e.shiftKey) {
if (scb) {
var initialRowSelect = $(ts).jqGrid('getGridParam', 'selrow'),
CurrentSelectIndex = $(ts).jqGrid('getInd', ri),
InitialSelectIndex = $(ts).jqGrid('getInd', initialRowSelect),
startID = "",
endID = "";
if (CurrentSelectIndex > InitialSelectIndex) {
startID = initialRowSelect;
endID = ri;
} else {
startID = ri;
endID = initialRowSelect;
}
var shouldSelectRow = false,
shouldResetRow = false,
perform_select = true;
if( $.inArray( ri, ts.p.selarrrow) > -1) {
perform_select = false;
}
$.each($(this).getDataIDs(), function(_, id){
if ((shouldResetRow = id === startID || shouldResetRow)){
$(ts).jqGrid('resetSelection', id);
}
return id !== endID;
});
if(perform_select) {
$.each($(this).getDataIDs(), function(_, id){
if ((shouldSelectRow = id === startID || shouldSelectRow)){
$(ts).jqGrid('setSelection', id, false);
}
return id !== endID;
});
}
ts.p.selrow = (CurrentSelectIndex > InitialSelectIndex) ? endID : startID;
return;
}
window.getSelection().removeAllRanges();
}
selectMultiRow( ri, scb, e, false );
} else if ( !ts.p.multikey ) {
selectMultiRow( ri, scb, e, true );
} else {
if(e[ts.p.multikey]) {
$(ts).jqGrid("setSelection", ri, true, e);
} else if(ts.p.multiselect && scb) {
scb = $("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+ri).is(":checked");
$("#jqg_"+$.jgrid.jqID(ts.p.id)+"_"+ri)[ts.p.useProp ? 'prop' : 'attr']("checked", !scb);
}
}
},
'reloadGrid': function(e,opts) {
if(ts.p.treeGrid ===true) {
ts.p.datatype = ts.p.treedatatype;
}
opts = opts || {};
if (opts.current) {
ts.grid.selectionPreserver(ts);
}
if(ts.p.datatype==="local"){
$(ts).jqGrid("resetSelection");
if(ts.p.data.length) {
normalizeData();
refreshIndex();
}
} else if(!ts.p.treeGrid) {
ts.p.selrow=null;
if(ts.p.multiselect) {
if(!ts.p.preserveSelection) {
ts.p.selarrrow =[];
setHeadCheckBox(false);
}
}
ts.p.savedRow = [];
}
if(ts.p.scroll) {
emptyRows.call(ts, true, false);
}
if (opts.page) {
var page = opts.page;
if (page > ts.p.lastpage) { page = ts.p.lastpage; }
if (page < 1) { page = 1; }
ts.p.page = page;
if (ts.grid.prevRowHeight) {
ts.grid.bDiv.scrollTop = (page - 1) * ts.grid.prevRowHeight * ts.p.rowNum;
} else {
ts.grid.bDiv.scrollTop = 0;
}
}
if (ts.grid.prevRowHeight && ts.p.scroll && opts.page === undefined) {
delete ts.p.lastpage;
ts.grid.populateVisible();
} else {
ts.grid.populate();
}
if(ts.p.inlineNav===true) {$(ts).jqGrid('showAddEditButtons');}
return false;
},
'dblclick' : function(e) {
td = e.target;
ptr = $(td,ts.rows).closest("tr.jqgrow");
if($(ptr).length === 0 ){return;}
ri = ptr[0].rowIndex;
ci = $.jgrid.getCellIndex(td);
var dbcr = $(ts).triggerHandler("jqGridDblClickRow", [$(ptr).attr("id"),ri,ci,e]);
if( dbcr != null) { return dbcr; }
if ($.isFunction(ts.p.ondblClickRow)) {
dbcr = ts.p.ondblClickRow.call(ts,$(ptr).attr("id"),ri,ci, e);
if( dbcr != null) { return dbcr; }
}
},
'contextmenu' : function(e) {
td = e.target;
ptr = $(td,ts.rows).closest("tr.jqgrow");
if($(ptr).length === 0 ){return;}
if(!ts.p.multiselect) { $(ts).jqGrid("setSelection",ptr[0].id,true,e); }
ri = ptr[0].rowIndex;
ci = $.jgrid.getCellIndex(td);
var rcr = $(ts).triggerHandler("jqGridRightClickRow", [$(ptr).attr("id"),ri,ci,e]);
if( rcr != null) { return rcr; }
if ($.isFunction(ts.p.onRightClickRow)) {
rcr = ts.p.onRightClickRow.call(ts,$(ptr).attr("id"),ri,ci, e);
if( rcr != null) { return rcr; }
}
}
});
//---
grid.bDiv = document.createElement("div");
if(isMSIE) { if(String(ts.p.height).toLowerCase() === "auto") { ts.p.height = "100%"; } }
$(grid.bDiv)
.append($('<div style="position:relative;"></div>').append('<div></div>').append(this))
.addClass("ui-jqgrid-bdiv")
.css({ height: ts.p.height+(isNaN(ts.p.height)?"":"px"), width: (grid.width - bstw)+"px"})
.on("scroll", grid.scrollGrid);
$("table:first",grid.bDiv).css({width:ts.p.tblwidth+"px"});
if( !$.support.tbody ) { //IE
if( $("tbody",this).length === 2 ) { $("tbody:gt(0)",this).remove();}
}
if(ts.p.multikey){
if( $.jgrid.msie()) {
$(grid.bDiv).on("selectstart",function(){return false;});
} else {
$(grid.bDiv).on("mousedown",function(){return false;});
}
}
if(hg) { // hidden grid
$(grid.bDiv).hide();
}
var icoo = iconbase + " " + getstyle(stylemodule,'icon_caption_open', true),
icoc = iconbase + " " + getstyle(stylemodule,'icon_caption_close', true);
grid.cDiv = document.createElement("div");
var arf = ts.p.hidegrid===true ? $("<a role='link' class='ui-jqgrid-titlebar-close HeaderButton "+cornerall+"' title='"+($.jgrid.getRegional(ts, "defaults.showhide", ts.p.showhide) || "")+"'" + " />").hover(
function(){ arf.addClass(hover);},
function() {arf.removeClass(hover);})
.append("<span class='ui-jqgrid-headlink " + icoo +"'></span>").css((dir==="rtl"?"left":"right"),"0px") : "";
$(grid.cDiv).append(arf).append("<span class='ui-jqgrid-title'>"+ts.p.caption+"</span>")
.addClass("ui-jqgrid-titlebar ui-jqgrid-caption"+(dir==="rtl" ? "-rtl" :"" )+" "+getstyle(stylemodule,'gridtitleBox',true));
///// toolbar menu
if( ts.p.menubar === true) {
//var fs = $('.ui-jqgrid-view').css('font-size') || '11px';
var arf1 = '<ul id="'+ts.p.id+'_menubar" class="ui-search-menu modal-content column-menu ui-menu jqgrid-caption-menu ' + colmenustyle.menu_widget+'" role="menubar" tabindex="0"></ul>';
$("#gbox_"+ts.p.id).append(arf1);
$(grid.cDiv).append("<a role='link' class='ui-jqgrid-menubar menubar-"+(dir==="rtl" ? "rtl" :"ltr" )+"' style=''><span class='colmenuspan "+iconbase+' '+colmenustyle.icon_toolbar_menu+"'></span></a>");
$(".ui-jqgrid-menubar",grid.cDiv).hover(
function(){ $(this).addClass(hover);},
function() {$(this).removeClass(hover);
}).on('click',function(e) {
var pos = $(e.target).position();
$("#"+ts.p.id+"_menubar").show();
if(ts.p.direction==="rtl") {
$("#"+ts.p.id+"_menubar").css({left : pos.left - $("#"+ts.p.id+"_menubar").width() - 20 });
}
});
}
///// end toolbar menu
$(grid.cDiv).insertBefore(grid.hDiv);
if( ts.p.toolbar[0] ) {
var tbstyle = getstyle(stylemodule, 'customtoolbarBox', true, 'ui-userdata');
grid.uDiv = document.createElement("div");
if(ts.p.toolbar[1] === "top") {$(grid.uDiv).insertBefore(grid.hDiv);}
else if (ts.p.toolbar[1]==="bottom" ) {$(grid.uDiv).insertAfter(grid.hDiv);}
if(ts.p.toolbar[1]==="both") {
grid.ubDiv = document.createElement("div");
$(grid.uDiv).addClass( tbstyle + " ui-userdata-top").attr("id","t_"+this.id).insertBefore(grid.hDiv).width(grid.width - bstw);
$(grid.ubDiv).addClass( tbstyle + " ui-userdata-bottom").attr("id","tb_"+this.id).insertAfter(grid.hDiv).width(grid.width - bstw);
if(hg) {$(grid.ubDiv).hide();}
} else {
$(grid.uDiv).width(grid.width - bstw).addClass( tbstyle + " ui-userdata-top").attr("id","t_"+this.id);
}
if(hg) {$(grid.uDiv).hide();}
}
if(ts.p.toppager) {
ts.p.toppager = $.jgrid.jqID(ts.p.id)+"_toppager";
grid.topDiv = $("<div id='"+ts.p.toppager+"'></div>")[0];
$(grid.topDiv).addClass(getstyle(stylemodule, 'toppagerBox', true, 'ui-jqgrid-toppager')).width(grid.width - bstw).insertBefore(grid.hDiv);
setPager(ts.p.toppager,'_t');
ts.p.toppager = "#"+ts.p.toppager;
}
if(ts.p.footerrow) {
grid.sDiv = $("<div class='ui-jqgrid-sdiv'></div>")[0];
hb = $("<div class='ui-jqgrid-hbox"+(dir==="rtl"?"-rtl":"")+"'></div>");
$(grid.sDiv).append(hb).width(grid.width - bstw).insertAfter(grid.hDiv);
$(hb).append(tfoot);
grid.footers = $(".ui-jqgrid-ftable",grid.sDiv)[0].rows[0].cells;
if(ts.p.rownumbers) { grid.footers[0].className = getstyle(stylemodule, 'rownumBox', true, 'jqgrid-rownum'); }
if(hg) {$(grid.sDiv).hide();}
}
if(ts.p.headerrow) {
grid.hrDiv = $("<div class='ui-jqgrid-hrdiv'></div>")[0];
hb = $("<div class='ui-jqgrid-hbox"+(dir==="rtl"?"-rtl":"")+"'></div>");
$(grid.hrDiv).append(hb).width(grid.width - bstw).insertAfter(grid.hDiv);
$(hb).append(trhead);
grid.hrheaders = $(".ui-jqgrid-hrtable",grid.hrDiv)[0].rows[0].cells;
if(ts.p.rownumbers) {
grid.hrheaders[0].className = getstyle(stylemodule, 'rownumBox', true, 'jqgrid-rownum');
}
if(hg) {
$(grid.nDiv).hide();
}
}
hb = null;
if(ts.p.caption) {
var tdt = ts.p.datatype;
if(ts.p.hidegrid===true) {
$(".ui-jqgrid-titlebar-close",grid.cDiv).click( function(e){
var onHdCl = $.isFunction(ts.p.onHeaderClick),
elems = ".ui-jqgrid-bdiv, .ui-jqgrid-hdiv, .ui-jqgrid-toppager, .ui-jqgrid-pager, .ui-jqgrid-sdiv, .ui-jqgrid-hrdiv",
counter, self = this;
if(ts.p.toolbar[0]===true) {
if( ts.p.toolbar[1]==='both') {
elems += ', #' + $(grid.ubDiv).attr('id');
}
elems += ', #' + $(grid.uDiv).attr('id');
}
counter = $(elems,"#gview_"+$.jgrid.jqID(ts.p.id)).length;
if(ts.p.gridstate === 'visible') {
$(elems,"#gbox_"+$.jgrid.jqID(ts.p.id)).slideUp("fast", function() {
counter--;
if (counter === 0) {
$("span",self).removeClass(icoo).addClass(icoc);
ts.p.gridstate = 'hidden';
if($("#gbox_"+$.jgrid.jqID(ts.p.id)).hasClass("ui-resizable")) { $(".ui-resizable-handle","#gbox_"+$.jgrid.jqID(ts.p.id)).hide(); }
$(ts).triggerHandler("jqGridHeaderClick", [ts.p.gridstate,e]);
if(onHdCl) {if(!hg) {ts.p.onHeaderClick.call(ts,ts.p.gridstate,e);}}
}
});
} else if(ts.p.gridstate === 'hidden'){
$(elems,"#gbox_"+$.jgrid.jqID(ts.p.id)).slideDown("fast", function() {
counter--;
if (counter === 0) {
$("span",self).removeClass(icoc).addClass(icoo);
if(hg) {ts.p.datatype = tdt;populate();hg=false;}
ts.p.gridstate = 'visible';
if($("#gbox_"+$.jgrid.jqID(ts.p.id)).hasClass("ui-resizable")) { $(".ui-resizable-handle","#gbox_"+$.jgrid.jqID(ts.p.id)).show(); }
$(ts).triggerHandler("jqGridHeaderClick", [ts.p.gridstate,e]);
if(onHdCl) {if(!hg) {ts.p.onHeaderClick.call(ts,ts.p.gridstate,e);}}
}
});
}
return false;
});
if(hg) {ts.p.datatype="local"; $(".ui-jqgrid-titlebar-close",grid.cDiv).trigger("click");}
}
} else {
$(grid.cDiv).hide();
if(!ts.p.toppager) {
$(grid.hDiv).addClass(getstyle(ts.p.styleUI+'.common', 'cornertop', true));
}
}
if(ts.p.headerrow) {
$(grid.hrDiv).after(grid.bDiv);
} else {
$(grid.hDiv).after(grid.bDiv);
}
$(grid.hDiv)
.mousemove(function (e) {
if(grid.resizing){grid.dragMove(e);return false;}
});
$(".ui-jqgrid-labels",grid.hDiv).on("selectstart", function () { return false; });
$(document).on( "mouseup.jqGrid" + ts.p.id, function () {
if(grid.resizing) { grid.dragEnd( true ); return false;}
return true;
});
if(ts.p.direction === 'rtl') {
$(ts).on('jqGridAfterGridComplete.setRTLPadding',function(){
var vScrollWidth = grid.bDiv.offsetWidth - grid.bDiv.clientWidth,
gridhbox = $("div:first",grid.hDiv);
//ts.p.scrollOffset = vScrollWidth;
// for future implementation
if( vScrollWidth > 0 ) vScrollWidth += 2;
if (gridhbox.hasClass("ui-jqgrid-hbox-rtl")) {
$("div:first",grid.hDiv).css({paddingLeft: vScrollWidth + "px"});
}
grid.hDiv.scrollLeft = grid.bDiv.scrollLeft;
});
}
if(ts.p.autoResizing) {
$(ts).on('jqGridAfterGridComplete.setAutoSizeColumns',function(){
$(ts.p.colModel).each(function(i){
if (this.autosize) {
if(this._maxsize && this._maxsize > 0) {
$(ts).jqGrid('resizeColumn', i, this._maxsize + ( bstw2 ? ts.p.cellLayout : 0 ));
this._maxsize = 0;
}
}
});
$(ts).jqGrid('refreshGroupHeaders');
});
}
ts.formatCol = formatCol;
ts.sortData = sortData;
ts.updatepager = updatepager;
ts.refreshIndex = refreshIndex;
ts.setHeadCheckBox = setHeadCheckBox;
ts.constructTr = constructTr;
ts.formatter = function ( rowId, cellval , colpos, rwdat, act){return formatter(rowId, cellval , colpos, rwdat, act);};
$.extend(grid,{populate : populate, emptyRows: emptyRows, beginReq: beginReq, endReq: endReq});
this.grid = grid;
ts.addXmlData = function(d) {addXmlData( d );};
ts.addJSONData = function(d) {addJSONData( d );};
ts.addLocalData = function(d) { return addLocalData( d );};
ts.treeGrid_beforeRequest = function() { treeGrid_beforeRequest(); }; //bvn13
ts.treeGrid_afterLoadComplete = function() {treeGrid_afterLoadComplete(); };
this.grid.cols = this.rows[0].cells;
if ($.isFunction( ts.p.onInitGrid )) { ts.p.onInitGrid.call(ts); }
$(ts).triggerHandler("jqGridInitGrid");
populate();
ts.p.hiddengrid=false;
if(ts.p.responsive) {
var supportsOrientationChange = "onorientationchange" in window,
orientationEvent = supportsOrientationChange ? "orientationchange" : "resize";
$(window).on( orientationEvent, function(){
$(ts).jqGrid('resizeGrid');
});
}
});
};
$.jgrid.extend({
getGridParam : function(name, module) {
var $t = this[0], ret;
if (!$t || !$t.grid) {return;}
if(module === undefined && typeof module !== 'string') {
module = 'jqGrid'; //$t.p
}
ret = $t.p;
if(module !== 'jqGrid') {
try {
ret = $($t).data( module );
} catch (e) {
ret = $t.p;
}
}
if (!name) { return ret; }
return ret[name] !== undefined ? ret[name] : null;
},
setGridParam : function (newParams, overwrite){
return this.each(function(){
if(overwrite == null) {
overwrite = false;
}
if (this.grid && typeof newParams === 'object') {
if(overwrite === true) {
var params = $.extend({}, this.p, newParams);
this.p = params;
} else {
$.extend(true,this.p,newParams);
}
}
});
},
getGridRowById : function ( rowid ) {
var row;
this.each( function(){
try {
//row = this.rows.namedItem( rowid );
var i = this.rows.length;
while(i--) {
if( rowid.toString() === this.rows[i].id) {
row = this.rows[i];
break;
}
}
} catch ( e ) {
row = $(this.grid.bDiv).find( "#" + $.jgrid.jqID( rowid ))[0];
}
});
return row;
},
getDataIDs : function () {
var ids=[], i=0, len, j=0;
this.each(function(){
len = this.rows.length;
if(len && len>0){
while(i<len) {
if($(this.rows[i]).hasClass('jqgrow') && this.rows[i].id !== "norecs") {
ids[j] = this.rows[i].id;
j++;
}
i++;
}
}
});
return ids;
},
setSelection : function(selection,onsr, e, isHight) {
return this.each(function(){
var $t = this, stat,pt, ner, ia, tpsr, fid, csr,
getstyle = $.jgrid.getMethod("getStyleUI"),
highlight = getstyle($t.p.styleUI+'.common','highlight', true),
disabled = getstyle($t.p.styleUI+'.common','disabled', true);
if(selection === undefined) { return; }
if(isHight === undefined ) {
isHight = true;
}
isHight = isHight === false ? false : true;
onsr = onsr === false ? false : true;
pt=$($t).jqGrid('getGridRowById', selection);
if(!pt || !pt.className || pt.className.indexOf( disabled ) > -1 ) { return; }
function scrGrid(iR){
var ch = $($t.grid.bDiv)[0].clientHeight,
st = $($t.grid.bDiv)[0].scrollTop,
rpos = $($t.rows[iR]).position().top,
rh = $t.rows[iR].clientHeight;
if(rpos+rh >= ch+st) { $($t.grid.bDiv)[0].scrollTop = rpos-(ch+st)+rh+st; }
else if(rpos < ch+st) {
if(rpos < st) {
$($t.grid.bDiv)[0].scrollTop = rpos;
}
}
}
if($t.p.scrollrows===true) {
ner = $($t).jqGrid('getGridRowById',selection).rowIndex;
if(ner >=0 ){
scrGrid(ner);
}
}
if($t.p.frozenColumns === true ) {
fid = $t.p.id+"_frozen";
}
if(!$t.p.multiselect) {
if(pt.className !== "ui-subgrid") {
if( $t.p.selrow !== pt.id ) {
if( isHight ) {
csr = $($t).jqGrid('getGridRowById', $t.p.selrow);
if( csr ) {
$( csr ).removeClass(highlight).attr({"aria-selected":"false" , "tabindex" : "-1"});
}
$(pt).addClass(highlight).attr({"aria-selected":"true" ,"tabindex" : "0"});//.focus();
if(fid) {
$("#"+$.jgrid.jqID($t.p.selrow), "#"+$.jgrid.jqID(fid)).removeClass(highlight);
$("#"+$.jgrid.jqID(selection), "#"+$.jgrid.jqID(fid)).addClass(highlight);
}
}
stat = true;
} else {
stat = false;
}
$t.p.selrow = pt.id;
if( onsr ) {
$($t).triggerHandler("jqGridSelectRow", [pt.id, stat, e]);
if( $t.p.onSelectRow) { $t.p.onSelectRow.call($t, pt.id, stat, e); }
}
}
} else {
//unselect selectall checkbox when deselecting a specific row
$t.setHeadCheckBox( false );
$t.p.selrow = pt.id;
ia = $.inArray($t.p.selrow,$t.p.selarrrow);
if ( ia === -1 ){
if(pt.className !== "ui-subgrid") { $(pt).addClass(highlight).attr("aria-selected","true");}
stat = true;
$t.p.selarrrow.push($t.p.selrow);
} else if( ia !== -1 && e === "_sp_") {
// selection preserver multiselect
if(pt.className !== "ui-subgrid") { $(pt).addClass(highlight).attr("aria-selected","true");}
stat = true;
} else {
if(pt.className !== "ui-subgrid") { $(pt).removeClass(highlight).attr("aria-selected","false");}
stat = false;
$t.p.selarrrow.splice(ia,1);
tpsr = $t.p.selarrrow[0];
$t.p.selrow = (tpsr === undefined) ? null : tpsr;
}
$("#jqg_"+$.jgrid.jqID($t.p.id)+"_"+$.jgrid.jqID(pt.id))[$t.p.useProp ? 'prop': 'attr']("checked",stat);
if(fid) {
if(isHight) {
if(ia === -1) {
$("#"+$.jgrid.jqID(selection), "#"+$.jgrid.jqID(fid)).addClass(highlight);
} else {
$("#"+$.jgrid.jqID(selection), "#"+$.jgrid.jqID(fid)).removeClass(highlight);
}
}
$("#jqg_"+$.jgrid.jqID($t.p.id)+"_"+$.jgrid.jqID(selection), "#"+$.jgrid.jqID(fid))[$t.p.useProp ? 'prop': 'attr']("checked",stat);
}
if( onsr ) {
$($t).triggerHandler("jqGridSelectRow", [pt.id, stat, e]);
if( $t.p.onSelectRow) { $t.p.onSelectRow.call($t, pt.id , stat, e); }
}
}
});
},
resetSelection : function( rowid ){
return this.each(function(){
var t = this, sr, fid,
getstyle = $.jgrid.getMethod("getStyleUI"),
highlight = getstyle(t.p.styleUI+'.common','highlight', true),
hover = getstyle(t.p.styleUI+'.common','hover', true);
if( t.p.frozenColumns === true ) {
fid = t.p.id+"_frozen";
}
if(rowid !== undefined ) {
sr = rowid === t.p.selrow ? t.p.selrow : rowid;
$("#"+$.jgrid.jqID(t.p.id)+" tbody:first tr#"+$.jgrid.jqID(sr)).removeClass( highlight ).attr("aria-selected","false");
if (fid) { $("#"+$.jgrid.jqID(sr), "#"+$.jgrid.jqID(fid)).removeClass( highlight ); }
if(t.p.multiselect) {
$("#jqg_"+$.jgrid.jqID(t.p.id)+"_"+$.jgrid.jqID(sr), "#"+$.jgrid.jqID(t.p.id))[t.p.useProp ? 'prop': 'attr']("checked",false);
if(fid) { $("#jqg_"+$.jgrid.jqID(t.p.id)+"_"+$.jgrid.jqID(sr), "#"+$.jgrid.jqID(fid))[t.p.useProp ? 'prop': 'attr']("checked",false); }
t.setHeadCheckBox( false);
var ia = $.inArray($.jgrid.jqID(sr), t.p.selarrrow);
if ( ia !== -1 ){
t.p.selarrrow.splice(ia,1);
}
}
if( t.p.onUnSelectRow) { t.p.onUnSelectRow.call(t, sr ); }
sr = null;
} else if(!t.p.multiselect) {
if(t.p.selrow) {
$("#"+$.jgrid.jqID(t.p.id)+" tbody:first tr#"+$.jgrid.jqID(t.p.selrow)).removeClass( highlight ).attr("aria-selected","false");
if(fid) { $("#"+$.jgrid.jqID(t.p.selrow), "#"+$.jgrid.jqID(fid)).removeClass( highlight ); }
if( t.p.onUnSelectRow) { t.p.onUnSelectRow.call(t, t.p.selrow ); }
t.p.selrow = null;
}
} else {
$(t.p.selarrrow).each(function(i,n){
$( $(t).jqGrid('getGridRowById',n) ).removeClass( highlight ).attr("aria-selected","false");
$("#jqg_"+$.jgrid.jqID(t.p.id)+"_"+$.jgrid.jqID(n))[t.p.useProp ? 'prop': 'attr']("checked",false);
if(fid) {
$("#"+$.jgrid.jqID(n), "#"+$.jgrid.jqID(fid)).removeClass( highlight );
$("#jqg_"+$.jgrid.jqID(t.p.id)+"_"+$.jgrid.jqID(n), "#"+$.jgrid.jqID(fid))[t.p.useProp ? 'prop': 'attr']("checked",false);
}
if( t.p.onUnSelectRow) { t.p.onUnSelectRow.call(t, n); }
});
t.setHeadCheckBox( false );
t.p.selarrrow = [];
t.p.selrow = null;
}
if(t.p.cellEdit === true) {
if(parseInt(t.p.iCol,10)>=0 && parseInt(t.p.iRow,10)>=0) {
$("td:eq("+t.p.iCol+")",t.rows[t.p.iRow]).removeClass("edit-cell " + highlight );
$(t.rows[t.p.iRow]).removeClass("selected-row " + hover );
}
}
//t.p.savedRow = [];
});
},
getRowData : function( rowid, usedata, treeindent ) {
var res = {}, resall, getall=false, len, j=0;
this.each(function(){
var $t = this,nm,ind;
if(rowid == null) {
getall = true;
resall = [];
len = $t.rows.length;
} else {
ind = $($t).jqGrid('getGridRowById', rowid);
if(!ind) { return res; }
len = 1;
}
if( !(usedata && usedata === true && $t.p.data.length > 0) ) {
usedata = false;
}
if(treeindent == null ) {
treeindent = false;
}
while(j<len){
if(getall) {
ind = $t.rows[j];
}
if( $(ind).hasClass('jqgrow') && ind.id !== "norecs") { // ignore first not visible row and norecs one
if(usedata) {
res = res = $.extend( {}, $t.p.data[ $t.p._index[ $.jgrid.stripPref($t.p.idPrefix, ind.id) ] ] );
} else {
$(ind).children('td[role="gridcell"]').each( function(i) {
nm = $t.p.colModel[i].name;
if ( nm !== 'cb' && nm !== 'subgrid' && nm !== 'rn') {
if($t.p.treeGrid===true && nm === $t.p.ExpandColumn) {
res[nm] = $.jgrid.htmlDecode($("span:first",this).html());
} else {
try {
res[nm] = $.unformat.call($t,this,{rowId:ind.id, colModel:$t.p.colModel[i]},i);
} catch (e){
res[nm] = $.jgrid.htmlDecode($(this).html());
}
}
}
});
}
if($t.p.treeGrid===true && treeindent) {
var level = $t.p.treeReader.level_field;
treeindent += '';
try {
level = parseInt(res[level],10);
} catch(e_) {
level = 0;
}
res[$t.p.ExpandColumn] = treeindent.repeat( level ) + res[$t.p.ExpandColumn];
}
if(getall) { resall.push(res); res={}; }
}
j++;
}
});
return resall || res;
},
delRowData : function(rowid) {
var success = false, rowInd, ia, nextRow;
this.each(function() {
var $t = this;
rowInd = $($t).jqGrid('getGridRowById', rowid);
if(!rowInd) {
return false;
} else {
rowid = rowInd.id;
}
if($t.p.subGrid) {
nextRow = $(rowInd).next();
if(nextRow.hasClass('ui-subgrid')) {
nextRow.remove();
}
}
$(rowInd).remove();
$t.p.records--;
$t.p.reccount--;
$t.updatepager(true,false);
success=true;
if($t.p.multiselect) {
ia = $.inArray(rowid,$t.p.selarrrow);
if(ia !== -1) { $t.p.selarrrow.splice(ia,1);}
}
if ($t.p.multiselect && $t.p.selarrrow.length > 0) {
$t.p.selrow = $t.p.selarrrow[$t.p.selarrrow.length-1];
} else {
if( $t.p.selrow === rowid ) {
$t.p.selrow = null;
}
}
if($t.p.datatype === 'local') {
var id = $.jgrid.stripPref($t.p.idPrefix, rowid),
pos = $t.p._index[id];
if(pos !== undefined) {
$t.p.data.splice(pos,1);
$t.refreshIndex();
}
}
});
return success;
},
setRowData : function(rowid, data, cssp, usegetrow) {
var nm, success=true;
this.each(function(){
if(!this.grid) {return false;}
var t = this, vl, ind, lcdata={}, prp, ohtml, tcell, jsondat;
ind = $(this).jqGrid('getGridRowById', rowid);
if(!ind) {
return false;
}
if(usegetrow === true) {
jsondat = $(t).jqGrid("getRowData", rowid, (t.p.datatype === 'local'));
}
if( data ) {
if(usegetrow) {
data = $.extend( jsondat, data);
}
try {
$(this.p.colModel).each(function(i){
nm = this.name;
var dval =$.jgrid.getAccessor(data,nm);
if( dval !== undefined) {
lcdata[nm] = this.formatter && typeof this.formatter === 'string' && this.formatter === 'date' ? $.unformat.date.call(t,dval,this) : dval;
vl = t.formatter( rowid, lcdata[nm], i, data, 'edit');
prp = t.formatCol( i, ind.rowIndex, vl, data, rowid, data);
ohtml = $("<td role=\"gridcell\" "+prp+">"+vl+"</td>")[0];
tcell = $(ind).children("td[role='gridcell']:eq("+i+")");
$(tcell).after(ohtml).remove();
if(t.p.treeGrid && t.p.ExpandColumn === nm ) {
$(t).jqGrid("setTreeNode", ind.rowIndex, ind.rowIndex+1);
}
}
});
if(t.p.datatype === 'local') {
var id = $.jgrid.stripPref(t.p.idPrefix, rowid),
pos = t.p._index[id], key;
if(t.p.treeGrid) {
for(key in t.p.treeReader){
if(t.p.treeReader.hasOwnProperty(key)) {
delete lcdata[t.p.treeReader[key]];
}
}
}
if(pos !== undefined) {
t.p.data[pos] = $.extend(true, t.p.data[pos], lcdata);
}
lcdata = null;
}
} catch (e) {
success = false;
}
}
if(success) {
if(typeof cssp === 'string') {
$(ind).addClass(cssp);
} else if(cssp !== null && typeof cssp === 'object') {
$(ind).css(cssp);
}
$(t).triggerHandler("jqGridAfterGridComplete");
}
});
return success;
},
addRowData : function(rowid,rdata,pos,src) {
if($.inArray( pos, ["first", "last", "before", "after"] ) === -1) {pos = "last";}
var success = false, nm, row, rnc="", msc="", gi, si, ni,sind, i, v, prp="", aradd, cnm, data, cm, id;
if(rdata) {
if($.isArray(rdata)) {
aradd=true;
//pos = "last";
cnm = rowid;
} else {
rdata = [rdata];
aradd = false;
}
this.each(function() {
var t = this, datalen = rdata.length;
ni = t.p.rownumbers===true ? 1 :0;
gi = t.p.multiselect ===true ? 1 :0;
si = t.p.subGrid===true ? 1 :0;
if(!aradd) {
if(rowid !== undefined) { rowid = String(rowid);}
else {
rowid = $.jgrid.randId();
if(t.p.keyName !== false) {
cnm = t.p.keyName;
if(rdata[0][cnm] !== undefined) { rowid = rdata[0][cnm]; }
}
}
}
var k = 0, classes = $(t).jqGrid('getStyleUI',t.p.styleUI+".base",'rowBox', true, 'jqgrow ui-row-'+ t.p.direction), lcdata = {},
air = $.isFunction(t.p.afterInsertRow) ? true : false;
if(ni) {
rnc = $(t).jqGrid('getStyleUI',t.p.styleUI+".base",'rownumBox', false, 'jqgrid-rownum');
}
if(gi) {
msc = $(t).jqGrid('getStyleUI',t.p.styleUI+".base",'multiBox', false, 'cbox');
}
while(k < datalen) {
data = rdata[k];
row=[];
if(aradd) {
try {
rowid = data[cnm];
if(rowid===undefined) {
rowid = $.jgrid.randId();
}
}
catch (e) {rowid = $.jgrid.randId();}
}
id = rowid;
rowid = t.p.idPrefix + rowid;
if(ni){
prp = t.formatCol(0,1,'',null,rowid, true);
row[row.length] = "<td role=\"gridcell\" " + rnc +" "+prp+">0</td>";
}
if(gi) {
v = "<input role=\"checkbox\" type=\"checkbox\""+" id=\"jqg_"+t.p.id+"_"+rowid+"\" "+msc+"/>";
prp = t.formatCol(ni,1,'', null, rowid, true);
row[row.length] = "<td role=\"gridcell\" "+prp+">"+v+"</td>";
}
if(si) {
row[row.length] = $(t).jqGrid("addSubGridCell",gi+ni,1);
}
for(i = gi+si+ni; i < t.p.colModel.length;i++){
cm = t.p.colModel[i];
nm = cm.name;
lcdata[nm] = data[nm];
v = t.formatter( rowid, $.jgrid.getAccessor(data,nm), i, data );
prp = t.formatCol(i,1,v, data, rowid, lcdata);
row[row.length] = "<td role=\"gridcell\" "+prp+">"+v+"</td>";
}
row.unshift( t.constructTr(rowid, false, classes, lcdata, data ) );
row[row.length] = "</tr>";
if(t.rows.length === 0){
$("table:first",t.grid.bDiv).append(row.join(''));
} else {
switch (pos) {
case 'last':
$(t.rows[t.rows.length-1]).after(row.join(''));
sind = t.rows.length-1;
break;
case 'first':
$(t.rows[0]).after(row.join(''));
sind = 1;
break;
case 'after':
sind = $(t).jqGrid('getGridRowById', src);
if (sind) {
if($(t.rows[sind.rowIndex+1]).hasClass("ui-subgrid")) { $(t.rows[sind.rowIndex+1]).after(row); }
else { $(sind).after(row.join('')); }
sind=sind.rowIndex + 1;
}
break;
case 'before':
sind = $(t).jqGrid('getGridRowById', src);
if(sind) {
$(sind).before(row.join(''));
sind=sind.rowIndex - 1;
}
break;
}
}
if(t.p.subGrid===true) {
$(t).jqGrid("addSubGrid",gi+ni, sind);
}
t.p.records++;
t.p.reccount++;
$(t).triggerHandler("jqGridAfterInsertRow", [rowid,data,data]);
if(air) { t.p.afterInsertRow.call(t,rowid,data,data); }
k++;
if(t.p.datatype === 'local') {
lcdata[t.p.localReader.id] = id;
switch (pos) {
case 'first':
t.p.data.unshift(lcdata);
break;
case 'last':
t.p.data.push(lcdata);
break;
case 'before':
case 'after':
t.p.data.splice(sind-1, 0, lcdata);
break;
}
}
lcdata = {};
if(t.p.reccount === 1) {
sind = $(t).jqGrid('getGridRowById', "norecs");
if(sind.rowIndex && sind.rowIndex > 0) {
$(t.rows[sind.rowIndex]).remove();
}
}
}
if(t.p.datatype === 'local') {
t.refreshIndex();
}
t.updatepager(true,true);
success = true;
});
}
return success;
},
footerData : function(action,data, format) {
var nm, success=false, res={}, title;
function isEmpty(obj) {
var i;
for(i in obj) {
if (obj.hasOwnProperty(i)) { return false; }
}
return true;
}
if(action === undefined) { action = "get"; }
if(typeof format !== "boolean") { format = true; }
action = action.toLowerCase();
this.each(function(){
var t = this, vl;
if(!t.grid || !t.p.footerrow) {return false;}
if(action === "set") { if(isEmpty(data)) { return false; } }
success=true;
$(this.p.colModel).each(function(i){
nm = this.name;
if(action === "set") {
if( data[nm] !== undefined) {
vl = format ? t.formatter( "", data[nm], i, data, 'edit') : data[nm];
title = this.title ? {"title":$.jgrid.stripHtml(vl)} : {};
$("tr.footrow td:eq("+i+")",t.grid.sDiv).html(vl).attr(title);
success = true;
}
} else if(action === "get") {
res[nm] = $("tr.footrow td:eq("+i+")",t.grid.sDiv).html();
}
});
});
return action === "get" ? res : success;
},
headerData : function(action,data, format) {
var nm, success=false, res={}, title;
function isEmpty(obj) {
var i;
for(i in obj) {
if (obj.hasOwnProperty(i)) { return false; }
}
return true;
}
if(action === undefined) { action = "get"; }
if(typeof format !== "boolean") { format = true; }
action = action.toLowerCase();
this.each(function(){
var t = this, vl;
if(!t.grid || !t.p.headerrow) {return false;}
if(action === "set") { if(isEmpty(data)) { return false; } }
success=true;
$(this.p.colModel).each(function(i){
nm = this.name;
if(action === "set") {
if( data[nm] !== undefined) {
vl = format ? t.formatter( "", data[nm], i, data, 'edit') : data[nm];
title = this.title ? {"title":$.jgrid.stripHtml(vl)} : {};
$("tr.hrheadrow td:eq("+i+")",t.grid.hrDiv).html(vl).attr(title);
success = true;
}
} else if(action === "get") {
res[nm] = $("tr.hrheadrow td:eq("+i+")",t.grid.hrDiv).html();
}
});
});
return action === "get" ? res : success;
},
showHideCol : function(colname,show) {
return this.each(function() {
var $t = this, fndh=false, brd=$.jgrid.cell_width ? 0: $t.p.cellLayout, cw, frozen = false;
if (!$t.grid ) {return;}
if( typeof colname === 'string') {colname=[colname];}
show = show !== "none" ? "" : "none";
var sw = show === "" ? true :false,
gHead = null,
gh = $($t).jqGrid("isGroupHeaderOn");
//$t.p.groupHeader && ($.isArray($t.p.groupHeader) || $.isFunction($t.p.groupHeader) );
if($t.p.frozenColumns) {
$($t).jqGrid('destroyFrozenColumns');
frozen = true;
}
if(gh) {
$($t).jqGrid('destroyGroupHeader', false);
gHead = $.extend([],$t.p.groupHeader);
$t.p.groupHeader = null;
}
$(this.p.colModel).each(function(i) {
if ($.inArray(this.name,colname) !== -1 && this.hidden === sw) {
//if($t.p.frozenColumns === true && this.frozen === true) {
// return true;
//}
$("tr[role=row]",$t.grid.hDiv).each(function(){
$(this.cells[i]).css("display", show);
});
$($t.rows).each(function(){
if (!$(this).hasClass("jqgroup")) {
$(this.cells[i]).css("display", show);
}
});
if($t.p.footerrow) { $("tr.footrow td:eq("+i+")", $t.grid.sDiv).css("display", show); }
if($t.p.headerrow) { $("tr.hrheadrow td:eq("+i+")", $t.grid.hrDiv).css("display", show); }
cw = parseInt(this.width,10);
if(show === "none") {
$t.p.tblwidth -= cw+brd;
} else {
$t.p.tblwidth += cw+brd;
}
this.hidden = !sw;
fndh=true;
$($t).triggerHandler("jqGridShowHideCol", [sw,this.name,i]);
}
});
if(fndh===true) {
if($t.p.shrinkToFit === true && !isNaN($t.p.height)) { $t.p.tblwidth += parseInt($t.p.scrollOffset,10);}
$($t).jqGrid("setGridWidth",$t.p.shrinkToFit === true ? $t.p.tblwidth : $t.p.width );
}
if( gh && gHead) {
for(var k =0; k < gHead.length; k++) {
$($t).jqGrid('setGroupHeaders', gHead[k]);
}
}
if(frozen) {
$($t).jqGrid('setFrozenColumns');
}
});
},
hideCol : function (colname) {
return this.each(function(){$(this).jqGrid("showHideCol",colname,"none");});
},
showCol : function(colname) {
return this.each(function(){$(this).jqGrid("showHideCol",colname,"");});
},
remapColumns : function(permutation, updateCells, keepHeader) {
function resortArray(a) {
var ac;
if (a.length) {
ac = $.makeArray(a);
} else {
ac = $.extend({}, a);
}
$.each(permutation, function(i) {
a[i] = ac[this];
});
}
var ts = this.get(0);
function resortRows(parent, clobj) {
$(">tr"+(clobj||""), parent).each(function() {
var row = this;
var elems = $.makeArray(row.cells);
$.each(permutation, function() {
var e = elems[this];
if (e) {
row.appendChild(e);
}
});
});
}
resortArray(ts.p.colModel);
resortArray(ts.p.colNames);
resortArray(ts.grid.headers);
resortRows($("thead:first", ts.grid.hDiv), keepHeader && ":not(.ui-jqgrid-labels)");
if (updateCells) {
resortRows($("#"+$.jgrid.jqID(ts.p.id)+" tbody:first"), ".jqgfirstrow, tr.jqgrow, tr.jqfoot");
}
if (ts.p.footerrow) {
resortRows($("tbody:first", ts.grid.sDiv));
}
if (ts.p.headerrow) {
resortRows($("tbody:first", ts.grid.hrDiv));
}
if (ts.p.remapColumns) {
if (!ts.p.remapColumns.length){
ts.p.remapColumns = $.makeArray(permutation);
} else {
resortArray(ts.p.remapColumns);
}
}
ts.p.lastsort = $.inArray(ts.p.lastsort, permutation);
if(ts.p.treeGrid) { ts.p.expColInd = $.inArray(ts.p.expColInd, permutation); }
$(ts).triggerHandler("jqGridRemapColumns", [permutation, updateCells, keepHeader]);
},
setGridWidth : function(nwidth, shrink) {
return this.each(function(){
if (!this.grid ) {return;}
var $t = this, cw, setgr, frozen = false,
initwidth = 0, brd=$.jgrid.cell_width ? 0: $t.p.cellLayout, lvc, vc=0, hs=false, scw=$t.p.scrollOffset, aw, gw=0, cr, bstw = $t.p.styleUI.search('Bootstrap') !== -1 && !isNaN($t.p.height) ? 2 : 0;
if(typeof shrink !== 'boolean') {
shrink=$t.p.shrinkToFit;
}
if(isNaN(nwidth)) {return;}
nwidth = parseInt(nwidth,10);
$t.grid.width = $t.p.width = nwidth;
$("#gbox_"+$.jgrid.jqID($t.p.id)).css("width",nwidth+"px");
$("#gview_"+$.jgrid.jqID($t.p.id)).css("width",nwidth+"px");
$($t.grid.bDiv).css("width",(nwidth - bstw) +"px");
$($t.grid.hDiv).css("width",(nwidth - bstw) +"px");
if($t.p.pager ) {
$($t.p.pager).css("width",(nwidth - bstw) +"px");
}
if($t.p.toppager ) {
$($t.p.toppager).css("width",(nwidth - bstw)+"px");
}
if($t.p.toolbar[0] === true){
$($t.grid.uDiv).css("width",(nwidth - bstw)+"px");
if($t.p.toolbar[1]==="both") {$($t.grid.ubDiv).css("width",(nwidth - bstw)+"px");}
}
if($t.p.footerrow) {
$($t.grid.sDiv).css("width",(nwidth - bstw)+"px");
}
if($t.p.headerrow) {
$($t.grid.hrDiv).css("width",(nwidth - bstw)+"px");
}
// if (group_header)
setgr = $($t).jqGrid("isGroupHeaderOn");
//$t.p.groupHeader && ($.isArray($t.p.groupHeader) || $.isFunction($t.p.groupHeader) );
if(setgr) {
$($t).jqGrid('destroyGroupHeader', false);
}
if($t.p.frozenColumns) {
$($t).jqGrid("destroyFrozenColumns");
frozen = true;
}
if(shrink ===false && $t.p.forceFit === true) {$t.p.forceFit=false;}
if(shrink===true) {
$.each($t.p.colModel, function() {
if(this.hidden===false){
cw = this.widthOrg;
initwidth += cw+brd;
if(this.fixed) {
gw += cw+brd;
} else {
vc++;
}
}
});
if(vc === 0) { return; }
$t.p.tblwidth = initwidth;
aw = nwidth-brd*vc-gw;
if(!isNaN($t.p.height)) {
if($($t.grid.bDiv)[0].clientHeight < $($t.grid.bDiv)[0].scrollHeight || $t.rows.length === 1 || $($t.grid.bDiv).css('overflow-y') === 'scroll'){
hs = true;
aw -= scw;
}
}
initwidth =0;
var cle = $t.grid.cols.length >0;
$.each($t.p.colModel, function(i) {
if(this.hidden === false && !this.fixed){
cw = this.widthOrg;
cw = Math.round(aw*cw/($t.p.tblwidth-brd*vc-gw));
if (cw < 0) { return; }
this.width =cw;
initwidth += cw;
$t.grid.headers[i].width=cw;
$t.grid.headers[i].el.style.width=cw+"px";
if($t.p.footerrow) { $t.grid.footers[i].style.width = cw+"px"; }
if($t.p.headerrow) { $t.grid.hrheaders[i].style.width = cw+"px"; }
if(cle) { $t.grid.cols[i].style.width = cw+"px"; }
lvc = i;
}
});
if (!lvc) { return; }
cr =0;
if (hs) {
if(nwidth-gw-(initwidth+brd*vc) !== scw){
cr = nwidth-gw-(initwidth+brd*vc)-scw;
}
} else if( !hs && Math.abs(nwidth-gw-(initwidth+brd*vc)) !== 0) {
cr = nwidth-gw-(initwidth+brd*vc) - bstw;
}
$t.p.colModel[lvc].width += cr;
$t.p.tblwidth = initwidth+cr+brd*vc+gw;
if($t.p.tblwidth > nwidth) {
var delta = $t.p.tblwidth - parseInt(nwidth,10);
$t.p.tblwidth = nwidth;
cw = $t.p.colModel[lvc].width = $t.p.colModel[lvc].width-delta;
} else if ($t.p.tblwidth === nwidth){
cw = $t.p.colModel[lvc].width = $t.p.colModel[lvc].width-bstw;
$t.p.tblwidth = nwidth - bstw;
} else {
cw= $t.p.colModel[lvc].width;
}
var has_scroll = ($($t.grid.bDiv)[0].scrollWidth > $($t.grid.bDiv).width()) && bstw !==0 ? -1 : 0;
cw = $t.p.colModel[lvc].width += has_scroll;
$t.grid.headers[lvc].width = cw;
$t.grid.headers[lvc].el.style.width=cw+"px";
if(cle) { $t.grid.cols[lvc].style.width = cw+"px"; }
if($t.p.footerrow) {
$t.grid.footers[lvc].style.width = cw+"px";
}
if($t.p.headerrow) {
$t.grid.hrheaders[lvc].style.width = cw+"px";
}
}
$('table:first',$t.grid.bDiv).css("width",$t.p.tblwidth+"px");
$('table:first',$t.grid.hDiv).css("width",$t.p.tblwidth+"px");
$t.grid.hDiv.scrollLeft = $t.grid.bDiv.scrollLeft;
if($t.p.footerrow) {
$('table:first',$t.grid.sDiv).css("width",$t.p.tblwidth+"px");
}
if($t.p.headerrow) {
$('table:first',$t.grid.hrDiv).css("width",$t.p.tblwidth+"px");
}
if( setgr ) {
var gHead = $.extend([],$t.p.groupHeader);
$t.p.groupHeader = null;
for(var k =0; k < gHead.length; k++) {
$($t).jqGrid('setGroupHeaders', gHead[k]);
}
$t.grid.hDiv.scrollLeft = $t.grid.bDiv.scrollLeft;
}
if(frozen) {
$($t).jqGrid('setFrozenColumns');
}
});
},
setGridHeight : function (nh, entrie_grid) {
return this.each(function (){
var $t = this;
if(!$t.grid) {return;}
if(!entrie_grid) {
entrie_grid = false;
}
var bDiv = $($t.grid.bDiv),
static_height = $($t.grid.hDiv).outerHeight();
if(entrie_grid === true) {
if($t.p.pager ) {
static_height += $($t.p.pager).outerHeight();
}
if($t.p.toppager ) {
static_height += $($t.p.toppager).outerHeight();
}
if($t.p.toolbar[0] === true){
static_height += $($t.grid.uDiv).outerHeight();
if($t.p.toolbar[1]==="both") {
static_height += $($t.grid.ubDiv).outerHeight();
}
}
if($t.p.footerrow) {
static_height += $($t.grid.sDiv).outerHeight();
}
if($t.p.headerrow) {
static_height += $($t.grid.hrDiv).outerHeight();
}
if($t.p.caption) {
static_height += $($t.grid.cDiv).outerHeight();
}
if(nh > static_height) { // set it for the body
nh = nh - static_height;
}
}
bDiv.css({height: nh+(isNaN(nh)?"":"px")});
if($t.p.frozenColumns === true){
//follow the original set height to use 16, better scrollbar width detection
$('#'+$.jgrid.jqID($t.p.id)+"_frozen").parent().height(bDiv.height() - 16);
}
$t.p.height = nh;
if ($t.p.scroll) { $t.grid.populateVisible(); }
});
},
maxGridHeight : function( action, newhgh ) {
return this.each(function() {
var $t = this;
if(!$t.grid) {return;}
if( action === 'set' && newhgh > 25) { // row min height
$($t).on('jqGridAfterGridComplete.setMaxHeght', function( e ) {
var bDiv = $($t.grid.bDiv),
id = $.jgrid.jqID($t.p.id),
enh = $("#gbox_" + id).outerHeight(),
static_height = $($t.grid.hDiv).outerHeight();
if($t.p.pager ) {
static_height += $($t.p.pager).outerHeight();
}
if($t.p.toppager ) {
static_height += $($t.p.toppager).outerHeight();
}
if($t.p.toolbar[0] === true){
static_height += $($t.grid.uDiv).outerHeight();
if($t.p.toolbar[1]==="both") {
static_height += $($t.grid.ubDiv).outerHeight();
}
}
if($t.p.footerrow) {
static_height += $($t.grid.sDiv).outerHeight();
}
if($t.p.headerrow) {
static_height += $($t.grid.hrDiv).outerHeight();
}
if($t.p.caption) {
static_height += $($t.grid.cDiv).outerHeight();
}
if( enh > static_height) { // min row height
$($t.grid.bDiv).css("max-height", newhgh-2 ); // 2 pix for the border
}
});
} else if( action === 'remove') {
$($t).off('jqGridAfterGridComplete.setMaxHeght');
$($t.grid.bDiv).css("max-height", "");
}
});
},
setCaption : function (newcap){
return this.each(function(){
var ctop = $(this).jqGrid('getStyleUI',this.p.styleUI+".common",'cornertop', true);
this.p.caption=newcap;
$(".ui-jqgrid-title, .ui-jqgrid-title-rtl",this.grid.cDiv).html(newcap);
$(this.grid.cDiv).show();
$(this.grid.hDiv).removeClass(ctop);
});
},
setLabel : function(colname, nData, prop, attrp ){
return this.each(function(){
var $t = this, pos=-1;
if(!$t.grid) {return;}
if(colname != null) {
if(isNaN(colname)) {
$($t.p.colModel).each(function(i){
if (this.name === colname) {
pos = i;return false;
}
});
} else {
pos = parseInt(colname,10);
}
} else { return; }
if(pos>=0) {
var thecol = $("tr.ui-jqgrid-labels th:eq("+pos+")",$t.grid.hDiv);
if (nData){
var ico = $(".s-ico",thecol);
$("[id^=jqgh_]",thecol).empty().html(nData).append(ico);
$t.p.colNames[pos] = nData;
}
if (prop) {
if(typeof prop === 'string') {$(thecol).addClass(prop);} else {$(thecol).css(prop);}
}
if(typeof attrp === 'object') {$(thecol).attr(attrp);}
}
});
},
setSortIcon : function(position, colname) {
return this.each(function(){
var $t = this, pos=-1, len=1,
nm, thecol, htmlcol, ico;
if(!$t.grid) {return;}
if(colname != null) {
if(isNaN(colname)) {
$($t.p.colModel).each(function(i){
if (this.name === colname) {
pos = i;
return false;
}
});
} else {
pos = parseInt(colname,10);
}
} else {
len = $t.p.colNames.length;
}
for(var i =0; i<len; i++) {
if(pos>=0) {
i = pos;
}
nm = $t.p.colModel[i].name;
if(nm === 'cb' || nm==='subgrid' || nm==='rn' ) {
continue;
}
thecol = $("tr.ui-jqgrid-labels th:eq("+i+")",$t.grid.hDiv);
htmlcol = $t.p.colNames[i];
ico = thecol.find(".s-ico");
if(position === 'left') {
thecol.find("div.ui-th-div:first").empty().addClass("ui-icon-left").append(ico).append(htmlcol);
} else if(position === 'right') {
thecol.find("div.ui-th-div:first").empty().removeClass("ui-icon-left").append(htmlcol).append(ico);
}
}
});
},
setCell : function(rowid,colname,nData,cssp,attrp, forceupd) {
return this.each(function(){
var $t = this, pos =-1, v, prp, ohtml, ind;
if(!$t.grid) {return;}
if(isNaN(colname)) {
$($t.p.colModel).each(function(i){
if (this.name === colname) {
pos = i;return false;
}
});
} else {
pos = parseInt(colname,10);
}
if(pos>=0) {
ind = $($t).jqGrid('getGridRowById', rowid);
if (ind){
var tcell, cl=0, rawdat={}, nm;
try {
tcell = ind.cells[pos];
} catch(e){}
if(tcell) {
if(nData !== "" || forceupd === true ) {
rawdat = $($t).jqGrid("getRowData", rowid, ($t.p.datatype === 'local'));
rawdat[$t.p.colModel[pos].name] = nData;
v = $t.formatter(rowid, nData, pos, rawdat, 'edit');
prp = $t.formatCol( pos, ind.rowIndex, v, rawdat, rowid, rawdat);
ohtml = $("<td role=\"gridcell\" "+prp+">"+v+"</td>")[0];
$(tcell).after(ohtml).remove();
if($t.p.treeGrid && $t.p.ExpandColumn === colname ) {
$($t).jqGrid("setTreeNode", ind.rowIndex, ind.rowIndex+1);
}
if($t.p.datatype === "local") {
var cm = $t.p.colModel[pos], index;
nData = cm.formatter && typeof cm.formatter === 'string' && cm.formatter === 'date' ? $.unformat.date.call($t,nData,cm) : nData;
index = $t.p._index[$.jgrid.stripPref($t.p.idPrefix, rowid)];
if(index !== undefined) {
$t.p.data[index][cm.name] = nData;
}
}
}
if(typeof cssp === 'string'){
$(ohtml).addClass(cssp);
} else if(cssp) {
$(ohtml).css(cssp);
}
if(typeof attrp === 'object') {
$(ohtml).attr(attrp);
}
}
}
}
});
},
getCell : function(rowid, col, returnobject) {
var ret = false, obj;
if(returnobject === undefined) {
returnobject = false;
}
this.each(function(){
var $t=this, pos=-1, cnm, ind;
if(!$t.grid) {return;}
cnm = col;
if(isNaN(col)) {
$($t.p.colModel).each(function(i){
if (this.name === col) {
cnm = this.name;
pos = i;
return false;
}
});
} else {
pos = parseInt(col,10);
}
if(pos>=0) {
ind = $($t).jqGrid('getGridRowById', rowid);
if(ind) {
obj = $("td:eq("+pos+")",ind);
if( returnobject ) {
ret = obj;
} else {
try {
ret = $.unformat.call($t, obj ,{rowId:ind.id, colModel:$t.p.colModel[pos]},pos);
} catch (e){
ret = $.jgrid.htmlDecode( obj.html() );
}
if($t.p.treeGrid && ret && $t.p.ExpandColumn === cnm ) {
ret = $( "<div>" + ret +"</div>").find("span:first").html();
}
}
}
}
});
return ret;
},
getCol : function (col, obj, mathopr) {
var ret = [], val, sum=0, min, max, v;
obj = typeof obj !== 'boolean' ? false : obj;
if(mathopr === undefined) { mathopr = false; }
var font = $.jgrid.getFont( this[0] );
this.each(function(){
var $t=this, pos=-1;
if(!$t.grid) {return;}
if(isNaN(col)) {
$($t.p.colModel).each(function(i){
if (this.name === col) {
pos = i;
return false;
}
});
} else {pos = parseInt(col,10);}
if(pos>=0) {
var ln = $t.rows.length, i = 0, dlen = 0;
if (ln && ln>0){
for(; i < ln; i++){
if($($t.rows[i]).hasClass('jqgrow') && $t.rows[i].id !== "norecs") {
if(mathopr === 'maxwidth') {
if(max === undefined) { max = 0;}
max = Math.max( $.jgrid.getTextWidth($t.rows[i].cells[pos].innerHTML, font), max);
continue;
}
try {
val = $.unformat.call($t,$($t.rows[i].cells[pos]),{rowId:$t.rows[i].id, colModel:$t.p.colModel[pos]},pos);
} catch (e) {
val = $.jgrid.htmlDecode($t.rows[i].cells[pos].innerHTML);
}
if(mathopr) {
v = parseFloat(val);
if(!isNaN(v)) {
sum += v;
if (max === undefined) {max = min = v;}
min = Math.min(min, v);
max = Math.max(max, v);
dlen++;
}
} else if(obj) {
ret.push( {id:$t.rows[i].id,value:val} );
} else {
ret.push( val );
}
}
}
if(mathopr) {
switch(mathopr.toLowerCase()){
case 'sum': ret =sum; break;
case 'avg': ret = sum/dlen; break;
case 'count': ret = dlen; break;
case 'min': ret = min; break;
case 'max': ret = max; break;
case 'maxwidth': ret = max;
}
}
}
}
});
return ret;
},
clearGridData : function(clearfooter, clearheader) {
return this.each(function(){
var $t = this;
if(!$t.grid) {return;}
if(typeof clearfooter !== 'boolean') { clearfooter = false; }
if(typeof clearheader !== 'boolean') { clearheader = false; }
if($t.p.deepempty) {$("#"+$.jgrid.jqID($t.p.id)+" tbody:first tr:gt(0)").remove();}
else {
var trf = $("#"+$.jgrid.jqID($t.p.id)+" tbody:first tr:first")[0];
$("#"+$.jgrid.jqID($t.p.id)+" tbody:first").empty().append(trf);
}
if($t.p.footerrow && clearfooter) { $(".ui-jqgrid-ftable td",$t.grid.sDiv).html(" "); }
if($t.p.headerrow && clearheader) { $(".ui-jqgrid-hrtable td",$t.grid.hrDiv).html(" "); }
$t.p.selrow = null; $t.p.selarrrow= []; $t.p.savedRow = [];
$t.p.records = 0;$t.p.page=1;$t.p.lastpage=0;$t.p.reccount=0;
$t.p.data = []; $t.p._index = {};
$t.p.groupingView._locgr = false;
$t.updatepager(true,false);
});
},
getInd : function(rowid,rc){
var ret =false,rw;
this.each(function(){
rw = $(this).jqGrid('getGridRowById', rowid);
if(rw) {
ret = rc===true ? rw: rw.rowIndex;
}
});
return ret;
},
bindKeys : function( settings ){
var o = $.extend({
onEnter: null,
onSpace: null,
onLeftKey: null,
onRightKey: null,
scrollingRows : true
},settings || {});
return this.each(function(){
var $t = this;
if( !$('body').is('[role]') ){$('body').attr('role','application');}
$t.p.scrollrows = o.scrollingRows;
$($t).on("keydown", function(event){
var target = $($t).find('tr[tabindex=0]')[0], id, r, mind,
expanded = $t.p.treeReader.expanded_field;
//check for arrow keys
if(target) {
var previd = $t.p.selrow;
mind = $t.p._index[$.jgrid.stripPref($t.p.idPrefix, target.id)];
if(event.keyCode === 37 || event.keyCode === 38 || event.keyCode === 39 || event.keyCode === 40){
// up key
if(event.keyCode === 38 ){
r = target.previousSibling;
id = "";
if(r && $(r).hasClass('jqgrow')) {
if($(r).is(":hidden")) {
while(r) {
r = r.previousSibling;
if(!$(r).is(":hidden") && $(r).hasClass('jqgrow')) {id = r.id;break;}
}
} else {
id = r.id;
}
$($t).jqGrid('setSelection', id, true, event);
}
$($t).triggerHandler("jqGridKeyUp", [id, previd, event]);
if($.isFunction(o.onUpKey)) {
o.onUpKey.call($t, id, previd, event);
}
event.preventDefault();
}
//if key is down arrow
if(event.keyCode === 40){
r = target.nextSibling;
id ="";
if(r && $(r).hasClass('jqgrow')) {
if($(r).is(":hidden")) {
while(r) {
r = r.nextSibling;
if(!$(r).is(":hidden") && $(r).hasClass('jqgrow') ) {id = r.id;break;}
}
} else {
id = r.id;
}
$($t).jqGrid('setSelection', id, true, event);
}
$($t).triggerHandler("jqGridKeyDown", [id, previd, event]);
if($.isFunction(o.onDownKey)) {
o.onDownKey.call($t, id, previd, event);
}
event.preventDefault();
}
// left
if(event.keyCode === 37 ){
if($t.p.treeGrid && $t.p.data[mind][expanded]) {
$(target).find("div.treeclick").trigger('click');
}
$($t).triggerHandler("jqGridKeyLeft", [$t.p.selrow, event]);
if($.isFunction(o.onLeftKey)) {
o.onLeftKey.call($t, $t.p.selrow, event);
}
}
// right
if(event.keyCode === 39 ){
if($t.p.treeGrid && !$t.p.data[mind][expanded]) {
$(target).find("div.treeclick").trigger('click');
}
$($t).triggerHandler("jqGridKeyRight", [$t.p.selrow, event]);
if($.isFunction(o.onRightKey)) {
o.onRightKey.call($t, $t.p.selrow, event);
}
}
}
//check if enter was pressed on a grid or treegrid node
else if( event.keyCode === 13 ){
$($t).triggerHandler("jqGridKeyEnter", [$t.p.selrow, event]);
if($.isFunction(o.onEnter)) {
o.onEnter.call($t, $t.p.selrow, event);
}
} else if(event.keyCode === 32) {
$($t).triggerHandler("jqGridKeySpace", [$t.p.selrow, event]);
if($.isFunction(o.onSpace)) {
o.onSpace.call($t, $t.p.selrow, event);
}
}
}
}).on('click', function(e) {
if( !$(e.target).is("input, textarea, select") ) {
$(e.target,$t.rows).closest("tr.jqgrow").focus();
}
});
});
},
unbindKeys : function(){
return this.each(function(){
$(this).off('keydown');
});
},
getLocalRow : function (rowid) {
var ret = false, ind;
this.each(function(){
if(rowid !== undefined) {
ind = this.p._index[$.jgrid.stripPref(this.p.idPrefix, rowid)];
if(ind >= 0 ) {
ret = this.p.data[ind];
}
}
});
return ret;
},
progressBar : function ( p ) {
p = $.extend({
htmlcontent : "",
method : "hide",
loadtype : "disable"
}, p || {});
return this.each(function(){
var sh = p.method==="show" ? true : false,
loadDiv = $("#load_"+$.jgrid.jqID(this.p.id)),
offsetParent, top,
scrollTop = $(window).scrollTop();
if(p.htmlcontent !== "") {
loadDiv.html( p.htmlcontent );
}
switch(p.loadtype) {
case "disable":
break;
case "enable":
loadDiv.toggle( sh );
break;
case "block":
$("#lui_"+$.jgrid.jqID(this.p.id)).css(sh ? {top: 0,left:0, height: $("#gbox_" + $.jgrid.jqID(this.p.id) ).height(), width:$("#gbox_" + $.jgrid.jqID(this.p.id)).width(), "z-index":10000, position:"absolute"} : {}).toggle( sh );
loadDiv.toggle( sh );
break;
}
if (loadDiv.is(':visible')) {
offsetParent = loadDiv.offsetParent();
loadDiv.css('top', '');
if (loadDiv.offset().top < scrollTop) {
top = Math.min(
10 + scrollTop - offsetParent.offset().top,
offsetParent.height() - loadDiv.height()
);
loadDiv.css('top', top + 'px');
}
}
});
},
getColProp : function(colname){
var ret ={}, $t = this[0];
if ( !$t.grid ) { return false; }
var cM = $t.p.colModel, i;
for ( i=0;i<cM.length;i++ ) {
if ( cM[i].name === colname ) {
ret = cM[i];
break;
}
}
return ret;
},
setColProp : function(colname, obj){
//do not set width will not work
return this.each(function(){
if ( this.grid ) {
if ( $.isPlainObject( obj ) ) {
var cM = this.p.colModel, i;
for ( i=0;i<cM.length;i++ ) {
if ( cM[i].name === colname ) {
$.extend(true, this.p.colModel[i],obj);
break;
}
}
}
}
});
},
sortGrid : function(colname,reload, sor){
return this.each(function(){
var $t=this,idx=-1,i, sobj=false;
if ( !$t.grid ) { return;}
if ( !colname ) { colname = $t.p.sortname; }
for ( i=0;i<$t.p.colModel.length;i++ ) {
if ( $t.p.colModel[i].index === colname || $t.p.colModel[i].name === colname ) {
idx = i;
if($t.p.frozenColumns === true && $t.p.colModel[i].frozen === true) {
sobj = $t.grid.fhDiv.find("#" + $t.p.id + "_" + colname);
}
break;
}
}
if ( idx !== -1 ){
var sort = $t.p.colModel[idx].sortable;
if(!sobj) {
sobj = $t.grid.headers[idx].el;
}
if ( typeof sort !== 'boolean' ) { sort = true; }
if ( typeof reload !=='boolean' ) { reload = false; }
if ( sort ) { $t.sortData("jqgh_"+$t.p.id+"_" + colname, idx, reload, sor, sobj); }
}
});
},
setGridState : function(state) {
return this.each(function(){
if ( !this.grid ) {return;}
var $t = this,
open = $(this).jqGrid('getStyleUI',this.p.styleUI+".base",'icon_caption_open', true),
close = $(this).jqGrid('getStyleUI',this.p.styleUI+".base",'icon_caption_close', true);
if(state === 'hidden'){
$(".ui-jqgrid-bdiv, .ui-jqgrid-hdiv","#gview_"+$.jgrid.jqID($t.p.id)).slideUp("fast");
if($t.p.pager) {$($t.p.pager).slideUp("fast");}
if($t.p.toppager) {$($t.p.toppager).slideUp("fast");}
if($t.p.toolbar[0]===true) {
if( $t.p.toolbar[1] === 'both') {
$($t.grid.ubDiv).slideUp("fast");
}
$($t.grid.uDiv).slideUp("fast");
}
if($t.p.footerrow) { $(".ui-jqgrid-sdiv","#gbox_"+$.jgrid.jqID($t.p.id)).slideUp("fast"); }
if($t.p.headerrow) { $(".ui-jqgrid-hrdiv","#gbox_"+$.jgrid.jqID($t.p.id)).slideUp("fast"); }
$(".ui-jqgrid-headlink",$t.grid.cDiv).removeClass( open ).addClass( close );
$t.p.gridstate = 'hidden';
} else if(state === 'visible') {
$(".ui-jqgrid-hdiv, .ui-jqgrid-bdiv","#gview_"+$.jgrid.jqID($t.p.id)).slideDown("fast");
if($t.p.pager) {$($t.p.pager).slideDown("fast");}
if($t.p.toppager) {$($t.p.toppager).slideDown("fast");}
if($t.p.toolbar[0]===true) {
if( $t.p.toolbar[1] === 'both') {
$($t.grid.ubDiv).slideDown("fast");
}
$($t.grid.uDiv).slideDown("fast");
}
if($t.p.footerrow) { $(".ui-jqgrid-sdiv","#gbox_"+$.jgrid.jqID($t.p.id)).slideDown("fast"); }
if($t.p.headerrow) { $(".ui-jqgrid-hrdiv","#gbox_"+$.jgrid.jqID($t.p.id)).slideDown("fast"); }
$(".ui-jqgrid-headlink",$t.grid.cDiv).removeClass( close ).addClass( open );
$t.p.gridstate = 'visible';
}
});
},
setFrozenColumns : function () {
return this.each(function() {
if ( !this.grid ) {return;}
var $t = this, cm = $t.p.colModel,i=0, len = cm.length, maxfrozen = -1, frozen= false,
hd= $($t).jqGrid('getStyleUI',$t.p.styleUI+".base",'headerDiv', true, 'ui-jqgrid-hdiv'),
hover = $($t).jqGrid('getStyleUI',$t.p.styleUI+".common",'hover', true),
borderbox = $("#gbox_"+$.jgrid.jqID($t.p.id)).css("box-sizing") === 'border-box',
pixelfix = borderbox ? 1 : 0;
// TODO treeGrid and grouping Support
if($t.p.subGrid === true ||
$t.p.treeGrid === true ||
$t.p.cellEdit === true ||
/*$t.p.sortable ||*/
$t.p.scroll /*||
$t.p.grouping === true*/)
{
return;
}
// get the max index of frozen col
while(i<len)
{
// from left, no breaking frozen
if(cm[i].frozen === true)
{
frozen = true;
maxfrozen = i;
} else {
break;
}
i++;
}
if( maxfrozen>=0 && frozen) {
var top = $t.p.caption ? $($t.grid.cDiv).outerHeight() : 0,
hhrh =0,
hth = parseInt( $(".ui-jqgrid-htable","#gview_"+$.jgrid.jqID($t.p.id)).height(), 10),
divhth = parseInt( $(".ui-jqgrid-hdiv","#gview_"+$.jgrid.jqID($t.p.id)).height(), 10);
var bpos = $(".ui-jqgrid-bdiv","#gview_"+$.jgrid.jqID($t.p.id)).position();
//headers
if($t.p.toppager) {
top = top + $($t.grid.topDiv).outerHeight();
}
if($t.p.toolbar[0] === true) {
if($t.p.toolbar[1] !== "bottom") {
top = top + $($t.grid.uDiv).outerHeight();
}
}
if($t.p.headerrow) {
hhrh = parseInt( $(".ui-jqgrid-hrdiv","#gview_"+$.jgrid.jqID($t.p.id)).height(), 10);
}
$t.grid.fhDiv = $('<div style="position:absolute;' + ($t.p.direction === "rtl" ? 'right:0;' : 'left:0;') + 'top:'+top+'px;height:'+(divhth - pixelfix)+'px;" class="frozen-div ' + hd +'"></div>');
$t.grid.fbDiv = $('<div style="position:absolute;' + ($t.p.direction === "rtl" ? 'right:0;' : 'left:0;') + 'top:'+ bpos.top +'px;overflow-y:hidden" class="frozen-bdiv ui-jqgrid-bdiv"></div>');
$("#gview_"+$.jgrid.jqID($t.p.id)).append($t.grid.fhDiv);
var htbl = $(".ui-jqgrid-htable","#gview_"+$.jgrid.jqID($t.p.id)).clone(true),
fthh = null;
// groupheader support - only if useColSpanstyle is false
if( $($t).jqGrid('isGroupHeaderOn') ) {
fthh = $("tr.jqg-third-row-header", $t.grid.hDiv).height();
$("tr.jqg-first-row-header, tr.jqg-third-row-header", htbl).each(function(){
$("th:gt("+maxfrozen+")",this).remove();
});
var swapfroz = -1, fdel = -1, cs, rs;
$("tr.jqg-second-row-header th", htbl).each(function(){
cs= parseInt($(this).attr("colspan"),10);
rs= parseInt($(this).attr("rowspan"),10);
if(rs) {
swapfroz++;
fdel++;
}
if(cs) {
swapfroz = swapfroz+cs;
fdel++;
}
if(swapfroz === maxfrozen) {
fdel = maxfrozen;
return false;
}
});
if(swapfroz !== maxfrozen) {
fdel = maxfrozen;
}
$("tr.jqg-second-row-header", htbl).each(function(){
$("th:gt("+fdel+")",this).remove();
});
} else {
var maxdh=[];
$(".ui-jqgrid-htable tr","#gview_"+$.jgrid.jqID($t.p.id)).each(function(i,n){
maxdh.push(parseInt($(this).height(),10));
});
$("tr",htbl).each(function(){
$("th:gt("+maxfrozen+")",this).remove();
});
$("tr",htbl).each(function(i){
$(this).height(maxdh[i]);
});
}
if($("tr.jqg-second-row-header th:eq(0)", htbl).text() === 0) {
$("tr.jqg-second-row-header th:eq(0)", htbl).prepend(' ');
}
if( $.trim($("tr.jqg-third-row-header th:eq(0)", htbl).text()) === "") {
$("tr.jqg-third-row-header th:eq(0) div", htbl).prepend(' ');
}
if( fthh ) {
$("tr.jqg-third-row-header th:eq(0)", htbl).height(fthh);
}
$(htbl).width(1);
if(!$.jgrid.msie()) {
$(htbl).css("height","100%");
}
// resizing stuff
$($t.grid.fhDiv).append(htbl)
.mousemove(function (e) {
if($t.grid.resizing){ $t.grid.dragMove(e);return false; }
});
if($t.p.headerrow) {
$t.grid.fhrDiv = $('<div style="position:absolute;' + ($t.p.direction === "rtl" ? 'right:0;' : 'left:0;') + 'top:'+ (parseInt(top,10)+ parseInt(divhth,10) + 1 - pixelfix)+'px;height:'+(divhth - pixelfix)+'px;" class="frozen-hrdiv ui-jqgrid-hrdiv "></div>');
$("#gview_"+$.jgrid.jqID($t.p.id)).append($t.grid.fhrDiv);
var hrtbl = $(".ui-jqgrid-hrtable","#gview_"+$.jgrid.jqID($t.p.id)).clone(true);
$("tr",hrtbl).each(function(){
$("td:gt("+maxfrozen+")",this).remove();
});
$(hrtbl).width(1);
$($t.grid.fhrDiv).append(hrtbl);
}
if($t.p.footerrow) {
var hbd = $(".ui-jqgrid-bdiv","#gview_"+$.jgrid.jqID($t.p.id)).height();
$t.grid.fsDiv = $('<div style="position:absolute;left:0px;top:'+(parseInt(top,10)+parseInt(hth,10) + parseInt(hbd,10) + 1 - pixelfix + parseInt(hhrh,10))+'px;" class="frozen-sdiv ui-jqgrid-sdiv"></div>');
$("#gview_"+$.jgrid.jqID($t.p.id)).append($t.grid.fsDiv);
var ftbl = $(".ui-jqgrid-ftable","#gview_"+$.jgrid.jqID($t.p.id)).clone(true);
$("tr",ftbl).each(function(){
$("td:gt("+maxfrozen+")",this).remove();
});
$(ftbl).width(1);
$($t.grid.fsDiv).append(ftbl);
}
// data stuff
//TODO support for setRowData
$("#gview_"+$.jgrid.jqID($t.p.id)).append($t.grid.fbDiv);
$($t.grid.fbDiv).on('mousewheel DOMMouseScroll', function (e) {
var st = $($t.grid.bDiv).scrollTop();
if (e.originalEvent.wheelDelta > 0 || e.originalEvent.detail < 0) {
//up
$($t.grid.bDiv).scrollTop( st - 25 );
} else {
//down
$($t.grid.bDiv).scrollTop( st + 25 );
}
e.preventDefault();
});
if($t.p.hoverrows === true) {
$("#"+$.jgrid.jqID($t.p.id)).off('mouseover mouseout');
}
var hasscroll;
$($t).on('jqGridAfterGridComplete.setFrozenColumns', function () {
$("#"+$.jgrid.jqID($t.p.id)+"_frozen").remove();
hasscroll = parseInt($($t.grid.bDiv)[0].scrollWidth,10) > parseInt($($t.grid.bDiv)[0].clientWidth,10);
$($t.grid.fbDiv).height( $($t.grid.bDiv)[0].clientHeight - (hasscroll ? 0 : $t.p.scrollOffset-3));
// find max height
var mh = [];
$("#"+$.jgrid.jqID($t.p.id) + " tr[role=row].jqgrow").each(function(){
mh.push( $(this).height() );
});
var btbl = $("#"+$.jgrid.jqID($t.p.id)).clone(true);
$("tr[role=row]",btbl).each(function(){
$("td[role=gridcell]:gt("+maxfrozen+")",this).remove();
});
$(btbl).width(1).attr("id",$t.p.id+"_frozen");
$($t.grid.fbDiv).append(btbl);
// set the height
$("tr[role=row].jqgrow",btbl).each(function(i, n){
$(this).height( mh[i] );
});
if($t.rows[1].id === 'norecs') {
$("#norecs td", btbl).html("");
}
if($t.p.hoverrows === true) {
$("tr.jqgrow", btbl).hover(
function(){
$(this).addClass( hover );
$("#"+$.jgrid.jqID(this.id), "#"+$.jgrid.jqID($t.p.id)).addClass( hover );
},function(){
$(this).removeClass( hover );
$("#"+$.jgrid.jqID(this.id), "#"+$.jgrid.jqID($t.p.id)).removeClass( hover );
}
);
$("tr.jqgrow", "#"+$.jgrid.jqID($t.p.id)).hover(
function(){
$(this).addClass( hover );
$("#"+$.jgrid.jqID(this.id), "#"+$.jgrid.jqID($t.p.id)+"_frozen").addClass( hover );
},
function(){
$(this).removeClass( hover );
$("#"+$.jgrid.jqID(this.id), "#"+$.jgrid.jqID($t.p.id)+"_frozen").removeClass( hover );
}
);
}
//btbl=null;
});
if(!$t.grid.hDiv.loading) {
$($t).triggerHandler("jqGridAfterGridComplete");
}
$t.p.frozenColumns = true;
}
});
},
destroyFrozenColumns : function() {
return this.each(function() {
if ( !this.grid ) {return;}
if(this.p.frozenColumns === true) {
var $t = this,
hover = $($t).jqGrid('getStyleUI',$t.p.styleUI+".common",'hover', true);
$($t.grid.fhDiv).remove();
$($t.grid.fbDiv).remove();
$t.grid.fhDiv = null; $t.grid.fbDiv=null;
if($t.p.footerrow) {
$($t.grid.fsDiv).remove();
$t.grid.fsDiv = null;
}
if($t.p.headerrow) {
$($t.grid.fhrDiv).remove();
$t.grid.fhrDiv = null;
}
$(this).off('.setFrozenColumns');
if($t.p.hoverrows === true) {
var ptr;
$("#"+$.jgrid.jqID($t.p.id)).on({
'mouseover': function(e) {
ptr = $(e.target).closest("tr.jqgrow");
if($(ptr).attr("class") !== "ui-subgrid") {
$(ptr).addClass( hover );
}
},
'mouseout' : function(e) {
ptr = $(e.target).closest("tr.jqgrow");
$(ptr).removeClass( hover );
}
});
}
this.p.frozenColumns = false;
}
});
},
resizeColumn : function (iCol, newWidth, forceresize) {
return this.each(function() {
var grid = this.grid, p = this.p,
cm = p.colModel, i, cmLen = cm.length, diff, diffnv;
if(typeof iCol === "string" ) {
for(i = 0; i < cmLen; i++) {
if(cm[i].name === iCol) {
iCol = i;
break;
}
}
} else {
iCol = parseInt( iCol, 10 );
}
if(forceresize === undefined) {
forceresize = false;
}
if( !cm[iCol].resizable && !forceresize ) {
return;
}
newWidth = parseInt( newWidth, 10);
// filters
if(typeof iCol !== "number" || iCol < 0 || iCol > cm.length-1 || typeof newWidth !== "number" ) {
return;
}
if( newWidth < p.minColWidth ) { return; }
if( p.forceFit ) {
p.nv = 0;
for (i = iCol+1; i < cmLen; i++){
if(cm[i].hidden !== true ) {
p.nv = i - iCol;
break;
}
}
}
// use resize stuff
grid.resizing = {idx : iCol };
diff = newWidth - grid.headers[iCol].width;
if(p.forceFit) {
diffnv = grid.headers[ iCol + p.nv].width - diff;
if(diffnv < p.minColWidth) { return; }
grid.headers[ iCol + p.nv].newWidth = grid.headers[ iCol + p.nv].width - diff;
}
grid.newWidth = p.tblwidth + diff;
grid.headers[ iCol ].newWidth = newWidth;
grid.dragEnd( false );
});
},
getStyleUI : function( styleui, classui, notclasstag, gridclass) {
var ret = "", q = "";
try {
var stylemod = styleui.split(".");
if(!notclasstag) {
ret = "class=";
q = "\"";
}
if(gridclass == null) {
gridclass = "";
}
switch(stylemod.length) {
case 1 :
ret += q + $.trim(gridclass + " " + $.jgrid.styleUI[stylemod[0]][classui] + q);
break;
case 2 :
ret += q + $.trim(gridclass + " " + $.jgrid.styleUI[stylemod[0]][stylemod[1]][classui] + q);
}
} catch (cls) {
ret = "";
}
return ret;
},
resizeGrid : function (timeout = 500, width = true, height = true) {
return this.each(function(){
var $t = this;
setTimeout(function(){
try {
if(width) {
var wh = $t.p.height,
winwidth = $(window).width(),
parentwidth = $("#gbox_"+$.jgrid.jqID($t.p.id)).parent().width(),
ww = $t.p.width;
if( (winwidth-parentwidth) > 3 ) {
ww = parentwidth;
} else {
ww = winwidth;
}
$("#"+$.jgrid.jqID($t.p.id)).jqGrid('setGridWidth', ww);
}
if(height) {
var bstw = $t.p.styleUI.search('Bootstrap') !== -1 && !isNaN($t.p.height) ? 2 : 0,
winheight = $(window).height(),
parentheight = $("#gbox_"+$.jgrid.jqID($t.p.id)).parent().height();
if( (winheight-parentheight) > 3 ) {
wh = parentheight;
} else {
wh = winheight;
}
$("#"+$.jgrid.jqID($t.p.id)).jqGrid('setGridHeight', wh - bstw, true);
}
} catch(e){}
}, timeout);
});
},
colMenuAdd : function (colname, options ) {
var currstyle = this[0].p.styleUI,
styles = $.jgrid.styleUI[currstyle].colmenu;
options = $.extend({
title: 'Item',
icon : styles.icon_new_item,
funcname: null,
position : "last",
closeOnRun : true,
exclude : "",
id : null
}, options ||{});
return this.each(function(){
options.colname = colname === 'all' ? "_all_" : colname;
var $t = this;
options.id = options.id===null? $.jgrid.randId(): options.id;
$t.p.colMenuCustom[options.id] = options;
});
},
colMenuDelete : function ( id ) {
return this.each(function(){
if(this.p.colMenuCustom.hasOwnProperty( id )) {
delete this.p.colMenuCustom[ id ];
}
});
},
menubarAdd : function( items ) {
var currstyle = this[0].p.styleUI,
styles = $.jgrid.styleUI[currstyle].common, item, str;
return this.each(function(){
var $t = this;
if( $.isArray(items)) {
for(var i = 0; i < items.length; i++) {
item = items[i];
// icon, title, position, id, click
if(!item.id ) {
item.id = $.jgrid.randId();
}
var ico = '';
if( item.icon) {
ico = '<span class="'+styles.icon_base+' ' + item.icon+'"></span>';
}
if(!item.position) {
item.position = 'last';
}
if(!item.closeoncall) {
item.closeoncall = true;
}
if(item.divider) {
str = '<li class="ui-menu-item divider" role="separator"></li>';
item.cick = null;
} else {
str = '<li class="ui-menu-item" role="presentation"><a id="'+ item.id+'" class="g-menu-item" tabindex="0" role="menuitem" ><table class="ui-common-table"><tr><td class="menu_icon">'+ico+'</td><td class="menu_text">'+item.title+'</td></tr></table></a></li>';
}
if(item.position === 'last') {
$("#"+this.p.id+"_menubar").append(str);
} else {
$("#"+this.p.id+"_menubar").prepend(str);
}
}
}
$("li a", "#"+this.p.id+"_menubar").each(function(i,n){
$(items).each(function(j,f){
if(f.id === n.id && $.isFunction(f.click)) {
$(n).on('click', function(e){
f.click.call($t, e);
});
return false;
}
});
$(this).hover(
function(e){
$(this).addClass(styles.hover);
e.stopPropagation();
},
function(e){ $(this).removeClass(styles.hover);}
);
});
});
},
menubarDelete : function( itemid ) {
return this.each(function(){
$("#"+itemid, "#"+this.p.id+"_menubar").remove();
});
}
});
//module begin
$.jgrid.extend({
editCell : function (iRow,iCol, ed, event){
return this.each(function (){
var $t = this, nm, tmp,cc, cm,
highlight = $(this).jqGrid('getStyleUI',$t.p.styleUI+'.common','highlight', true),
hover = $(this).jqGrid('getStyleUI',$t.p.styleUI+'.common','hover', true),
inpclass = $(this).jqGrid('getStyleUI',$t.p.styleUI+".celledit",'inputClass', true);
if (!$t.grid || $t.p.cellEdit !== true) {return;}
iCol = parseInt(iCol,10);
// select the row that can be used for other methods
$t.p.selrow = $t.rows[iRow].id;
if (!$t.p.knv) {$($t).jqGrid("GridNav");}
// check to see if we have already edited cell
if ($t.p.savedRow.length>0) {
// prevent second click on that field and enable selects
if (ed===true ) {
if(iRow == $t.p.iRow && iCol == $t.p.iCol){
return;
}
}
// save the cell
$($t).jqGrid("saveCell",$t.p.savedRow[0].id,$t.p.savedRow[0].ic);
} else {
window.setTimeout(function () { $("#"+$.jgrid.jqID($t.p.knv)).attr("tabindex","-1").focus();},1);
}
cm = $t.p.colModel[iCol];
nm = cm.name;
if (nm==='subgrid' || nm==='cb' || nm==='rn') {return;}
try {
cc = $($t.rows[iRow].cells[iCol]);
} catch(e) {
cc = $("td:eq("+iCol+")",$t.rows[iRow]);
}
if(parseInt($t.p.iCol,10)>=0 && parseInt($t.p.iRow,10)>=0 && $t.p.iRowId !== undefined) {
var therow = $($t).jqGrid('getGridRowById', $t.p.iRowId);
//$("td:eq("+$t.p.iCol+")",$t.rows[$t.p.iRow]).removeClass("edit-cell " + highlight);
$(therow).removeClass("selected-row " + hover).find("td:eq("+$t.p.iCol+")").removeClass("edit-cell " + highlight);
}
cc.addClass("edit-cell " + highlight);
$($t.rows[iRow]).addClass("selected-row " + hover);
if (cm.editable===true && ed===true && !cc.hasClass("not-editable-cell") && (!$.isFunction($t.p.isCellEditable) || $t.p.isCellEditable.call($t,nm,iRow,iCol))) {
try {
tmp = $.unformat.call($t,cc,{rowId: $t.rows[iRow].id, colModel:cm},iCol);
} catch (_) {
tmp = ( cm.edittype && cm.edittype === 'textarea' ) ? cc.text() : cc.html();
}
if($t.p.autoencode) { tmp = $.jgrid.htmlDecode(tmp); }
if (!cm.edittype) {cm.edittype = "text";}
$t.p.savedRow.push({id:iRow, ic:iCol, name:nm, v:tmp, rowId: $t.rows[iRow].id });
if(tmp === " " || tmp === " " || (tmp.length===1 && tmp.charCodeAt(0)===160) ) {tmp='';}
if($.isFunction($t.p.formatCell)) {
var tmp2 = $t.p.formatCell.call($t, $t.rows[iRow].id,nm,tmp,iRow,iCol);
if(tmp2 !== undefined ) {tmp = tmp2;}
}
$($t).triggerHandler("jqGridBeforeEditCell", [$t.rows[iRow].id, nm, tmp, iRow, iCol]);
if ($.isFunction($t.p.beforeEditCell)) {
$t.p.beforeEditCell.call($t, $t.rows[iRow].id,nm,tmp,iRow,iCol);
}
var opt = $.extend({}, cm.editoptions || {} ,{id:iRow+"_"+nm,name:nm,rowId: $t.rows[iRow].id, oper:'edit', module : 'cell'});
var elc = $.jgrid.createEl.call($t,cm.edittype,opt,tmp,true,$.extend({},$.jgrid.ajaxOptions,$t.p.ajaxSelectOptions || {}));
if( $.inArray(cm.edittype, ['text','textarea','password','select']) > -1) {
$(elc).addClass(inpclass);
}
cc.html("").append(elc).attr("tabindex","0");
$.jgrid.bindEv.call($t, elc, opt);
window.setTimeout(function () { $(elc).focus();},1);
$("input, select, textarea",cc).on("keydown",function(e) {
if (e.keyCode === 27) {
if($("input.hasDatepicker",cc).length >0) {
if( $(".ui-datepicker").is(":hidden") ) { $($t).jqGrid("restoreCell",iRow,iCol); }
else { $("input.hasDatepicker",cc).datepicker('hide'); }
} else {
$($t).jqGrid("restoreCell",iRow,iCol);
}
} //ESC
if (e.keyCode === 13 && e.altKey && this.nodeName === "TEXTAREA") {
this.value = this.value + "\r";
return true;
}
if (e.keyCode === 13 && !e.shiftKey) {
$($t).jqGrid("saveCell",iRow,iCol);
// Prevent default action
return false;
} //Enter
if (e.keyCode === 9) {
if(!$t.grid.hDiv.loading ) {
if (e.shiftKey) { //Shift TAb
var succ2 = $($t).jqGrid("prevCell", iRow, iCol, e);
if(!succ2 && $t.p.editNextRowCell) {
if(iRow-1 > 0 && $t.rows[iRow-1]) {
iRow--;
$($t).jqGrid("prevCell", iRow, $t.p.colModel.length, e);
}
}
} else {
var succ = $($t).jqGrid("nextCell", iRow, iCol, e);
if(!succ && $t.p.editNextRowCell) {
if($t.rows[iRow+1]) {
iRow++;
$($t).jqGrid("nextCell", iRow, 0, e);
}
}
} //Tab
} else {
return false;
}
}
e.stopPropagation();
});
$($t).triggerHandler("jqGridAfterEditCell", [$t.rows[iRow].id, nm, tmp, iRow, iCol]);
if ($.isFunction($t.p.afterEditCell)) {
$t.p.afterEditCell.call($t, $t.rows[iRow].id,nm,tmp,iRow,iCol);
}
} else {
tmp = cc.html().replace(/\ \;/ig,'');
$($t).triggerHandler("jqGridCellSelect", [$t.rows[iRow].id, iCol, tmp, event]);
if ($.isFunction($t.p.onCellSelect)) {
$t.p.onCellSelect.call($t, $t.rows[iRow].id, iCol, tmp, event);
}
}
$t.p.iCol = iCol; $t.p.iRow = iRow; $t.p.iRowId = $t.rows[iRow].id;
});
},
saveCell : function (iRow, iCol){
return this.each(function(){
var $t= this, fr = $t.p.savedRow.length >= 1 ? 0 : null,
errors = $.jgrid.getRegional(this, 'errors'),
edit =$.jgrid.getRegional(this, 'edit');
if (!$t.grid || $t.p.cellEdit !== true) {return;}
if(fr !== null) {
var trow = $($t).jqGrid("getGridRowById", $t.p.savedRow[0].rowId),
cc = $('td:eq('+iCol+')', trow),
cm = $t.p.colModel[iCol], nm = cm.name, nmjq = $.jgrid.jqID(nm), v, v2,
p = $(cc).offset();
switch (cm.edittype) {
case "select":
if(!cm.editoptions.multiple) {
v = $("#"+iRow+"_"+nmjq+" option:selected", trow ).val();
v2 = $("#"+iRow+"_"+nmjq+" option:selected", trow).text();
} else {
var sel = $("#"+iRow+"_"+nmjq, trow), selectedText = [];
v = $(sel).val();
if(v) { v.join(",");} else { v=""; }
$("option:selected",sel).each(
function(i,selected){
selectedText[i] = $(selected).text();
}
);
v2 = selectedText.join(",");
}
if(cm.formatter) { v2 = v; }
break;
case "checkbox":
var cbv = ["Yes","No"];
if(cm.editoptions && cm.editoptions.value){
cbv = cm.editoptions.value.split(":");
}
v = $("#"+iRow+"_"+nmjq, trow).is(":checked") ? cbv[0] : cbv[1];
v2=v;
break;
case "password":
case "text":
case "textarea":
case "button" :
v = $("#"+iRow+"_"+nmjq, trow).val();
v2=v;
break;
case 'custom' :
try {
if(cm.editoptions && $.isFunction(cm.editoptions.custom_value)) {
v = cm.editoptions.custom_value.call($t, $(".customelement",cc),'get');
if (v===undefined) { throw "e2";} else { v2=v; }
} else { throw "e1"; }
} catch (e) {
if (e==="e1") { $.jgrid.info_dialog(errors.errcap, "function 'custom_value' " + edit.msg.nodefined, edit.bClose, {styleUI : $t.p.styleUI }); }
else if (e==="e2") { $.jgrid.info_dialog(errors.errcap, "function 'custom_value' " + edit.msg.novalue, edit.bClose, {styleUI : $t.p.styleUI }); }
else {$.jgrid.info_dialog(errors.errcap, e.message, edit.bClose, {styleUI : $t.p.styleUI }); }
}
break;
}
// The common approach is if nothing changed do not do anything
if (v2 !== $t.p.savedRow[fr].v){
var vvv = $($t).triggerHandler("jqGridBeforeSaveCell", [$t.p.savedRow[fr].rowId, nm, v, iRow, iCol]);
if (vvv) {v = vvv; v2=vvv;}
if ($.isFunction($t.p.beforeSaveCell)) {
var vv = $t.p.beforeSaveCell.call($t, $t.p.savedRow[fr].rowId, nm, v, iRow, iCol);
if (vv) {v = vv; v2=vv;}
}
var cv = $.jgrid.checkValues.call($t, v, iCol), nuem = false;
if(cv[0] === true) {
var addpost = $($t).triggerHandler("jqGridBeforeSubmitCell", [$t.p.savedRow[fr].rowId, nm, v, iRow, iCol]) || {};
if ($.isFunction($t.p.beforeSubmitCell)) {
addpost = $t.p.beforeSubmitCell.call($t, $t.p.savedRow[fr].rowId, nm, v, iRow, iCol);
if (!addpost) {addpost={};}
}
var retsub = $($t).triggerHandler("jqGridOnSubmitCell", [$t.p.savedRow[fr].rowId, nm, v, iRow, iCol]);
if(retsub === undefined) {
retsub = true;
}
if($.isFunction($t.p.onSubmitCell) ) {
retsub = $t.p.onSubmitCell($t.p.savedRow[fr].rowId, nm, v, iRow, iCol);
if( retsub === undefined) {
retsub = true;
}
}
if( retsub === false) {
return;
}
if( $("input.hasDatepicker",cc).length >0) { $("input.hasDatepicker",cc).datepicker('hide'); }
if ($t.p.cellsubmit === 'remote') {
if ($t.p.cellurl) {
var postdata = {};
if($t.p.autoencode) { v = $.jgrid.htmlEncode(v); }
if(cm.editoptions && cm.editoptions.NullIfEmpty && v === "") {
v = 'null';
nuem = true;
}
postdata[nm] = v;
var opers = $t.p.prmNames,
idname = opers.id,
oper = opers.oper;
postdata[idname] = $.jgrid.stripPref($t.p.idPrefix, $t.p.savedRow[fr].rowId);
postdata[oper] = opers.editoper;
postdata = $.extend(addpost,postdata);
$($t).jqGrid("progressBar", {method:"show", loadtype : $t.p.loadui, htmlcontent: $.jgrid.getRegional($t,'defaults.savetext') });
$t.grid.hDiv.loading = true;
$.ajax( $.extend( {
url: $t.p.cellurl,
data :$.isFunction($t.p.serializeCellData) ? $t.p.serializeCellData.call($t, postdata, nm) : postdata,
type: "POST",
complete: function (result, stat) {
$($t).jqGrid("progressBar", {method:"hide", loadtype : $t.p.loadui });
$t.grid.hDiv.loading = false;
if (stat === 'success') {
var ret = $($t).triggerHandler("jqGridAfterSubmitCell", [$t, result, postdata[idname], nm, v, iRow, iCol]) || [true, ''];
if (ret[0] === true && $.isFunction($t.p.afterSubmitCell)) {
ret = $t.p.afterSubmitCell.call($t, result, postdata[idname], nm, v, iRow, iCol);
}
if(ret[0] === true){
if(nuem) {
v = "";
}
$(cc).empty();
$($t).jqGrid("setCell",$t.p.savedRow[fr].rowId, iCol, v2, false, false, true);
cc = $('td:eq('+iCol+')', trow);
$(cc).addClass("dirty-cell");
$(trow).addClass("edited");
$($t).triggerHandler("jqGridAfterSaveCell", [$t.p.savedRow[fr].rowId, nm, v, iRow, iCol]);
if ($.isFunction($t.p.afterSaveCell)) {
$t.p.afterSaveCell.call($t, $t.p.savedRow[fr].rowId, nm, v, iRow,iCol);
}
$t.p.savedRow.splice(0,1);
} else {
$($t).triggerHandler("jqGridErrorCell", [result, stat]);
if ($.isFunction($t.p.errorCell)) {
$t.p.errorCell.call($t, result, stat);
} else {
$.jgrid.info_dialog(errors.errcap, ret[1], edit.bClose, {
styleUI : $t.p.styleUI,
top:p.top+30,
left:p.left ,
onClose : function() {
if(!$t.p.restoreCellonFail) {
$("#"+iRow+"_"+nmjq, trow).focus();
}
}
});
}
if( $t.p.restoreCellonFail) {
$($t).jqGrid("restoreCell",iRow,iCol);
}
}
}
},
error:function(res,stat,err) {
$("#lui_"+$.jgrid.jqID($t.p.id)).hide();
$t.grid.hDiv.loading = false;
$($t).triggerHandler("jqGridErrorCell", [res, stat, err]);
if ($.isFunction($t.p.errorCell)) {
$t.p.errorCell.call($t, res,stat,err);
} else {
$.jgrid.info_dialog(errors.errcap, res.status+" : "+res.statusText+"<br/>"+stat, edit.bClose, {
styleUI : $t.p.styleUI,
top:p.top+30,
left:p.left ,
onClose : function() {
if(!$t.p.restoreCellonFail) {
$("#"+iRow+"_"+nmjq, trow).focus();
}
}
});
}
if( $t.p.restoreCellonFail) {
$($t).jqGrid("restoreCell", iRow, iCol);
}
}
}, $.jgrid.ajaxOptions, $t.p.ajaxCellOptions || {}));
} else {
try {
$.jgrid.info_dialog(errors.errcap,errors.nourl, edit.bClose, {styleUI : $t.p.styleUI });
if( $t.p.restoreCellonFail) {
$($t).jqGrid("restoreCell", iRow, iCol);
}
} catch (e) {}
}
}
if ($t.p.cellsubmit === 'clientArray') {
$(cc).empty();
$($t).jqGrid("setCell", $t.p.savedRow[fr].rowId, iCol, v2, false, false, true);
cc = $('td:eq('+iCol+')', trow);
$(cc).addClass("dirty-cell");
$(trow).addClass("edited");
$($t).triggerHandler("jqGridAfterSaveCell", [$t.p.savedRow[fr].rowId, nm, v, iRow, iCol]);
if ($.isFunction($t.p.afterSaveCell)) {
$t.p.afterSaveCell.call($t, $t.p.savedRow[fr].rowId, nm, v, iRow, iCol);
}
$t.p.savedRow.splice(0,1);
}
} else {
try {
if( $.isFunction($t.p.validationCell) ) {
$t.p.validationCell.call($t, $("#"+iRow+"_"+nmjq, trow), cv[1], iRow, iCol);
} else {
window.setTimeout(function(){
$.jgrid.info_dialog(errors.errcap,v+ " " + cv[1], edit.bClose, {
styleUI : $t.p.styleUI,
top:p.top+30,
left:p.left ,
onClose : function() {
if(!$t.p.restoreCellonFail) {
$("#"+iRow+"_"+nmjq, trow).focus();
}
}
});
},50);
if( $t.p.restoreCellonFail) {
$($t).jqGrid("restoreCell", iRow, iCol);
}
}
} catch (e) {
alert(cv[1]);
}
}
} else {
$($t).jqGrid("restoreCell", iRow, iCol);
}
}
window.setTimeout(function () { $("#"+$.jgrid.jqID($t.p.knv)).attr("tabindex","-1").focus();},0);
});
},
restoreCell : function(iRow, iCol) {
return this.each(function(){
var $t= this, fr = $t.p.savedRow.length >= 1 ? 0 : null;
if (!$t.grid || $t.p.cellEdit !== true ) {return;}
if(fr !== null) {
var trow = $($t).jqGrid("getGridRowById", $t.p.savedRow[fr].rowId),
cc = $('td:eq('+iCol+')', trow);
// datepicker fix
if($.isFunction($.fn.datepicker)) {
try {
$("input.hasDatepicker",cc).datepicker('hide');
} catch (e) {}
}
$(cc).empty().attr("tabindex","-1");
$($t).jqGrid("setCell", $t.p.savedRow[0].rowId, iCol, $t.p.savedRow[fr].v, false, false, true);
$($t).triggerHandler("jqGridAfterRestoreCell", [$t.p.savedRow[fr].rowId, $t.p.savedRow[fr].v, iRow, iCol]);
if ($.isFunction($t.p.afterRestoreCell)) {
$t.p.afterRestoreCell.call($t, $t.p.savedRow[fr].rowId, $t.p.savedRow[fr].v, iRow, iCol);
}
$t.p.savedRow.splice(0,1);
}
window.setTimeout(function () { $("#"+$t.p.knv).attr("tabindex","-1").focus();},0);
});
},
nextCell : function (iRow, iCol, event) {
var ret;
this.each(function (){
var $t = this, nCol=false, i;
if (!$t.grid || $t.p.cellEdit !== true) {return;}
// try to find next editable cell
for (i=iCol+1; i<$t.p.colModel.length; i++) {
if ( $t.p.colModel[i].editable ===true && (!$.isFunction($t.p.isCellEditable) || $t.p.isCellEditable.call($t, $t.p.colModel[i].name,iRow,i))) {
nCol = i; break;
}
}
if(nCol !== false) {
ret = true;
$($t).jqGrid("editCell", iRow, nCol, true, event);
} else {
ret = false;
if ($t.p.savedRow.length >0) {
$($t).jqGrid("saveCell",iRow,iCol);
}
}
});
return ret;
},
prevCell : function (iRow, iCol, event) {
var ret;
this.each(function (){
var $t = this, nCol=false, i;
if (!$t.grid || $t.p.cellEdit !== true) {return false;}
// try to find next editable cell
for (i=iCol-1; i>=0; i--) {
if ( $t.p.colModel[i].editable ===true && (!$.isFunction($t.p.isCellEditable) || $t.p.isCellEditable.call($t, $t.p.colModel[i].name, iRow,i))) {
nCol = i;
break;
}
}
if(nCol !== false) {
ret = true;
$($t).jqGrid("editCell", iRow, nCol, true, event);
} else {
ret = false;
if ($t.p.savedRow.length >0) {
$($t).jqGrid("saveCell",iRow,iCol);
}
}
});
return ret;
},
GridNav : function() {
return this.each(function () {
var $t = this;
if (!$t.grid || $t.p.cellEdit !== true ) {return;}
// trick to process keydown on non input elements
$t.p.knv = $t.p.id + "_kn";
var selection = $("<div style='position:fixed;top:0px;width:1px;height:1px;' tabindex='0'><div tabindex='-1' style='width:1px;height:1px;' id='"+$t.p.knv+"'></div></div>"),
i, kdir;
function scrollGrid(iR, iC, tp){
if (tp.substr(0,1)==='v') {
var ch = $($t.grid.bDiv)[0].clientHeight,
st = $($t.grid.bDiv)[0].scrollTop,
nROT = $t.rows[iR].offsetTop+$t.rows[iR].clientHeight,
pROT = $t.rows[iR].offsetTop;
if(tp === 'vd') {
if(nROT >= ch) {
$($t.grid.bDiv)[0].scrollTop = $($t.grid.bDiv)[0].scrollTop + $t.rows[iR].clientHeight;
}
}
if(tp === 'vu'){
if (pROT < st ) {
$($t.grid.bDiv)[0].scrollTop = $($t.grid.bDiv)[0].scrollTop - $t.rows[iR].clientHeight;
}
}
}
if(tp==='h') {
var cw = $($t.grid.bDiv)[0].clientWidth,
sl = $($t.grid.bDiv)[0].scrollLeft,
nCOL = $t.rows[iR].cells[iC].offsetLeft+$t.rows[iR].cells[iC].clientWidth,
pCOL = $t.rows[iR].cells[iC].offsetLeft;
if(nCOL >= cw+parseInt(sl,10)) {
$($t.grid.bDiv)[0].scrollLeft = $($t.grid.bDiv)[0].scrollLeft + $t.rows[iR].cells[iC].clientWidth;
} else if (pCOL < sl) {
$($t.grid.bDiv)[0].scrollLeft = $($t.grid.bDiv)[0].scrollLeft - $t.rows[iR].cells[iC].clientWidth;
}
}
}
function findNextVisible(iC,act){
var ind, i;
if(act === 'lft') {
ind = iC+1;
for (i=iC;i>=0;i--){
if ($t.p.colModel[i].hidden !== true) {
ind = i;
break;
}
}
}
if(act === 'rgt') {
ind = iC-1;
for (i=iC; i<$t.p.colModel.length;i++){
if ($t.p.colModel[i].hidden !== true) {
ind = i;
break;
}
}
}
return ind;
}
$(selection).insertBefore($t.grid.cDiv);
$("#"+$t.p.knv)
.focus()
.keydown(function (e){
kdir = e.keyCode;
if($t.p.direction === "rtl") {
if(kdir===37) { kdir = 39;}
else if (kdir===39) { kdir = 37; }
}
switch (kdir) {
case 38:
if ($t.p.iRow-1 >0 ) {
scrollGrid($t.p.iRow-1,$t.p.iCol,'vu');
$($t).jqGrid("editCell",$t.p.iRow-1,$t.p.iCol,false,e);
}
break;
case 40 :
if ($t.p.iRow+1 <= $t.rows.length-1) {
scrollGrid($t.p.iRow+1,$t.p.iCol,'vd');
$($t).jqGrid("editCell",$t.p.iRow+1,$t.p.iCol,false,e);
}
break;
case 37 :
if ($t.p.iCol -1 >= 0) {
i = findNextVisible($t.p.iCol-1,'lft');
scrollGrid($t.p.iRow, i,'h');
$($t).jqGrid("editCell",$t.p.iRow, i,false,e);
}
break;
case 39 :
if ($t.p.iCol +1 <= $t.p.colModel.length-1) {
i = findNextVisible($t.p.iCol+1,'rgt');
scrollGrid($t.p.iRow,i,'h');
$($t).jqGrid("editCell",$t.p.iRow,i,false,e);
}
break;
case 13:
if (parseInt($t.p.iCol,10)>=0 && parseInt($t.p.iRow,10)>=0) {
$($t).jqGrid("editCell",$t.p.iRow,$t.p.iCol,true,e);
}
break;
default :
return true;
}
return false;
});
});
},
getChangedCells : function (mthd) {
var ret=[];
if (!mthd) {mthd='all';}
this.each(function(){
var $t= this,nm;
if (!$t.grid || $t.p.cellEdit !== true ) {return;}
$($t.rows).each(function(j){
var res = {};
if ($(this).hasClass("edited")) {
$('td',this).each( function(i) {
nm = $t.p.colModel[i].name;
if ( nm !== 'cb' && nm !== 'subgrid') {
if (mthd==='dirty') {
if ($(this).hasClass('dirty-cell')) {
try {
res[nm] = $.unformat.call($t,this,{rowId:$t.rows[j].id, colModel:$t.p.colModel[i]},i);
} catch (e){
res[nm] = $.jgrid.htmlDecode($(this).html());
}
}
} else {
try {
res[nm] = $.unformat.call($t,this,{rowId:$t.rows[j].id,colModel:$t.p.colModel[i]},i);
} catch (e) {
res[nm] = $.jgrid.htmlDecode($(this).html());
}
}
}
});
res.id = this.id;
ret.push(res);
}
});
});
return ret;
}
/// end cell editing
});
//module begin
$.extend($.jgrid,{
// Modal functions
showModal : function(h) {
h.w.show();
},
closeModal : function(h) {
h.w.hide().attr("aria-hidden","true");
if(h.o) {h.o.remove();}
},
hideModal : function (selector,o) {
o = $.extend({jqm : true, gb :'', removemodal: false, formprop: false, form : ''}, o || {});
var thisgrid = o.gb && typeof o.gb === "string" && o.gb.substr(0,6) === "#gbox_" ? $("#" + o.gb.substr(6))[0] : false;
if(o.onClose) {
var oncret = thisgrid ? o.onClose.call(thisgrid, selector) : o.onClose(selector);
if (typeof oncret === 'boolean' && !oncret ) { return; }
}
if( o.formprop && thisgrid && o.form) {
var fh = $(selector)[0].style.height,
fw = $(selector)[0].style.width;
if(fh.indexOf("px") > -1 ) {
fh = parseFloat(fh);
}
if(fw.indexOf("px") > -1 ) {
fw = parseFloat(fw);
}
var frmgr, frmdata;
if(o.form==='edit'){
frmgr = '#' +$.jgrid.jqID("FrmGrid_"+ o.gb.substr(6));
frmdata = "formProp";
} else if( o.form === 'view') {
frmgr = '#' +$.jgrid.jqID("ViewGrid_"+ o.gb.substr(6));
frmdata = "viewProp";
}
$(thisgrid).data(frmdata, {
top:parseFloat($(selector).css("top")),
left : parseFloat($(selector).css("left")),
width : fw,
height : fh,
dataheight : $(frmgr).height(),
datawidth: $(frmgr).width()
});
}
if ($.fn.jqm && o.jqm === true) {
$(selector).attr("aria-hidden","true").jqmHide();
} else {
if(o.gb !== '') {
try {$(".jqgrid-overlay:first",o.gb).hide();} catch (e){}
}
try { $(".jqgrid-overlay-modal").hide(); } catch (e) {}
$(selector).hide().attr("aria-hidden","true");
}
if( o.removemodal ) {
$(selector).remove();
}
},
//Helper functions
findPos : function(obj) {
var offset = $(obj).offset();
return [offset.left,offset.top];
},
createModal : function(aIDs, content, p, insertSelector, posSelector, appendsel, css) {
p = $.extend(true, {}, $.jgrid.jqModal || {}, p);
var self = this,
rtlsup = $(p.gbox).attr("dir") === "rtl" ? true : false,
classes = $.jgrid.styleUI[(p.styleUI || 'jQueryUI')].modal,
common = $.jgrid.styleUI[(p.styleUI || 'jQueryUI')].common,
mw = document.createElement('div');
css = $.extend({}, css || {});
mw.className= "ui-jqdialog " + classes.modal;
mw.id = aIDs.themodal;
var mh = document.createElement('div');
mh.className = "ui-jqdialog-titlebar " + classes.header;
mh.id = aIDs.modalhead;
$(mh).append("<span class='ui-jqdialog-title'>"+p.caption+"</span>");
var ahr= $("<a class='ui-jqdialog-titlebar-close "+common.cornerall+"'></a>")
.hover(function(){ahr.addClass(common.hover);},
function(){ahr.removeClass(common.hover);})
.append("<span class='" + common.icon_base+" " + classes.icon_close + "'></span>");
$(mh).append(ahr);
if(rtlsup) {
mw.dir = "rtl";
$(".ui-jqdialog-title",mh).css("float","right");
$(".ui-jqdialog-titlebar-close",mh).css("left",0.3+"em");
} else {
mw.dir = "ltr";
$(".ui-jqdialog-title",mh).css("float","left");
$(".ui-jqdialog-titlebar-close",mh).css("right",0.3+"em");
}
var mc = document.createElement('div');
$(mc).addClass("ui-jqdialog-content " + classes.content).attr("id",aIDs.modalcontent);
$(mc).append(content);
mw.appendChild(mc);
$(mw).prepend(mh);
if(appendsel===true) {
$('body').append(mw);
} //append as first child in body -for alert dialog
else if (typeof appendsel === "string") {
$(appendsel).append(mw);
} else {
$(mw).insertBefore(insertSelector);
}
$(mw).css(css);
if(p.jqModal === undefined) {p.jqModal = true;} // internal use
var coord = {};
if ( $.fn.jqm && p.jqModal === true) {
if(p.left ===0 && p.top===0 && p.overlay) {
var pos = [];
pos = $.jgrid.findPos(posSelector);
p.left = pos[0] + 4;
p.top = pos[1] + 4;
}
coord.top = p.top+"px";
coord.left = p.left;
} else if(p.left !==0 || p.top!==0) {
coord.left = p.left;
coord.top = p.top+"px";
}
$("a.ui-jqdialog-titlebar-close",mh).click(function(){
var oncm = $("#"+$.jgrid.jqID(aIDs.themodal)).data("onClose") || p.onClose;
var gboxclose = $("#"+$.jgrid.jqID(aIDs.themodal)).data("gbox") || p.gbox;
self.hideModal("#"+$.jgrid.jqID(aIDs.themodal),{gb:gboxclose,jqm:p.jqModal,onClose:oncm, removemodal: p.removemodal || false, formprop : !p.recreateForm || false, form: p.form || ''});
return false;
});
if (p.width === 0 || !p.width) {p.width = 300;}
if(p.height === 0 || !p.height) {p.height =200;}
if(!p.zIndex) {
var parentZ = $(insertSelector).parents("*[role=dialog]").filter(':first').css("z-index");
if(parentZ) {
p.zIndex = parseInt(parentZ,10)+2;
} else {
p.zIndex = 950;
}
}
var rtlt = 0;
if( rtlsup && coord.hasOwnProperty('left') && !appendsel) {
rtlt = $(p.gbox).outerWidth()- (!isNaN(p.width) ? parseInt(p.width,10) :0) + 12;// to do
// just in case
coord.left = parseInt(coord.left,10) + parseInt(rtlt,10);
}
if(coord.hasOwnProperty('left')) {
coord.left += "px";
}
$(mw).css($.extend({
width: isNaN(p.width) ? "auto": p.width+"px",
height:isNaN(p.height) ? "auto" : p.height + "px",
zIndex:p.zIndex,
overflow: 'hidden'
},coord))
.attr({tabIndex: "-1","role":"dialog","aria-labelledby":aIDs.modalhead,"aria-hidden":"true"});
if(p.drag === undefined) { p.drag=true;}
if(p.resize === undefined) {p.resize=true;}
if (p.drag) {
$(mh).css('cursor','move');
if($.fn.tinyDraggable) {
//$(mw).jqDrag(mh);
$(mw).tinyDraggable({ handle:"#"+$.jgrid.jqID(mh.id) });
} else {
try {
$(mw).draggable({handle: $("#"+$.jgrid.jqID(mh.id))});
} catch (e) {}
}
}
if(p.resize) {
if($.fn.jqResize) {
$(mw).append("<div class='jqResize "+classes.resizable+" "+common.icon_base + " " +classes.icon_resizable+"'></div>");
$("#"+$.jgrid.jqID(aIDs.themodal)).jqResize(".jqResize",aIDs.scrollelm ? "#"+$.jgrid.jqID(aIDs.scrollelm) : false);
} else {
try {
$(mw).resizable({handles: 'se, sw',alsoResize: aIDs.scrollelm ? "#"+$.jgrid.jqID(aIDs.scrollelm) : false});
} catch (r) {}
}
}
if(p.closeOnEscape === true){
$(mw).keydown( function( e ) {
if( e.which === 27 ) {
var cone = $("#"+$.jgrid.jqID(aIDs.themodal)).data("onClose") || p.onClose;
self.hideModal("#"+$.jgrid.jqID(aIDs.themodal),{gb:p.gbox,jqm:p.jqModal,onClose: cone, removemodal: p.removemodal || false, formprop : !p.recreateForm || false, form: p.form || ''});
}
});
}
},
viewModal : function (selector,o){
o = $.extend({
toTop: true,
overlay: 10,
modal: false,
overlayClass : 'ui-widget-overlay', // to be fixed
onShow: $.jgrid.showModal,
onHide: $.jgrid.closeModal,
gbox: '',
jqm : true,
jqM : true
}, o || {});
var style="";
if(o.gbox) {
var grid = $("#"+o.gbox.substring(6))[0];
try {
style = $(grid).jqGrid('getStyleUI', grid.p.styleUI+'.common','overlay', false, 'jqgrid-overlay-modal');
o.overlayClass = $(grid).jqGrid('getStyleUI', grid.p.styleUI+'.common','overlay', true);
} catch (em){}
}
if(o.focusField === undefined) {
o.focusField = 0;
}
if(typeof o.focusField === "number" && o.focusField >= 0 ) {
o.focusField = parseInt(o.focusField,10);
} else if(typeof o.focusField === "boolean" && !o.focusField) {
o.focusField = false;
} else {
o.focusField = 0;
}
if ($.fn.jqm && o.jqm === true) {
if(o.jqM) { $(selector).attr("aria-hidden","false").jqm(o).jqmShow(); }
else {$(selector).attr("aria-hidden","false").jqmShow();}
} else {
if(o.gbox !== '') {
var zInd = parseInt($(selector).css("z-index")) - 1;
if(o.modal) {
if(!$(".jqgrid-overlay-modal")[0] ) {
$('body').prepend("<div "+style+"></div>" );
}
$(".jqgrid-overlay-modal").css("z-index",zInd).show();
} else {
$(".jqgrid-overlay:first",o.gbox).css("z-index",zInd).show();
$(selector).data("gbox",o.gbox);
}
}
$(selector).show().attr("aria-hidden","false");
if(o.focusField >= 0) {
try{$(':input:visible',selector)[o.focusField].focus();}catch(_){}
}
}
},
info_dialog : function(caption, content,c_b, modalopt) {
var mopt = {
width:290,
height:'auto',
dataheight: 'auto',
drag: true,
resize: false,
left:250,
top:170,
zIndex : 1000,
jqModal : true,
modal : false,
closeOnEscape : true,
align: 'center',
buttonalign : 'center',
buttons : []
// {text:'textbutt', id:"buttid", onClick : function(){...}}
// if the id is not provided we set it like info_button_+ the index in the array - i.e info_button_0,info_button_1...
};
$.extend(true, mopt, $.jgrid.jqModal || {}, {caption:"<b>"+caption+"</b>"}, modalopt || {});
var jm = mopt.jqModal, self = this,
classes = $.jgrid.styleUI[(mopt.styleUI || 'jQueryUI')].modal,
common = $.jgrid.styleUI[(mopt.styleUI || 'jQueryUI')].common;
if($.fn.jqm && !jm) { jm = false; }
// in case there is no jqModal
var buttstr ="", i;
if(mopt.buttons.length > 0) {
for(i=0;i<mopt.buttons.length;i++) {
if(mopt.buttons[i].id === undefined) { mopt.buttons[i].id = "info_button_"+i; }
buttstr += "<a id='"+mopt.buttons[i].id+"' class='fm-button " + common.button+"'>"+mopt.buttons[i].text+"</a>";
}
}
var dh = isNaN(mopt.dataheight) ? mopt.dataheight : mopt.dataheight+"px",
cn = "text-align:"+mopt.align+";";
var cnt = "<div id='info_id'>";
cnt += "<div id='infocnt' style='margin:0px;padding-bottom:1em;width:100%;overflow:auto;position:relative;height:"+dh+";"+cn+"'>"+content+"</div>";
cnt += c_b ? "<div class='" + classes.content + "' style='text-align:"+mopt.buttonalign+";padding-bottom:0.8em;padding-top:0.5em;background-image: none;border-width: 1px 0 0 0;'><a id='closedialog' class='fm-button " + common.button + "'>"+c_b+"</a>"+buttstr+"</div>" :
buttstr !== "" ? "<div class='" + classes.content + "' style='text-align:"+mopt.buttonalign+";padding-bottom:0.8em;padding-top:0.5em;background-image: none;border-width: 1px 0 0 0;'>"+buttstr+"</div>" : "";
cnt += "</div>";
try {
if($("#info_dialog").attr("aria-hidden") === "false") {
$.jgrid.hideModal("#info_dialog",{jqm:jm});
}
$("#info_dialog").remove();
} catch (e){}
var fs = $('.ui-jqgrid').css('font-size') || '11px';
$.jgrid.createModal({
themodal:'info_dialog',
modalhead:'info_head',
modalcontent:'info_content',
scrollelm: 'infocnt'},
cnt,
mopt,
'','',true,
{ "font-size":fs}
);
// attach onclick after inserting into the dom
if(buttstr) {
$.each(mopt.buttons,function(i){
$("#"+$.jgrid.jqID(this.id),"#info_id").on('click',function(){mopt.buttons[i].onClick.call($("#info_dialog")); return false;});
});
}
$("#closedialog", "#info_id").on('click',function(){
self.hideModal("#info_dialog",{
jqm:jm,
onClose: $("#info_dialog").data("onClose") || mopt.onClose,
gb: $("#info_dialog").data("gbox") || mopt.gbox
});
return false;
});
$(".fm-button","#info_dialog").hover(
function(){$(this).addClass(common.hover);},
function(){$(this).removeClass(common.hover);}
);
if($.isFunction(mopt.beforeOpen) ) { mopt.beforeOpen(); }
$.jgrid.viewModal("#info_dialog",{
onHide: function(h) {
h.w.hide().remove();
if(h.o) { h.o.remove(); }
},
modal :mopt.modal,
jqm:jm
});
if($.isFunction(mopt.afterOpen) ) { mopt.afterOpen(); }
try{ $("#info_dialog").focus();} catch (m){}
},
bindEv: function (el, opt) {
var $t = this;
if($.isFunction(opt.dataInit)) {
opt.dataInit.call($t,el,opt);
}
if(opt.dataEvents) {
$.each(opt.dataEvents, function() {
if (this.data !== undefined) {
$(el).on(this.type, this.data, this.fn);
} else {
$(el).on(this.type, this.fn);
}
});
}
},
// Form Functions
createEl : function(eltype,options,vl,autowidth, ajaxso) {
var elem = "", $t = this;
function setAttributes(elm, atr, exl ) {
var exclude = ['dataInit','dataEvents','dataUrl', 'buildSelect','sopt', 'searchhidden', 'defaultValue', 'attr', 'custom_element', 'custom_value', 'oper'];
exclude = exclude.concat(['cacheUrlData','delimiter','separator']);
if(exl !== undefined && $.isArray(exl)) {
$.merge(exclude, exl);
}
$.each(atr, function(key, value){
if($.inArray(key, exclude) === -1) {
$(elm).attr(key,value);
}
});
if(!atr.hasOwnProperty('id')) {
$(elm).attr('id', $.jgrid.randId());
}
}
switch (eltype)
{
case "textarea" :
elem = document.createElement("textarea");
if(autowidth) {
if(!options.cols) { $(elem).css({width:"98%"});}
} else if (!options.cols) { options.cols = 20; }
if(!options.rows) { options.rows = 2; }
if(vl===' ' || vl===' ' || (vl.length===1 && vl.charCodeAt(0)===160)) {vl="";}
elem.value = vl;
$(elem).attr({"role":"textbox","multiline":"true"});
setAttributes(elem, options);
break;
case "checkbox" : //what code for simple checkbox
elem = document.createElement("input");
elem.type = "checkbox";
if( !options.value ) {
var vl1 = (vl+"").toLowerCase();
if(vl1.search(/(false|f|0|no|n|off|undefined)/i)<0 && vl1!=="") {
elem.checked=true;
elem.defaultChecked=true;
elem.value = vl;
} else {
elem.value = "on";
}
$(elem).attr("offval","off");
} else {
var cbval = options.value.split(":");
if(vl === cbval[0]) {
elem.checked=true;
elem.defaultChecked=true;
}
elem.value = cbval[0];
$(elem).attr("offval",cbval[1]);
}
$(elem).attr("role","checkbox");
setAttributes(elem, options, ['value']);
break;
case "select" :
elem = document.createElement("select");
elem.setAttribute("role","select");
var msl, ovm = [];
if(options.multiple===true) {
msl = true;
elem.multiple="multiple";
$(elem).attr("aria-multiselectable","true");
} else { msl = false; }
if(options.dataUrl != null) {
var rowid = null, postData = options.postData || ajaxso.postData;
try {
rowid = options.rowId;
} catch(e) {}
if ($t.p && $t.p.idPrefix) {
rowid = $.jgrid.stripPref($t.p.idPrefix, rowid);
}
$.ajax($.extend({
url: $.isFunction(options.dataUrl) ? options.dataUrl.call($t, rowid, vl, String(options.name)) : options.dataUrl,
type : "GET",
dataType: "html",
data: $.isFunction(postData) ? postData.call($t, rowid, vl, String(options.name)) : postData,
context: {elem:elem, options:options, vl:vl},
success: function(data){
var ovm = [], elem = this.elem, vl = this.vl,
options = $.extend({},this.options),
msl = options.multiple===true,
cU = options.cacheUrlData === true,
oV ='', txt, mss =[],
a = $.isFunction(options.buildSelect) ? options.buildSelect.call($t,data) : data;
if(typeof a === 'string') {
a = $( $.trim( a ) ).html();
}
if(a) {
$(elem).append(a);
setAttributes(elem, options, postData ? ['postData'] : undefined );
if(options.size === undefined) { options.size = msl ? 3 : 1;}
if(msl) {
ovm = vl.split(",");
ovm = $.map(ovm,function(n){return $.trim(n);});
} else {
ovm[0] = $.trim(vl);
}
//$(elem).attr(options);
//setTimeout(function(){
$("option",elem).each(function(i){
txt = $(this).text();
vl = $(this).val();
if(cU) {
oV += (i!== 0 ? ";": "")+ vl+":"+txt;
}
//if(i===0) { this.selected = ""; }
// fix IE8/IE7 problem with selecting of the first item on multiple=true
if (i === 0 && elem.multiple) { this.selected = false; }
$(this).attr("role","option");
if($.inArray($.trim(txt),ovm) > -1 || $.inArray($.trim(vl),ovm) > -1 ) {
this.selected= "selected";
mss.push(vl);
}
});
if( options.hasOwnProperty('checkUpdate') ) {
if (options.checkUpdate) {
$t.p.savedData[options.name] = mss.join(",");
}
}
if(cU) {
if(options.oper === 'edit') {
$($t).jqGrid('setColProp',options.name,{ editoptions: {buildSelect: null, dataUrl : null, value : oV} });
} else if(options.oper === 'search') {
$($t).jqGrid('setColProp',options.name,{ searchoptions: {dataUrl : null, value : oV} });
} else if(options.oper ==='filter') {
if($("#fbox_"+$t.p.id)[0].p) {
var cols = $("#fbox_"+$t.p.id)[0].p.columns, nm;
$.each(cols,function(i) {
nm = this.index || this.name;
if(options.name === nm) {
this.searchoptions.dataUrl = null;
this.searchoptions.value = oV;
return false;
}
});
}
}
}
$($t).triggerHandler("jqGridAddEditAfterSelectUrlComplete", [elem]);
//},0);
}
}
},ajaxso || {}));
} else if(options.value) {
var i;
if(options.size === undefined) {
options.size = msl ? 3 : 1;
}
if(msl) {
ovm = vl.split(",");
ovm = $.map(ovm,function(n){return $.trim(n);});
}
if(typeof options.value === 'function') { options.value = options.value(); }
var so,sv, ov, oSv, key, value,
sep = options.separator === undefined ? ":" : options.separator,
delim = options.delimiter === undefined ? ";" : options.delimiter;
if(typeof options.value === 'string') {
so = options.value.split(delim);
for(i=0; i<so.length;i++){
sv = so[i].split(sep);
if(sv.length > 2 ) {
sv[1] = $.map(sv,function(n,ii){if(ii>0) { return n;} }).join(sep);
}
ov = document.createElement("option");
ov.setAttribute("role","option");
ov.value = sv[0]; ov.innerHTML = sv[1];
elem.appendChild(ov);
if (!msl && ($.trim(sv[0]) === $.trim(vl) || $.trim(sv[1]) === $.trim(vl))) { ov.selected ="selected"; }
if (msl && ($.inArray($.trim(sv[1]), ovm)>-1 || $.inArray($.trim(sv[0]), ovm)>-1)) {ov.selected ="selected";}
}
} else if (Object.prototype.toString.call(options.value) === "[object Array]") {
oSv = options.value;
// array of arrays [[Key, Value], [Key, Value], ...]
for (i=0; i<oSv.length; i++) {
if(oSv[i].length === 2) {
key = oSv[i][0];
value = oSv[i][1];
ov = document.createElement("option");
ov.setAttribute("role","option");
ov.value = key; ov.innerHTML = value;
elem.appendChild(ov);
if (!msl && ( $.trim(key) === $.trim(vl) || $.trim(value) === $.trim(vl)) ) { ov.selected ="selected"; }
if (msl && ($.inArray($.trim(value),ovm)>-1 || $.inArray($.trim(key),ovm)>-1)) { ov.selected ="selected"; }
}
}
} else if (typeof options.value === 'object') {
oSv = options.value;
for (key in oSv) {
if (oSv.hasOwnProperty(key ) ){
ov = document.createElement("option");
ov.setAttribute("role","option");
ov.value = key; ov.innerHTML = oSv[key];
elem.appendChild(ov);
if (!msl && ( $.trim(key) === $.trim(vl) || $.trim(oSv[key]) === $.trim(vl)) ) { ov.selected ="selected"; }
if (msl && ($.inArray($.trim(oSv[key]),ovm)>-1 || $.inArray($.trim(key),ovm)>-1)) { ov.selected ="selected"; }
}
}
}
setAttributes(elem, options, ['value']);
} else {
setAttributes(elem, options );
}
break;
case "image" :
case "file" :
elem = document.createElement("input");
elem.type = eltype;
setAttributes(elem, options);
break;
case "custom" :
elem = document.createElement("span");
try {
if($.isFunction(options.custom_element)) {
var celm = options.custom_element.call($t,vl,options);
if(celm) {
celm = $(celm).addClass("customelement").attr({id:options.id,name:options.name});
$(elem).empty().append(celm);
} else {
throw "e2";
}
} else {
throw "e1";
}
} catch (e) {
var errors = $.jgrid.getRegional($t, 'errors'),
edit =$.jgrid.getRegional($t, 'edit');
if (e==="e1") { $.jgrid.info_dialog(errors.errcap,"function 'custom_element' "+edit.msg.nodefined, edit.bClose, {styleUI : $t.p.styleUI });}
else if (e==="e2") { $.jgrid.info_dialog(errors.errcap,"function 'custom_element' "+edit.msg.novalue,edit.bClose, {styleUI : $t.p.styleUI });}
else { $.jgrid.info_dialog(errors.errcap,typeof e==="string"?e:e.message,edit.bClose, {styleUI : $t.p.styleUI }); }
}
break;
default :
var role;
if(eltype==="button") { role = "button"; }
else { role = "textbox"; } // ???
elem = document.createElement("input");
elem.type = eltype;
elem.value = vl;
if(eltype !== "button"){
if(autowidth) {
if(!options.size) { $(elem).css({width:"96%"}); }
} else if (!options.size) { options.size = 20; }
}
$(elem).attr("role",role);
setAttributes(elem, options);
}
return elem;
},
// Date Validation Javascript
checkDate : function (format, date) {
var daysInFebruary = function(year){
// February has 29 days in any year evenly divisible by four,
// EXCEPT for centurial years which are not also divisible by 400.
return (((year % 4 === 0) && ( year % 100 !== 0 || (year % 400 === 0))) ? 29 : 28 );
},
tsp = {}, sep;
format = format.toLowerCase();
//we search for /,-,. for the date separator
if(format.indexOf("/") !== -1) {
sep = "/";
} else if(format.indexOf("-") !== -1) {
sep = "-";
} else if(format.indexOf(".") !== -1) {
sep = ".";
} else {
sep = "/";
}
format = format.split(sep);
date = date.split(sep);
if (date.length !== 3) { return false; }
var j=-1,yln, dln=-1, mln=-1, i;
for(i=0;i<format.length;i++){
var dv = isNaN(date[i]) ? 0 : parseInt(date[i],10);
tsp[format[i]] = dv;
yln = format[i];
if(yln.indexOf("y") !== -1) { j=i; }
if(yln.indexOf("m") !== -1) { mln=i; }
if(yln.indexOf("d") !== -1) { dln=i; }
}
if (format[j] === "y" || format[j] === "yyyy") {
yln=4;
} else if(format[j] ==="yy"){
yln = 2;
} else {
yln = -1;
}
var daysInMonth = [0,31,29,31,30,31,30,31,31,30,31,30,31],
strDate;
if (j === -1) {
return false;
}
strDate = tsp[format[j]].toString();
if(yln === 2 && strDate.length === 1) {yln = 1;}
if (strDate.length !== yln || (tsp[format[j]]===0 && date[j]!=="00")){
return false;
}
if(mln === -1) {
return false;
}
strDate = tsp[format[mln]].toString();
if (strDate.length<1 || tsp[format[mln]]<1 || tsp[format[mln]]>12){
return false;
}
if(dln === -1) {
return false;
}
strDate = tsp[format[dln]].toString();
if (strDate.length<1 || tsp[format[dln]]<1 || tsp[format[dln]]>31 || (tsp[format[mln]]===2 && tsp[format[dln]]>daysInFebruary(tsp[format[j]])) || tsp[format[dln]] > daysInMonth[tsp[format[mln]]]){
return false;
}
return true;
},
isEmpty : function(val)
{
if (val === undefined || val.match(/^\s+$/) || val === "") {
return true;
}
return false;
},
checkTime : function(time){
// checks only hh:ss (and optional am/pm)
var re = /^(\d{1,2}):(\d{2})([apAP][Mm])?$/,regs;
if(!$.jgrid.isEmpty(time))
{
regs = time.match(re);
if(regs) {
if(regs[3]) {
if(regs[1] < 1 || regs[1] > 12) { return false; }
} else {
if(regs[1] > 23) { return false; }
}
if(regs[2] > 59) {
return false;
}
} else {
return false;
}
}
return true;
},
checkValues : function(val, valref, customobject, nam) {
var edtrul,i, nm, dft, len, g = this, cm = g.p.colModel,
msg = $.jgrid.getRegional(this, 'edit.msg'), fmtdate,
isNum = function(vn) {
var vn = vn.toString();
if(vn.length >= 2) {
var chkv, dot;
if(vn[0] === "-" ) {
chkv = vn[1];
if(vn[2]) { dot = vn[2];}
} else {
chkv = vn[0];
if(vn[1]) { dot = vn[1];}
}
if( chkv === "0" && dot !== ".") {
return false; //octal
}
}
return typeof parseFloat(vn) === 'number' && isFinite(vn);
};
if(customobject === undefined) {
if(typeof valref==='string'){
for( i =0, len=cm.length;i<len; i++){
if(cm[i].name===valref) {
edtrul = cm[i].editrules;
valref = i;
if(cm[i].formoptions != null) { nm = cm[i].formoptions.label; }
break;
}
}
} else if(valref >=0) {
edtrul = cm[valref].editrules;
}
} else {
edtrul = customobject;
nm = nam===undefined ? "_" : nam;
}
if(edtrul) {
if(!nm) { nm = g.p.colNames != null ? g.p.colNames[valref] : cm[valref].label; }
if(edtrul.required === true) {
if( $.jgrid.isEmpty(val) ) { return [false,nm+": "+msg.required,""]; }
}
// force required
var rqfield = edtrul.required === false ? false : true;
if(edtrul.number === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(!isNum(val)) { return [false,nm+": "+msg.number,""]; }
}
}
if(edtrul.minValue !== undefined && !isNaN(edtrul.minValue)) {
if (parseFloat(val) < parseFloat(edtrul.minValue) ) { return [false,nm+": "+msg.minValue+" "+edtrul.minValue,""];}
}
if(edtrul.maxValue !== undefined && !isNaN(edtrul.maxValue)) {
if (parseFloat(val) > parseFloat(edtrul.maxValue) ) { return [false,nm+": "+msg.maxValue+" "+edtrul.maxValue,""];}
}
var filter;
if(edtrul.email === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
// taken from $ Validate plugin
filter = /^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$/i;
if(!filter.test(val)) {return [false,nm+": "+msg.email,""];}
}
}
if(edtrul.integer === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(!isNum(val)) { return [false,nm+": "+msg.integer,""]; }
if ((val % 1 !== 0) || (val.indexOf('.') !== -1)) { return [false,nm+": "+msg.integer,""];}
}
}
if(edtrul.date === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(cm[valref].formatoptions && cm[valref].formatoptions.newformat) {
dft = cm[valref].formatoptions.newformat;
fmtdate = $.jgrid.getRegional(g, 'formatter.date.masks');
if(fmtdate && fmtdate.hasOwnProperty(dft) ) {
dft = fmtdate[dft];
}
} else {
dft = cm[valref].datefmt || "Y-m-d";
}
if(!$.jgrid.checkDate (dft, val)) { return [false,nm+": "+msg.date+" - "+dft,""]; }
}
}
if(edtrul.time === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if(!$.jgrid.checkTime (val)) { return [false,nm+": "+msg.date+" - hh:mm (am/pm)",""]; }
}
}
if(edtrul.url === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
filter = /^(((https?)|(ftp)):\/\/([\-\w]+\.)+\w{2,3}(\/[%\-\w]+(\.\w{2,})?)*(([\w\-\.\?\\\/+@&#;`~=%!]*)(\.\w{2,})?)*\/?)/i;
if(!filter.test(val)) {return [false,nm+": "+msg.url,""];}
}
}
if(edtrul.custom === true) {
if( !(rqfield === false && $.jgrid.isEmpty(val)) ) {
if($.isFunction(edtrul.custom_func)) {
var ret = edtrul.custom_func.call(g,val,nm,valref);
return $.isArray(ret) ? ret : [false,msg.customarray,""];
}
return [false,msg.customfcheck,""];
}
}
}
return [true,"",""];
},
validateForm : function(form) {
var f, field, formvalid = true;
for (f = 0; f < form.elements.length; f++) {
field = form.elements[f];
// ignore buttons, fieldsets, etc.
if (field.nodeName !== "INPUT" && field.nodeName !== "TEXTAREA" && field.nodeName !== "SELECT") continue;
// is native browser validation available?
if (typeof field.willValidate !== "undefined") {
// native validation available
if (field.nodeName === "INPUT" && field.type !== field.getAttribute("type")) {
// input type not supported! Use legacy JavaScript validation
field.setCustomValidity($.jgrid.LegacyValidation(field) ? "" : "error");
}
// native browser check display error
field.reportValidity();
} else {
// native validation not available
field.validity = field.validity || {};
field.validity.valid = $.jgrid.LegacyValidation(field);
}
if (field.validity.valid) {
// remove error styles and messages
} else {
// style field, show error, etc.
// form is invalid
//var message = field.validationMessage;
formvalid = false;
break;
}
}
return formvalid;
},
// basic legacy validation checking
LegacyValidation : function (field) {
var valid = true,
val = field.value,
type = field.getAttribute("type"),
chkbox = (type === "checkbox" || type === "radio"),
required = field.getAttribute("required"),
minlength = field.getAttribute("minlength"),
maxlength = field.getAttribute("maxlength"),
pattern = field.getAttribute("pattern");
// disabled fields should not be validated
if ( field.disabled ) {
return valid;
}
// value required?
valid = valid && (!required ||
(chkbox && field.checked) ||
(!chkbox && val !== "")
);
// minlength or maxlength set?
valid = valid && (chkbox || (
(!minlength || val.length >= minlength) &&
(!maxlength || val.length <= maxlength)
));
// test pattern
if (valid && pattern) {
pattern = new RegExp(pattern);
valid = pattern.test(val);
}
return valid;
},
buildButtons : function ( buttons, source, commonstyle) {
var icon, str;
$.each(buttons, function(i,n) {
// side, position, text, icon, click, id, index
if(!n.id) {
n.id = $.jgrid.randId();
}
if(!n.position) {
n.position = 'last';
}
if(!n.side) {
n.side = 'left';
}
icon = n.icon ? " fm-button-icon-" + n.side + "'><span class='" + commonstyle.icon_base + " " + n.icon + "'></span>" : "'>";
str = "<a data-index='"+i+"' id='" + n.id + "' class='fm-button " + commonstyle.button + icon + n.text+"</a>";
if(n.position === "last" ) {
source = source + str;
} else {
source = str + source;
}
});
return source;
},
setSelNavIndex : function ($t, selelem ) {
var cels = $(".ui-pg-button",$t.p.pager);
$.each(cels, function(i,n) {
if(selelem===n) {
$t.p.navIndex = i;
return false;
}
});
$(selelem).attr("tabindex","0");
},
getFirstVisibleCol : function( $t ) {
var ret = -1;
for(var i = 0;i<$t.p.colModel.length;i++) {
if($t.p.colModel[i].hidden !== true ) {
ret = i;
break;
}
}
return ret;
}
});
//module begin
$.fn.jqFilter = function( arg ) {
if (typeof arg === 'string') {
var fn = $.fn.jqFilter[arg];
if (!fn) {
throw ("jqFilter - No such method: " + arg);
}
var args = $.makeArray(arguments).slice(1);
return fn.apply(this,args);
}
var p = $.extend(true,{
filter: null,
columns: [],
sortStrategy: null,
onChange : null,
afterRedraw : null,
checkValues : null,
error: false,
errmsg : "",
errorcheck : true,
showQuery : true,
sopt : null,
ops : [],
operands : null,
numopts : ['eq','ne', 'lt', 'le', 'gt', 'ge', 'nu', 'nn', 'in', 'ni'],
stropts : ['eq', 'ne', 'bw', 'bn', 'ew', 'en', 'cn', 'nc', 'nu', 'nn', 'in', 'ni'],
strarr : ['text', 'string', 'blob'],
groupOps : [{ op: "AND", text: "AND" }, { op: "OR", text: "OR" }],
groupButton : true,
ruleButtons : true,
uniqueSearchFields : false,
direction : "ltr",
addsubgrup : "Add subgroup",
addrule : "Add rule",
delgroup : "Delete group",
delrule : "Delete rule",
autoencode : false,
unaryOperations : []
}, $.jgrid.filter, arg || {});
return this.each( function() {
if (this.filter) {return;}
this.p = p;
// setup filter in case if they is not defined
if (this.p.filter === null || this.p.filter === undefined) {
this.p.filter = {
groupOp: this.p.groupOps[0].op,
rules: [],
groups: []
};
}
// Sort the columns if the sort strategy is provided.
if (this.p.sortStrategy != null && $.isFunction(this.p.sortStrategy)) {
this.p.columns.sort(this.p.sortStrategy);
}
var i, len = this.p.columns.length, cl,
isIE = /msie/i.test(navigator.userAgent) && !window.opera;
// translating the options
this.p.initFilter = $.extend(true,{},this.p.filter);
// set default values for the columns if they are not set
if( !len ) {return;}
for(i=0; i < len; i++) {
cl = this.p.columns[i];
if( cl.stype ) {
// grid compatibility
cl.inputtype = cl.stype;
} else if(!cl.inputtype) {
cl.inputtype = 'text';
}
if( cl.sorttype ) {
// grid compatibility
cl.searchtype = cl.sorttype;
} else if (!cl.searchtype) {
cl.searchtype = 'string';
}
if(cl.hidden === undefined) {
// jqGrid compatibility
cl.hidden = false;
}
if(!cl.label) {
cl.label = cl.name;
}
if(cl.index) {
cl.name = cl.index;
}
if(!cl.hasOwnProperty('searchoptions')) {
cl.searchoptions = {};
}
if(!cl.hasOwnProperty('searchrules')) {
cl.searchrules = {};
}
if(cl.search === undefined) {
cl.inlist = true;
} else {
cl.inlist = cl.search;
}
}
var getGrid = function () {
return $("#" + $.jgrid.jqID(p.id))[0] || null;
},
$tg = getGrid(),
classes = $.jgrid.styleUI[($tg.p.styleUI || 'jQueryUI')].filter,
common = $.jgrid.styleUI[($tg.p.styleUI || 'jQueryUI')].common;
if(this.p.showQuery) {
$(this).append("<table class='queryresult " + classes.table_widget + "' style='display:block;max-width:440px;border:0px none;' dir='"+this.p.direction+"'><tbody><tr><td class='query'></td></tr></tbody></table>");
}
/*
*Perform checking.
*
*/
var checkData = function(val, colModelItem) {
var ret = [true,""], $t = getGrid();
if($.isFunction(colModelItem.searchrules)) {
ret = colModelItem.searchrules.call($t, val, colModelItem);
} else if($.jgrid && $.jgrid.checkValues) {
try {
ret = $.jgrid.checkValues.call($t, val, -1, colModelItem.searchrules, colModelItem.label);
} catch (e) {}
}
if(ret && ret.length && ret[0] === false) {
p.error = !ret[0];
p.errmsg = ret[1];
}
};
/* moving to common
randId = function() {
return Math.floor(Math.random()*10000).toString();
};
*/
this.onchange = function ( ){
// clear any error
this.p.error = false;
this.p.errmsg="";
return $.isFunction(this.p.onChange) ? this.p.onChange.call( this, this.p ) : false;
};
/*
* Redraw the filter every time when new field is added/deleted
* and field is changed
*/
this.reDraw = function() {
$("table.group:first",this).remove();
var t = this.createTableForGroup(p.filter, null);
$(this).append(t);
if($.isFunction(this.p.afterRedraw) ) {
this.p.afterRedraw.call(this, this.p);
}
};
/*
* Creates a grouping data for the filter
* @param group - object
* @param parentgroup - object
*/
this.createTableForGroup = function(group, parentgroup) {
var that = this, i;
// this table will hold all the group (tables) and rules (rows)
var table = $("<table class='group " + classes.table_widget +" ui-search-table' style='border:0px none;'><tbody></tbody></table>"),
// create error message row
align = "left";
if(this.p.direction === "rtl") {
align = "right";
table.attr("dir","rtl");
}
if(parentgroup === null) {
table.append("<tr class='error' style='display:none;'><th colspan='5' class='" + common.error + "' align='"+align+"'></th></tr>");
}
var tr = $("<tr></tr>");
table.append(tr);
// this header will hold the group operator type and group action buttons for
// creating subgroup "+ {}", creating rule "+" or deleting the group "-"
var th = $("<th colspan='5' align='"+align+"'></th>");
tr.append(th);
if(this.p.ruleButtons === true) {
// dropdown for: choosing group operator type
var groupOpSelect = $("<select size='1' class='opsel " + classes.srSelect + "'></select>");
th.append(groupOpSelect);
// populate dropdown with all posible group operators: or, and
var str= "", selected;
for (i = 0; i < p.groupOps.length; i++) {
selected = group.groupOp === that.p.groupOps[i].op ? " selected='selected'" :"";
str += "<option value='"+that.p.groupOps[i].op+"'" + selected+">"+that.p.groupOps[i].text+"</option>";
}
groupOpSelect
.append(str)
.on('change',function() {
group.groupOp = $(groupOpSelect).val();
that.onchange(); // signals that the filter has changed
});
}
// button for adding a new subgroup
var inputAddSubgroup ="<span></span>";
if(this.p.groupButton) {
inputAddSubgroup = $("<input type='button' value='+ {}' title='" +that.p.subgroup+"' class='add-group " + common.button + "'/>");
inputAddSubgroup.on('click',function() {
if (group.groups === undefined ) {
group.groups = [];
}
group.groups.push({
groupOp: p.groupOps[0].op,
rules: [],
groups: []
}); // adding a new group
that.reDraw(); // the html has changed, force reDraw
that.onchange(); // signals that the filter has changed
return false;
});
}
th.append(inputAddSubgroup);
if(this.p.ruleButtons === true) {
// button for adding a new rule
var inputAddRule = $("<input type='button' value='+' title='"+that.p.addrule+"' class='add-rule ui-add " + common.button + "'/>"), cm;
inputAddRule.on('click',function() {
//if(!group) { group = {};}
if (group.rules === undefined) {
group.rules = [];
}
for (i = 0; i < that.p.columns.length; i++) {
// but show only serchable and serchhidden = true fields
var searchable = (that.p.columns[i].search === undefined) ? true: that.p.columns[i].search,
hidden = (that.p.columns[i].hidden === true),
ignoreHiding = (that.p.columns[i].searchoptions.searchhidden === true);
if ((ignoreHiding && searchable) || (searchable && !hidden)) {
cm = that.p.columns[i];
break;
}
}
if( !cm ) {
return false;
}
var opr;
if( cm.searchoptions.sopt ) {opr = cm.searchoptions.sopt;}
else if(that.p.sopt) { opr= that.p.sopt; }
else if ( $.inArray(cm.searchtype, that.p.strarr) !== -1 ) {opr = that.p.stropts;}
else {opr = that.p.numopts;}
group.rules.push({
field: cm.name,
op: opr[0],
data: ""
}); // adding a new rule
that.reDraw(); // the html has changed, force reDraw
// for the moment no change have been made to the rule, so
// this will not trigger onchange event
return false;
});
th.append(inputAddRule);
}
// button for delete the group
if (parentgroup !== null) { // ignore the first group
var inputDeleteGroup = $("<input type='button' value='-' title='"+that.p.delgroup+"' class='delete-group " + common.button + "'/>");
th.append(inputDeleteGroup);
inputDeleteGroup.on('click',function() {
// remove group from parent
for (i = 0; i < parentgroup.groups.length; i++) {
if (parentgroup.groups[i] === group) {
parentgroup.groups.splice(i, 1);
break;
}
}
that.reDraw(); // the html has changed, force reDraw
that.onchange(); // signals that the filter has changed
return false;
});
}
// append subgroup rows
if (group.groups !== undefined) {
for (i = 0; i < group.groups.length; i++) {
var trHolderForSubgroup = $("<tr></tr>");
table.append(trHolderForSubgroup);
var tdFirstHolderForSubgroup = $("<td class='first'></td>");
trHolderForSubgroup.append(tdFirstHolderForSubgroup);
var tdMainHolderForSubgroup = $("<td colspan='4'></td>");
tdMainHolderForSubgroup.append(this.createTableForGroup(group.groups[i], group));
trHolderForSubgroup.append(tdMainHolderForSubgroup);
}
}
if(group.groupOp === undefined) {
group.groupOp = that.p.groupOps[0].op;
}
// append rules rows
var suni = that.p.ruleButtons && that.p.uniqueSearchFields, ii;
if( suni ) {
for ( ii = 0; ii < that.p.columns.length; ii++) {
if(that.p.columns[ii].inlist) {
that.p.columns[ii].search = true;
}
}
}
if (group.rules !== undefined) {
for (i = 0; i < group.rules.length; i++) {
table.append(
this.createTableRowForRule(group.rules[i], group)
);
if( suni ) {
var field = group.rules[i].field;
for ( ii = 0; ii < that.p.columns.length; ii++) {
if(field === that.p.columns[ii].name) {
that.p.columns[ii].search = false;
break;
}
}
}
}
}
return table;
};
/*
* Create the rule data for the filter
*/
this.createTableRowForRule = function(rule, group ) {
// save current entity in a variable so that it could
// be referenced in anonimous method calls
var that=this, $t = getGrid(), tr = $("<tr></tr>"),
//document.createElement("tr"),
// first column used for padding
//tdFirstHolderForRule = document.createElement("td"),
i, op, trpar, cm, str="", selected;
//tdFirstHolderForRule.setAttribute("class", "first");
tr.append("<td class='first'></td>");
// create field container
var ruleFieldTd = $("<td class='columns'></td>");
tr.append(ruleFieldTd);
// dropdown for: choosing field
var ruleFieldSelect = $("<select size='1' class='" + classes.srSelect + "'></select>"), ina, aoprs = [];
ruleFieldTd.append(ruleFieldSelect);
ruleFieldSelect.on('change',function() {
if( that.p.ruleButtons && that.p.uniqueSearchFields ) {
var prev = parseInt($(this).data('curr'),10),
curr = this.selectedIndex;
if(prev >= 0 ) {
that.p.columns[prev].search = true;
$(this).data('curr', curr);
that.p.columns[curr].search = false;
}
}
rule.field = $(ruleFieldSelect).val();
trpar = $(this).parents("tr:first");
$(".data",trpar).empty();
for (i=0;i<that.p.columns.length;i++) {
if(that.p.columns[i].name === rule.field) {
cm = that.p.columns[i];
break;
}
}
if(!cm) {return;}
cm.searchoptions.id = $.jgrid.randId();
cm.searchoptions.name = rule.field;
cm.searchoptions.oper = 'filter';
if(isIE && cm.inputtype === "text") {
if(!cm.searchoptions.size) {
cm.searchoptions.size = 10;
}
}
var elm = $.jgrid.createEl.call($t, cm.inputtype,cm.searchoptions, "", true, that.p.ajaxSelectOptions || {}, true);
$(elm).addClass("input-elm " + classes.srInput );
//that.createElement(rule, "");
if( cm.searchoptions.sopt ) {op = cm.searchoptions.sopt;}
else if(that.p.sopt) { op= that.p.sopt; }
else if ($.inArray(cm.searchtype, that.p.strarr) !== -1) {op = that.p.stropts;}
else {op = that.p.numopts;}
// operators
var s ="", so = 0;
aoprs = [];
$.each(that.p.ops, function() { aoprs.push(this.oper); });
for ( i = 0 ; i < op.length; i++) {
ina = $.inArray(op[i],aoprs);
if(ina !== -1) {
if(so===0) {
rule.op = that.p.ops[ina].oper;
}
s += "<option value='"+that.p.ops[ina].oper+"'>"+that.p.ops[ina].text+"</option>";
so++;
}
}
$(".selectopts",trpar).empty().append( s );
$(".selectopts",trpar)[0].selectedIndex = 0;
if( $.jgrid.msie() && $.jgrid.msiever() < 9) {
var sw = parseInt($("select.selectopts",trpar)[0].offsetWidth, 10) + 1;
$(".selectopts",trpar).width( sw );
$(".selectopts",trpar).css("width","auto");
}
// data
$(".data",trpar).append( elm );
$.jgrid.bindEv.call($t, elm, cm.searchoptions);
$(".input-elm",trpar).on('change',function( e ) {
var elem = e.target;
if( cm.inputtype === 'custom' && $.isFunction(cm.searchoptions.custom_value) ) {
rule.data = cm.searchoptions.custom_value.call($t, $(".customelement", this), 'get');
} else {
rule.data = $(elem).val();
}
if(cm.inputtype === 'select' && cm.searchoptions.multiple ) {
rule.data = rule.data.join(",");
}
that.onchange(); // signals that the filter has changed
});
setTimeout(function(){ //IE, Opera, Chrome
rule.data = $(elm).val();
if(rule.op === 'nu' || rule.op === 'nn' || $.inArray(rule.op, that.p.unaryOperations) >=0 ) {
$(elm).attr('readonly','true');
$(elm).attr('disabled','true');
}
if(cm.inputtype === 'select' && cm.searchoptions.multiple && $.isArray(rule.data)) {
rule.data = rule.data.join(",");
}
that.onchange(); // signals that the filter has changed
}, 0);
});
// populate drop down with user provided column definitions
var j=0;
for (i = 0; i < that.p.columns.length; i++) {
// but show only serchable and serchhidden = true fields
var searchable = (that.p.columns[i].search === undefined) ? true: that.p.columns[i].search,
hidden = (that.p.columns[i].hidden === true),
ignoreHiding = (that.p.columns[i].searchoptions.searchhidden === true);
if ((ignoreHiding && searchable) || (searchable && !hidden)) {
selected = "";
if(rule.field === that.p.columns[i].name) {
selected = " selected='selected'";
j=i;
}
str += "<option value='"+that.p.columns[i].name+"'" +selected+">"+that.p.columns[i].label+"</option>";
}
}
ruleFieldSelect.append( str );
ruleFieldSelect.data('curr', j);
// create operator container
var ruleOperatorTd = $("<td class='operators'></td>");
tr.append(ruleOperatorTd);
cm = p.columns[j];
// create it here so it can be referentiated in the onchange event
//var RD = that.createElement(rule, rule.data);
cm.searchoptions.id = $.jgrid.randId();
if(isIE && cm.inputtype === "text") {
if(!cm.searchoptions.size) {
cm.searchoptions.size = 10;
}
}
cm.searchoptions.name = rule.field;
cm.searchoptions.oper = 'filter';
var ruleDataInput = $.jgrid.createEl.call($t, cm.inputtype,cm.searchoptions, rule.data, true, that.p.ajaxSelectOptions || {}, true);
if(rule.op === 'nu' || rule.op === 'nn' || $.inArray(rule.op, that.p.unaryOperations) >=0 ) {
$(ruleDataInput).attr('readonly','true');
$(ruleDataInput).attr('disabled','true');
} //retain the state of disabled text fields in case of null ops
// dropdown for: choosing operator
var ruleOperatorSelect = $("<select size='1' class='selectopts " + classes.srSelect + "'></select>");
ruleOperatorTd.append(ruleOperatorSelect);
ruleOperatorSelect.on('change',function() {
rule.op = $(ruleOperatorSelect).val();
trpar = $(this).parents("tr:first");
var rd = $(".input-elm",trpar)[0];
if (rule.op === "nu" || rule.op === "nn" || $.inArray(rule.op, that.p.unaryOperations) >= 0 ) { // disable for operator "is null" and "is not null"
rule.data = "";
if(rd.tagName.toUpperCase() !== 'SELECT') { rd.value = ""; }
rd.setAttribute("readonly", "true");
rd.setAttribute("disabled", "true");
} else {
if(rd.tagName.toUpperCase() === 'SELECT') { rule.data = rd.value; }
rd.removeAttribute("readonly");
rd.removeAttribute("disabled");
}
that.onchange(); // signals that the filter has changed
});
// populate drop down with all available operators
if( cm.searchoptions.sopt ) {op = cm.searchoptions.sopt;}
else if(that.p.sopt) { op= that.p.sopt; }
else if ($.inArray(cm.searchtype, that.p.strarr) !== -1) {op = that.p.stropts;}
else {op = that.p.numopts;}
str="";
$.each(that.p.ops, function() { aoprs.push(this.oper); });
for ( i = 0; i < op.length; i++) {
ina = $.inArray(op[i],aoprs);
if(ina !== -1) {
selected = rule.op === that.p.ops[ina].oper ? " selected='selected'" : "";
str += "<option value='"+that.p.ops[ina].oper+"'"+selected+">"+that.p.ops[ina].text+"</option>";
}
}
ruleOperatorSelect.append( str );
// create data container
var ruleDataTd = $("<td class='data'></td>");
tr.append(ruleDataTd);
// textbox for: data
// is created previously
//ruleDataInput.setAttribute("type", "text");
ruleDataTd.append(ruleDataInput);
$.jgrid.bindEv.call($t, ruleDataInput, cm.searchoptions);
$(ruleDataInput)
.addClass("input-elm " + classes.srInput )
.on('change', function() {
rule.data = cm.inputtype === 'custom' ? cm.searchoptions.custom_value.call($t, $(".customelement", this),'get') : $(this).val();
that.onchange(); // signals that the filter has changed
});
// create action container
var ruleDeleteTd = $("<td></td>");
tr.append(ruleDeleteTd);
// create button for: delete rule
if(this.p.ruleButtons === true) {
var ruleDeleteInput = $("<input type='button' value='-' title='"+that.p.delrule+"' class='delete-rule ui-del " + common.button + "'/>");
ruleDeleteTd.append(ruleDeleteInput);
//$(ruleDeleteInput).html("").height(20).width(30).button({icons: { primary: "ui-icon-minus", text:false}});
ruleDeleteInput.on('click',function() {
// remove rule from group
for (i = 0; i < group.rules.length; i++) {
if (group.rules[i] === rule) {
group.rules.splice(i, 1);
break;
}
}
that.reDraw(); // the html has changed, force reDraw
that.onchange(); // signals that the filter has changed
return false;
});
}
return tr;
};
this.getStringForGroup = function(group) {
var s = "(", index;
if (group.groups !== undefined) {
for (index = 0; index < group.groups.length; index++) {
if (s.length > 1) {
s += " " + group.groupOp + " ";
}
try {
s += this.getStringForGroup(group.groups[index]);
} catch (eg) {alert(eg);}
}
}
if (group.rules !== undefined) {
try{
for (index = 0; index < group.rules.length; index++) {
if (s.length > 1) {
s += " " + group.groupOp + " ";
}
s += this.getStringForRule(group.rules[index]);
}
} catch (e) {alert(e);}
}
s += ")";
if (s === "()") {
return ""; // ignore groups that don't have rules
}
return s;
};
this.getStringForRule = function(rule) {
var opUF = "",opC="", i, cm, ret, val,
numtypes = ['int', 'integer', 'float', 'number', 'currency']; // jqGrid
for (i = 0; i < this.p.ops.length; i++) {
if (this.p.ops[i].oper === rule.op) {
opUF = this.p.operands.hasOwnProperty(rule.op) ? this.p.operands[rule.op] : "";
opC = this.p.ops[i].oper;
break;
}
}
for (i=0; i<this.p.columns.length; i++) {
if(this.p.columns[i].name === rule.field) {
cm = this.p.columns[i];
break;
}
}
if (cm === undefined) { return ""; }
val = this.p.autoencode ? $.jgrid.htmlEncode(rule.data) : rule.data;
if(opC === 'bw' || opC === 'bn') { val = val+"%"; }
if(opC === 'ew' || opC === 'en') { val = "%"+val; }
if(opC === 'cn' || opC === 'nc') { val = "%"+val+"%"; }
if(opC === 'in' || opC === 'ni') { val = " ("+val+")"; }
if(p.errorcheck) { checkData(rule.data, cm); }
if($.inArray(cm.searchtype, numtypes) !== -1 || opC === 'nn' || opC === 'nu' || $.inArray(rule.op, this.p.unaryOperations) >= 0 ) {
ret = rule.field + " " + opUF + " " + val;
} else {
ret = rule.field + " " + opUF + " \"" + val + "\"";
}
return ret;
};
this.resetFilter = function () {
this.p.filter = $.extend(true,{},this.p.initFilter);
this.reDraw();
this.onchange();
};
this.hideError = function() {
$("th."+common.error, this).html("");
$("tr.error", this).hide();
};
this.showError = function() {
$("th."+common.error, this).html(this.p.errmsg);
$("tr.error", this).show();
};
this.toUserFriendlyString = function() {
return this.getStringForGroup(p.filter);
};
this.toString = function() {
// this will obtain a string that can be used to match an item.
var that = this;
function getStringRule(rule) {
if(that.p.errorcheck) {
var i, cm;
for (i=0; i<that.p.columns.length; i++) {
if(that.p.columns[i].name === rule.field) {
cm = that.p.columns[i];
break;
}
}
if(cm) {checkData(rule.data, cm);}
}
return rule.op + "(item." + rule.field + ",'" + rule.data + "')";
}
function getStringForGroup(group) {
var s = "(", index;
if (group.groups !== undefined) {
for (index = 0; index < group.groups.length; index++) {
if (s.length > 1) {
if (group.groupOp === "OR") {
s += " || ";
}
else {
s += " && ";
}
}
s += getStringForGroup(group.groups[index]);
}
}
if (group.rules !== undefined) {
for (index = 0; index < group.rules.length; index++) {
if (s.length > 1) {
if (group.groupOp === "OR") {
s += " || ";
}
else {
s += " && ";
}
}
s += getStringRule(group.rules[index]);
}
}
s += ")";
if (s === "()") {
return ""; // ignore groups that don't have rules
}
return s;
}
return getStringForGroup(this.p.filter);
};
// Here we init the filter
this.reDraw();
if(this.p.showQuery) {
this.onchange();
}
// mark is as created so that it will not be created twice on this element
this.filter = true;
});
};
$.extend($.fn.jqFilter,{
/*
* Return SQL like string. Can be used directly
*/
toSQLString : function()
{
var s ="";
this.each(function(){
s = this.toUserFriendlyString();
});
return s;
},
/*
* Return filter data as object.
*/
filterData : function()
{
var s;
this.each(function(){
s = this.p.filter;
});
return s;
},
getParameter : function (param) {
var ret = null;
if(param !== undefined) {
this.each(function(i,n){
if (n.p.hasOwnProperty(param) ) {
ret = n.p[param];
}
});
}
return ret ? ret : this[0].p; },
resetFilter: function() {
return this.each(function(){
this.resetFilter();
});
},
addFilter: function (pfilter) {
if (typeof pfilter === "string") {
pfilter = $.jgrid.parse( pfilter );
}
this.each(function(){
this.p.filter = pfilter;
this.reDraw();
this.onchange();
});
}
});
$.extend($.jgrid,{
filterRefactor : function ( p ) {
/*ruleGroup : {}, ssfield:[], splitSelect:",", groupOpSelect:"OR"*/
var filters={} /*?*/, rules, k, rule, ssdata, group;
try {
filters = typeof p.ruleGroup === "string" ? $.jgrid.parse(p.ruleGroup) : p.ruleGroup;
if(filters.rules && filters.rules.length) {
rules = filters.rules;
for(k=0; k < rules.length; k++) {
rule = rules[k];
if($.inArray(rule.filed, p.ssfield)) {
ssdata = rule.data.split(p.splitSelect);
if(ssdata.length > 1) {
if(filters.groups === undefined) {
filters.groups = [];
}
group = { groupOp: p.groupOpSelect, groups: [], rules: [] };
filters.groups.push(group);
$.each(ssdata,function(l) {
if (ssdata[l]) {
group.rules.push({ data: ssdata[l], op: rule.op, field: rule.field});
}
});
rules.splice(k, 1);
k--;
}
}
}
}
} catch(e) {}
return filters;
}
});
$.jgrid.extend({
filterToolbar : function(p){
var regional = $.jgrid.getRegional(this[0], 'search');
p = $.extend({
autosearch: true,
autosearchDelay: 500,
searchOnEnter : true,
beforeSearch: null,
afterSearch: null,
beforeClear: null,
afterClear: null,
onClearSearchValue : null,
url : '',
stringResult: false,
groupOp: 'AND',
defaultSearch : "bw",
searchOperators : false,
resetIcon : "x",
splitSelect : ",",
groupOpSelect : "OR",
errorcheck : true,
operands : { "eq" :"==", "ne":"!","lt":"<","le":"<=","gt":">","ge":">=","bw":"^","bn":"!^","in":"=","ni":"!=","ew":"|","en":"!@","cn":"~","nc":"!~","nu":"#","nn":"!#", "bt":"..."},
disabledKeys : [9, 16, 17,18,19, 20, 33, 34, 35,36,37,38,39,30, 45,112,113,114,115,116,117,118,119,120,121,122,123, 144, 145]
}, regional , p || {});
return this.each(function(){
var $t = this, unaryOpers=[];;
if($t.p.filterToolbar) { return; }
if(!$($t).data('filterToolbar')) {
$($t).data('filterToolbar', p);
}
if($t.p.force_regional) {
p = $.extend(p, regional);
}
if ($t.p.customFilterDef !== undefined) {
for(var uskey in $t.p.customFilterDef) {
if($t.p.customFilterDef.hasOwnProperty(uskey) && !p.operands.hasOwnProperty(uskey) ) {
p.odata.push({ oper: uskey, text: $t.p.customFilterDef[uskey].text} );
p.operands[uskey] = $t.p.customFilterDef[uskey].operand;
if($t.p.customFilterDef[uskey].unary === true) {
unaryOpers.push(uskey);
}
}
}
}
var classes = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].filter,
common = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].common,
base = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].base,
triggerToolbar = function() {
var sdata={}, j=0, v, nm, sopt={},so, ms = false, ssfield = [],
bbt =false, sop, ret=[true,"",""], err=false;
$.each($t.p.colModel,function(){
var $elem = $("#gs_"+ $t.p.idPrefix + $.jgrid.jqID(this.name), (this.frozen===true && $t.p.frozenColumns === true) ? $t.grid.fhDiv : $t.grid.hDiv);
nm = this.index || this.name;
sop = this.searchoptions || {};
if(p.searchOperators && sop.searchOperMenu) {
so = $elem.parents("table.ui-search-table").find("td.ui-search-oper").children("a").attr("soper") || p.defaultSearch;
} else {
so = (sop.sopt) ? sop.sopt[0] : this.stype==='select' ? 'eq' : p.defaultSearch;
}
v = this.stype === "custom" && $.isFunction(sop.custom_value) && $elem.length > 0 ?
sop.custom_value.call($t, $elem, "get") :
$elem.val();
// detect multiselect
if(this.stype === 'select' && sop.multiple && $.isArray(v)) {
if(v.length > 0) {
ms = true;
ssfield.push(nm);
v= v.length === 1 ? v[0] : v;
} else {
v = "";
}
}
if(this.searchrules && p.errorcheck) {
if($.isFunction( this.searchrules)) {
ret = this.searchrules.call($t, v, this);
} else if($.jgrid && $.jgrid.checkValues) {
ret = $.jgrid.checkValues.call($t, v, -1, this.searchrules, this.label || this.name);
}
if(ret && ret.length && ret[0] === false ) {
if(this.searchrules.hasOwnProperty('validationError') ){
err = this.searchrules.validationError;
}
return false;
}
}
if(so==="bt") {
bbt = true;
}
if(v || so==="nu" || so==="nn" || $.inArray(so, unaryOpers) >=0) {
sdata[nm] = v;
sopt[nm] = so;
j++;
} else {
try {
delete $t.p.postData[nm];
} catch (z) {}
}
});
if(ret[0] === false ) {
if($.isFunction(err)) {
err.call($t, ret[1]);
} else {
var errors = $.jgrid.getRegional($t, 'errors');
$.jgrid.info_dialog(errors.errcap, ret[1], '', {styleUI : $t.p.styleUI });
}
return;
}
var sd = j>0 ? true : false;
if(p.stringResult === true || $t.p.datatype === "local" || p.searchOperators === true)
{
var ruleGroup = "{\"groupOp\":\"" + p.groupOp + "\",\"rules\":[";
var gi=0;
$.each(sdata,function(i,n){
if (gi > 0) {ruleGroup += ",";}
ruleGroup += "{\"field\":\"" + i + "\",";
ruleGroup += "\"op\":\"" + sopt[i] + "\",";
n+="";
ruleGroup += "\"data\":\"" + n.replace(/\\/g,'\\\\').replace(/\"/g,'\\"') + "\"}";
gi++;
});
ruleGroup += "]}";
// multiselect
var filters, rules, k,str, rule, ssdata, group;
if(ms) {
filters = $.jgrid.filterRefactor({
ruleGroup : ruleGroup,
ssfield : ssfield,
splitSelect : p.splitSelect,
groupOpSelect : p.groupOpSelect
});
ruleGroup = JSON.stringify( filters );
}
if(bbt) {
if(!$.isPlainObject(filters)) {
filters = $.jgrid.parse(ruleGroup);
}
if(filters.rules && filters.rules.length) {
rules = filters.rules;
for(k=0;k < rules.length; k++) {
rule = rules[k];
if(rule.op === "bt") {
ssdata = rule.data.split("...");
if(ssdata.length > 1) {
if(filters.groups === undefined) {
filters.groups = [];
}
group = { groupOp: 'AND', groups: [], rules: [] };
filters.groups.push(group);
$.each(ssdata,function(l) {
var btop = l === 0 ? 'ge' : 'le';
str = ssdata[l];
if(str) {
group.rules.push({ data: ssdata[l], op: btop, field: rule.field});
}
});
rules.splice(k, 1);
k--;
}
}
}
}
}
if(bbt || ms ) {
ruleGroup = JSON.stringify( filters );
}
if($t.p.mergeSearch === true && $t.p.searchModules.hasOwnProperty('filterToolbar') && $t.p.searchModules.filterToolbar !== false ) {
if(gi > 0) {
$t.p.searchModules.filterToolbar = ruleGroup;
} else {
$t.p.searchModules.filterToolbar = null;
}
sd = true;
$.extend($t.p.postData,{filters: $.jgrid.splitSearch($t.p.searchModules)});
} else {
$.extend($t.p.postData,{filters:ruleGroup});
}
$.each(['searchField', 'searchString', 'searchOper'], function(i, n){
if($t.p.postData.hasOwnProperty(n)) { delete $t.p.postData[n];}
});
} else {
$.extend($t.p.postData,sdata);
}
var saveurl;
if(p.url) {
saveurl = $t.p.url;
$($t).jqGrid("setGridParam", { url: p.url });
}
var bsr = $($t).triggerHandler("jqGridToolbarBeforeSearch") === 'stop' ? true : false;
if(!bsr && $.isFunction(p.beforeSearch)){bsr = p.beforeSearch.call($t);}
if(!bsr) { $($t).jqGrid("setGridParam",{search:sd}).trigger("reloadGrid",[{page:1}]); }
if(saveurl) {$($t).jqGrid("setGridParam",{url:saveurl});}
$($t).triggerHandler("jqGridToolbarAfterSearch");
if($.isFunction(p.afterSearch)){p.afterSearch.call($t);}
},
clearToolbar = function(trigger){
var sdata={}, j=0, nm;
trigger = (typeof trigger !== 'boolean') ? true : trigger;
$.each($t.p.colModel,function(){
var v, $elem = $("#gs_"+$t.p.idPrefix+$.jgrid.jqID(this.name),(this.frozen===true && $t.p.frozenColumns === true) ? $t.grid.fhDiv : $t.grid.hDiv);
if(this.searchoptions && this.searchoptions.defaultValue !== undefined) {
v = this.searchoptions.defaultValue;
}
nm = this.index || this.name;
switch (this.stype) {
case 'select' :
$elem.find("option").each(function (i){
if(i===0) { this.selected = true; }
if ($(this).val() === v) {
this.selected = true;
return false;
}
});
if ( v !== undefined ) {
// post the key and not the text
sdata[nm] = v;
j++;
} else {
try {
delete $t.p.postData[nm];
} catch(e) {}
}
break;
case 'text':
$elem.val(v || "");
if(v !== undefined) {
sdata[nm] = v;
j++;
} else {
try {
delete $t.p.postData[nm];
} catch (y){}
}
break;
case 'custom':
if ($.isFunction(this.searchoptions.custom_value) && $elem.length > 0 ) {
this.searchoptions.custom_value.call($t, $elem, "set", v || "");
}
break;
}
});
var sd = j>0 ? true : false;
$t.p.resetsearch = true;
if(p.stringResult === true || $t.p.datatype === "local") {
var ruleGroup = "{\"groupOp\":\"" + p.groupOp + "\",\"rules\":[";
var gi=0;
$.each(sdata,function(i,n){
if (gi > 0) {ruleGroup += ",";}
ruleGroup += "{\"field\":\"" + i + "\",";
ruleGroup += "\"op\":\"" + "eq" + "\",";
n+="";
ruleGroup += "\"data\":\"" + n.replace(/\\/g,'\\\\').replace(/\"/g,'\\"') + "\"}";
gi++;
});
ruleGroup += "]}";
if($t.p.mergeSearch === true && $t.p.searchModules.hasOwnProperty('filterToolbar') && $t.p.searchModules.filterToolbar !== false ) {
if(gi > 0) {
$t.p.searchModules.filterToolbar = ruleGroup;
} else {
$t.p.searchModules.filterToolbar = null;
}
sd = true;
$.extend($t.p.postData,{filters: $.jgrid.splitSearch($t.p.searchModules)});
} else {
$.extend($t.p.postData,{filters:ruleGroup});
}
$.each(['searchField', 'searchString', 'searchOper'], function(i, n){
if($t.p.postData.hasOwnProperty(n)) { delete $t.p.postData[n];}
});
} else {
$.extend($t.p.postData,sdata);
}
var saveurl;
if(p.url) {
saveurl = $t.p.url;
$($t).jqGrid("setGridParam",{url:p.url});
}
var bcv = $($t).triggerHandler("jqGridToolbarBeforeClear") === 'stop' ? true : false;
if(!bcv && $.isFunction(p.beforeClear)){bcv = p.beforeClear.call($t);}
if(!bcv) {
if(trigger) {
$($t).jqGrid("setGridParam",{search:sd}).trigger("reloadGrid",[{page:1}]);
}
}
if(saveurl) {$($t).jqGrid("setGridParam",{url:saveurl});}
$($t).triggerHandler("jqGridToolbarAfterClear");
if($.isFunction(p.afterClear)){p.afterClear();}
},
toggleToolbar = function(){
var trow = $("tr.ui-search-toolbar",$t.grid.hDiv);
if($t.p.frozenColumns === true) {
$($t).jqGrid('destroyFrozenColumns');
}
if(trow.css("display") === 'none') {
trow.show();
} else {
trow.hide();
}
if($t.p.frozenColumns === true) {
$($t).jqGrid("setFrozenColumns");
}
},
buildRuleMenu = function( elem, left, top ){
$("#sopt_menu").remove();
left=parseInt(left,10);
top=parseInt(top,10) + 18;
var fs = $('.ui-jqgrid').css('font-size') || '11px';
var str = '<ul id="sopt_menu" class="ui-search-menu modal-content" role="menu" tabindex="0" style="font-size:'+fs+';left:'+left+'px;top:'+top+'px;">',
selected = $(elem).attr("soper"), selclass,
aoprs = [], ina;
var i=0, nm =$(elem).attr("colname"),len = $t.p.colModel.length;
while(i<len) {
if($t.p.colModel[i].name === nm) {
break;
}
i++;
}
var cm = $t.p.colModel[i], options = $.extend({}, cm.searchoptions);
if(!options.sopt) {
options.sopt = [];
options.sopt[0]= cm.stype==='select' ? 'eq' : p.defaultSearch;
}
$.each(p.odata, function() { aoprs.push(this.oper); });
for ( i = 0 ; i < options.sopt.length; i++) {
ina = $.inArray(options.sopt[i],aoprs);
if(ina !== -1) {
selclass = selected === p.odata[ina].oper ? common.highlight : "";
str += '<li class="ui-menu-item '+selclass+'" role="presentation"><a class="'+ common.cornerall+' g-menu-item" tabindex="0" role="menuitem" value="'+p.odata[ina].oper+'" oper="'+p.operands[p.odata[ina].oper]+'"><table class="ui-common-table"><tr><td class="opersign">'+p.operands[p.odata[ina].oper]+'</td><td>'+ p.odata[ina].text+'</td></tr></table></a></li>';
}
}
str += "</ul>";
$('body').append(str);
$("#sopt_menu").addClass("ui-menu " + classes.menu_widget);
$("#sopt_menu > li > a").hover(
function(){ $(this).addClass(common.hover); },
function(){ $(this).removeClass(common.hover); }
).click(function() {
var v = $(this).attr("value"),
oper = $(this).attr("oper");
$($t).triggerHandler("jqGridToolbarSelectOper", [v, oper, elem]);
$("#sopt_menu").hide();
$(elem).text(oper).attr("soper",v);
if(p.autosearch===true){
var inpelm = $(elem).parent().next().children()[0];
if( $(inpelm).val() || v==="nu" || v ==="nn" || $.inArray(v, unaryOpers) >=0) {
triggerToolbar();
}
}
});
};
// create the row
var tr = $("<tr class='ui-search-toolbar' role='row'></tr>"),
timeoutHnd, rules, filterobj;
if( p.restoreFromFilters ) {
filterobj = $t.p.postData.filters;
if(filterobj) {
if( typeof filterobj === "string") {
filterobj = $.jgrid.parse( filterobj );
}
rules = filterobj.rules.length ? filterobj.rules : false;
}
}
p.disabledKeys = new Set(p.disabledKeys); // experimental
$.each($t.p.colModel,function(ci){
var cm=this, soptions, select="", sot="=", so, i, st, csv, df, elem, restores,
th = $("<th role='columnheader' class='" + base.headerBox+" ui-th-"+$t.p.direction+"' id='gsh_" + $t.p.id + "_" + cm.name + "' ></th>"),
thd = $("<div></div>"),
stbl = $("<table class='ui-search-table' cellspacing='0'><tr><td class='ui-search-oper' headers=''></td><td class='ui-search-input' headers=''></td><td class='ui-search-clear' headers=''></td></tr></table>");
if(this.hidden===true) { $(th).css("display","none");}
this.search = this.search === false ? false : true;
if(this.stype === undefined) {this.stype='text';}
this.searchoptions = this.searchoptions || {};
if(this.searchoptions.searchOperMenu === undefined) {
this.searchoptions.searchOperMenu = true;
}
soptions = $.extend({},this.searchoptions , {name:cm.index || cm.name, id: "gs_"+$t.p.idPrefix+cm.name, oper:'search'});
if(this.search){
if( p.restoreFromFilters && rules) {
restores = false;
for( var is = 0; is < rules.length; is++) {
if(rules[is].field ) {
var snm = cm.index || cm.name;
if( snm === rules[is].field) {
restores = rules[is];
break;
}
}
}
}
if(p.searchOperators) {
so = (soptions.sopt) ? soptions.sopt[0] : cm.stype==='select' ? 'eq' : p.defaultSearch;
// overwrite search operators
if( p.restoreFromFilters && restores) {
so = restores.op;
}
for(i = 0;i<p.odata.length;i++) {
if(p.odata[i].oper === so) {
sot = p.operands[so] || "";
break;
}
}
st = soptions.searchtitle != null ? soptions.searchtitle : p.operandTitle;
select = this.searchoptions.searchOperMenu ? "<a title='"+st+"' soper='"+so+"' class='soptclass' colname='"+this.name+"'>"+sot+"</a>" : "";
}
$("td:eq(0)",stbl).attr("columname", cm.name).append(select);
if(soptions.clearSearch === undefined) {
soptions.clearSearch = true;
}
if(soptions.clearSearch) {
csv = p.resetTitle || 'Clear Search Value';
$("td:eq(2)",stbl).append("<a title='"+csv+"' style='padding-right: 0.3em;padding-left: 0.3em;' class='clearsearchclass'>"+p.resetIcon+"</a>");
} else {
$("td:eq(2)", stbl).hide();
}
if(this.surl) {
soptions.dataUrl = this.surl;
}
df="";
if(soptions.defaultValue ) {
df = $.isFunction(soptions.defaultValue) ? soptions.defaultValue.call($t) : soptions.defaultValue;
}
//overwrite default value if restore from filters
if( p.restoreFromFilters && restores) {
df = restores.data;
}
elem = $.jgrid.createEl.call($t, this.stype, soptions , df, false, $.extend({},$.jgrid.ajaxOptions, $t.p.ajaxSelectOptions || {}));
$(elem).addClass( classes.srInput );
$("td:eq(1)",stbl).append(elem);
$(thd).append(stbl);
if(soptions.dataEvents == null ) {
soptions.dataEvents = [];
}
switch (this.stype)
{
case "select":
if(p.autosearch === true) {
soptions.dataEvents.push({
type : "change",
fn : function() {
triggerToolbar();
return false;
}
});
}
break;
case "text":
if(p.autosearch===true){
if(p.searchOnEnter) {
soptions.dataEvents.push({
type: "keypress",
fn : function(e) {
var key = e.charCode || e.keyCode || 0;
if(key === 13){
triggerToolbar();
return false;
}
return this;
}
});
} else {
soptions.dataEvents.push({
type: "keydown",
fn : function(e) {
var key = e.which;
if( p.disabledKeys.has(key)) {
// do nothing
} else if( key === 13 ) {
return false;
} else {
if(timeoutHnd) { clearTimeout(timeoutHnd); }
timeoutHnd = setTimeout(function(){triggerToolbar();}, p.autosearchDelay);
}
}
});
}
}
break;
}
$.jgrid.bindEv.call($t, elem , soptions);
}
$(th).append(thd);
$(tr).append(th);
if(!p.searchOperators || select === "") {
$("td:eq(0)",stbl).hide();
}
});
$("table thead",$t.grid.hDiv).append(tr);
if(p.searchOperators) {
$(".soptclass",tr).click(function(e){
var offset = $(this).offset(),
left = ( offset.left ),
top = ( offset.top);
buildRuleMenu(this, left, top );
e.stopPropagation();
});
$("body").on('click', function(e){
if(e.target.className !== "soptclass") {
$("#sopt_menu").remove();
}
});
}
$(".clearsearchclass",tr).click(function() {
var ptr = $(this).parents("tr:first"),
colname = $("td.ui-search-oper", ptr).attr('columname'), coli=0, len = $t.p.colModel.length,
soper = $("td.ui-search-oper a", ptr).attr('soper'), cm,vv;
while(coli<len) {
if($t.p.colModel[coli].name === colname) {
cm = $t.p.colModel[coli];
break;
}
coli++;
}
var sval = $.extend({},$t.p.colModel[coli].searchoptions || {}),
dval = sval.defaultValue ? sval.defaultValue : "",
elem;
if($t.p.colModel[coli].stype === "select") {
elem = $("td.ui-search-input select", ptr);
if(dval) {
elem.val( dval );
} else {
elem[0].selectedIndex = 0;
}
} else {
elem = $("td.ui-search-input input", ptr);
elem.val( dval );
}
$($t).triggerHandler("jqGridToolbarClearVal",[elem[0], coli, sval, dval]);
if($.isFunction(p.onClearSearchValue)) {
p.onClearSearchValue.call($t, elem[0], coli, sval, dval);
}
if(soper==="nu" || soper==="nn" || $.inArray(soper, unaryOpers) >=0) {
vv = sval.sopt ?
sval.sopt[0] :
cm.stype === "select" ?
"eq" :
p.defaultSearch;
var operText = $t.p.customFilterDef != null && $t.p.customFilterDef[vv] != null ?
$t.p.customFilterDef[vv].operand :
p.operands[vv] || "";
if(vv === soper) {
$("td.ui-search-oper a", ptr).attr('soper', 'dummy').text(operText);
} else {
$("td.ui-search-oper a", ptr).attr('soper',vv).text(operText);
}
}
// ToDo custom search type
if(p.autosearch===true){
triggerToolbar();
if(vv === soper) {
$("td.ui-search-oper a", ptr).attr('soper',vv).text(operText);
}
}
});
$($t.grid.hDiv).on("scroll", function(e){
$t.grid.bDiv.scrollLeft = $t.grid.hDiv.scrollLeft;
});
this.p.filterToolbar = true;
this.triggerToolbar = triggerToolbar;
this.clearToolbar = clearToolbar;
this.toggleToolbar = toggleToolbar;
});
},
destroyFilterToolbar: function () {
return this.each(function () {
if (!this.p.filterToolbar) {
return;
}
this.triggerToolbar = null;
this.clearToolbar = null;
this.toggleToolbar = null;
this.p.filterToolbar = false;
$(this.grid.hDiv).find("table thead tr.ui-search-toolbar").remove();
});
},
refreshFilterToolbar : function ( p ) {
p = $.extend(true, {
filters : "",
onClearVal : null,
onSetVal : null
}, p || {});
return this.each(function () {
var $t = this, cm = $t.p.colModel, i, l = $t.p.colModel.length, params,
searchitem, filters, rules, rule, ssfield =[], ia;
// clear the values on toolbar.
// do not call clearToolbar
if(!$t.p.filterToolbar) {
return;
}
params = $($t).data('filterToolbar');
for (i = 0; i < l; i++) {
ssfield.push(cm[i].name);
searchitem = $("#gs_" +$t.p.idPrefix+ $.jgrid.jqID(cm[i].name));
switch (cm[i].stype) {
case 'select' :
case 'text' :
searchitem.val("");
break;
}
if($.isFunction(p.onClearVal)) {
p.onClearVal.call($t, searchitem, cm[i].name);
}
}
function setrules (filter) {
if(filter && filter.rules) { // condition to exit
rules = filter.rules;
l = rules.length;
for (i = 0; i < l; i++) {
rule = rules[i];
ia = $.inArray(rule.field, ssfield);
if( ia !== -1) {
searchitem = $("#gs_" + $t.p.idPrefix + $.jgrid.jqID(cm[ia].name));
// problem for between operator
if ( searchitem.length > 0) {
if (cm[ia].stype === "select") {
searchitem.find("option[value='" + $.jgrid.jqID(rule.data) + "']").prop('selected', true);
} else if (cm[ia].stype === "text") {
searchitem.val(rule.data);
}
if($.isFunction(p.onSetVal)) {
p.onSetVal.call($t, searchitem, cm[ia].name);
}
if( params && params.searchOperators) {
var fsi = searchitem.parent().prev();
if( fsi.hasClass("ui-search-oper") ) {
$(".soptclass", fsi ).attr("soper", rule.op);
if(params.operands.hasOwnProperty(rule.op)) {
$(".soptclass", fsi ).html( params.operands[rule.op] );
}
}
}
}
}
}
if(filter.groups) {
for(var k=0;k<filter.groups.length;k++) {
setrules(filter.groups[k]);
}
}
}
}
if (typeof (p.filters) === "string") {
if(p.filters.length) {
filters = p.filters;
// flat filters only
} else if( $t.p.postData.hasOwnProperty("filters")) {
filters = $t.p.postData.filters;
}
filters = $.jgrid.parse(filters);
}
if ($.isPlainObject(filters)) {
setrules( filters );
}
});
},
searchGrid : function (p) {
var regional = $.jgrid.getRegional(this[0], 'search');
p = $.extend(true, {
recreateFilter: false,
drag: true,
sField:'searchField',
sValue:'searchString',
sOper: 'searchOper',
sFilter: 'filters',
loadDefaults: true, // this options activates loading of default filters from grid's postData for Multipe Search only.
beforeShowSearch: null,
afterShowSearch : null,
onInitializeSearch: null,
afterRedraw : null,
afterChange: null,
sortStrategy: null,
closeAfterSearch : false,
closeAfterReset: false,
closeOnEscape : false,
searchOnEnter : false,
multipleSearch : false,
multipleGroup : false,
//cloneSearchRowOnAdd: true,
top : 0,
left: 0,
jqModal : true,
modal: false,
resize : true,
width: 450,
height: 'auto',
dataheight: 'auto',
showQuery: false,
errorcheck : true,
sopt: null,
stringResult: undefined,
onClose : null,
onSearch : null,
onReset : null,
toTop : true,
overlay : 30,
columns : [],
tmplNames : null,
tmplFilters : null,
tmplLabel : ' Template: ',
showOnLoad: false,
layer: null,
splitSelect : ",",
groupOpSelect : "OR",
operands : { "eq" :"=", "ne":"<>","lt":"<","le":"<=","gt":">","ge":">=","bw":"LIKE","bn":"NOT LIKE","in":"IN","ni":"NOT IN","ew":"LIKE","en":"NOT LIKE","cn":"LIKE","nc":"NOT LIKE","nu":"IS NULL","nn":"ISNOT NULL"},
buttons :[]
}, regional, p || {});
return this.each(function() {
var $t = this;
if(!$t.grid) {return;}
var fid = "fbox_"+$t.p.id,
showFrm = true,
mustReload = true,
IDs = {themodal:'searchmod'+fid,modalhead:'searchhd'+fid,modalcontent:'searchcnt'+fid, scrollelm : fid},
defaultFilters,// = ($.isPlainObject($t.p._savedFilter) && !$.isEmptyObject($t.p._savedFilter ) ) ? $t.p._savedFilter : $t.p.postData[p.sFilter],
fl,
unaryOpers = [],
classes = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].filter,
common = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].common;
p.styleUI = $t.p.styleUI;
if($.isPlainObject($t.p._savedFilter) && !$.isEmptyObject($t.p._savedFilter )) {
defaultFilters = $t.p._savedFilter;
} else if($t.p.mergeSearch === true && $t.p.searchModules.hasOwnProperty('searchGrid') && $t.p.searchModules.searchGrid !== false ) {
defaultFilters = $t.p.searchModules.searchGrid === true ? "" : $t.p.searchModules.searchGrid;
} else {
defaultFilters = $t.p.postData[p.sFilter];
}
if(typeof defaultFilters === "string") {
defaultFilters = $.jgrid.parse( defaultFilters );
}
if(p.recreateFilter === true) {
$("#"+$.jgrid.jqID(IDs.themodal)).remove();
}
function showFilter(_filter) {
showFrm = $($t).triggerHandler("jqGridFilterBeforeShow", [_filter]);
if(showFrm === undefined) {
showFrm = true;
}
if(showFrm && $.isFunction(p.beforeShowSearch)) {
showFrm = p.beforeShowSearch.call($t,_filter);
}
if(showFrm) {
$.jgrid.viewModal("#"+$.jgrid.jqID(IDs.themodal),{gbox:"#gbox_"+$.jgrid.jqID( $t.p.id ),jqm:p.jqModal, modal:p.modal, overlay: p.overlay, toTop: p.toTop});
$($t).triggerHandler("jqGridFilterAfterShow", [_filter]);
if($.isFunction(p.afterShowSearch)) {
p.afterShowSearch.call($t, _filter);
}
}
}
if ( $("#"+$.jgrid.jqID(IDs.themodal))[0] !== undefined ) {
showFilter($("#fbox_"+$.jgrid.jqID( $t.p.id )));
} else {
var fil = $("<div><div id='"+fid+"' class='searchFilter' style='overflow:auto'></div></div>").insertBefore("#gview_"+$.jgrid.jqID($t.p.id)),
align = "left", butleft ="";
if($t.p.direction === "rtl") {
align = "right";
butleft = " style='text-align:left'";
fil.attr("dir","rtl");
}
var columns = $.extend([],$t.p.colModel),
bS ="<a id='"+fid+"_search' class='fm-button " + common.button + " fm-button-icon-right ui-search'><span class='" + common.icon_base + " " +classes.icon_search + "'></span>"+p.Find+"</a>",
bC ="<a id='"+fid+"_reset' class='fm-button " + common.button +" fm-button-icon-left ui-reset'><span class='" + common.icon_base + " " +classes.icon_reset + "'></span>"+p.Reset+"</a>",
bQ = "", tmpl="", colnm, found = false, bt, cmi=-1, ms = false, ssfield = [];
if(p.showQuery) {
bQ ="<a id='"+fid+"_query' class='fm-button " + common.button + " fm-button-icon-left'><span class='" + common.icon_base + " " +classes.icon_query + "'></span>Query</a>";
}
var user_buttons = $.jgrid.buildButtons( p.buttons, bQ+ bS, common);
// groupheaders names
var groupH = null;
if( $($t).jqGrid('isGroupHeaderOn') ) {
var htable = $("table.ui-jqgrid-htable", $t.grid.hDiv),
secRow = htable.find(".jqg-second-row-header"),
gh_len = $t.p.groupHeader.length;
// use the last set one
if(secRow[0] !== undefined) {
groupH = $t.p.groupHeader[gh_len-1];
}
}
var inColumnHeader = function (text, columnHeaders) {
var length = columnHeaders.length, i;
for (i = 0; i < length; i++) {
if (columnHeaders[i].startColumnName === text) {
return i;
}
}
return -1;
};
if(!p.columns.length) {
if(groupH !== null) {
for(var ij=0;ij<columns.length; ij++){
var iCol = inColumnHeader( columns[ij].name, groupH.groupHeaders);
if(iCol>=0) {
columns[ij].label = groupH.groupHeaders[iCol].titleText + "::" + $t.p.colNames[ij];
for(var jj= 1; jj<= groupH.groupHeaders[iCol].numberOfColumns-1; jj++) {
columns[ij+jj].label = groupH.groupHeaders[iCol].titleText + "::"+$t.p.colNames[ij+jj];
}
ij = ij+groupH.groupHeaders[iCol].numberOfColumns-1;
}
}
}
$.each(columns, function(i,n){
if(!n.label) {
n.label = $t.p.colNames[i];
}
// find first searchable column and set it if no default filter
if(!found) {
var searchable = (n.search === undefined) ? true: n.search ,
hidden = (n.hidden === true),
ignoreHiding = (n.searchoptions && n.searchoptions.searchhidden === true);
if ((ignoreHiding && searchable) || (searchable && !hidden)) {
found = true;
colnm = n.index || n.name;
cmi =i;
}
}
if( n.stype==="select" && n.searchoptions && n.searchoptions.multiple) {
ms = true;
ssfield.push( n.index || n.name );
}
});
} else {
columns = p.columns;
cmi = 0;
colnm = columns[0].index || columns[0].name;
}
// old behaviour
if( (!defaultFilters && colnm) || p.multipleSearch === false ) {
var cmop = "eq";
if(cmi >=0 && columns[cmi].searchoptions && columns[cmi].searchoptions.sopt) {
cmop = columns[cmi].searchoptions.sopt[0];
} else if(p.sopt && p.sopt.length) {
cmop = p.sopt[0];
}
defaultFilters = {groupOp: "AND", rules: [{field: colnm, op: cmop, data: ""}]};
}
found = false;
if(p.tmplNames && p.tmplNames.length) {
found = true;
tmpl = "<tr><td class='ui-search-label'>"+ p.tmplLabel +"</td>";
tmpl += "<td><select size='1' class='ui-template " + classes.srSelect + "'>";
tmpl += "<option value='default'>Default</option>";
$.each(p.tmplNames, function(i,n){
tmpl += "<option value='"+i+"'>"+n+"</option>";
});
tmpl += "</select></td></tr>";
}
if ($t.p.customFilterDef !== undefined) {
for(var uskey in $t.p.customFilterDef) {
if($t.p.customFilterDef.hasOwnProperty(uskey) && !p.operands.hasOwnProperty(uskey) ) {
p.odata.push({ oper: uskey, text: $t.p.customFilterDef[uskey].text} );
p.operands[uskey] = $t.p.customFilterDef[uskey].operand;
if($t.p.customFilterDef[uskey].unary === true) {
unaryOpers.push(uskey);
}
}
}
}
bt = "<table class='EditTable' style='border:0px none;margin-top:5px' id='"+fid+"_2'><tbody><tr><td colspan='2'><hr class='" + common.content + "' style='margin:1px'/></td></tr>"+tmpl+"<tr><td class='EditButton' style='text-align:"+align+"'>"+bC+"</td><td class='EditButton' "+butleft+">"+ user_buttons +"</td></tr></tbody></table>";
fid = $.jgrid.jqID( fid);
$("#"+fid).jqFilter({
columns: columns,
sortStrategy: p.sortStrategy,
filter: p.loadDefaults ? defaultFilters : null,
showQuery: p.showQuery,
errorcheck : p.errorcheck,
sopt: p.sopt,
groupButton : p.multipleGroup,
ruleButtons : p.multipleSearch,
uniqueSearchFields : p.uniqueSearchFields,
afterRedraw : p.afterRedraw,
ops : p.odata,
operands : p.operands,
ajaxSelectOptions: $t.p.ajaxSelectOptions,
groupOps: p.groupOps,
addsubgrup : p.addsubgrup,
addrule : p.addrule,
delgroup : p.delgroup,
delrule : p.delrule,
autoencode : $t.p.autoencode,
unaryOperations : unaryOpers,
onChange : function() {
if(this.p.showQuery) {
$('.query',this).html(this.toUserFriendlyString());
}
if ($.isFunction(p.afterChange)) {
p.afterChange.call($t, $("#"+fid), p);
}
},
direction : $t.p.direction,
id: $t.p.id
});
fil.append( bt );
$("#"+fid+"_2").find("[data-index]").each(function(){
var index = parseInt($(this).attr('data-index'),10);
if(index >=0 ) {
$(this).on('click', function(e) {
p.buttons[index].click.call($t, $("#"+fid), p, e);
});
}
});
if(found && p.tmplFilters && p.tmplFilters.length) {
$(".ui-template", fil).on('change', function(){
var curtempl = $(this).val();
if(curtempl==="default") {
$("#"+fid).jqFilter('addFilter', defaultFilters);
} else {
$("#"+fid).jqFilter('addFilter', p.tmplFilters[parseInt(curtempl,10)]);
}
return false;
});
}
if(p.multipleGroup === true) {p.multipleSearch = true;}
$($t).triggerHandler("jqGridFilterInitialize", [$("#"+fid)]);
if($.isFunction(p.onInitializeSearch) ) {
p.onInitializeSearch.call($t, $("#"+fid));
}
p.gbox = "#gbox_"+$.jgrid.jqID($t.p.id);//fid;
var fs = $('.ui-jqgrid').css('font-size') || '11px';
if (p.layer) {
$.jgrid.createModal(IDs ,fil,p,"#gview_"+$.jgrid.jqID($t.p.id),$("#gbox_"+$.jgrid.jqID($t.p.id))[0], (typeof p.layer ==="string" ? "#"+$.jgrid.jqID(p.layer) : p.layer), (typeof p.layer ==="string" ? {position: "relative", "font-size":fs} :{ "font-size":fs} ) );
} else {
$.jgrid.createModal(IDs ,fil,p,"#gview_"+$.jgrid.jqID($t.p.id),$("#gbox_"+$.jgrid.jqID($t.p.id))[0], null, { "font-size":fs});
}
if (p.searchOnEnter || p.closeOnEscape) {
$("#"+$.jgrid.jqID(IDs.themodal)).keydown(function (e) {
var $target = $(e.target);
if (p.searchOnEnter && e.which === 13 && // 13 === $.ui.keyCode.ENTER
!$target.hasClass('add-group') && !$target.hasClass('add-rule') &&
!$target.hasClass('delete-group') && !$target.hasClass('delete-rule') &&
(!$target.hasClass("fm-button") || !$target.is("[id$=_query]"))) {
$("#"+fid+"_search").click();
return false;
}
if (p.closeOnEscape && e.which === 27) { // 27 === $.ui.keyCode.ESCAPE
$("#"+$.jgrid.jqID(IDs.modalhead)).find(".ui-jqdialog-titlebar-close").click();
return false;
}
});
}
if(bQ) {
$("#"+fid+"_query").on('click', function(){
$(".queryresult", fil).toggle();
return false;
});
}
if (p.stringResult===undefined) {
// to provide backward compatibility, inferring stringResult value from multipleSearch
p.stringResult = p.multipleSearch;
}
$("#"+fid+"_search").on('click', function(){
var sdata={}, res, filters;
fl = $("#"+fid);
fl.find(".input-elm:focus").change();
if( ms && p.multipleSearch) {
$t.p._savedFilter = {};
filters = $.jgrid.filterRefactor({
ruleGroup: $.extend(true, {}, fl.jqFilter('filterData')),
ssfield : ssfield,
splitSelect : p.splitSelect,
groupOpSelect : p.groupOpSelect
});
$t.p._savedFilter = $.extend(true, {}, fl.jqFilter('filterData'));
} else {
filters = fl.jqFilter('filterData');
}
if(p.errorcheck) {
fl[0].hideError();
if(!p.showQuery) {fl.jqFilter('toSQLString');}
if(fl[0].p.error) {
fl[0].showError();
return false;
}
}
if(p.stringResult) {
sdata[p.sFilter] = JSON.stringify( filters );
$.each([p.sField,p.sValue, p.sOper], function() {sdata[this] = "";});
} else {
if(p.multipleSearch) {
sdata[p.sFilter] = filters;
$.each([p.sField,p.sValue, p.sOper], function() {sdata[this] = "";});
} else {
sdata[p.sField] = filters.rules[0].field;
sdata[p.sValue] = filters.rules[0].data;
sdata[p.sOper] = filters.rules[0].op;
sdata[p.sFilter] = "";
}
}
if(typeof sdata[p.sFilter] !== "string") {
sdata[p.sFilter] = JSON.stringify( sdata[p.sFilter] );
}
$t.p.search = true;
if($t.p.mergeSearch === true && $t.p.searchModules.hasOwnProperty('searchGrid') && $t.p.searchModules.searchGrid !== false ) {
if(sdata[p.sFilter] !== "") {
$t.p.searchModules.searchGrid = sdata[p.sFilter];
} else {
$t.p.searchModules.searchGrid = null;
}
$.extend($t.p.postData,{filters: $.jgrid.splitSearch($t.p.searchModules)});
} else {
$.extend($t.p.postData,sdata);
}
mustReload = $($t).triggerHandler("jqGridFilterSearch");
if( mustReload === undefined) {
mustReload = true;
}
if(mustReload && $.isFunction(p.onSearch) ) {
mustReload = p.onSearch.call($t, $t.p.filters);
}
if (mustReload !== false) {
$($t).trigger("reloadGrid",[{page:1}]);
}
if(p.closeAfterSearch) {
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:p.jqModal,onClose: p.onClose});
}
return false;
});
$("#"+fid+"_reset").on('click', function(){
var sdata={},
fl = $("#"+fid);
$t.p.search = false;
$t.p.resetsearch = true;
if(p.multipleSearch===false) {
sdata[p.sField] = sdata[p.sValue] = sdata[p.sOper] = "";
} else {
sdata[p.sFilter] = "";
}
fl[0].resetFilter();
if(found) {
$(".ui-template", fil).val("default");
}
if($t.p.mergeSearch === true && $t.p.searchModules.hasOwnProperty('searchGrid') && $t.p.searchModules.searchGrid !== false ) {
$t.p.searchModules.searchGrid = null;
$.extend($t.p.postData,{filters: $.jgrid.splitSearch($t.p.searchModules)});
$t.p.search = true;
} else {
$.extend($t.p.postData,sdata);
}
mustReload = $($t).triggerHandler("jqGridFilterReset");
if(mustReload === undefined) {
mustReload = true;
}
if(mustReload && $.isFunction(p.onReset) ) {
mustReload = p.onReset.call($t);
}
if(mustReload !== false) {
$($t).trigger("reloadGrid",[{page:1}]);
}
if (p.closeAfterReset) {
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:p.jqModal,onClose: p.onClose});
}
return false;
});
showFilter($("#"+fid));
$(".fm-button:not(."+common.disabled+")",fil).hover(
function(){$(this).addClass(common.hover);},
function(){$(this).removeClass(common.hover);}
);
}
});
},
filterInput : function( val, p) {
p = $.extend(true, {
defaultSearch : 'cn',
groupOp : 'OR',
searchAll : false,
beforeSearch : null,
afterSearch : null
}, p || {});
return this.each(function(){
var $t = this;
if(!$t.grid) {return;}
var nm, sop,ruleGroup = "{\"groupOp\":\"" + p.groupOp + "\",\"rules\":[", gi=0, so;
val +="";
if($t.p.datatype !== 'local') { return; }
$.each($t.p.colModel,function(){
nm = this.index || this.name;
sop = this.searchoptions || {};
so = p.defaultSearch ? p.defaultSearch : (sop.sopt) ? sop.sopt[0] : p.defaultSearch;
this.search = this.search === false ? false : true;
if (this.search || p.searchAll) {
if (gi > 0) {ruleGroup += ",";}
ruleGroup += "{\"field\":\"" + nm + "\",";
ruleGroup += "\"op\":\"" + so + "\",";
ruleGroup += "\"data\":\"" + val.replace(/\\/g,'\\\\').replace(/\"/g,'\\"') + "\"}";
gi++;
}
});
ruleGroup += "]}";
if($t.p.mergeSearch === true && $t.p.searchModules.hasOwnProperty('filterInput') && $t.p.searchModules.filterInput !== false ) {
if(gi > 0) {
$t.p.searchModules.filterInput = ruleGroup;
} else {
$t.p.searchModules.filterInput = null;
}
$.extend($t.p.postData,{filters: $.jgrid.splitSearch($t.p.searchModules)});
} else {
$.extend($t.p.postData,{filters:ruleGroup});
}
$.each(['searchField', 'searchString', 'searchOper'], function(i, n){
if($t.p.postData.hasOwnProperty(n)) { delete $t.p.postData[n];}
});
var bsr = $($t).triggerHandler("jqGridFilterInputBeforeSearch") === 'stop' ? true : false;
if(!bsr && $.isFunction(p.beforeSearch)){bsr = p.beforeSearch.call($t);}
if(!bsr) { $($t).jqGrid("setGridParam",{search:true}).trigger("reloadGrid",[{page:1}]); }
$($t).triggerHandler("jqGridFilterInputAfterSearch");
if($.isFunction(p.afterSearch)){p.afterSearch.call($t);}
});
},
autoSelect : function (o) {
o = $.extend(true,{
field : "",
direction : "asc",
src_date : "Y-m-d",
allValues : "All",
count_item : true,
create_value : true
}, o || {} );
return this.each(function() {
var $t = this, item, sdata="";
if( o.field && $t.p.data && $.isArray( $t.p.data )) {
var query, res, s_cnt, tmp = [], cm, len,
result, i;
try {
query = $.jgrid.from.call($t, $t.p.data);
result = query.groupBy( o.field, o.direction, "text", o.src_date);
i = result.length;
} catch(e) {
}
if(result && result.length) {
res = $("#gsh_"+$t.p.id+"_"+o.field).find("td.ui-search-input > select");
i = result.length;
if(o.allValues) {
sdata = "<option value=''>"+ o.allValues +"</option>";
tmp.push(":" + o.allValues);
}
while(i--) {
item = result[i];
s_cnt = o.count_item ? " (" +item.items.length+")" : "";
sdata += "<option value='"+item.unique+"'>"+ item.unique + s_cnt+"</option>";
tmp.push(item.unique+":"+item.unique + s_cnt);
}
res.append(sdata);
res.on('change',function(){
$t.triggerToolbar();
});
if( o.create_value ) {
for(i=0, len = $t.p.colModel.length; i < len; i++ ) {
if($t.p.colModel[i].name === o.field) {
cm = $t.p.colModel[i];
break;
}
}
if(cm) {
if(cm.searchoptions) {
$.extend(cm.searchoptions, {value: tmp.join(";")});
} else {
cm.searchoptions = {};
cm.searchoptions.value = tmp.join(";");
}
}
}
}
}
});
}
});
//module begin
var rp_ge = {};
$.jgrid.extend({
editGridRow : function(rowid, p){
var regional = $.jgrid.getRegional(this[0], 'edit'),
currstyle = this[0].p.styleUI,
styles = $.jgrid.styleUI[currstyle].formedit,
commonstyle = $.jgrid.styleUI[currstyle].common;
p = $.extend(true, {
top : 0,
left: 0,
width: '500',
datawidth: 'auto',
height: 'auto',
dataheight: 'auto',
modal: false,
overlay : 30,
drag: true,
resize: true,
url: null,
mtype : "POST",
clearAfterAdd :true,
closeAfterEdit : false,
reloadAfterSubmit : true,
onInitializeForm: null,
beforeInitData: null,
beforeShowForm: null,
afterShowForm: null,
beforeSubmit: null,
afterSubmit: null,
onclickSubmit: null,
afterComplete: null,
onclickPgButtons : null,
afterclickPgButtons: null,
editData : {},
recreateForm : false,
jqModal : true,
closeOnEscape : false,
addedrow : "first",
topinfo : '',
bottominfo: '',
saveicon : [],
closeicon : [],
savekey: [false,13],
navkeys: [false,38,40],
checkOnSubmit : false,
checkOnUpdate : false,
processing : false,
onClose : null,
ajaxEditOptions : {},
serializeEditData : null,
viewPagerButtons : true,
overlayClass : commonstyle.overlay,
removemodal : true,
form: 'edit',
template : null,
focusField : true,
editselected : false,
html5Check : false,
buttons : []
}, regional, p || {});
rp_ge[$(this)[0].p.id] = p;
return this.each(function(){
var $t = this;
if (!$t.grid || !rowid) {return;}
$t.p.savedData = {};
var gID = $t.p.id,
frmgr = "FrmGrid_"+gID, frmtborg = "TblGrid_"+gID, frmtb = "#"+$.jgrid.jqID(frmtborg), frmtb2,
IDs = {themodal:'editmod'+gID,modalhead:'edithd'+gID,modalcontent:'editcnt'+gID, scrollelm : frmgr},
showFrm = true, maxCols = 1, maxRows=0, postdata, diff, frmoper,
templ = typeof rp_ge[$t.p.id].template === "string" && rp_ge[$t.p.id].template.length > 0,
errors =$.jgrid.getRegional(this, 'errors');
rp_ge[$t.p.id].styleUI = $t.p.styleUI || 'jQueryUI';
if($.jgrid.isMobile()) {
rp_ge[$t.p.id].resize = false;
}
if (rowid === "new") {
rowid = "_empty";
frmoper = "add";
p.caption=rp_ge[$t.p.id].addCaption;
} else {
p.caption=rp_ge[$t.p.id].editCaption;
frmoper = "edit";
}
if(!p.recreateForm) {
if( $($t).data("formProp") ) {
$.extend(rp_ge[$(this)[0].p.id], $($t).data("formProp"));
}
}
var closeovrl = true;
if(p.checkOnUpdate && p.jqModal && !p.modal) {
closeovrl = false;
}
function getFormData(){
var a2 ={}, i;
$(frmtb).find(".FormElement").each(function() {
var celm = $(".customelement", this);
if (celm.length) {
var elem = celm[0], nm = $(elem).attr('name');
$.each($t.p.colModel, function(){
if(this.name === nm && this.editoptions && $.isFunction(this.editoptions.custom_value)) {
try {
postdata[nm] = this.editoptions.custom_value.call($t, $("#"+$.jgrid.jqID(nm),frmtb),'get');
if (postdata[nm] === undefined) {throw "e1";}
} catch (e) {
if (e==="e1") {$.jgrid.info_dialog(errors.errcap,"function 'custom_value' "+rp_ge[$(this)[0]].p.msg.novalue,rp_ge[$(this)[0]].p.bClose, {styleUI : rp_ge[$(this)[0]].p.styleUI });}
else {$.jgrid.info_dialog(errors.errcap,e.message,rp_ge[$(this)[0]].p.bClose, {styleUI : rp_ge[$(this)[0]].p.styleUI });}
}
return true;
}
});
} else {
switch ($(this).get(0).type) {
case "checkbox":
if($(this).is(":checked")) {
postdata[this.name]= $(this).val();
} else {
var ofv = $(this).attr("offval");
postdata[this.name]= ofv;
}
break;
case "select-one":
postdata[this.name]= $(this).val();
break;
case "select-multiple":
postdata[this.name]= $(this).val();
postdata[this.name] = postdata[this.name] ? postdata[this.name].join(",") : "";
break;
case "radio" :
if(a2.hasOwnProperty(this.name)) {
return true;
} else {
a2[this.name] = ($(this).attr("offval") === undefined) ? "off" : $(this).attr("offval");
}
break;
default:
postdata[this.name] = $(this).val();
}
if($t.p.autoencode) {
postdata[this.name] = $.jgrid.htmlEncode(postdata[this.name]);
}
}
});
for(i in a2 ) {
if( a2.hasOwnProperty(i)) {
var val = $('input[name="'+i+'"]:checked',frmtb).val();
postdata[i] = (val !== undefined) ? val : a2[i];
if($t.p.autoencode) {
postdata[i] = $.jgrid.htmlEncode(postdata[i]);
}
}
}
return true;
}
function createData(rowid,obj,tb,maxcols){
var nm, hc,trdata, cnt=0,tmp, dc,elc, retpos=[], ind=false,
tdtmpl = "<td class='CaptionTD'></td><td class='DataTD'></td>", tmpl="", i, ffld; //*2
for (i =1; i<=maxcols;i++) {
tmpl += tdtmpl;
}
if(rowid !== '_empty') {
ind = $(obj).jqGrid("getInd",rowid);
}
$(obj.p.colModel).each( function(i) {
nm = this.name;
// hidden fields are included in the form
if(this.editrules && this.editrules.edithidden === true) {
hc = false;
} else {
hc = this.hidden === true ? true : false;
}
dc = hc ? "style='display:none'" : "";
if ( nm !== 'cb' && nm !== 'subgrid' && this.editable===true && nm !== 'rn') {
if(ind === false) {
tmp = "";
} else {
if(nm === obj.p.ExpandColumn && obj.p.treeGrid === true) {
tmp = $("td[role='gridcell']:eq("+i+")",obj.rows[ind]).text();
} else {
try {
tmp = $.unformat.call(obj, $("td[role='gridcell']:eq("+i+")",obj.rows[ind]),{rowId:rowid, colModel:this},i);
} catch (_) {
tmp = (this.edittype && this.edittype === "textarea") ? $("td[role='gridcell']:eq("+i+")",obj.rows[ind]).text() : $("td[role='gridcell']:eq("+i+")",obj.rows[ind]).html();
}
if(!tmp || tmp === " " || tmp === " " || (tmp.length===1 && tmp.charCodeAt(0)===160) ) {tmp='';}
}
}
var opt = $.extend({}, this.editoptions || {} ,{id:nm,name:nm, rowId: rowid, oper:'edit', module : 'form', checkUpdate : rp_ge[$t.p.id].checkOnSubmit || rp_ge[$t.p.id].checkOnUpdate}),
frmopt = $.extend({}, {elmprefix:'',elmsuffix:'',rowabove:false,rowcontent:''}, this.formoptions || {}),
rp = parseInt(frmopt.rowpos,10) || cnt+1,
cp = parseInt((parseInt(frmopt.colpos,10) || 1)*2,10);
if(rowid === "_empty" && opt.defaultValue ) {
tmp = $.isFunction(opt.defaultValue) ? opt.defaultValue.call($t) : opt.defaultValue;
}
if(!this.edittype) {
this.edittype = "text";
}
if($t.p.autoencode) {
tmp = $.jgrid.htmlDecode(tmp);
}
elc = $.jgrid.createEl.call($t,this.edittype,opt,tmp,false,$.extend({},$.jgrid.ajaxOptions,obj.p.ajaxSelectOptions || {}));
//if(tmp === "" && this.edittype == "checkbox") {tmp = $(elc).attr("offval");}
//if(tmp === "" && this.edittype == "select") {tmp = $("option:eq(0)",elc).text();}
if(this.edittype === "select") {
tmp = $(elc).val();
if($(elc).get(0).type === 'select-multiple' && tmp) {
tmp = tmp.join(",");
}
}
if(this.edittype === 'checkbox') {
if($(elc).is(":checked")) {
tmp= $(elc).val();
} else {
tmp = $(elc).attr("offval");
}
}
$(elc).addClass("FormElement");
if( $.inArray(this.edittype,
['text','textarea','password','select',
'color', 'date', 'datetime', 'datetime-local','email','month',
'number','range', 'search', 'tel', 'time', 'url','week'] ) > -1) {
$(elc).addClass( styles.inputClass );
}
ffld = true;
if(templ) {
var ftmplfld = $(frm).find("#"+nm);
if(ftmplfld.length){
ftmplfld.replaceWith( elc );
} else {
ffld = false;
}
} else {
//--------------------
trdata = $(tb).find("tr[rowpos="+rp+"]");
if(frmopt.rowabove) {
var newdata = $("<tr><td class='contentinfo' colspan='"+(maxcols*2)+"'>"+frmopt.rowcontent+"</td></tr>");
$(tb).append(newdata);
newdata[0].rp = rp;
}
if ( trdata.length===0 ) {
if(maxcols > 1) {
trdata = $("<tr rowpos='"+rp+"'></tr>").addClass("FormData").attr("id","tr_"+nm);
} else {
trdata = $("<tr "+dc+" rowpos='"+rp+"'></tr>").addClass("FormData").attr("id","tr_"+nm);
}
$(trdata).append(tmpl);
$(tb).append(trdata);
trdata[0].rp = rp;
}
$("td:eq("+(cp-2)+")",trdata[0]).html("<label for='"+nm+"'>"+ (frmopt.label === undefined ? obj.p.colNames[i]: frmopt.label) + "</label>");
$("td:eq("+(cp-1)+")",trdata[0]).append(frmopt.elmprefix).append(elc).append(frmopt.elmsuffix);
if( maxcols > 1 && hc) {
$("td:eq("+(cp-2)+")",trdata[0]).hide();
$("td:eq("+(cp-1)+")",trdata[0]).hide();
}
//-------------------------
}
if( (rp_ge[$t.p.id].checkOnSubmit || rp_ge[$t.p.id].checkOnUpdate) && ffld) {
$t.p.savedData[nm] = tmp;
}
if(this.edittype==='custom' && $.isFunction(opt.custom_value) ) {
opt.custom_value.call($t, $("#"+nm, frmgr),'set',tmp);
}
$.jgrid.bindEv.call($t, elc, opt);
retpos[cnt] = i;
cnt++;
}
});
if( cnt > 0) {
var idrow;
if(templ) {
idrow = "<div class='FormData' style='display:none'><input class='FormElement' id='id_g' type='text' name='"+obj.p.id+"_id' value='"+rowid+"'/>";
$(frm).append(idrow);
} else {
idrow = $("<tr class='FormData' style='display:none'><td class='CaptionTD'></td><td colspan='"+ (maxcols*2-1)+"' class='DataTD'><input class='FormElement' id='id_g' type='text' name='"+obj.p.id+"_id' value='"+rowid+"'/></td></tr>");
idrow[0].rp = cnt+999;
$(tb).append(idrow);
}
//$(tb).append(idrow);
if(rp_ge[$t.p.id].checkOnSubmit || rp_ge[$t.p.id].checkOnUpdate) {
$t.p.savedData[obj.p.id+"_id"] = rowid;
}
}
return retpos;
}
function fillData(rowid,obj,fmid){
var nm,cnt=0,tmp, fld,opt,vl,vlc;
if(rp_ge[$t.p.id].checkOnSubmit || rp_ge[$t.p.id].checkOnUpdate) {
$t.p.savedData = {};
$t.p.savedData[obj.p.id+"_id"]=rowid;
}
var cm = obj.p.colModel;
if(rowid === '_empty') {
$(cm).each(function(){
nm = this.name;
opt = $.extend({}, this.editoptions || {} );
fld = $("#"+$.jgrid.jqID(nm),fmid);
if(fld && fld.length && fld[0] !== null) {
vl = "";
if(this.edittype === 'custom' && $.isFunction(opt.custom_value)) {
opt.custom_value.call($t, $("#"+nm,fmid),'set',vl);
} else if(opt.defaultValue ) {
vl = $.isFunction(opt.defaultValue) ? opt.defaultValue.call($t) : opt.defaultValue;
if(fld[0].type==='checkbox') {
vlc = vl.toLowerCase();
if(vlc.search(/(false|f|0|no|n|off|undefined)/i)<0 && vlc!=="") {
fld[0].checked = true;
fld[0].defaultChecked = true;
fld[0].value = vl;
} else {
fld[0].checked = false;
fld[0].defaultChecked = false;
}
} else {fld.val(vl);}
} else {
if( fld[0].type==='checkbox' ) {
fld[0].checked = false;
fld[0].defaultChecked = false;
vl = $(fld).attr("offval");
} else if (fld[0].type && fld[0].type.substr(0,6)==='select') {
fld[0].selectedIndex = 0;
} else {
fld.val(vl);
}
}
if(rp_ge[$t.p.id].checkOnSubmit===true || rp_ge[$t.p.id].checkOnUpdate) {
$t.p.savedData[nm] = vl;
}
}
});
$("#id_g",fmid).val(rowid);
return;
}
var tre = $(obj).jqGrid("getInd",rowid,true);
if(!tre) {return;}
$('td[role="gridcell"]',tre).each( function(i) {
nm = cm[i].name;
// hidden fields are included in the form
if ( nm !== 'cb' && nm !== 'subgrid' && nm !== 'rn' && cm[i].editable===true) {
if(nm === obj.p.ExpandColumn && obj.p.treeGrid === true) {
tmp = $(this).text();
} else {
try {
tmp = $.unformat.call(obj, $(this),{rowId:rowid, colModel:cm[i]},i);
} catch (_) {
tmp = cm[i].edittype==="textarea" ? $(this).text() : $(this).html();
}
}
if($t.p.autoencode) {tmp = $.jgrid.htmlDecode(tmp);}
if(rp_ge[$t.p.id].checkOnSubmit===true || rp_ge[$t.p.id].checkOnUpdate) {
$t.p.savedData[nm] = tmp;
}
nm = $.jgrid.jqID(nm);
switch (cm[i].edittype) {
case "select":
var opv = tmp.split(",");
opv = $.map(opv,function(n){return $.trim(n);});
$("#"+nm+" option",fmid).each(function(){
if (!cm[i].editoptions.multiple && ($.trim(tmp) === $.trim($(this).text()) || opv[0] === $.trim($(this).text()) || opv[0] === $.trim($(this).val())) ){
this.selected= true;
} else if (cm[i].editoptions.multiple){
if( $.inArray($.trim($(this).text()), opv ) > -1 || $.inArray($.trim($(this).val()), opv ) > -1 ){
this.selected = true;
}else{
this.selected = false;
}
} else {
this.selected = false;
}
});
if(rp_ge[$t.p.id].checkOnSubmit===true || rp_ge[$t.p.id].checkOnUpdate) {
tmp = $("#"+nm,fmid).val();
if(cm[i].editoptions.multiple) {
tmp = tmp.join(",");
}
$t.p.savedData[nm] = tmp;
}
break;
case "checkbox":
tmp = String(tmp);
if(cm[i].editoptions && cm[i].editoptions.value) {
var cb = cm[i].editoptions.value.split(":");
if(cb[0] === tmp) {
$("#"+nm, fmid)[$t.p.useProp ? 'prop': 'attr']({"checked":true, "defaultChecked" : true});
} else {
$("#"+nm, fmid)[$t.p.useProp ? 'prop': 'attr']({"checked":false, "defaultChecked" : false});
}
} else {
tmp = tmp.toLowerCase();
if(tmp.search(/(false|f|0|no|n|off|undefined)/i)<0 && tmp!=="") {
$("#"+nm, fmid)[$t.p.useProp ? 'prop': 'attr']("checked",true);
$("#"+nm, fmid)[$t.p.useProp ? 'prop': 'attr']("defaultChecked",true); //ie
} else {
$("#"+nm, fmid)[$t.p.useProp ? 'prop': 'attr']("checked", false);
$("#"+nm, fmid)[$t.p.useProp ? 'prop': 'attr']("defaultChecked", false); //ie
}
}
if(rp_ge[$t.p.id].checkOnSubmit===true || rp_ge[$t.p.id].checkOnUpdate) {
if($("#"+nm, fmid).is(":checked")) {
tmp = $("#"+nm, fmid).val();
} else {
tmp = $("#"+nm, fmid).attr("offval");
}
$t.p.savedData[nm] = tmp;
}
break;
case 'custom' :
try {
if(cm[i].editoptions && $.isFunction(cm[i].editoptions.custom_value)) {
cm[i].editoptions.custom_value.call($t, $("#"+nm, fmid),'set',tmp);
} else {throw "e1";}
} catch (e) {
if (e==="e1") {$.jgrid.info_dialog(errors.errcap,"function 'custom_value' "+rp_ge[$(this)[0]].p.msg.nodefined,$.rp_ge[$(this)[0]].p.bClose, {styleUI : rp_ge[$(this)[0]].p.styleUI });}
else {$.jgrid.info_dialog(errors.errcap,e.message,$.rp_ge[$(this)[0]].p.bClose, {styleUI : rp_ge[$(this)[0]].p.styleUI });}
}
break;
default :
if(tmp === " " || tmp === " " || (tmp.length===1 && tmp.charCodeAt(0)===160) ) {tmp='';}
$("#"+nm,fmid).val(tmp);
}
cnt++;
}
});
if(cnt>0) {
$("#id_g",frmtb).val(rowid);
if( rp_ge[$t.p.id].checkOnSubmit===true || rp_ge[$t.p.id].checkOnUpdate ) {
$t.p.savedData[obj.p.id+"_id"] = rowid;
}
}
}
function setNulls() {
$.each($t.p.colModel, function(i,n){
if(n.editoptions && n.editoptions.NullIfEmpty === true) {
if(postdata.hasOwnProperty(n.name) && postdata[n.name] === "") {
postdata[n.name] = 'null';
}
}
});
}
function postIt() {
var copydata, ret=[true,"",""], onCS = {}, opers = $t.p.prmNames, idname, oper, key, selr, i, url;
var retvals = $($t).triggerHandler("jqGridAddEditBeforeCheckValues", [postdata, $(frmgr), frmoper]);
if(retvals && typeof retvals === 'object') {postdata = retvals;}
if($.isFunction(rp_ge[$t.p.id].beforeCheckValues)) {
retvals = rp_ge[$t.p.id].beforeCheckValues.call($t, postdata, $(frmgr),frmoper);
if(retvals && typeof retvals === 'object') {postdata = retvals;}
}
if(rp_ge[$t.p.id].html5Check) {
if( !$.jgrid.validateForm(frm[0]) ) {
return false;
}
}
for( key in postdata ){
if(postdata.hasOwnProperty(key)) {
ret = $.jgrid.checkValues.call($t,postdata[key],key);
if(ret[0] === false) {break;}
}
}
setNulls();
if(ret[0]) {
onCS = $($t).triggerHandler("jqGridAddEditClickSubmit", [rp_ge[$t.p.id], postdata, frmoper]);
if( onCS === undefined && $.isFunction( rp_ge[$t.p.id].onclickSubmit)) {
onCS = rp_ge[$t.p.id].onclickSubmit.call($t, rp_ge[$t.p.id], postdata, frmoper) || {};
}
ret = $($t).triggerHandler("jqGridAddEditBeforeSubmit", [postdata, $(frmgr), frmoper]);
if(ret === undefined) {
ret = [true,"",""];
}
if( ret[0] && $.isFunction(rp_ge[$t.p.id].beforeSubmit)) {
ret = rp_ge[$t.p.id].beforeSubmit.call($t,postdata,$(frmgr), frmoper);
}
}
if(ret[0] && !rp_ge[$t.p.id].processing) {
rp_ge[$t.p.id].processing = true;
$("#sData", frmtb+"_2").addClass( commonstyle.active );
url = rp_ge[$t.p.id].url || $($t).jqGrid('getGridParam','editurl');
oper = opers.oper;
idname = url === 'clientArray' ? $t.p.keyName : opers.id;
// we add to pos data array the action - the name is oper
postdata[oper] = ($.trim(postdata[$t.p.id+"_id"]) === "_empty") ? opers.addoper : opers.editoper;
if(postdata[oper] !== opers.addoper) {
postdata[idname] = postdata[$t.p.id+"_id"];
} else {
// check to see if we have allredy this field in the form and if yes lieve it
if( postdata[idname] === undefined ) {postdata[idname] = postdata[$t.p.id+"_id"];}
}
delete postdata[$t.p.id+"_id"];
postdata = $.extend(postdata,rp_ge[$t.p.id].editData,onCS);
if($t.p.treeGrid === true) {
if(postdata[oper] === opers.addoper) {
selr = $($t).jqGrid("getGridParam", 'selrow');
var tr_par_id = $t.p.treeGridModel === 'adjacency' ? $t.p.treeReader.parent_id_field : 'parent_id';
postdata[tr_par_id] = selr;
}
for(i in $t.p.treeReader){
if($t.p.treeReader.hasOwnProperty(i)) {
var itm = $t.p.treeReader[i];
if(postdata.hasOwnProperty(itm)) {
if(postdata[oper] === opers.addoper && i === 'parent_id_field') {continue;}
delete postdata[itm];
}
}
}
}
postdata[idname] = $.jgrid.stripPref($t.p.idPrefix, postdata[idname]);
var ajaxOptions = $.extend({
url: url,
type: rp_ge[$t.p.id].mtype,
data: $.isFunction(rp_ge[$t.p.id].serializeEditData) ? rp_ge[$t.p.id].serializeEditData.call($t,postdata) : postdata,
complete:function(data,status){
var key;
$("#sData", frmtb+"_2").removeClass( commonstyle.active );
postdata[idname] = $t.p.idPrefix + postdata[idname];
if(data.status >= 300 && data.status !== 304) {
ret[0] = false;
ret[1] = $($t).triggerHandler("jqGridAddEditErrorTextFormat", [data, frmoper]);
if ($.isFunction(rp_ge[$t.p.id].errorTextFormat)) {
ret[1] = rp_ge[$t.p.id].errorTextFormat.call($t, data, frmoper);
} else {
ret[1] = status + " Status: '" + data.statusText + "'. Error code: " + data.status;
}
} else {
// data is posted successful
// execute aftersubmit with the returned data from server
ret = $($t).triggerHandler("jqGridAddEditAfterSubmit", [data, postdata, frmoper]);
if(ret === undefined) {
ret = [true,"",""];
}
if( ret[0] && $.isFunction(rp_ge[$t.p.id].afterSubmit) ) {
ret = rp_ge[$t.p.id].afterSubmit.call($t, data,postdata, frmoper);
}
}
if(ret[0] === false) {
$(".FormError",frmgr).html(ret[1]);
$(".FormError",frmgr).show();
} else {
if($t.p.autoencode) {
$.each(postdata,function(n,v){
postdata[n] = $.jgrid.htmlDecode(v);
});
}
//rp_ge[$t.p.id].reloadAfterSubmit = rp_ge[$t.p.id].reloadAfterSubmit && $t.p.datatype != "local";
// the action is add
if(postdata[oper] === opers.addoper ) {
//id processing
// user not set the id ret[2]
if(!ret[2]) {ret[2] = $.jgrid.randId();}
if(postdata[idname] == null || postdata[idname] === ($t.p.idPrefix + "_empty") || postdata[idname] === ""){
postdata[idname] = ret[2];
} else {
ret[2] = postdata[idname];
}
if(rp_ge[$t.p.id].reloadAfterSubmit) {
$($t).trigger("reloadGrid");
} else {
if($t.p.treeGrid === true){
$($t).jqGrid("addChildNode",ret[2],selr,postdata );
} else {
$($t).jqGrid("addRowData",ret[2],postdata,p.addedrow);
}
}
if(rp_ge[$t.p.id].closeAfterAdd) {
if($t.p.treeGrid !== true){
$($t).jqGrid("setSelection",ret[2]);
}
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal,onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
} else if (rp_ge[$t.p.id].clearAfterAdd) {
fillData("_empty", $t, frmgr);
}
} else {
// the action is update
if(rp_ge[$t.p.id].reloadAfterSubmit) {
$($t).trigger("reloadGrid");
if( !rp_ge[$t.p.id].closeAfterEdit ) {setTimeout(function(){$($t).jqGrid("setSelection",postdata[idname]);},1000);}
} else {
if($t.p.treeGrid === true) {
$($t).jqGrid("setTreeRow", postdata[idname],postdata);
} else {
$($t).jqGrid("setRowData", postdata[idname],postdata);
}
}
if(rp_ge[$t.p.id].closeAfterEdit) {$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal,onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});}
}
if( $.isFunction(rp_ge[$t.p.id].afterComplete) || Object.prototype.hasOwnProperty.call($._data( $($t)[0], 'events' ), 'jqGridAddEditAfterComplete') ) {
copydata = data;
setTimeout(function(){
$($t).triggerHandler("jqGridAddEditAfterComplete", [copydata, postdata, $(frmgr), frmoper]);
try {
rp_ge[$t.p.id].afterComplete.call($t, copydata, postdata, $(frmgr), frmoper);
} catch(excacmp) {
//do nothing
}
copydata=null;
},500);
}
if(rp_ge[$t.p.id].checkOnSubmit || rp_ge[$t.p.id].checkOnUpdate) {
$(frmgr).data("disabled",false);
if($t.p.savedData[$t.p.id+"_id"] !== "_empty"){
for(key in $t.p.savedData) {
if($t.p.savedData.hasOwnProperty(key) && postdata[key]) {
$t.p.savedData[key] = postdata[key];
}
}
}
}
}
rp_ge[$t.p.id].processing=false;
try{$(':input:visible',frmgr)[0].focus();} catch (e){}
}
}, $.jgrid.ajaxOptions, rp_ge[$t.p.id].ajaxEditOptions );
if (!ajaxOptions.url && !rp_ge[$t.p.id].useDataProxy) {
if ($.isFunction($t.p.dataProxy)) {
rp_ge[$t.p.id].useDataProxy = true;
} else {
ret[0]=false;ret[1] += " "+errors.nourl;
}
}
if (ret[0]) {
if (rp_ge[$t.p.id].useDataProxy) {
var dpret = $t.p.dataProxy.call($t, ajaxOptions, "set_"+$t.p.id);
if(dpret === undefined) {
dpret = [true, ""];
}
if(dpret[0] === false ) {
ret[0] = false;
ret[1] = dpret[1] || "Error deleting the selected row!" ;
} else {
if(ajaxOptions.data.oper === opers.addoper && rp_ge[$t.p.id].closeAfterAdd ) {
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal, onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
}
if(ajaxOptions.data.oper === opers.editoper && rp_ge[$t.p.id].closeAfterEdit ) {
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal, onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
}
}
} else {
if(ajaxOptions.url === "clientArray") {
rp_ge[$t.p.id].reloadAfterSubmit = false;
postdata = ajaxOptions.data;
ajaxOptions.complete({status:200, statusText:''},'');
} else {
$.ajax(ajaxOptions);
}
}
}
}
if(ret[0] === false) {
$(".FormError",frmgr).html(ret[1]);
$(".FormError",frmgr).show();
// return;
}
}
function compareData(nObj, oObj ) {
var ret = false,key;
ret = !( $.isPlainObject(nObj) && $.isPlainObject(oObj) && Object.getOwnPropertyNames(nObj).length === Object.getOwnPropertyNames(oObj).length);
if(!ret) {
for (key in oObj) {
if(oObj.hasOwnProperty(key) ) {
if(nObj.hasOwnProperty(key) ) {
if( nObj[key] !== oObj[key] ) {
ret = true;
break;
}
} else {
ret = true;
break;
}
}
}
}
return ret;
}
function checkUpdates () {
var stat = true;
$(".FormError",frmgr).hide();
if(rp_ge[$t.p.id].checkOnUpdate) {
postdata = {};
getFormData();
diff = compareData(postdata, $t.p.savedData);
if(diff) {
$(frmgr).data("disabled",true);
$(".confirm","#"+IDs.themodal).show();
stat = false;
}
}
return stat;
}
function restoreInline() {
var i;
if (rowid !== "_empty" && $t.p.savedRow !== undefined && $t.p.savedRow.length > 0 && $.isFunction($.fn.jqGrid.restoreRow)) {
for (i=0;i<$t.p.savedRow.length;i++) {
if ($t.p.savedRow[i].id === rowid) {
$($t).jqGrid('restoreRow',rowid);
break;
}
}
}
}
function updateNav(cr, posarr){
var totr = posarr[1].length-1;
if (cr===0) {
$("#pData",frmtb2).addClass( commonstyle.disabled );
} else if( posarr[1][cr-1] !== undefined && $("#"+$.jgrid.jqID(posarr[1][cr-1])).hasClass( commonstyle.disabled )) {
$("#pData",frmtb2).addClass( commonstyle.disabled );
} else {
$("#pData",frmtb2).removeClass( commonstyle.disabled );
}
if (cr===totr) {
$("#nData",frmtb2).addClass( commonstyle.disabled );
} else if( posarr[1][cr+1] !== undefined && $("#"+$.jgrid.jqID(posarr[1][cr+1])).hasClass( commonstyle.disabled )) {
$("#nData",frmtb2).addClass( commonstyle.disabled );
} else {
$("#nData",frmtb2).removeClass( commonstyle.disabled );
}
}
function getCurrPos() {
var rowsInGrid = $($t).jqGrid("getDataIDs"),
selrow = $("#id_g",frmtb).val(), pos;
if($t.p.multiselect && rp_ge[$t.p.id].editselected) {
var arr = [];
for(var i=0, len = rowsInGrid.length;i<len;i++) {
if($.inArray(rowsInGrid[i],$t.p.selarrrow) !== -1) {
arr.push(rowsInGrid[i]);
}
}
pos = $.inArray(selrow,arr);
return [pos, arr];
} else {
pos = $.inArray(selrow,rowsInGrid);
}
return [pos,rowsInGrid];
}
function parseTemplate ( template ){
var tmpl ="";
if(typeof template === "string") {
tmpl = template.replace(/\{([\w\-]+)(?:\:([\w\.]*)(?:\((.*?)?\))?)?\}/g, function(m,i){
return '<span id="'+ i+ '" ></span>';
});
}
return tmpl;
}
function syncSavedData () {
if(rp_ge[$t.p.id].checkOnSubmit || rp_ge[$t.p.id].checkOnUpdate) {
var a1=[], a2={};
a1 = $.map($t.p.savedData, function(v, i){
return i;
});
$(".FormElement", frm ).each(function(){
if( $.trim(this.name) !== "" && a1.indexOf(this.name) === -1 ) {
var tv = $(this).val(), tt = $(this).get(0).type;
if( tt === 'checkbox') {
if(!$(this).is(":checked")) {
tv = $(this).attr("offval");
}
} else if(tt === 'select-multiple') {
tv = tv.join(",");
} else if(tt === 'radio') {
if(a2.hasOwnProperty(this.name)) {
return true;
} else {
a2[this.name] = ($(this).attr("offval") === undefined) ? "off" : $(this).attr("offval");
}
}
$t.p.savedData[this.name] = tv;
}
});
for(var i in a2 ) {
if( a2.hasOwnProperty(i)) {
var val = $('input[name="'+i+'"]:checked',frm).val();
$t.p.savedData[i] = (val !== undefined) ? val : a2[i];
}
}
}
}
var dh = isNaN(rp_ge[$(this)[0].p.id].dataheight) ? rp_ge[$(this)[0].p.id].dataheight : rp_ge[$(this)[0].p.id].dataheight+"px",
dw = isNaN(rp_ge[$(this)[0].p.id].datawidth) ? rp_ge[$(this)[0].p.id].datawidth : rp_ge[$(this)[0].p.id].datawidth+"px",
frm = $("<form name='FormPost' id='"+frmgr+"' class='FormGrid' onSubmit='return false;' style='width:"+dw+";height:"+dh+";'></form>").data("disabled",false),
tbl;
if(templ) {
tbl = parseTemplate( rp_ge[$(this)[0].p.id].template );
frmtb2 = frmtb;
} else {
tbl = $("<table id='"+frmtborg+"' class='EditTable ui-common-table'><tbody></tbody></table>");
frmtb2 = frmtb+"_2";
}
frmgr = "#"+ $.jgrid.jqID(frmgr);
// errors
$(frm).append("<div class='FormError " + commonstyle.error + "' style='display:none;'></div>" );
// topinfo
$(frm).append("<div class='tinfo topinfo'>"+rp_ge[$t.p.id].topinfo+"</div>");
$($t.p.colModel).each( function() {
var fmto = this.formoptions;
maxCols = Math.max(maxCols, fmto ? fmto.colpos || 0 : 0 );
maxRows = Math.max(maxRows, fmto ? fmto.rowpos || 0 : 0 );
});
$(frm).append(tbl);
showFrm = $($t).triggerHandler("jqGridAddEditBeforeInitData", [frm, frmoper]);
if(showFrm === undefined) {
showFrm = true;
}
if(showFrm && $.isFunction(rp_ge[$t.p.id].beforeInitData)) {
showFrm = rp_ge[$t.p.id].beforeInitData.call($t,frm, frmoper);
}
if(showFrm === false) {return;}
restoreInline();
// set the id.
// use carefull only to change here colproperties.
// create data
createData(rowid,$t,tbl,maxCols);
// buttons at footer
var rtlb = $t.p.direction === "rtl" ? true :false,
bp = rtlb ? "nData" : "pData",
bn = rtlb ? "pData" : "nData";
var bP = "<a id='"+bp+"' class='fm-button " + commonstyle.button + "'><span class='" + commonstyle.icon_base + " " + styles.icon_prev+ "'></span></a>",
bN = "<a id='"+bn+"' class='fm-button " + commonstyle.button + "'><span class='" + commonstyle.icon_base + " " + styles.icon_next+ "'></span></a>",
bS ="<a id='sData' class='fm-button " + commonstyle.button + "'>"+p.bSubmit+"</a>",
bC ="<a id='cData' class='fm-button " + commonstyle.button + "'>"+p.bCancel+"</a>",
user_buttons = ( $.isArray( rp_ge[$t.p.id].buttons ) ? $.jgrid.buildButtons( rp_ge[$t.p.id].buttons, bS + bC, commonstyle ) : bS + bC );
var bt = "<table style='height:auto' class='EditTable ui-common-table' id='"+frmtborg+"_2'><tbody><tr><td colspan='2'><hr class='"+commonstyle.content+"' style='margin:1px'/></td></tr><tr id='Act_Buttons'><td class='navButton'>"+(rtlb ? bN+bP : bP+bN)+"</td><td class='EditButton'>"+ user_buttons +"</td></tr>";
//bt += "<tr style='display:none' class='binfo'><td class='bottominfo' colspan='2'>"+rp_ge[$t.p.id].bottominfo+"</td></tr>";
bt += "</tbody></table>";
if(maxRows > 0) {
var sd=[];
$.each($(tbl)[0].rows,function(i,r){
sd[i] = r;
});
sd.sort(function(a,b){
if(a.rp > b.rp) {return 1;}
if(a.rp < b.rp) {return -1;}
return 0;
});
$.each(sd, function(index, row) {
$('tbody',tbl).append(row);
});
}
p.gbox = "#gbox_"+$.jgrid.jqID(gID);
var cle = false;
if(p.closeOnEscape===true){
p.closeOnEscape = false;
cle = true;
}
var tms;
if(templ) {
$(frm).find("#pData").replaceWith( bP );
$(frm).find("#nData").replaceWith( bN );
$(frm).find("#sData").replaceWith( bS );
$(frm).find("#cData").replaceWith( bC );
tms = $("<div id="+frmtborg+"></div>").append(frm);
} else {
tms = $("<div></div>").append(frm).append(bt);
}
$(frm).append("<div class='binfo topinfo bottominfo'>"+rp_ge[$t.p.id].bottominfo+"</div>");
var fs = $('.ui-jqgrid').css('font-size') || '11px';
$.jgrid.createModal(IDs, tms, rp_ge[$(this)[0].p.id], "#gview_"+$.jgrid.jqID($t.p.id), $("#gbox_"+$.jgrid.jqID($t.p.id))[0], null, {"font-size": fs});
if(rtlb) {
$("#pData, #nData",frmtb+"_2").css("float","right");
$(".EditButton",frmtb+"_2").css("text-align","left");
}
if(rp_ge[$t.p.id].topinfo) {$(".tinfo", frmgr).show();}
if(rp_ge[$t.p.id].bottominfo) {$(".binfo",frmgr).show();}
tms = null;bt=null;
$("#"+$.jgrid.jqID(IDs.themodal)).keydown( function( e ) {
var wkey = e.target;
if ($(frmgr).data("disabled")===true ) {return false;}//??
if(rp_ge[$t.p.id].savekey[0] === true && e.which === rp_ge[$t.p.id].savekey[1]) { // save
if(wkey.tagName !== "TEXTAREA") {
$("#sData", frmtb+"_2").trigger("click");
return false;
}
}
if(e.which === 27) {
if(!checkUpdates()) {return false;}
if(cle) {$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:p.gbox,jqm:p.jqModal, onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});}
return false;
}
if(rp_ge[$t.p.id].navkeys[0]===true) {
if($("#id_g",frmtb).val() === "_empty") {return true;}
if(e.which === rp_ge[$t.p.id].navkeys[1]){ //up
$("#pData", frmtb2).trigger("click");
return false;
}
if(e.which === rp_ge[$t.p.id].navkeys[2]){ //down
$("#nData", frmtb2).trigger("click");
return false;
}
}
});
if(p.checkOnUpdate) {
$("a.ui-jqdialog-titlebar-close span","#"+$.jgrid.jqID(IDs.themodal)).removeClass("jqmClose");
$("a.ui-jqdialog-titlebar-close","#"+$.jgrid.jqID(IDs.themodal)).off("click")
.click(function(){
if(!checkUpdates()) {return false;}
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal,onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
return false;
});
}
p.saveicon = $.extend([true,"left", styles.icon_save ],p.saveicon);
p.closeicon = $.extend([true,"left", styles.icon_close ],p.closeicon);
// beforeinitdata after creation of the form
if(p.saveicon[0]===true) {
$("#sData",frmtb2).addClass(p.saveicon[1] === "right" ? 'fm-button-icon-right' : 'fm-button-icon-left')
.append("<span class='"+commonstyle.icon_base + " " +p.saveicon[2]+"'></span>");
}
if(p.closeicon[0]===true) {
$("#cData",frmtb2).addClass(p.closeicon[1] === "right" ? 'fm-button-icon-right' : 'fm-button-icon-left')
.append("<span class='" + commonstyle.icon_base +" "+p.closeicon[2]+"'></span>");
}
if(rp_ge[$t.p.id].checkOnSubmit || rp_ge[$t.p.id].checkOnUpdate) {
bS ="<a id='sNew' class='fm-button "+commonstyle.button + "' style='z-index:1002'>"+p.bYes+"</a>";
bN ="<a id='nNew' class='fm-button "+commonstyle.button + "' style='z-index:1002;margin-left:5px'>"+p.bNo+"</a>";
bC ="<a id='cNew' class='fm-button "+commonstyle.button + "' style='z-index:1002;margin-left:5px;'>"+p.bExit+"</a>";
var zI = p.zIndex || 999;zI ++;
$("#"+IDs.themodal).append("<div class='"+ p.overlayClass+" jqgrid-overlay confirm' style='z-index:"+zI+";display:none;position:absolute;'> "+"</div><div class='confirm ui-jqconfirm "+commonstyle.content+"' style='z-index:"+(zI+1)+"'>"+p.saveData+"<br/><br/>"+bS+bN+bC+"</div>");
$("#sNew","#"+$.jgrid.jqID(IDs.themodal)).click(function(){
postIt();
$(frmgr).data("disabled",false);
$(".confirm","#"+$.jgrid.jqID(IDs.themodal)).hide();
return false;
});
$("#nNew","#"+$.jgrid.jqID(IDs.themodal)).click(function(){
$(".confirm","#"+$.jgrid.jqID(IDs.themodal)).hide();
$(frmgr).data("disabled",false);
setTimeout(function(){$(":input:visible",frmgr)[0].focus();},0);
return false;
});
$("#cNew","#"+$.jgrid.jqID(IDs.themodal)).click(function(){
$(".confirm","#"+$.jgrid.jqID(IDs.themodal)).hide();
$(frmgr).data("disabled",false);
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal,onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
return false;
});
}
// here initform
$($t).triggerHandler("jqGridAddEditInitializeForm", [$(frmgr), frmoper]);
if($.isFunction(rp_ge[$t.p.id].onInitializeForm)) { rp_ge[$t.p.id].onInitializeForm.call($t,$(frmgr), frmoper);}
if(rowid==="_empty" || !rp_ge[$t.p.id].viewPagerButtons) {$("#pData,#nData",frmtb2).hide();} else {$("#pData,#nData",frmtb2).show();}
$($t).triggerHandler("jqGridAddEditBeforeShowForm", [$(frmgr), frmoper]);
if($.isFunction(rp_ge[$t.p.id].beforeShowForm)) { rp_ge[$t.p.id].beforeShowForm.call($t, $(frmgr), frmoper);}
syncSavedData();
$("#"+$.jgrid.jqID(IDs.themodal)).data("onClose",rp_ge[$t.p.id].onClose);
$.jgrid.viewModal("#"+$.jgrid.jqID(IDs.themodal),{
gbox:"#gbox_"+$.jgrid.jqID(gID),
jqm:p.jqModal,
overlay: p.overlay,
modal:p.modal,
overlayClass: p.overlayClass,
focusField : p.focusField,
onHide : function(h) {
var fh = $('#editmod'+gID)[0].style.height,
fw = $('#editmod'+gID)[0].style.width,
rtlsup = $("#gbox_"+$.jgrid.jqID(gID)).attr("dir") === "rtl" ? true : false;
if(fh.indexOf("px") > -1 ) {
fh = parseFloat(fh);
}
if(fw.indexOf("px") > -1 ) {
fw = parseFloat(fw);
}
$($t).data("formProp", {
top:parseFloat($(h.w).css("top")),
left : rtlsup ? ( $("#gbox_"+$.jgrid.jqID(gID)).outerWidth() - fw - parseFloat($(h.w).css("left")) + 12 ) : parseFloat($(h.w).css("left")),
width : fw,
height : fh,
dataheight : $(frmgr).height(),
datawidth: $(frmgr).width()
});
h.w.remove();
if(h.o) {h.o.remove();}
}
});
if(!closeovrl) {
$("." + $.jgrid.jqID(p.overlayClass)).click(function(){
if(!checkUpdates()) {return false;}
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal, onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
return false;
});
}
$(".fm-button","#"+$.jgrid.jqID(IDs.themodal)).hover(
function(){$(this).addClass( commonstyle.hover );},
function(){$(this).removeClass( commonstyle.hover );}
);
$("#sData", frmtb2).click(function(){
postdata = {};
$(".FormError",frmgr).hide();
// all depend on ret array
//ret[0] - succes
//ret[1] - msg if not succes
//ret[2] - the id that will be set if reload after submit false
getFormData();
if(postdata[$t.p.id+"_id"] === "_empty") {
postIt();
} else if(p.checkOnSubmit===true ) {
diff = compareData(postdata, $t.p.savedData);
if(diff) {
$(frmgr).data("disabled",true);
$(".confirm","#"+$.jgrid.jqID(IDs.themodal)).show();
} else {
postIt();
}
} else {
postIt();
}
return false;
});
$("#cData", frmtb2).click(function(){
if(!checkUpdates()) {return false;}
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal,onClose: rp_ge[$t.p.id].onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
return false;
});
// user buttons bind
$(frmtb2).find("[data-index]").each(function(){
var index = parseInt($(this).attr('data-index'),10);
if(index >=0 ) {
if( p.buttons[index].hasOwnProperty('click')) {
$(this).on('click', function(e) {
p.buttons[index].click.call($t, $(frmgr)[0], rp_ge[$t.p.id], e);
});
}
}
});
$("#nData", frmtb2).click(function(){
if(!checkUpdates()) {return false;}
$(".FormError",frmgr).hide();
var npos = getCurrPos();
npos[0] = parseInt(npos[0],10);
if(npos[0] !== -1 && npos[1][npos[0]+1]) {
$($t).triggerHandler("jqGridAddEditClickPgButtons", ['next',$(frmgr),npos[1][npos[0]]]);
var nposret;
if($.isFunction(p.onclickPgButtons)) {
nposret = p.onclickPgButtons.call($t, 'next',$(frmgr),npos[1][npos[0]]);
if( nposret !== undefined && nposret === false ) {return false;}
}
if( $("#"+$.jgrid.jqID(npos[1][npos[0]+1])).hasClass( commonstyle.disabled )) {return false;}
fillData(npos[1][npos[0]+1],$t,frmgr);
if(!($t.p.multiselect && rp_ge[$t.p.id].editselected)) {
$($t).jqGrid("setSelection",npos[1][npos[0]+1]);
}
$($t).triggerHandler("jqGridAddEditAfterClickPgButtons", ['next',$(frmgr),npos[1][npos[0]]]);
if($.isFunction(p.afterclickPgButtons)) {
p.afterclickPgButtons.call($t, 'next',$(frmgr),npos[1][npos[0]+1]);
}
syncSavedData();
updateNav(npos[0]+1,npos);
}
return false;
});
$("#pData", frmtb2).click(function(){
if(!checkUpdates()) {return false;}
$(".FormError",frmgr).hide();
var ppos = getCurrPos();
if(ppos[0] !== -1 && ppos[1][ppos[0]-1]) {
$($t).triggerHandler("jqGridAddEditClickPgButtons", ['prev',$(frmgr),ppos[1][ppos[0]]]);
var pposret;
if($.isFunction(p.onclickPgButtons)) {
pposret = p.onclickPgButtons.call($t, 'prev',$(frmgr),ppos[1][ppos[0]]);
if( pposret !== undefined && pposret === false ) {return false;}
}
if( $("#"+$.jgrid.jqID(ppos[1][ppos[0]-1])).hasClass( commonstyle.disabled )) {return false;}
fillData(ppos[1][ppos[0]-1],$t,frmgr);
if(!($t.p.multiselect && rp_ge[$t.p.id].editselected)) {
$($t).jqGrid("setSelection",ppos[1][ppos[0]-1]);
}
$($t).triggerHandler("jqGridAddEditAfterClickPgButtons", ['prev',$(frmgr),ppos[1][ppos[0]]]);
if($.isFunction(p.afterclickPgButtons)) {
p.afterclickPgButtons.call($t, 'prev',$(frmgr),ppos[1][ppos[0]-1]);
}
syncSavedData();
updateNav(ppos[0]-1,ppos);
}
return false;
});
$($t).triggerHandler("jqGridAddEditAfterShowForm", [$(frmgr), frmoper]);
if($.isFunction(rp_ge[$t.p.id].afterShowForm)) { rp_ge[$t.p.id].afterShowForm.call($t, $(frmgr), frmoper); }
var posInit =getCurrPos();
updateNav(posInit[0],posInit);
});
},
viewGridRow : function(rowid, p){
var regional = $.jgrid.getRegional(this[0], 'view'),
currstyle = this[0].p.styleUI,
styles = $.jgrid.styleUI[currstyle].formedit,
commonstyle = $.jgrid.styleUI[currstyle].common;
p = $.extend(true, {
top : 0,
left: 0,
width: 500,
datawidth: 'auto',
height: 'auto',
dataheight: 'auto',
modal: false,
overlay: 30,
drag: true,
resize: true,
jqModal: true,
closeOnEscape : false,
labelswidth: 'auto',
closeicon: [],
navkeys: [false,38,40],
onClose: null,
beforeShowForm : null,
beforeInitData : null,
viewPagerButtons : true,
recreateForm : false,
removemodal: true,
form: 'view',
buttons : []
}, regional, p || {});
rp_ge[$(this)[0].p.id] = p;
return this.each(function(){
var $t = this;
if (!$t.grid || !rowid) {return;}
var gID = $t.p.id,
frmgr = "ViewGrid_"+$.jgrid.jqID( gID ), frmtb = "ViewTbl_" + $.jgrid.jqID( gID ),
frmgr_id = "ViewGrid_"+gID, frmtb_id = "ViewTbl_"+gID,
IDs = {themodal:'viewmod'+gID,modalhead:'viewhd'+gID,modalcontent:'viewcnt'+gID, scrollelm : frmgr},
showFrm = true,
maxCols = 1, maxRows=0;
rp_ge[$t.p.id].styleUI = $t.p.styleUI || 'jQueryUI';
if(!p.recreateForm) {
if( $($t).data("viewProp") ) {
$.extend(rp_ge[$(this)[0].p.id], $($t).data("viewProp"));
}
}
function focusaref(){ //Sfari 3 issues
if(rp_ge[$t.p.id].closeOnEscape===true || rp_ge[$t.p.id].navkeys[0]===true) {
setTimeout(function(){$(".ui-jqdialog-titlebar-close","#"+$.jgrid.jqID(IDs.modalhead)).attr("tabindex", "-1").focus();},0);
}
}
function createData(rowid,obj,tb,maxcols){
var nm, hc,trdata, cnt=0,tmp, dc, retpos=[], ind=false, i,
tdtmpl = "<td class='CaptionTD form-view-label " + commonstyle.content + "' width='"+p.labelswidth+"'></td><td class='DataTD form-view-data ui-helper-reset " + commonstyle.content +"'></td>", tmpl="",
tdtmpl2 = "<td class='CaptionTD form-view-label " + commonstyle.content +"'></td><td class='DataTD form-view-data " + commonstyle.content +"'></td>",
fmtnum = ['integer','number','currency'],max1 =0, max2=0 ,maxw,setme, viewfld;
for (i=1;i<=maxcols;i++) {
tmpl += i === 1 ? tdtmpl : tdtmpl2;
}
// find max number align rigth with property formatter
$(obj.p.colModel).each( function() {
if(this.editrules && this.editrules.edithidden === true) {
hc = false;
} else {
hc = this.hidden === true ? true : false;
}
if(!hc && this.align==='right') {
if(this.formatter && $.inArray(this.formatter,fmtnum) !== -1 ) {
max1 = Math.max(max1,parseInt(this.width,10));
} else {
max2 = Math.max(max2,parseInt(this.width,10));
}
}
});
maxw = max1 !==0 ? max1 : max2 !==0 ? max2 : 0;
ind = $(obj).jqGrid("getInd",rowid);
$(obj.p.colModel).each( function(i) {
nm = this.name;
setme = false;
// hidden fields are included in the form
if(this.editrules && this.editrules.edithidden === true) {
hc = false;
} else {
hc = this.hidden === true ? true : false;
}
dc = hc ? "style='display:none'" : "";
viewfld = (typeof this.viewable !== 'boolean') ? true : this.viewable;
if ( nm !== 'cb' && nm !== 'subgrid' && nm !== 'rn' && viewfld) {
if(ind === false) {
tmp = "";
} else {
if(nm === obj.p.ExpandColumn && obj.p.treeGrid === true) {
tmp = $("td:eq("+i+")",obj.rows[ind]).text();
} else {
tmp = $("td:eq("+i+")",obj.rows[ind]).html();
}
}
setme = this.align === 'right' && maxw !==0 ? true : false;
var frmopt = $.extend({},{rowabove:false,rowcontent:''}, this.formoptions || {}),
rp = parseInt(frmopt.rowpos,10) || cnt+1,
cp = parseInt((parseInt(frmopt.colpos,10) || 1)*2,10);
if(frmopt.rowabove) {
var newdata = $("<tr><td class='contentinfo' colspan='"+(maxcols*2)+"'>"+frmopt.rowcontent+"</td></tr>");
$(tb).append(newdata);
newdata[0].rp = rp;
}
trdata = $(tb).find("tr[rowpos="+rp+"]");
if ( trdata.length===0 ) {
trdata = $("<tr "+dc+" rowpos='"+rp+"'></tr>").addClass("FormData").attr("id","trv_"+nm);
$(trdata).append(tmpl);
$(tb).append(trdata);
trdata[0].rp = rp;
}
$("td:eq("+(cp-2)+")",trdata[0]).html('<b>'+ (frmopt.label === undefined ? obj.p.colNames[i]: frmopt.label)+'</b>');
$("td:eq("+(cp-1)+")",trdata[0]).append("<span>"+tmp+"</span>").attr("id","v_"+nm);
if(setme){
$("td:eq("+(cp-1)+") span",trdata[0]).css({'text-align':'right',width:maxw+"px"});
}
retpos[cnt] = i;
cnt++;
}
});
if( cnt > 0) {
var idrow = $("<tr class='FormData' style='display:none'><td class='CaptionTD'></td><td colspan='"+ (maxcols*2-1)+"' class='DataTD'><input class='FormElement' id='id_g' type='text' name='id' value='"+rowid+"'/></td></tr>");
idrow[0].rp = cnt+99;
$(tb).append(idrow);
}
return retpos;
}
function fillData(rowid,obj){
var nm, hc,cnt=0,tmp,trv;
trv = $(obj).jqGrid("getInd",rowid,true);
if(!trv) {return;}
$('td',trv).each( function(i) {
nm = obj.p.colModel[i].name;
// hidden fields are included in the form
if(obj.p.colModel[i].editrules && obj.p.colModel[i].editrules.edithidden === true) {
hc = false;
} else {
hc = obj.p.colModel[i].hidden === true ? true : false;
}
if ( nm !== 'cb' && nm !== 'subgrid' && nm !== 'rn') {
if(nm === obj.p.ExpandColumn && obj.p.treeGrid === true) {
tmp = $(this).text();
} else {
tmp = $(this).html();
}
nm = $.jgrid.jqID("v_"+nm);
$("#"+nm+" span","#"+frmtb).html(tmp);
if (hc) {$("#"+nm,"#"+frmtb).parents("tr:first").hide();}
cnt++;
}
});
if(cnt>0) {$("#id_g","#"+frmtb).val(rowid);}
}
function updateNav(cr,posarr){
var totr = posarr[1].length-1;
if (cr===0) {
$("#pData","#"+frmtb+"_2").addClass( commonstyle.disabled );
} else if( posarr[1][cr-1] !== undefined && $("#"+$.jgrid.jqID(posarr[1][cr-1])).hasClass(commonstyle.disabled)) {
$("#pData",frmtb+"_2").addClass( commonstyle.disabled );
} else {
$("#pData","#"+frmtb+"_2").removeClass( commonstyle.disabled );
}
if (cr===totr) {
$("#nData","#"+frmtb+"_2").addClass( commonstyle.disabled );
} else if( posarr[1][cr+1] !== undefined && $("#"+$.jgrid.jqID(posarr[1][cr+1])).hasClass( commonstyle.disabled )) {
$("#nData",frmtb+"_2").addClass( commonstyle.disabled );
} else {
$("#nData","#"+frmtb+"_2").removeClass( commonstyle.disabled );
}
}
function getCurrPos() {
var rowsInGrid = $($t).jqGrid("getDataIDs"),
selrow = $("#id_g","#"+frmtb).val(), pos;
if($t.p.multiselect && rp_ge[$t.p.id].viewselected) {
var arr = [];
for(var i=0, len = rowsInGrid.length;i<len;i++) {
if($.inArray(rowsInGrid[i],$t.p.selarrrow) !== -1) {
arr.push(rowsInGrid[i]);
}
}
pos = $.inArray(selrow,arr);
return [pos, arr];
} else {
pos = $.inArray(selrow,rowsInGrid);
}
return [pos,rowsInGrid];
}
var dh = isNaN(rp_ge[$(this)[0].p.id].dataheight) ? rp_ge[$(this)[0].p.id].dataheight : rp_ge[$(this)[0].p.id].dataheight+"px",
dw = isNaN(rp_ge[$(this)[0].p.id].datawidth) ? rp_ge[$(this)[0].p.id].datawidth : rp_ge[$(this)[0].p.id].datawidth+"px",
frm = $("<form name='FormPost' id='"+frmgr_id+"' class='FormGrid' style='width:"+dw+";height:"+dh+";'></form>"),
tbl =$("<table id='"+frmtb_id+"' class='EditTable ViewTable'><tbody></tbody></table>");
$($t.p.colModel).each( function() {
var fmto = this.formoptions;
maxCols = Math.max(maxCols, fmto ? fmto.colpos || 0 : 0 );
maxRows = Math.max(maxRows, fmto ? fmto.rowpos || 0 : 0 );
});
// set the id.
$(frm).append(tbl);
showFrm = $($t).triggerHandler("jqGridViewRowBeforeInitData", [frm]);
if(showFrm === undefined) {
showFrm = true;
}
if(showFrm && $.isFunction(rp_ge[$t.p.id].beforeInitData)) {
showFrm = rp_ge[$t.p.id].beforeInitData.call($t, frm);
}
if(showFrm === false) {return;}
createData(rowid, $t, tbl, maxCols);
var rtlb = $t.p.direction === "rtl" ? true :false,
bp = rtlb ? "nData" : "pData",
bn = rtlb ? "pData" : "nData",
// buttons at footer
bP = "<a id='"+bp+"' class='fm-button " + commonstyle.button + "'><span class='" + commonstyle.icon_base + " " + styles.icon_prev+ "'></span></a>",
bN = "<a id='"+bn+"' class='fm-button " + commonstyle.button + "'><span class='" + commonstyle.icon_base + " " + styles.icon_next+ "'></span></a>",
bC ="<a id='cData' class='fm-button " + commonstyle.button + "'>"+p.bClose+"</a>",
user_buttons = ( $.isArray( rp_ge[$t.p.id].buttons ) ? $.jgrid.buildButtons( rp_ge[$t.p.id].buttons, bC, commonstyle ) : bC );
if(maxRows > 0) {
var sd=[];
$.each($(tbl)[0].rows,function(i,r){
sd[i] = r;
});
sd.sort(function(a,b){
if(a.rp > b.rp) {return 1;}
if(a.rp < b.rp) {return -1;}
return 0;
});
$.each(sd, function(index, row) {
$('tbody',tbl).append(row);
});
}
p.gbox = "#gbox_"+$.jgrid.jqID(gID);
var bt = $("<div></div>").append(frm).append("<table border='0' class='EditTable' id='"+frmtb+"_2'><tbody><tr id='Act_Buttons'><td class='navButton' width='"+p.labelswidth+"'>"+(rtlb ? bN+bP : bP+bN)+"</td><td class='EditButton'>"+ user_buttons+"</td></tr></tbody></table>"),
fs = $('.ui-jqgrid').css('font-size') || '11px';
$.jgrid.createModal(IDs,bt, rp_ge[$(this)[0].p.id],"#gview_"+$.jgrid.jqID($t.p.id),$("#gview_"+$.jgrid.jqID($t.p.id))[0], null, {"font-size":fs});
if(rtlb) {
$("#pData, #nData","#"+frmtb+"_2").css("float","right");
$(".EditButton","#"+frmtb+"_2").css("text-align","left");
}
if(!p.viewPagerButtons) {$("#pData, #nData","#"+frmtb+"_2").hide();}
bt = null;
$("#"+IDs.themodal).keydown( function( e ) {
if(e.which === 27) {
if(rp_ge[$t.p.id].closeOnEscape) {$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:p.gbox,jqm:p.jqModal, onClose: p.onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});}
return false;
}
if(p.navkeys[0]===true) {
if(e.which === p.navkeys[1]){ //up
$("#pData", "#"+frmtb+"_2").trigger("click");
return false;
}
if(e.which === p.navkeys[2]){ //down
$("#nData", "#"+frmtb+"_2").trigger("click");
return false;
}
}
});
p.closeicon = $.extend([true,"left", styles.icon_close ],p.closeicon);
if(p.closeicon[0]===true) {
$("#cData","#"+frmtb+"_2").addClass(p.closeicon[1] === "right" ? 'fm-button-icon-right' : 'fm-button-icon-left')
.append("<span class='" + commonstyle.icon_base+ " " +p.closeicon[2]+"'></span>");
}
$($t).triggerHandler("jqGridViewRowBeforeShowForm", [$("#"+frmgr)]);
if($.isFunction(p.beforeShowForm)) {p.beforeShowForm.call($t,$("#"+frmgr));}
$.jgrid.viewModal("#"+$.jgrid.jqID(IDs.themodal),{
gbox:"#gbox_"+$.jgrid.jqID(gID),
jqm:p.jqModal,
overlay: p.overlay,
modal:p.modal,
onHide : function(h) {
var rtlsup = $("#gbox_"+$.jgrid.jqID(gID)).attr("dir") === "rtl" ? true : false,
fw = parseFloat($('#viewmod'+gID)[0].style.width);
$($t).data("viewProp", {
top:parseFloat($(h.w).css("top")),
left : rtlsup ? ( $("#gbox_"+$.jgrid.jqID(gID)).outerWidth() - fw - parseFloat($(h.w).css("left")) + 12 ) : parseFloat($(h.w).css("left")),
width : $(h.w).width(),
height : $(h.w).height(),
dataheight : $("#"+frmgr).height(),
datawidth: $("#"+frmgr).width()
});
h.w.remove();
if(h.o) {h.o.remove();}
}
});
$(".fm-button:not(." + commonstyle.disabled + ")","#"+frmtb+"_2").hover(
function(){$(this).addClass( commonstyle.hover );},
function(){$(this).removeClass( commonstyle.hover );}
);
focusaref();
$("#cData", "#"+frmtb+"_2").click(function(){
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal, onClose: p.onClose, removemodal: rp_ge[$t.p.id].removemodal, formprop: !rp_ge[$t.p.id].recreateForm, form: rp_ge[$t.p.id].form});
return false;
});
$("#"+frmtb+"_2").find("[data-index]").each(function(){
var index = parseInt($(this).attr('data-index'),10);
if(index >=0 ) {
if( p.buttons[index].hasOwnProperty('click')) {
$(this).on('click', function(e) {
p.buttons[index].click.call($t, $("#"+frmgr_id)[0], rp_ge[$t.p.id], e);
});
}
}
});
$("#nData", "#"+frmtb+"_2").click(function(){
$("#FormError","#"+frmtb).hide();
var npos = getCurrPos();
npos[0] = parseInt(npos[0],10);
if(npos[0] !== -1 && npos[1][npos[0]+1]) {
$($t).triggerHandler("jqGridViewRowClickPgButtons", ['next',$("#"+frmgr),npos[1][npos[0]]]);
if($.isFunction(p.onclickPgButtons)) {
p.onclickPgButtons.call($t,'next',$("#"+frmgr),npos[1][npos[0]]);
}
fillData(npos[1][npos[0]+1],$t);
if(!($t.p.multiselect && rp_ge[$t.p.id].viewselected)) {
$($t).jqGrid("setSelection",npos[1][npos[0]+1]);
}
$($t).triggerHandler("jqGridViewRowAfterClickPgButtons", ['next',$("#"+frmgr),npos[1][npos[0]+1]]);
if($.isFunction(p.afterclickPgButtons)) {
p.afterclickPgButtons.call($t,'next',$("#"+frmgr),npos[1][npos[0]+1]);
}
updateNav(npos[0]+1,npos);
}
focusaref();
return false;
});
$("#pData", "#"+frmtb+"_2").click(function(){
$("#FormError","#"+frmtb).hide();
var ppos = getCurrPos();
if(ppos[0] !== -1 && ppos[1][ppos[0]-1]) {
$($t).triggerHandler("jqGridViewRowClickPgButtons", ['prev',$("#"+frmgr),ppos[1][ppos[0]]]);
if($.isFunction(p.onclickPgButtons)) {
p.onclickPgButtons.call($t,'prev',$("#"+frmgr),ppos[1][ppos[0]]);
}
fillData(ppos[1][ppos[0]-1],$t);
if(!($t.p.multiselect && rp_ge[$t.p.id].viewselected)) {
$($t).jqGrid("setSelection",ppos[1][ppos[0]-1]);
}
$($t).triggerHandler("jqGridViewRowAfterClickPgButtons", ['prev',$("#"+frmgr),ppos[1][ppos[0]-1]]);
if($.isFunction(p.afterclickPgButtons)) {
p.afterclickPgButtons.call($t,'prev',$("#"+frmgr),ppos[1][ppos[0]-1]);
}
updateNav(ppos[0]-1,ppos);
}
focusaref();
return false;
});
var posInit =getCurrPos();
updateNav(posInit[0],posInit);
});
},
delGridRow : function(rowids,p) {
var regional = $.jgrid.getRegional(this[0], 'del'),
currstyle = this[0].p.styleUI,
styles = $.jgrid.styleUI[currstyle].formedit,
commonstyle = $.jgrid.styleUI[currstyle].common;
p = $.extend(true, {
top : 0,
left: 0,
width: 240,
height: 'auto',
dataheight : 'auto',
modal: false,
overlay: 30,
drag: true,
resize: true,
url : '',
mtype : "POST",
reloadAfterSubmit: true,
beforeShowForm: null,
beforeInitData : null,
afterShowForm: null,
beforeSubmit: null,
onclickSubmit: null,
afterSubmit: null,
jqModal : true,
closeOnEscape : false,
delData: {},
delicon : [],
cancelicon : [],
onClose : null,
ajaxDelOptions : {},
processing : false,
serializeDelData : null,
useDataProxy : false
}, regional, p ||{});
rp_ge[$(this)[0].p.id] = p;
return this.each(function(){
var $t = this;
if (!$t.grid ) {return;}
if(!rowids) {return;}
var gID = $t.p.id, onCS = {},
showFrm = true,
dtbl = "DelTbl_"+$.jgrid.jqID(gID),postd, idname, opers, oper,
dtbl_id = "DelTbl_" + gID,
IDs = {themodal:'delmod'+gID,modalhead:'delhd'+gID,modalcontent:'delcnt'+gID, scrollelm: dtbl};
rp_ge[$t.p.id].styleUI = $t.p.styleUI || 'jQueryUI';
if ($.isArray(rowids)) {rowids = rowids.join();}
if ( $("#"+$.jgrid.jqID(IDs.themodal))[0] !== undefined ) {
showFrm = $($t).triggerHandler("jqGridDelRowBeforeInitData", [$("#"+dtbl)]);
if(showFrm === undefined) {
showFrm = true;
}
if(showFrm && $.isFunction(rp_ge[$t.p.id].beforeInitData)) {
showFrm = rp_ge[$t.p.id].beforeInitData.call($t, $("#"+dtbl));
}
if(showFrm === false) {return;}
$("#DelData>td","#"+dtbl).text(rowids);
$("#DelError","#"+dtbl).hide();
if( rp_ge[$t.p.id].processing === true) {
rp_ge[$t.p.id].processing=false;
$("#dData", "#"+dtbl).removeClass( commonstyle.active );
}
$($t).triggerHandler("jqGridDelRowBeforeShowForm", [$("#"+dtbl)]);
if($.isFunction( rp_ge[$t.p.id].beforeShowForm )) {
rp_ge[$t.p.id].beforeShowForm.call($t,$("#"+dtbl));
}
$.jgrid.viewModal("#"+$.jgrid.jqID(IDs.themodal),{gbox:"#gbox_"+$.jgrid.jqID(gID),jqm:rp_ge[$t.p.id].jqModal, overlay: rp_ge[$t.p.id].overlay, modal:rp_ge[$t.p.id].modal});
$($t).triggerHandler("jqGridDelRowAfterShowForm", [$("#"+dtbl)]);
if($.isFunction( rp_ge[$t.p.id].afterShowForm )) {
rp_ge[$t.p.id].afterShowForm.call($t, $("#"+dtbl));
}
} else {
var dh = isNaN(rp_ge[$t.p.id].dataheight) ? rp_ge[$t.p.id].dataheight : rp_ge[$t.p.id].dataheight+"px",
dw = isNaN(p.datawidth) ? p.datawidth : p.datawidth+"px",
tbl = "<div id='"+dtbl_id+"' class='formdata' style='width:"+dw+";overflow:auto;position:relative;height:"+dh+";'>";
tbl += "<table class='DelTable'><tbody>";
// error data
tbl += "<tr id='DelError' style='display:none'><td class='" + commonstyle.error +"'></td></tr>";
tbl += "<tr id='DelData' style='display:none'><td >"+rowids+"</td></tr>";
tbl += "<tr><td class=\"delmsg\" style=\"white-space:pre;\">"+rp_ge[$t.p.id].msg+"</td></tr><tr><td > </td></tr>";
// buttons at footer
tbl += "</tbody></table></div>";
var bS = "<a id='dData' class='fm-button " + commonstyle.button + "'>"+p.bSubmit+"</a>",
bC = "<a id='eData' class='fm-button " + commonstyle.button + "'>"+p.bCancel+"</a>",
user_buttons = ( $.isArray( rp_ge[$t.p.id].buttons ) ? $.jgrid.buildButtons( rp_ge[$t.p.id].buttons, bS + bC, commonstyle ) : bS + bC ),
fs = $('.ui-jqgrid').css('font-size') || '11px';
tbl += "<table class='EditTable ui-common-table' id='"+dtbl+"_2'><tbody><tr><td><hr class='" + commonstyle.content + "' style='margin:1px'/></td></tr><tr><td class='DelButton EditButton'>"+ user_buttons +"</td></tr></tbody></table>";
p.gbox = "#gbox_"+$.jgrid.jqID(gID);
$.jgrid.createModal(IDs,tbl, rp_ge[$t.p.id] ,"#gview_"+$.jgrid.jqID($t.p.id),$("#gview_"+$.jgrid.jqID($t.p.id))[0], null, {"font-size": fs});
$(".fm-button","#"+dtbl+"_2").hover(
function(){$(this).addClass( commonstyle.hover );},
function(){$(this).removeClass( commonstyle.hover );}
);
p.delicon = $.extend([true,"left", styles.icon_del ],rp_ge[$t.p.id].delicon);
p.cancelicon = $.extend([true,"left", styles.icon_cancel ],rp_ge[$t.p.id].cancelicon);
if(p.delicon[0]===true) {
$("#dData","#"+dtbl+"_2").addClass(p.delicon[1] === "right" ? 'fm-button-icon-right' : 'fm-button-icon-left')
.append("<span class='" + commonstyle.icon_base + " " + p.delicon[2]+"'></span>");
}
if(p.cancelicon[0]===true) {
$("#eData","#"+dtbl+"_2").addClass(p.cancelicon[1] === "right" ? 'fm-button-icon-right' : 'fm-button-icon-left')
.append("<span class='" + commonstyle.icon_base + " " + p.cancelicon[2]+"'></span>");
}
$("#dData","#"+dtbl+"_2").click(function(){
var ret=[true,""], pk,
postdata = $("#DelData>td","#"+dtbl).text(); //the pair is name=val1,val2,...
onCS = {};
onCS = $($t).triggerHandler("jqGridDelRowClickSubmit", [rp_ge[$t.p.id], postdata]);
if(onCS === undefined && $.isFunction( rp_ge[$t.p.id].onclickSubmit ) ) {
onCS = rp_ge[$t.p.id].onclickSubmit.call($t, rp_ge[$t.p.id], postdata) || {};
}
ret = $($t).triggerHandler("jqGridDelRowBeforeSubmit", [postdata]);
if(ret === undefined) {
ret = [true,"",""];
}
if( ret[0] && $.isFunction(rp_ge[$t.p.id].beforeSubmit)) {
ret = rp_ge[$t.p.id].beforeSubmit.call($t, postdata);
}
if(ret[0] && !rp_ge[$t.p.id].processing) {
rp_ge[$t.p.id].processing = true;
opers = $t.p.prmNames;
postd = $.extend({},rp_ge[$t.p.id].delData, onCS);
oper = opers.oper;
postd[oper] = opers.deloper;
idname = opers.id;
postdata = String(postdata).split(",");
if(!postdata.length) { return false; }
for(pk in postdata) {
if(postdata.hasOwnProperty(pk)) {
postdata[pk] = $.jgrid.stripPref($t.p.idPrefix, postdata[pk]);
}
}
postd[idname] = postdata.join();
$(this).addClass( commonstyle.active );
var ajaxOptions = $.extend({
url: rp_ge[$t.p.id].url || $($t).jqGrid('getGridParam','editurl'),
type: rp_ge[$t.p.id].mtype,
data: $.isFunction(rp_ge[$t.p.id].serializeDelData) ? rp_ge[$t.p.id].serializeDelData.call($t,postd) : postd,
complete:function(data,status){
var i;
$("#dData", "#"+dtbl+"_2").removeClass( commonstyle.active );
if(data.status >= 300 && data.status !== 304) {
ret[0] = false;
ret[1] = $($t).triggerHandler("jqGridDelRowErrorTextFormat", [data]);
if ($.isFunction(rp_ge[$t.p.id].errorTextFormat)) {
ret[1] = rp_ge[$t.p.id].errorTextFormat.call($t, data);
}
if(ret[1] === undefined) {
ret[1] = status + " Status: '" + data.statusText + "'. Error code: " + data.status;
}
} else {
// data is posted successful
// execute aftersubmit with the returned data from server
ret = $($t).triggerHandler("jqGridDelRowAfterSubmit", [data, postd]);
if(ret === undefined) {
ret = [true,"",""];
}
if( ret[0] && $.isFunction(rp_ge[$t.p.id].afterSubmit) ) {
ret = rp_ge[$t.p.id].afterSubmit.call($t, data, postd);
}
}
if(ret[0] === false) {
$("#DelError>td","#"+dtbl).html(ret[1]);
$("#DelError","#"+dtbl).show();
} else {
if(rp_ge[$t.p.id].reloadAfterSubmit && $t.p.datatype !== "local") {
$($t).trigger("reloadGrid");
} else {
if($t.p.treeGrid===true){
try {$($t).jqGrid("delTreeNode",$t.p.idPrefix+postdata[0]);} catch(e){}
} else {
for(i=0;i<postdata.length;i++) {
$($t).jqGrid("delRowData",$t.p.idPrefix+ postdata[i]);
}
}
$t.p.selrow = null;
$t.p.selarrrow = [];
}
if($.isFunction(rp_ge[$t.p.id].afterComplete) || Object.prototype.hasOwnProperty.call($._data( $($t)[0], 'events' ), 'jqGridDelRowAfterComplete')) {
var copydata = data;
setTimeout(function(){
$($t).triggerHandler("jqGridDelRowAfterComplete", [copydata, postd]);
try {
rp_ge[$t.p.id].afterComplete.call($t, copydata, postd);
} catch(eacg) {
// do nothing
}
},500);
}
}
rp_ge[$t.p.id].processing=false;
if(ret[0]) {$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal, onClose: rp_ge[$t.p.id].onClose});}
}
}, $.jgrid.ajaxOptions, rp_ge[$t.p.id].ajaxDelOptions);
if (!ajaxOptions.url && !rp_ge[$t.p.id].useDataProxy) {
if ($.isFunction($t.p.dataProxy)) {
rp_ge[$t.p.id].useDataProxy = true;
} else {
ret[0]=false;ret[1] += " "+$.jgrid.getRegional($t, 'errors.nourl');
}
}
if (ret[0]) {
if (rp_ge[$t.p.id].useDataProxy) {
var dpret = $t.p.dataProxy.call($t, ajaxOptions, "del_"+$t.p.id);
if(dpret === undefined) {
dpret = [true, ""];
}
if(dpret[0] === false ) {
ret[0] = false;
ret[1] = dpret[1] || "Error deleting the selected row!" ;
} else {
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:p.jqModal, onClose: rp_ge[$t.p.id].onClose});
}
}
else {
if(ajaxOptions.url === "clientArray") {
postd = ajaxOptions.data;
ajaxOptions.complete({status:200, statusText:''},'');
} else {
$.ajax(ajaxOptions);
}
}
}
}
if(ret[0] === false) {
$("#DelError>td","#"+dtbl).html(ret[1]);
$("#DelError","#"+dtbl).show();
}
return false;
});
$("#eData", "#"+dtbl+"_2").click(function(){
$.jgrid.hideModal("#"+$.jgrid.jqID(IDs.themodal),{gb:"#gbox_"+$.jgrid.jqID(gID),jqm:rp_ge[$t.p.id].jqModal, onClose: rp_ge[$t.p.id].onClose});
return false;
});
$("#"+dtbl+"_2").find("[data-index]").each(function(){
var index = parseInt($(this).attr('data-index'),10);
if(index >=0 ) {
if( p.buttons[index].hasOwnProperty('click')) {
$(this).on('click', function(e) {
p.buttons[index].click.call($t, $("#"+dtbl_id)[0], rp_ge[$t.p.id], e);
});
}
}
});
showFrm = $($t).triggerHandler("jqGridDelRowBeforeInitData", [$("#"+dtbl)]);
if(showFrm === undefined) {
showFrm = true;
}
if(showFrm && $.isFunction(rp_ge[$t.p.id].beforeInitData)) {
showFrm = rp_ge[$t.p.id].beforeInitData.call($t, $("#"+dtbl));
}
if(showFrm === false) {return;}
$($t).triggerHandler("jqGridDelRowBeforeShowForm", [$("#"+dtbl)]);
if($.isFunction( rp_ge[$t.p.id].beforeShowForm )) {
rp_ge[$t.p.id].beforeShowForm.call($t,$("#"+dtbl));
}
$.jgrid.viewModal("#"+$.jgrid.jqID(IDs.themodal),{gbox:"#gbox_"+$.jgrid.jqID(gID),jqm:rp_ge[$t.p.id].jqModal, overlay: rp_ge[$t.p.id].overlay, modal:rp_ge[$t.p.id].modal});
$($t).triggerHandler("jqGridDelRowAfterShowForm", [$("#"+dtbl)]);
if($.isFunction( rp_ge[$t.p.id].afterShowForm )) {
rp_ge[$t.p.id].afterShowForm.call($t,$("#"+dtbl));
}
}
if(rp_ge[$t.p.id].closeOnEscape===true) {
setTimeout(function(){$(".ui-jqdialog-titlebar-close","#"+$.jgrid.jqID(IDs.modalhead)).attr("tabindex","-1").focus();},0);
}
});
},
navGrid : function (elem, p, pEdit, pAdd, pDel, pSearch, pView) {
var regional = $.jgrid.getRegional(this[0], 'nav'),
currstyle = this[0].p.styleUI,
styles = $.jgrid.styleUI[currstyle].navigator,
commonstyle = $.jgrid.styleUI[currstyle].common;
p = $.extend({
edit: true,
editicon: styles.icon_edit_nav,
add: true,
addicon: styles.icon_add_nav,
del: true,
delicon: styles.icon_del_nav,
search: true,
searchicon: styles.icon_search_nav,
refresh: true,
refreshicon: styles.icon_refresh_nav,
refreshstate: 'firstpage',
view: false,
viewicon : styles.icon_view_nav,
position : "left",
closeOnEscape : true,
beforeRefresh : null,
afterRefresh : null,
cloneToTop : false,
alertwidth : 200,
alertheight : 'auto',
alerttop: null,
alertleft: null,
alertzIndex : null,
dropmenu : false,
navButtonText : ''
}, regional, p ||{});
return this.each(function() {
if(this.p.navGrid) {return;}
var alertIDs = {themodal: 'alertmod_' + this.p.id, modalhead: 'alerthd_' + this.p.id,modalcontent: 'alertcnt_' + this.p.id},
$t = this, twd, tdw, o;
if(!$t.grid || typeof elem !== 'string') {return;}
if(!$($t).data('navGrid')) {
$($t).data('navGrid',p);
}
// speedoverhead, but usefull for future
o = $($t).data('navGrid');
if($t.p.force_regional) {
o = $.extend(o, regional);
}
if ($("#"+alertIDs.themodal)[0] === undefined) {
if(!o.alerttop && !o.alertleft) {
var pos=$.jgrid.findPos(this);
pos[0]=Math.round(pos[0]);
pos[1]=Math.round(pos[1]);
o.alertleft = pos[0] + (this.p.width/2)-parseInt(o.alertwidth,10)/2;
o.alerttop = pos[1] + (this.p.height/2)-25;
}
var fs = $('.ui-jqgrid').css('font-size') || '11px';
$.jgrid.createModal(alertIDs,
"<div>"+o.alerttext+"</div><span tabindex='0'><span tabindex='-1' id='jqg_alrt'></span></span>",
{
gbox:"#gbox_"+$.jgrid.jqID($t.p.id),
jqModal:true,
drag:true,
resize:true,
caption:o.alertcap,
top:o.alerttop,
left:o.alertleft,
width:o.alertwidth,
height: o.alertheight,
closeOnEscape:o.closeOnEscape,
zIndex: o.alertzIndex,
styleUI: $t.p.styleUI
},
"#gview_"+$.jgrid.jqID($t.p.id),
$("#gbox_"+$.jgrid.jqID($t.p.id))[0],
true,
{"font-size": fs}
);
}
var clone = 1, i,
onHoverIn = function () {
if (!$(this).hasClass(commonstyle.disabled)) {
$(this).addClass(commonstyle.hover);
}
},
onHoverOut = function () {
$(this).removeClass(commonstyle.hover);
};
if(o.cloneToTop && $t.p.toppager) {clone = 2;}
for(i = 0; i<clone; i++) {
var tbd,
navtbl = $("<table class='ui-pg-table navtable ui-common-table'><tbody><tr></tr></tbody></table>"),
sep = "<td class='ui-pg-button " +commonstyle.disabled + "' style='width:4px;'><span class='ui-separator'></span></td>",
pgid, elemids;
if(i===0) {
pgid = elem;
if(pgid.indexOf("#") === 0 ) {
pgid = pgid.substring(1);
pgid = "#"+ $.jgrid.jqID( pgid );
}
elemids = $t.p.id;
if(pgid === $t.p.toppager) {
elemids += "_top";
clone = 1;
}
} else {
pgid = $t.p.toppager;
elemids = $t.p.id+"_top";
}
if($t.p.direction === "rtl") {
$(navtbl).attr("dir","rtl").css("float","right");
}
pAdd = pAdd || {};
if (o.add) {
tbd = $("<td class='ui-pg-button "+commonstyle.cornerall+"'></td>");
$(tbd).append("<div class='ui-pg-div'><span class='"+commonstyle.icon_base +" " +o.addicon+"'></span>"+o.addtext+"</div>");
$("tr",navtbl).append(tbd);
$(tbd,navtbl)
.attr({"title":o.addtitle || "",id : pAdd.id || "add_"+elemids})
.click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
$.jgrid.setSelNavIndex( $t, this);
if ($.isFunction( o.addfunc )) {
o.addfunc.call($t);
} else {
$($t).jqGrid("editGridRow","new",pAdd);
}
}
return false;
}).hover(onHoverIn, onHoverOut);
tbd = null;
}
pEdit = pEdit || {};
if (o.edit) {
tbd = $("<td class='ui-pg-button "+commonstyle.cornerall+"'></td>");
$(tbd).append("<div class='ui-pg-div'><span class='"+commonstyle.icon_base+" "+o.editicon+"'></span>"+o.edittext+"</div>");
$("tr",navtbl).append(tbd);
$(tbd,navtbl)
.attr({"title":o.edittitle || "",id: pEdit.id || "edit_"+elemids})
.click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
var sr = $t.p.selrow;
if (sr) {
$.jgrid.setSelNavIndex( $t, this);
if($.isFunction( o.editfunc ) ) {
o.editfunc.call($t, sr);
} else {
$($t).jqGrid("editGridRow",sr,pEdit);
}
} else {
$.jgrid.viewModal("#"+alertIDs.themodal,{gbox:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:true});
$("#jqg_alrt").focus();
}
}
return false;
}).hover(onHoverIn, onHoverOut);
tbd = null;
}
pView = pView || {};
if (o.view) {
tbd = $("<td class='ui-pg-button "+commonstyle.cornerall+"'></td>");
$(tbd).append("<div class='ui-pg-div'><span class='"+commonstyle.icon_base+" "+o.viewicon+"'></span>"+o.viewtext+"</div>");
$("tr",navtbl).append(tbd);
$(tbd,navtbl)
.attr({"title":o.viewtitle || "",id: pView.id || "view_"+elemids})
.click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
var sr = $t.p.selrow;
if (sr) {
$.jgrid.setSelNavIndex( $t, this);
if($.isFunction( o.viewfunc ) ) {
o.viewfunc.call($t, sr);
} else {
$($t).jqGrid("viewGridRow",sr,pView);
}
} else {
$.jgrid.viewModal("#"+alertIDs.themodal,{gbox:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:true});
$("#jqg_alrt").focus();
}
}
return false;
}).hover(onHoverIn, onHoverOut);
tbd = null;
}
pDel = pDel || {};
if (o.del) {
tbd = $("<td class='ui-pg-button "+commonstyle.cornerall+"'></td>");
$(tbd).append("<div class='ui-pg-div'><span class='"+commonstyle.icon_base+" "+o.delicon+"'></span>"+o.deltext+"</div>");
$("tr",navtbl).append(tbd);
$(tbd,navtbl)
.attr({"title":o.deltitle || "",id: pDel.id || "del_"+elemids})
.click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
var dr;
if($t.p.multiselect) {
dr = $t.p.selarrrow;
if(dr.length===0) {dr = null;}
} else {
dr = $t.p.selrow;
}
if(dr){
$.jgrid.setSelNavIndex( $t, this);
if($.isFunction( o.delfunc )){
o.delfunc.call($t, dr);
}else{
$($t).jqGrid("delGridRow",dr,pDel);
}
} else {
$.jgrid.viewModal("#"+alertIDs.themodal,{gbox:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:true});$("#jqg_alrt").focus();
}
}
return false;
}).hover(onHoverIn, onHoverOut);
tbd = null;
}
if(o.add || o.edit || o.del || o.view) {$("tr",navtbl).append(sep);}
pSearch = pSearch || {};
if (o.search) {
tbd = $("<td class='ui-pg-button "+commonstyle.cornerall+"'></td>");
$(tbd).append("<div class='ui-pg-div'><span class='"+commonstyle.icon_base+" "+o.searchicon+"'></span>"+o.searchtext+"</div>");
$("tr",navtbl).append(tbd);
$(tbd,navtbl)
.attr({"title":o.searchtitle || "",id:pSearch.id || "search_"+elemids})
.click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
$.jgrid.setSelNavIndex( $t, this);
if($.isFunction( o.searchfunc )) {
o.searchfunc.call($t, pSearch);
} else {
$($t).jqGrid("searchGrid",pSearch);
}
}
return false;
}).hover(onHoverIn, onHoverOut);
if (pSearch.showOnLoad && pSearch.showOnLoad === true) {
$(tbd,navtbl).click();
}
tbd = null;
}
if (o.refresh) {
tbd = $("<td class='ui-pg-button "+commonstyle.cornerall+"'></td>");
$(tbd).append("<div class='ui-pg-div'><span class='"+commonstyle.icon_base+" "+o.refreshicon+"'></span>"+o.refreshtext+"</div>");
$("tr",navtbl).append(tbd);
$(tbd,navtbl)
.attr({"title":o.refreshtitle || "",id: "refresh_"+elemids})
.click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
if($.isFunction(o.beforeRefresh)) {o.beforeRefresh.call($t);}
$t.p.search = false;
$t.p.resetsearch = true;
try {
if( o.refreshstate !== 'currentfilter') {
var gID = $t.p.id;
$t.p.postData.filters ="";
try {
$("#fbox_"+$.jgrid.jqID(gID)).jqFilter('resetFilter');
} catch(ef) {}
if($.isFunction($t.clearToolbar)) {$t.clearToolbar.call($t,false);}
}
} catch (e) {}
switch (o.refreshstate) {
case 'firstpage':
$($t).trigger("reloadGrid", [{page:1}]);
break;
case 'current':
case 'currentfilter':
$($t).trigger("reloadGrid", [{current:true}]);
break;
}
if($.isFunction(o.afterRefresh)) {o.afterRefresh.call($t);}
$.jgrid.setSelNavIndex( $t, this);
}
return false;
}).hover(onHoverIn, onHoverOut);
tbd = null;
}
tdw = $(".ui-jqgrid").css("font-size") || "11px";
$('body').append("<div id='testpg2' class='ui-jqgrid "+$.jgrid.styleUI[currstyle].base.entrieBox+"' style='font-size:"+tdw+";visibility:hidden;' ></div>");
twd = $(navtbl).clone().appendTo("#testpg2").width();
$("#testpg2").remove();
if($t.p._nvtd) {
if(o.dropmenu) {
navtbl = null;
$($t).jqGrid('_buildNavMenu', pgid, elemids, p, pEdit, pAdd, pDel, pSearch, pView );
} else if(twd > $t.p._nvtd[0] ) {
if($t.p.responsive) {
navtbl = null;
$($t).jqGrid('_buildNavMenu', pgid, elemids, p, pEdit, pAdd, pDel, pSearch, pView );
} else {
$(pgid+"_"+o.position,pgid).append(navtbl).width(twd);
}
$t.p._nvtd[0] = twd;
} else {
$(pgid+"_"+o.position,pgid).append(navtbl);
}
$t.p._nvtd[1] = twd;
}
$t.p.navGrid = true;
}
if($t.p.storeNavOptions) {
$t.p.navOptions = o;
$t.p.editOptions = pEdit;
$t.p.addOptions = pAdd;
$t.p.delOptions = pDel;
$t.p.searchOptions = pSearch;
$t.p.viewOptions = pView;
$t.p.navButtons =[];
}
});
},
navButtonAdd : function (elem, p) {
var currstyle = this[0].p.styleUI,
styles = $.jgrid.styleUI[currstyle].navigator;
p = $.extend({
caption : "newButton",
title: '',
buttonicon : styles.icon_newbutton_nav,
onClickButton: null,
position : "last",
cursor : 'pointer',
internal : false
}, p ||{});
return this.each(function() {
if(!this.grid || typeof elem !== 'string') {return;}
if( elem.indexOf("#") === 0 ) {
elem = elem.substring(1);
}
elem = "#" + $.jgrid.jqID(elem);
var findnav = $(".navtable",elem)[0], $t = this,
//getstyle = $.jgrid.getMethod("getStyleUI"),
disabled = $.jgrid.styleUI[currstyle].common.disabled,
hover = $.jgrid.styleUI[currstyle].common.hover,
cornerall = $.jgrid.styleUI[currstyle].common.cornerall,
iconbase = $.jgrid.styleUI[currstyle].common.icon_base;
if ($t.p.storeNavOptions && !p.internal) {
$t.p.navButtons.push([elem,p]);
}
if (findnav) {
if( p.id && $("#"+$.jgrid.jqID(p.id), findnav)[0] !== undefined ) {return;}
var tbd = $("<td></td>");
if(p.buttonicon.toString().toUpperCase() === "NONE") {
$(tbd).addClass('ui-pg-button '+cornerall).append("<div class='ui-pg-div'>"+p.caption+"</div>");
} else {
$(tbd).addClass('ui-pg-button '+cornerall).append("<div class='ui-pg-div'><span class='"+iconbase+" "+p.buttonicon+"'></span>"+p.caption+"</div>");
}
if(p.id) {$(tbd).attr("id",p.id);}
if(p.position==='first'){
if(findnav.rows[0].cells.length ===0 ) {
$("tr",findnav).append(tbd);
} else {
$("tr td:eq(0)",findnav).before(tbd);
}
} else {
$("tr",findnav).append(tbd);
}
$(tbd,findnav)
.attr("title",p.title || "")
.click(function(e){
if (!$(this).hasClass(disabled)) {
$.jgrid.setSelNavIndex( $t, this);
if ($.isFunction(p.onClickButton) ) {p.onClickButton.call($t,e);}
}
return false;
})
.hover(
function () {
if (!$(this).hasClass(disabled)) {
$(this).addClass(hover);
}
},
function () {$(this).removeClass(hover);}
);
} else {
findnav = $(".dropdownmenu",elem)[0];
if (findnav) {
var id = $(findnav).val(),
eid = p.id || $.jgrid.randId(),
item = $('<li class="ui-menu-item" role="presentation"><a class="'+ cornerall+' g-menu-item" tabindex="0" role="menuitem" id="'+eid+'">'+(p.caption || p.title)+'</a></li>');
if(id) {
if(p.position === 'first') {
$("#"+id).prepend( item );
} else {
$("#"+id).append( item );
}
$(item).on("click", function(e){
if (!$(this).hasClass(disabled)) {
$("#"+id).hide();
if ($.isFunction(p.onClickButton) ) {
p.onClickButton.call($t,e);
}
}
return false;
}).find("a")
.hover(
function () {
if (!$(this).hasClass(disabled)) {
$(this).addClass(hover);
}
},
function () {$(this).removeClass(hover);}
);
}
}
}
});
},
navSeparatorAdd:function (elem,p) {
var currstyle = this[0].p.styleUI,
commonstyle = $.jgrid.styleUI[currstyle].common;
p = $.extend({
sepclass : "ui-separator",
sepcontent: '',
position : "last"
}, p ||{});
return this.each(function() {
if( !this.grid) {return;}
if( typeof elem === "string" && elem.indexOf("#") !== 0) {elem = "#"+$.jgrid.jqID(elem);}
var findnav = $(".navtable",elem)[0], sep, id;
if ( this.p.storeNavOptions ) {
this.p.navButtons.push([elem,p]);
}
if(findnav) {
sep = "<td class='ui-pg-button "+ commonstyle.disabled +"' style='width:4px;'><span class='"+p.sepclass+"'></span>"+p.sepcontent+"</td>";
if (p.position === 'first') {
if (findnav.rows[0].cells.length === 0) {
$("tr", findnav).append(sep);
} else {
$("tr td:eq(0)", findnav).before(sep);
}
} else {
$("tr", findnav).append(sep);
}
} else {
findnav = $(".dropdownmenu",elem)[0];
sep = "<li class='ui-menu-item " +commonstyle.disabled + "' style='width:100%' role='presentation'><hr class='ui-separator-li'></li>";
if(findnav) {
id = $(findnav).val();
if(id) {
if(p.position === "first") {
$("#"+id).prepend( sep );
} else {
$("#"+id).append( sep );
}
}
}
}
});
},
_buildNavMenu : function ( elem, elemids, p, pEdit, pAdd, pDel, pSearch, pView ) {
return this.each(function() {
var $t = this,
//actions = ['add','edit', 'del', 'view', 'search','refresh'],
regional = $.jgrid.getRegional($t, 'nav'),
currstyle = $t.p.styleUI,
styles = $.jgrid.styleUI[currstyle].navigator,
classes = $.jgrid.styleUI[currstyle].filter,
commonstyle = $.jgrid.styleUI[currstyle].common,
mid = "form_menu_"+$.jgrid.randId(),
bt = p.navButtonText ? p.navButtonText : regional.selectcaption || 'Actions',
act = "<button class='dropdownmenu "+commonstyle.button+"' value='"+mid+"'>" + bt +"</button>";
$(elem+"_"+p.position, elem).append( act );
var alertIDs = {themodal: 'alertmod_' + this.p.id, modalhead: 'alerthd_' + this.p.id,modalcontent: 'alertcnt_' + this.p.id},
_buildMenu = function() {
var fs = $('.ui-jqgrid').css('font-size') || '11px',
eid, itm,
str = $('<ul id="'+mid+'" class="ui-nav-menu modal-content" role="menu" tabindex="0" style="display:none;font-size:'+fs+'"></ul>');
if( p.add ) {
pAdd = pAdd || {};
eid = pAdd.id || "add_"+elemids;
itm = $('<li class="ui-menu-item" role="presentation"><a class="'+ commonstyle.cornerall+' g-menu-item" tabindex="0" role="menuitem" id="'+eid+'">'+(p.addtext || p.addtitle)+'</a></li>').click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
if ($.isFunction( p.addfunc )) {
p.addfunc.call($t);
} else {
$($t).jqGrid("editGridRow","new",pAdd);
}
$(str).hide();
}
return false;
});
$(str).append(itm);
}
if( p.edit ) {
pEdit = pEdit || {};
eid = pEdit.id || "edit_"+elemids;
itm = $('<li class="ui-menu-item" role="presentation"><a class="'+ commonstyle.cornerall+' g-menu-item" tabindex="0" role="menuitem" id="'+eid+'">'+(p.edittext || p.edittitle)+'</a></li>').click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
var sr = $t.p.selrow;
if (sr) {
if($.isFunction( p.editfunc ) ) {
p.editfunc.call($t, sr);
} else {
$($t).jqGrid("editGridRow",sr,pEdit);
}
} else {
$.jgrid.viewModal("#"+alertIDs.themodal,{gbox:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:true});
$("#jqg_alrt").focus();
}
$(str).hide();
}
return false;
});
$(str).append(itm);
}
if( p.view ) {
pView = pView || {};
eid = pView.id || "view_"+elemids;
itm = $('<li class="ui-menu-item" role="presentation"><a class="'+ commonstyle.cornerall+' g-menu-item" tabindex="0" role="menuitem" id="'+eid+'">'+(p.viewtext || p.viewtitle)+'</a></li>').click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
var sr = $t.p.selrow;
if (sr) {
if($.isFunction( p.editfunc ) ) {
p.viewfunc.call($t, sr);
} else {
$($t).jqGrid("viewGridRow",sr,pView);
}
} else {
$.jgrid.viewModal("#"+alertIDs.themodal,{gbox:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:true});
$("#jqg_alrt").focus();
}
$(str).hide();
}
return false;
});
$(str).append(itm);
}
if( p.del ) {
pDel = pDel || {};
eid = pDel.id || "del_"+elemids;
itm = $('<li class="ui-menu-item" role="presentation"><a class="'+ commonstyle.cornerall+' g-menu-item" tabindex="0" role="menuitem" id="'+eid+'">'+(p.deltext || p.deltitle)+'</a></li>').click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
var dr;
if($t.p.multiselect) {
dr = $t.p.selarrrow;
if(dr.length===0) {dr = null;}
} else {
dr = $t.p.selrow;
}
if(dr){
if($.isFunction( p.delfunc )){
p.delfunc.call($t, dr);
}else{
$($t).jqGrid("delGridRow",dr,pDel);
}
} else {
$.jgrid.viewModal("#"+alertIDs.themodal,{gbox:"#gbox_"+$.jgrid.jqID($t.p.id),jqm:true});$("#jqg_alrt").focus();
}
$(str).hide();
}
return false;
});
$(str).append(itm);
}
if(p.add || p.edit || p.del || p.view) {
$(str).append("<li class='ui-menu-item " +commonstyle.disabled + "' style='width:100%' role='presentation'><hr class='ui-separator-li'></li>");
}
if( p.search ) {
pSearch = pSearch || {};
eid = pSearch.id || "search_"+elemids;
itm = $('<li class="ui-menu-item" role="presentation"><a class="'+ commonstyle.cornerall+' g-menu-item" tabindex="0" role="menuitem" id="'+eid+'">'+(p.searchtext || p.searchtitle)+'</a></li>').click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
if($.isFunction( p.searchfunc )) {
p.searchfunc.call($t, pSearch);
} else {
$($t).jqGrid("searchGrid",pSearch);
}
$(str).hide();
}
return false;
});
$(str).append(itm);
if (pSearch.showOnLoad && pSearch.showOnLoad === true) {
$( itm ).click();
}
}
if( p.refresh ) {
eid = pSearch.id || "search_"+elemids;
itm = $('<li class="ui-menu-item" role="presentation"><a class="'+ commonstyle.cornerall+' g-menu-item" tabindex="0" role="menuitem" id="'+eid+'">'+(p.refreshtext || p.refreshtitle)+'</a></li>').click(function(){
if (!$(this).hasClass( commonstyle.disabled )) {
if($.isFunction(p.beforeRefresh)) {p.beforeRefresh.call($t);}
$t.p.search = false;
$t.p.resetsearch = true;
try {
if( p.refreshstate !== 'currentfilter') {
var gID = $t.p.id;
$t.p.postData.filters ="";
try {
$("#fbox_"+$.jgrid.jqID(gID)).jqFilter('resetFilter');
} catch(ef) {}
if($.isFunction($t.clearToolbar)) {$t.clearToolbar.call($t,false);}
}
} catch (e) {}
switch (p.refreshstate) {
case 'firstpage':
$($t).trigger("reloadGrid", [{page:1}]);
break;
case 'current':
case 'currentfilter':
$($t).trigger("reloadGrid", [{current:true}]);
break;
}
if($.isFunction(p.afterRefresh)) {p.afterRefresh.call($t);}
$(str).hide();
}
return false;
});
$(str).append(itm);
}
$(str).hide();
$('body').append(str);
$("#"+mid).addClass("ui-menu " + classes.menu_widget);
$("#"+mid+" > li > a").hover(
function(){ $(this).addClass(commonstyle.hover); },
function(){ $(this).removeClass(commonstyle.hover); }
);
};
_buildMenu();
$(".dropdownmenu", elem+"_"+p.position).on("click", function( e ){
var offset = $(this).offset(),
left = ( offset.left ),
top = parseInt( offset.top),
bid =$(this).val();
//if( $("#"+mid)[0] === undefined) {
//_buildMenu();
//}
$("#"+bid).show().css({"top":top - ($("#"+bid).height() +10)+"px", "left":left+"px"});
e.stopPropagation();
});
$("body").on('click', function(e){
if(!$(e.target).hasClass("dropdownmenu")) {
$("#"+mid).hide();
}
});
});
},
GridToForm : function( rowid, formid ) {
return this.each(function(){
var $t = this, i;
if (!$t.grid) {return;}
var rowdata = $($t).jqGrid("getRowData",rowid);
if (rowdata) {
for(i in rowdata) {
if(rowdata.hasOwnProperty(i)) {
if ( $("[name="+$.jgrid.jqID(i)+"]",formid).is("input:radio") || $("[name="+$.jgrid.jqID(i)+"]",formid).is("input:checkbox")) {
$("[name="+$.jgrid.jqID(i)+"]",formid).each( function() {
if( $(this).val() == rowdata[i] ) {
$(this)[$t.p.useProp ? 'prop': 'attr']("checked",true);
} else {
$(this)[$t.p.useProp ? 'prop': 'attr']("checked", false);
}
});
} else {
// this is very slow on big table and form.
$("[name="+$.jgrid.jqID(i)+"]",formid).val(rowdata[i]);
}
}
}
}
});
},
FormToGrid : function(rowid, formid, mode, position){
return this.each(function() {
var $t = this;
if(!$t.grid) {return;}
if(!mode) {mode = 'set';}
if(!position) {position = 'first';}
var fields = $(formid).serializeArray();
var griddata = {};
$.each(fields, function(i, field){
griddata[field.name] = field.value;
});
if(mode==='add') {$($t).jqGrid("addRowData",rowid,griddata, position);}
else if(mode==='set') {$($t).jqGrid("setRowData",rowid,griddata);}
});
}
});
//module begin
$.jgrid.extend({
groupingSetup : function () {
return this.each(function (){
var $t = this, i, j, cml, cm = $t.p.colModel, grp = $t.p.groupingView,
classes = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].grouping;
if(grp !== null && ( (typeof grp === 'object') || $.isFunction(grp) ) ) {
if(!grp.plusicon) { grp.plusicon = classes.icon_plus;}
if(!grp.minusicon) { grp.minusicon = classes.icon_minus;}
if(!grp.groupField.length) {
$t.p.grouping = false;
} else {
if (grp.visibiltyOnNextGrouping === undefined) {
grp.visibiltyOnNextGrouping = [];
}
grp.lastvalues=[];
if(!grp._locgr) {
grp.groups =[];
}
grp.counters =[];
for(i=0;i<grp.groupField.length;i++) {
if(!grp.groupOrder[i]) {
grp.groupOrder[i] = 'asc';
}
if(!grp.groupText[i]) {
grp.groupText[i] = '{0}';
}
if( typeof grp.groupColumnShow[i] !== 'boolean') {
grp.groupColumnShow[i] = true;
}
if( typeof grp.groupSummary[i] !== 'boolean') {
grp.groupSummary[i] = false;
}
if( !grp.groupSummaryPos[i]) {
grp.groupSummaryPos[i] = 'footer';
}
if(grp.groupColumnShow[i] === true) {
grp.visibiltyOnNextGrouping[i] = true;
$($t).jqGrid('showCol',grp.groupField[i]);
} else {
grp.visibiltyOnNextGrouping[i] = $("#"+$.jgrid.jqID($t.p.id+"_"+grp.groupField[i])).is(":visible");
$($t).jqGrid('hideCol',grp.groupField[i]);
}
}
grp.summary =[];
if(grp.hideFirstGroupCol) {
if($.isArray(grp.formatDisplayField) && !$.isFunction(grp.formatDisplayField[0] ) ) {
grp.formatDisplayField[0] = function (v) { return v;};
}
}
for(j=0, cml = cm.length; j < cml; j++) {
if(grp.hideFirstGroupCol) {
if(!cm[j].hidden && grp.groupField[0] === cm[j].name) {
cm[j].formatter = function(){return '';};
}
}
if(cm[j].summaryType ) {
if(cm[j].summaryDivider) {
grp.summary.push({nm:cm[j].name,st:cm[j].summaryType, v: '', sd:cm[j].summaryDivider, vd:'', sr: cm[j].summaryRound, srt: cm[j].summaryRoundType || 'round'});
} else {
grp.summary.push({nm:cm[j].name,st:cm[j].summaryType, v: '', sr: cm[j].summaryRound, srt: cm[j].summaryRoundType || 'round'});
}
}
}
}
} else {
$t.p.grouping = false;
}
});
},
groupingPrepare : function ( record, irow ) {
this.each(function(){
var grp = this.p.groupingView, $t= this, i,
sumGroups = function() {
if ($.isFunction(this.st)) {
this.v = this.st.call($t, this.v, this.nm, record);
} else {
this.v = $($t).jqGrid('groupingCalculations.handler',this.st, this.v, this.nm, this.sr, this.srt, record);
if(this.st.toLowerCase() === 'avg' && this.sd) {
this.vd = $($t).jqGrid('groupingCalculations.handler',this.st, this.vd, this.sd, this.sr, this.srt, record);
}
}
},
grlen = grp.groupField.length,
fieldName,
v,
displayName,
displayValue,
changed = 0;
for(i=0;i<grlen;i++) {
fieldName = grp.groupField[i];
displayName = grp.displayField[i];
v = record[fieldName];
displayValue = displayName == null ? null : record[displayName];
if( displayValue == null ) {
displayValue = v;
}
if( v !== undefined ) {
if(irow === 0 ) {
// First record always starts a new group
grp.groups.push({idx:i,dataIndex:fieldName,value:v, displayValue: displayValue, startRow: irow, cnt:1, summary : [] } );
grp.lastvalues[i] = v;
grp.counters[i] = {cnt:1, pos:grp.groups.length-1, summary: $.extend(true,[],grp.summary)};
$.each(grp.counters[i].summary, sumGroups);
grp.groups[grp.counters[i].pos].summary = grp.counters[i].summary;
} else {
if (typeof v !== "object" && ($.isArray(grp.isInTheSameGroup) && $.isFunction(grp.isInTheSameGroup[i]) ? ! grp.isInTheSameGroup[i].call($t, grp.lastvalues[i], v, i, grp): grp.lastvalues[i] !== v)) {
// This record is not in same group as previous one
grp.groups.push({idx:i,dataIndex:fieldName,value:v, displayValue: displayValue, startRow: irow, cnt:1, summary : [] } );
grp.lastvalues[i] = v;
changed = 1;
grp.counters[i] = {cnt:1, pos:grp.groups.length-1, summary: $.extend(true,[],grp.summary)};
$.each(grp.counters[i].summary, sumGroups);
grp.groups[grp.counters[i].pos].summary = grp.counters[i].summary;
} else {
if (changed === 1) {
// This group has changed because an earlier group changed.
grp.groups.push({idx:i,dataIndex:fieldName,value:v, displayValue: displayValue, startRow: irow, cnt:1, summary : [] } );
grp.lastvalues[i] = v;
grp.counters[i] = {cnt:1, pos:grp.groups.length-1, summary: $.extend(true,[],grp.summary)};
$.each(grp.counters[i].summary, sumGroups);
grp.groups[grp.counters[i].pos].summary = grp.counters[i].summary;
} else {
grp.counters[i].cnt += 1;
grp.groups[grp.counters[i].pos].cnt = grp.counters[i].cnt;
$.each(grp.counters[i].summary, sumGroups);
grp.groups[grp.counters[i].pos].summary = grp.counters[i].summary;
}
}
}
}
}
//gdata.push( rData );
});
return this;
},
groupingToggle : function(hid){
this.each(function(){
var $t = this,
grp = $t.p.groupingView,
strpos = hid.split('_'),
num = parseInt(strpos[strpos.length-2], 10);
strpos.splice(strpos.length-2,2);
var uid = strpos.join("_"),
minus = grp.minusicon,
plus = grp.plusicon,
tar = $("#"+$.jgrid.jqID(hid)),
r = tar.length ? tar[0].nextSibling : null,
tarspan = $("#"+$.jgrid.jqID(hid)+" span."+"tree-wrap-"+$t.p.direction),
getGroupingLevelFromClass = function (className) {
var nums = $.map(className.split(" "), function (item) {
if (item.substring(0, uid.length + 1) === uid + "_") {
return parseInt(item.substring(uid.length + 1), 10);
}
});
return nums.length > 0 ? nums[0] : undefined;
},
itemGroupingLevel,
showData,
collapsed = false,
footLevel,
skip = false,
frz = $t.p.frozenColumns ? $t.p.id+"_frozen" : false,
tar2 = frz ? $("#"+$.jgrid.jqID(hid), "#"+$.jgrid.jqID(frz) ) : false,
r2 = (tar2 && tar2.length) ? tar2[0].nextSibling : null;
if( tarspan.hasClass(minus) ) {
if(r){
while(r) {
itemGroupingLevel = getGroupingLevelFromClass(r.className);
if (itemGroupingLevel !== undefined && itemGroupingLevel <= num) {
break;
}
footLevel = parseInt($(r).attr("jqfootlevel") ,10);
skip = isNaN(footLevel) ? false :
(grp.showSummaryOnHide && footLevel <= num);
if( !skip) {
$(r).hide();
}
r = r.nextSibling;
if(frz) {
if(!skip) {
$(r2).hide();
}
r2 = r2.nextSibling;
}
}
}
tarspan.removeClass(minus).addClass(plus);
collapsed = true;
} else {
if(r){
showData = undefined;
while(r) {
itemGroupingLevel = getGroupingLevelFromClass(r.className);
if (showData === undefined) {
showData = itemGroupingLevel === undefined; // if the first row after the opening group is data row then show the data rows
}
skip = $(r).hasClass("ui-subgrid") && $(r).hasClass("ui-sg-collapsed");
if (itemGroupingLevel !== undefined) {
if (itemGroupingLevel <= num) {
break;// next item of the same lever are found
}
if (itemGroupingLevel === num + 1) {
if(!skip) {
$(r).show().find(">td>span."+"tree-wrap-"+$t.p.direction).removeClass(minus).addClass(plus);
if(frz) {
$(r2).show().find(">td>span."+"tree-wrap-"+$t.p.direction).removeClass(minus).addClass(plus);
}
}
}
} else if (showData) {
if(!skip) {
$(r).show();
if(frz) {
$(r2).show();
}
}
}
r = r.nextSibling;
if(frz) {
r2 = r2.nextSibling;
}
}
}
tarspan.removeClass(plus).addClass(minus);
}
$($t).triggerHandler("jqGridGroupingClickGroup", [hid , collapsed]);
if( $.isFunction($t.p.onClickGroup)) { $t.p.onClickGroup.call($t, hid , collapsed); }
});
return false;
},
groupingRender : function (grdata, colspans, page, rn ) {
return this.each(function(){
var $t = this,
grp = $t.p.groupingView,
str = "", icon = "", hid, clid, pmrtl = grp.groupCollapse ? grp.plusicon : grp.minusicon, gv, cp=[], len =grp.groupField.length,
//classes = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')]['grouping'],
common = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].common;
pmrtl = pmrtl+" tree-wrap-"+$t.p.direction;
$.each($t.p.colModel, function (i,n){
var ii;
for(ii=0;ii<len;ii++) {
if(grp.groupField[ii] === n.name ) {
cp[ii] = i;
break;
}
}
});
var toEnd = 0;
function findGroupIdx( ind , offset, grp) {
var ret = false, i;
if(offset===0) {
ret = grp[ind];
} else {
var id = grp[ind].idx;
if(id===0) {
ret = grp[ind];
} else {
for(i=ind;i >= 0; i--) {
if(grp[i].idx === id-offset) {
ret = grp[i];
break;
}
}
}
}
return ret;
}
function buildSummaryTd(i, ik, grp, foffset, fstr) {
var fdata = findGroupIdx(i, ik, grp),
cm = $t.p.colModel,
vv, grlen = fdata.cnt, str="", k , isput = false, tmpdata, tplfld;
for(k=foffset; k<colspans;k++) {
if(cm[k].hidden ) {
tmpdata = "<td "+$t.formatCol(k,1,'')+"> </td>";
} else if(!isput && fstr) {
tmpdata = fstr;
isput = true;
} else {
tmpdata = "<td "+$t.formatCol(k,1,'')+"> </td>";
}
$.each(fdata.summary,function(){
if(this.nm === cm[k].name) {
tplfld = (cm[k].summaryTpl) ? cm[k].summaryTpl : "{0}";
if(typeof this.st === 'string' && this.st.toLowerCase() === 'avg') {
if(this.sd && this.vd) {
this.v = (this.v/this.vd);
} else if(this.v && grlen > 0) {
this.v = (this.v/grlen);
}
}
try {
this.groupCount = fdata.cnt;
this.groupIndex = fdata.dataIndex;
this.groupValue = fdata.value;
vv = $t.formatter('', this.v, k, this);
} catch (ef) {
vv = this.v;
}
tmpdata= "<td "+$t.formatCol(k,1,'')+">"+$.jgrid.template(tplfld, vv, fdata.cnt, fdata.dataIndex, fdata.displayValue)+ "</td>";
return false;
}
});
str += tmpdata;
}
return str;
}
var sumreverse = $.makeArray(grp.groupSummary), mul;
sumreverse.reverse();
mul = $t.p.multiselect ? " colspan=\"2\"" : "";
$.each(grp.groups,function(i,n){
if(grp._locgr) {
if( !(n.startRow +n.cnt > (page-1)*rn && n.startRow < page*rn)) {
return true;
}
}
toEnd++;
clid = $t.p.id+"ghead_"+n.idx;
hid = clid+"_"+i;
icon = "<span style='cursor:pointer;margin-right:8px;margin-left:5px;' class='" + common.icon_base +" "+pmrtl+"' onclick=\"jQuery('#"+$.jgrid.jqID($t.p.id)+"').jqGrid('groupingToggle','"+hid+"');return false;\"></span>";
try {
if ($.isArray(grp.formatDisplayField) && $.isFunction(grp.formatDisplayField[n.idx])) {
gv = grp.formatDisplayField[n.idx].call($t, n.displayValue, n.value, $t.p.colModel[cp[n.idx]], n.idx, grp);
} else {
gv = $t.formatter(hid, n.displayValue, cp[n.idx], n.value );
}
} catch (egv) {
gv = n.displayValue;
}
var grpTextStr = '';
if($.isFunction(grp.groupText[n.idx])) {
grpTextStr = grp.groupText[n.idx].call($t, gv, n.cnt, n.summary);
} else {
grpTextStr = $.jgrid.template(grp.groupText[n.idx], gv, n.cnt, n.summary);
}
if( !(typeof grpTextStr ==='string' || typeof grpTextStr ==='number' ) ) {
grpTextStr = gv;
}
if(grp.groupSummaryPos[n.idx] === 'header') {
str += "<tr id=\""+hid+"\"" +(grp.groupCollapse && n.idx>0 ? " style=\"display:none;\" " : " ") + "role=\"row\" class= \"" + common.content + " jqgroup ui-row-"+$t.p.direction+" "+clid+"\">";
str += buildSummaryTd(i, 0, grp.groups, (mul==="" ? 0 : 1), "<td style=\"padding-left:"+(n.idx * 12) + "px;"+"\"" + mul +">" + icon+grpTextStr + "</td>" );
str += "</tr>";
} else {
str += "<tr id=\""+hid+"\"" +(grp.groupCollapse && n.idx>0 ? " style=\"display:none;\" " : " ") + "role=\"row\" class= \"" + common.content + " jqgroup ui-row-"+$t.p.direction+" "+clid+"\"><td style=\"padding-left:"+(n.idx * 12) + "px;"+"\" colspan=\""+(grp.groupColumnShow[n.idx] === false ? colspans-1 : colspans)+"\">" + icon + grpTextStr + "</td></tr>";
}
var leaf = len-1 === n.idx;
if( leaf ) {
var gg = grp.groups[i+1], kk, ik, offset = 0, sgr = n.startRow,
end = gg !== undefined ? gg.startRow : grp.groups[i].startRow + grp.groups[i].cnt;
if(grp._locgr) {
offset = (page-1)*rn;
if(offset > n.startRow) {
sgr = offset;
}
}
for(kk=sgr;kk<end;kk++) {
if(!grdata[kk - offset]) { break; }
str += grdata[kk - offset].join('');
}
if(grp.groupSummaryPos[n.idx] !== 'header') {
var jj;
if (gg !== undefined) {
for (jj = 0; jj < grp.groupField.length; jj++) {
if (gg.dataIndex === grp.groupField[jj]) {
break;
}
}
toEnd = grp.groupField.length - jj;
}
for (ik = 0; ik < toEnd; ik++) {
if(!sumreverse[ik]) { continue; }
var hhdr = "";
if(grp.groupCollapse && !grp.showSummaryOnHide) {
hhdr = " style=\"display:none;\"";
}
str += "<tr"+hhdr+" jqfootlevel=\""+(n.idx-ik)+"\" role=\"row\" class=\"" + common.content + " jqfoot ui-row-"+$t.p.direction+"\">";
str += buildSummaryTd(i, ik, grp.groups, 0, false);
str += "</tr>";
}
toEnd = jj;
}
}
});
$("#"+$.jgrid.jqID($t.p.id)+" tbody:first").append(str);
// free up memory
str = null;
});
},
groupingGroupBy : function (name, options ) {
return this.each(function(){
var $t = this;
if(typeof name === "string") {
name = [name];
}
var grp = $t.p.groupingView;
$t.p.grouping = true;
grp._locgr = false;
//Set default, in case visibilityOnNextGrouping is undefined
if (grp.visibiltyOnNextGrouping === undefined) {
grp.visibiltyOnNextGrouping = [];
}
var i;
// show previous hidden groups if they are hidden and weren't removed yet
for(i=0;i<grp.groupField.length;i++) {
if(!grp.groupColumnShow[i] && grp.visibiltyOnNextGrouping[i]) {
$($t).jqGrid('showCol',grp.groupField[i]);
}
}
// set visibility status of current group columns on next grouping
for(i=0;i<name.length;i++) {
grp.visibiltyOnNextGrouping[i] = $("#"+$.jgrid.jqID($t.p.id)+"_"+$.jgrid.jqID(name[i])).is(":visible");
}
$t.p.groupingView = $.extend($t.p.groupingView, options || {});
grp.groupField = name;
$($t).trigger("reloadGrid");
});
},
groupingRemove : function (current) {
return this.each(function(){
var $t = this;
if(current === undefined) {
current = true;
}
$t.p.grouping = false;
if(current===true) {
var grp = $t.p.groupingView, i;
// show previous hidden groups if they are hidden and weren't removed yet
for(i=0;i<grp.groupField.length;i++) {
if (!grp.groupColumnShow[i] && grp.visibiltyOnNextGrouping[i]) {
$($t).jqGrid('showCol', grp.groupField);
}
}
$("tr.jqgroup, tr.jqfoot","#"+$.jgrid.jqID($t.p.id)+" tbody:first").remove();
$("tr.jqgrow:hidden","#"+$.jgrid.jqID($t.p.id)+" tbody:first").show();
} else {
$($t).trigger("reloadGrid");
}
});
},
groupingCalculations : {
handler: function(fn, v, field, round, roundType, rc) {
var funcs = {
sum: function() {
return parseFloat(v||0) + parseFloat((rc[field]||0));
},
min: function() {
if(v==="") {
return parseFloat(rc[field]||0);
}
return Math.min(parseFloat(v),parseFloat(rc[field]||0));
},
max: function() {
if(v==="") {
return parseFloat(rc[field]||0);
}
return Math.max(parseFloat(v),parseFloat(rc[field]||0));
},
count: function() {
if(v==="") {v=0;}
if(rc.hasOwnProperty(field)) {
return v+1;
}
return 0;
},
avg: function() {
// the same as sum, but at end we divide it
// so use sum instead of duplicating the code (?)
return funcs.sum();
}
};
if(!funcs[fn]) {
throw ("jqGrid Grouping No such method: " + fn);
}
var res = funcs[fn]();
if (round != null) {
if (roundType === 'fixed') {
res = res.toFixed(round);
} else {
var mul = Math.pow(10, round);
res = Math.round(res * mul) / mul;
}
}
return res;
}
},
setGroupHeaders : function ( o ) {
o = $.extend({
useColSpanStyle : false,
groupHeaders: []
},o || {});
return this.each(function(){
var ts = this,
i, cmi, skip = 0, $tr, $colHeader, th, $th, thStyle,
iCol,
cghi,
//startColumnName,
numberOfColumns,
titleText,
cVisibleColumns,
className,
colModel = ts.p.colModel,
cml = colModel.length,
ths = ts.grid.headers,
$htable = $("table.ui-jqgrid-htable", ts.grid.hDiv),
$trLabels = $htable.children("thead").children("tr.ui-jqgrid-labels:last").addClass("jqg-second-row-header"),
$thead = $htable.children("thead"),
$theadInTable,
$firstHeaderRow = $htable.find(".jqg-first-row-header"),
$firstRow,
$focusElem = false,
//classes = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')]['grouping'],
base = $.jgrid.styleUI[(ts.p.styleUI || 'jQueryUI')].base;
if(!ts.p.groupHeader) {
ts.p.groupHeader = [];
}
ts.p.groupHeader.push(o);
ts.p.groupHeaderOn = true;
if($firstHeaderRow[0] === undefined) {
$firstHeaderRow = $('<tr>', {role: "row", "aria-hidden": "true"}).addClass("jqg-first-row-header").css("height", "auto");
} else {
$firstHeaderRow.empty();
}
var inColumnHeader = function (text, columnHeaders) {
var length = columnHeaders.length, i;
for (i = 0; i < length; i++) {
if (columnHeaders[i].startColumnName === text) {
return i;
}
}
return -1;
};
if( $(document.activeElement).is('input') || $(document.activeElement).is('textarea') ) {
$focusElem = document.activeElement;
}
$(ts).prepend($thead);
$(ts).prepend($thead);
$tr = $('<tr>', {role: "row"}).addClass("ui-jqgrid-labels jqg-third-row-header");
for (i = 0; i < cml; i++) {
th = ths[i].el;
$th = $(th);
cmi = colModel[i];
// build the next cell for the first header row
thStyle = { height: '0px', width: ths[i].width + 'px', display: (cmi.hidden ? 'none' : '')};
$("<th>", {role: 'gridcell'}).css(thStyle).addClass("ui-first-th-"+ts.p.direction).appendTo($firstHeaderRow);
th.style.width = ""; // remove unneeded style
iCol = inColumnHeader(cmi.name, o.groupHeaders);
if (iCol >= 0) {
cghi = o.groupHeaders[iCol];
numberOfColumns = cghi.numberOfColumns;
titleText = cghi.titleText;
className = cghi.className || "";
// caclulate the number of visible columns from the next numberOfColumns columns
for (cVisibleColumns = 0, iCol = 0; iCol < numberOfColumns && (i + iCol < cml); iCol++) {
if (!colModel[i + iCol].hidden) {
cVisibleColumns++;
}
}
// The next numberOfColumns headers will be moved in the next row
// in the current row will be placed the new column header with the titleText.
// The text will be over the cVisibleColumns columns
$colHeader = $('<th>').attr({role: "columnheader"})
.addClass(base.headerBox+ " ui-th-column-header ui-th-"+ts.p.direction+" "+className)
//.css({'height':'22px', 'border-top': '0 none'})
.html(titleText);
if(cVisibleColumns > 0) {
$colHeader.attr("colspan", String(cVisibleColumns));
}
if (ts.p.headertitles) {
$colHeader.attr("title", $colHeader.text());
}
// hide if not a visible cols
if( cVisibleColumns === 0) {
$colHeader.hide();
}
$th.before($colHeader); // insert new column header before the current
$tr.append(th); // move the current header in the next row
// set the coumter of headers which will be moved in the next row
skip = numberOfColumns - 1;
} else {
if (skip === 0) {
if (o.useColSpanStyle) {
// expand the header height to n rows
var rowspan = $th.attr("rowspan") ? parseInt($th.attr("rowspan"),10) + 1 : 2;
$th.attr("rowspan", rowspan);
} else {
$('<th>', {role: "columnheader"})
.addClass(base.headerBox+" ui-th-column-header ui-th-"+ts.p.direction)
.css({"display": cmi.hidden ? 'none' : ''})
.insertBefore($th);
$tr.append(th);
}
} else {
// move the header to the next row
//$th.css({"padding-top": "2px", height: "19px"});
$tr.append(th);
skip--;
}
}
}
$theadInTable = $(ts).children("thead");
$theadInTable.prepend($firstHeaderRow);
$tr.insertAfter($trLabels);
$htable.append($theadInTable);
if (o.useColSpanStyle) {
// Increase the height of resizing span of visible headers
$htable.find("span.ui-jqgrid-resize").each(function () {
var $parent = $(this).parent();
if ($parent.is(":visible")) {
this.style.cssText = 'height: ' + $parent.height() + 'px !important; cursor: col-resize;';
}
});
// Set position of the sortable div (the main lable)
// with the column header text to the middle of the cell.
// One should not do this for hidden headers.
$htable.find("div.ui-jqgrid-sortable").each(function () {
var $ts = $(this), $parent = $ts.parent();
if ($parent.is(":visible") && $parent.is(":has(span.ui-jqgrid-resize)")) {
// minus 4px from the margins of the resize markers
$ts.css('top', ($parent.height() - $ts.outerHeight()) / 2 - 4 + 'px');
}
});
}
$firstRow = $theadInTable.find("tr.jqg-first-row-header");
$(ts).on('jqGridResizeStop.setGroupHeaders', function (e, nw, idx) {
$firstRow.find('th').eq(idx)[0].style.width = nw + "px";
});
if( $focusElem ) {
try {
$($focusElem).focus();
} catch(fe) {}
}
if( $.trim($("tr.jqg-second-row-header th:eq(0)").text()) === "" ) {
$("tr.jqg-second-row-header th:eq(0)").prepend(' ');
}
});
},
destroyGroupHeader : function(nullHeader) {
if(nullHeader === undefined) {
nullHeader = true;
}
return this.each(function()
{
var $t = this, $tr, i, l, headers, $th, $resizing, grid = $t.grid,
thead = $("table.ui-jqgrid-htable thead", grid.hDiv), cm = $t.p.colModel, hc, frozen = false;
if(!grid) { return; }
if($t.p.frozenColumns) {
$($t).jqGrid("destroyFrozenColumns");
frozen = true;
}
$(this).off('.setGroupHeaders');
$t.p.groupHeaderOn = false;
$tr = $("<tr>", {role: "row"}).addClass("ui-jqgrid-labels");
headers = grid.headers;
for (i = 0, l = headers.length; i < l; i++) {
hc = cm[i].hidden ? "none" : "";
$th = $(headers[i].el)
.width( $('tr.jqg-first-row-header th:eq('+i+')', thead).width() )
.css('display',hc);
try {
$th.removeAttr("rowSpan");
} catch (rs) {
//IE 6/7
$th.attr("rowSpan",1);
}
$tr.append($th);
$resizing = $th.children("span.ui-jqgrid-resize");
if ($resizing.length>0) {// resizable column
$resizing[0].style.height = "";
}
$th.children("div")[0].style.top = "";
}
$(thead).children('tr.ui-jqgrid-labels').remove();
$(thead).children('tr.jqg-first-row-header').remove();
$(thead).prepend($tr);
if(nullHeader === true) {
$($t).jqGrid('setGridParam',{ 'groupHeader': null});
}
if(frozen) {
$($t).jqGrid("setFrozenColumns");
}
});
},
isGroupHeaderOn : function () {
var $t = this[0];
return $t.p.groupHeaderOn === true && $t.p.groupHeader && ($.isArray($t.p.groupHeader) || $.isFunction($t.p.groupHeader) );
},
refreshGroupHeaders : function() {
return this.each(function(){
var ts = this,
gHead,
gh = $(ts).jqGrid("isGroupHeaderOn");
//ts.p.groupHeader && ($.isArray(ts.p.groupHeader) || $.isFunction(ts.p.groupHeader) );
if(gh) {
$(ts).jqGrid('destroyGroupHeader', false);
gHead = $.extend([],ts.p.groupHeader);
ts.p.groupHeader = null;
}
if( gh && gHead) {
for(var k =0; k < gHead.length; k++) {
$(ts).jqGrid('setGroupHeaders', gHead[k]);
}
}
});
}
});
//module begin
$.jgrid = $.jgrid || {};
$.extend($.jgrid,{
saveState : function ( jqGridId, o ) {
o = $.extend({
useStorage : true,
storageType : "localStorage", // localStorage or sessionStorage
beforeSetItem : null,
compression: false,
compressionModule : 'LZString', // object by example gzip, LZString
compressionMethod : 'compressToUTF16', // string by example zip, compressToUTF16
debug : false,
saveData : true
}, o || {});
if(!jqGridId) { return; }
var gridstate = "", data = "", ret, $t = $("#"+jqGridId)[0], tmp;
// to use navigator set storeNavOptions to true in grid options
if(!$t.grid) { return;}
tmp = $($t).data('inlineNav');
if(tmp && $t.p.inlineNav) {
$($t).jqGrid('setGridParam',{_iN: tmp});
}
tmp = $($t).data('filterToolbar');
if(tmp && $t.p.filterToolbar) {
$($t).jqGrid('setGridParam',{_fT: tmp});
}
gridstate = $($t).jqGrid('jqGridExport', { exptype : "jsonstring", ident:"", root:"", data : o.saveData });
data = '';
if( o.saveData ) {
data = $($t.grid.bDiv).find(".ui-jqgrid-btable tbody:first").html();
var firstrow = data.indexOf("</tr>");
data = data.slice(firstrow + 5);
}
if($.isFunction(o.beforeSetItem)) {
ret = o.beforeSetItem.call($t, gridstate);
if(ret != null) {
gridstate = ret;
}
}
if(o.debug) {
$("#gbox_tree").prepend('<a id="link_save" target="_blank" download="jqGrid_dump.txt">Click to save Dump Data</a>');
var temp = [], file, properties = {}, url;
temp.push("Grid Options\n");
temp.push(gridstate);
temp.push("\n");
temp.push("GridData\n");
temp.push(data);
properties.type = 'plain/text;charset=utf-8'; // Specify the file's mime-type.
try {
file = new File(temp, "jqGrid_dump.txt", properties);
} catch (e) {
file = new Blob(temp, properties);
}
url = URL.createObjectURL(file);
$("#link_save").attr("href",url).on('click',function(){
$(this).remove();
});
}
if(o.compression) {
if(o.compressionModule) {
try {
ret = window[o.compressionModule][o.compressionMethod](gridstate);
if(ret != null) {
gridstate = ret;
data = window[o.compressionModule][o.compressionMethod](data);
}
} catch (e) {
// can not execute a compression.
}
}
}
if(o.useStorage && $.jgrid.isLocalStorage()) {
try {
window[o.storageType].setItem("jqGrid"+$t.p.id, gridstate);
window[o.storageType].setItem("jqGrid"+$t.p.id+"_data", data);
} catch (e) {
if(e.code === 22) { // chrome is 21
// just for now. we should make some additionla changes and eventually clear some local items
alert("Local storage limit is over!");
}
}
}
return gridstate;
},
loadState : function (jqGridId, gridstring, o) {
o = $.extend({
useStorage : true,
storageType : "localStorage",
clearAfterLoad: false, // clears the jqGrid localStorage items aftre load
beforeSetGrid : null,
afterSetGrid : null,
decompression: false,
decompressionModule : 'LZString', // object by example gzip, LZString
decompressionMethod : 'decompressFromUTF16', // string by example unzip, decompressFromUTF16
restoreData : true
}, o || {});
if(!jqGridId) { return; }
var ret, tmp, $t = $("#"+jqGridId)[0], data, iN, fT;
if(o.useStorage) {
try {
gridstring = window[o.storageType].getItem("jqGrid"+$t.id);
data = window[o.storageType].getItem("jqGrid"+$t.id+"_data");
} catch (e) {
// can not get data
}
}
if(!gridstring) { return; }
if(o.decompression) {
if(o.decompressionModule) {
try {
ret = window[o.decompressionModule][o.decompressionMethod]( gridstring );
if(ret != null ) {
gridstring = ret;
data = window[o.decompressionModule][o.decompressionMethod]( data );
}
} catch (e) {
// decompression can not be done
}
}
}
ret = $.jgrid.parseFunc( gridstring );
if( ret && $.type(ret) === 'object') {
if($t.grid) {
$.jgrid.gridUnload( jqGridId );
}
if($.isFunction(o.beforeSetGrid)) {
tmp = o.beforeSetGrid( ret );
if(tmp && $.type(tmp) === 'object') {
ret = tmp;
}
}
// some preparings
var retfunc = function( param ) { var p; p = param; return p;},
prm = {
"reccount" : ret.reccount,
"records" : ret.records,
"lastpage" : ret.lastpage,
"shrinkToFit" : retfunc( ret.shrinkToFit),
"data": retfunc(ret.data),
"datatype" : retfunc(ret.datatype),
"grouping" : retfunc(ret.grouping)
};
ret.shrinkToFit = false;
ret.data = [];
ret.datatype = 'local';
ret.grouping = false;
//ret.navGrid = false;
if(ret.inlineNav) {
iN = retfunc( ret._iN );
ret._iN = null; delete ret._iN;
}
if(ret.filterToolbar) {
fT = retfunc( ret._fT );
ret._fT = null; delete ret._fT;
}
var grid = $("#"+jqGridId).jqGrid( ret );
grid.jqGrid('delRowData','norecs');
if( o.restoreData && $.trim( data ) !== '') {
grid.append( data );
}
grid.jqGrid( 'setGridParam', prm);
if(ret.storeNavOptions && ret.navGrid) {
// set to false so that nav grid can be run
grid[0].p.navGrid = false;
grid.jqGrid('navGrid', ret.pager, ret.navOptions, ret.editOptions, ret.addOptions, ret.delOptions, ret.searchOptions, ret.viewOptions);
if(ret.navButtons && ret.navButtons.length) {
for(var b = 0; b < ret.navButtons.length; b++) {
if( 'sepclass' in ret.navButtons[b][1]) {
grid.jqGrid('navSeparatorAdd', ret.navButtons[b][0], ret.navButtons[b][1]);
} else {
grid.jqGrid('navButtonAdd', ret.navButtons[b][0], ret.navButtons[b][1]);
}
}
}
}
// refresh index
grid[0].refreshIndex();
// subgrid
if(ret.subGrid) {
var ms = ret.multiselect === 1 ? 1 : 0,
rn = ret.rownumbers === true ? 1 :0;
grid.jqGrid('addSubGrid', ms + rn);
// reopen the sugrid in order to maintain the subgrid state.
// currently only one level is supported
// todo : supposrt for unlimited levels
$.each(grid[0].rows, function(i, srow){
if( $(srow).hasClass('ui-sg-expanded') ) {
// reopen the subgrid
$(grid[0].rows[i-1]).find('td.sgexpanded').click().click();
}
});
}
// treegrid
if(ret.treeGrid) {
var i = 1, len = grid[0].rows.length,
expCol = ret.expColInd,
isLeaf = ret.treeReader.leaf_field,
expanded = ret.treeReader.expanded_field;
// optimization of code needed here
while(i<len) {
$(grid[0].rows[i].cells[expCol])
.find("div.treeclick")
.on("click",function(e){
var target = e.target || e.srcElement,
ind2 =$.jgrid.stripPref(ret.idPrefix,$(target,grid[0].rows).closest("tr.jqgrow")[0].id),
pos = grid[0].p._index[ind2];
if(!grid[0].p.data[pos][isLeaf]){
if(grid[0].p.data[pos][expanded]){
grid.jqGrid("collapseRow",grid[0].p.data[pos]);
grid.jqGrid("collapseNode",grid[0].p.data[pos]);
} else {
grid.jqGrid("expandRow",grid[0].p.data[pos]);
grid.jqGrid("expandNode",grid[0].p.data[pos]);
}
}
return false;
});
if(ret.ExpandColClick === true) {
$(grid[0].rows[i].cells[expCol])
.find("span.cell-wrapper")
.css("cursor","pointer")
.on("click",function(e) {
var target = e.target || e.srcElement,
ind2 =$.jgrid.stripPref(ret.idPrefix,$(target,grid[0].rows).closest("tr.jqgrow")[0].id),
pos = grid[0].p._index[ind2];
if(!grid[0].p.data[pos][isLeaf]){
if(grid[0].p.data[pos][expanded]){
grid.jqGrid("collapseRow", grid[0].p.data[pos]);
grid.jqGrid("collapseNode", grid[0].p.data[pos]);
} else {
grid.jqGrid("expandRow", grid[0].p.data[pos]);
grid.jqGrid("expandNode", grid[0].p.data[pos]);
}
}
grid.jqGrid("setSelection",ind2);
return false;
});
}
i++;
}
}
// multiselect
if(ret.multiselect) {
$.each(ret.selarrrow, function(){
$("#jqg_" + jqGridId + "_"+this)[ret.useProp ? 'prop': 'attr']("checked", "checked");
});
}
// grouping
// pivotgrid
if(ret.inlineNav && iN) {
grid.jqGrid('setGridParam', { inlineNav:false });
grid.jqGrid('inlineNav', ret.pager, iN);
}
if(ret.filterToolbar && fT) {
grid.jqGrid('setGridParam', { filterToolbar:false });
fT.restoreFromFilters = true;
grid.jqGrid('filterToolbar', fT);
}
// finally frozenColums
if( ret.frozenColumns ) {
grid.jqGrid('setFrozenColumns');
}
grid[0].updatepager(true, true);
if($.isFunction(o.afterSetGrid)) {
o.afterSetGrid( grid );
}
if(o.clearAfterLoad) {
window[o.storageType].removeItem("jqGrid"+$t.id);
window[o.storageType].removeItem("jqGrid"+$t.id + "_data");
}
} else {
alert("can not convert to object");
}
},
isGridInStorage : function ( jqGridId, options ) {
var o = {
storageType: "localStorage"
};
o = $.extend(o , options || {});
var ret, gridstring, data;
try {
gridstring = window[o.storageType].getItem("jqGrid"+jqGridId);
data = window[o.storageType].getItem("jqGrid" + jqGridId + "_data");
ret = gridstring != null && data != null && typeof gridstring === "string" && typeof data === "string" ;
} catch (e) {
ret = false;
}
return ret;
},
setRegional : function( jqGridId , options) {
var o = {
storageType: "sessionStorage"
};
o = $.extend(o , options || {});
if( !o.regional ) {
return;
}
$.jgrid.saveState( jqGridId, o );
o.beforeSetGrid = function(params) {
params.regional = o.regional;
params.force_regional = true;
return params;
};
$.jgrid.loadState( jqGridId, null, o);
// check for formatter actions
var grid = $("#"+jqGridId)[0],
model = $(grid).jqGrid('getGridParam','colModel'), i=-1, nav = $.jgrid.getRegional(grid, 'nav');
$.each(model,function(k){
if(this.formatter && this.formatter === 'actions') {
i = k;
return false;
}
});
if(i !== -1 && nav) {
$("#"+jqGridId + " tbody tr").each(function(){
var td = this.cells[i];
$(td).find(".ui-inline-edit").attr("title",nav.edittitle);
$(td).find(".ui-inline-del").attr("title",nav.deltitle);
$(td).find(".ui-inline-save").attr("title",nav.savetitle);
$(td).find(".ui-inline-cancel").attr("title",nav.canceltitle);
});
}
try {
window[o.storageType].removeItem("jqGrid"+grid.id);
window[o.storageType].removeItem("jqGrid"+grid.id+"_data");
} catch (e) {}
},
jqGridImport : function(jqGridId, o) {
o = $.extend({
imptype : "xml", // xml, json, xmlstring, jsonstring
impstring: "",
impurl: "",
mtype: "GET",
impData : {},
xmlGrid :{
config : "root>grid",
data: "root>rows"
},
jsonGrid :{
config : "grid",
data: "data"
},
ajaxOptions :{}
}, o || {});
var $t = (jqGridId.indexOf("#") === 0 ? "": "#") + $.jgrid.jqID(jqGridId);
var xmlConvert = function (xml,o) {
var cnfg = $(o.xmlGrid.config,xml)[0];
var xmldata = $(o.xmlGrid.data,xml)[0], jstr, jstr1, key;
if($.grid.xmlToJSON ) {
jstr = $.jgrid.xmlToJSON( cnfg );
//jstr = $.jgrid.parse(jstr);
for(key in jstr) {
if(jstr.hasOwnProperty(key)) {
jstr1=jstr[key];
}
}
if(xmldata) {
// save the datatype
var svdatatype = jstr.grid.datatype;
jstr.grid.datatype = 'xmlstring';
jstr.grid.datastr = xml;
$($t).jqGrid( jstr1 ).jqGrid("setGridParam",{datatype:svdatatype});
} else {
setTimeout(function() { $($t).jqGrid( jstr1 ); },0);
}
} else {
alert("xml2json or parse are not present");
}
};
var jsonConvert = function (jsonstr,o){
if (jsonstr && typeof jsonstr === 'string') {
var json = $.jgrid.parseFunc(jsonstr);
var gprm = json[o.jsonGrid.config];
var jdata = json[o.jsonGrid.data];
if(jdata) {
var svdatatype = gprm.datatype;
gprm.datatype = 'jsonstring';
gprm.datastr = jdata;
$($t).jqGrid( gprm ).jqGrid("setGridParam",{datatype:svdatatype});
} else {
$($t).jqGrid( gprm );
}
}
};
switch (o.imptype){
case 'xml':
$.ajax($.extend({
url:o.impurl,
type:o.mtype,
data: o.impData,
dataType:"xml",
complete: function(xml,stat) {
if(stat === 'success') {
xmlConvert(xml.responseXML,o);
$($t).triggerHandler("jqGridImportComplete", [xml, o]);
if($.isFunction(o.importComplete)) {
o.importComplete(xml);
}
}
xml=null;
}
}, o.ajaxOptions));
break;
case 'xmlstring' :
// we need to make just the conversion and use the same code as xml
if(o.impstring && typeof o.impstring === 'string') {
var xmld = $.parseXML(o.impstring);
if(xmld) {
xmlConvert(xmld,o);
$($t).triggerHandler("jqGridImportComplete", [xmld, o]);
if($.isFunction(o.importComplete)) {
o.importComplete(xmld);
}
}
}
break;
case 'json':
$.ajax($.extend({
url:o.impurl,
type:o.mtype,
data: o.impData,
dataType:"json",
complete: function(json) {
try {
jsonConvert(json.responseText,o );
$($t).triggerHandler("jqGridImportComplete", [json, o]);
if($.isFunction(o.importComplete)) {
o.importComplete(json);
}
} catch (ee){}
json=null;
}
}, o.ajaxOptions ));
break;
case 'jsonstring' :
if(o.impstring && typeof o.impstring === 'string') {
jsonConvert(o.impstring,o );
$($t).triggerHandler("jqGridImportComplete", [o.impstring, o]);
if($.isFunction(o.importComplete)) {
o.importComplete(o.impstring);
}
}
break;
}
}
});
$.jgrid.extend({
jqGridExport : function(o) {
o = $.extend({
exptype : "xmlstring",
root: "grid",
ident: "\t",
addOptions : {},
data : true
}, o || {});
var ret = null;
this.each(function () {
if(!this.grid) { return;}
var gprm = $.extend(true, {}, $(this).jqGrid("getGridParam"), o.addOptions);
// we need to check for:
// 1.multiselect, 2.subgrid 3. treegrid and remove the unneded columns from colNames
if(gprm.rownumbers) {
gprm.colNames.splice(0,1);
gprm.colModel.splice(0,1);
}
if(gprm.multiselect) {
gprm.colNames.splice(0,1);
gprm.colModel.splice(0,1);
}
if(gprm.subGrid) {
gprm.colNames.splice(0,1);
gprm.colModel.splice(0,1);
}
gprm.knv = null;
if(!o.data) {
gprm.data = [];
gprm._index = {};
}
switch (o.exptype) {
case 'xmlstring' :
ret = "<"+o.root+">"+ $.jgrid.jsonToXML( gprm, {xmlDecl:""} )+"</"+o.root+">";
break;
case 'jsonstring' :
ret = $.jgrid.stringify( gprm );
if(o.root) { ret = "{"+ o.root +":"+ret+"}"; }
break;
}
});
return ret;
},
excelExport : function(o) {
o = $.extend({
exptype : "remote",
url : null,
oper: "oper",
tag: "excel",
beforeExport : null,
exporthidden : false,
exportgrouping: false,
exportOptions : {}
}, o || {});
return this.each(function(){
if(!this.grid) { return;}
var url;
if(o.exptype === "remote") {
var pdata = $.extend({},this.p.postData), expg;
pdata[o.oper] = o.tag;
if($.isFunction(o.beforeExport)) {
var result = o.beforeExport.call(this, pdata );
if( $.isPlainObject( result ) ) {
pdata = result;
}
}
if(o.exporthidden) {
var cm = this.p.colModel, i, len = cm.length, newm=[];
for(i=0; i< len; i++) {
if(cm[i].hidden === undefined) { cm[i].hidden = false; }
newm.push({name:cm[i].name, hidden:cm[i].hidden});
}
var newm1 = JSON.stringify( newm );
if(typeof newm1 === 'string' ) {
pdata.colModel = newm1;
}
}
if(o.exportgrouping) {
expg = JSON.stringify( this.p.groupingView );
if(typeof expg === 'string' ) {
pdata.groupingView = expg;
}
}
var params = jQuery.param(pdata);
if(o.url.indexOf("?") !== -1) { url = o.url+"&"+params; }
else { url = o.url+"?"+params; }
window.location = url;
}
});
}
});
//module begin
$.jgrid.inlineEdit = $.jgrid.inlineEdit || {};
$.jgrid.extend({
//Editing
editRow : function(rowid,keys,oneditfunc,successfunc, url, extraparam, aftersavefunc,errorfunc, afterrestorefunc) {
// Compatible mode old versions
var o={}, args = $.makeArray(arguments).slice(1), $t = this[0];
if( $.type(args[0]) === "object" ) {
o = args[0];
} else {
if (keys !== undefined) { o.keys = keys; }
if ($.isFunction(oneditfunc)) { o.oneditfunc = oneditfunc; }
if ($.isFunction(successfunc)) { o.successfunc = successfunc; }
if (url !== undefined) { o.url = url; }
if (extraparam !== undefined) { o.extraparam = extraparam; }
if ($.isFunction(aftersavefunc)) { o.aftersavefunc = aftersavefunc; }
if ($.isFunction(errorfunc)) { o.errorfunc = errorfunc; }
if ($.isFunction(afterrestorefunc)) { o.afterrestorefunc = afterrestorefunc; }
// last two not as param, but as object (sorry)
//if (restoreAfterError !== undefined) { o.restoreAfterError = restoreAfterError; }
//if (mtype !== undefined) { o.mtype = mtype || "POST"; }
}
o = $.extend(true, {
keys : false,
keyevent : "keydown",
onEnter : null,
onEscape : null,
oneditfunc: null,
successfunc: null,
url: null,
extraparam: {},
aftersavefunc: null,
errorfunc: null,
afterrestorefunc: null,
restoreAfterError: true,
mtype: "POST",
focusField : true,
saveui : "enable",
savetext : $.jgrid.getRegional($t,'defaults.savetext')
}, $.jgrid.inlineEdit, o );
// End compatible
return this.each(function(){
var nm, tmp, editable, cnt=0, focus=null, svr={}, ind,cm, bfer,
inpclass = $(this).jqGrid('getStyleUI',$t.p.styleUI+".inlinedit",'inputClass', true);
if (!$t.grid ) { return; }
ind = $($t).jqGrid("getInd",rowid,true);
if( ind === false ) {return;}
$t.p.beforeAction = true;
bfer = $.isFunction( o.beforeEditRow ) ? o.beforeEditRow.call($t,o, rowid) : undefined;
if( bfer === undefined ) {
bfer = true;
}
if(!bfer) {
$t.p.beforeAction = false;
return;
}
editable = $(ind).attr("editable") || "0";
if (editable === "0" && !$(ind).hasClass("not-editable-row")) {
cm = $t.p.colModel;
$(ind).children('td[role="gridcell"]').each( function(i) {
nm = cm[i].name;
var treeg = $t.p.treeGrid===true && nm === $t.p.ExpandColumn;
if(treeg) { tmp = $("span:first",this).html();}
else {
try {
tmp = $.unformat.call($t,this,{rowId:rowid, colModel:cm[i]},i);
} catch (_) {
tmp = ( cm[i].edittype && cm[i].edittype === 'textarea' ) ? $(this).text() : $(this).html();
}
}
if ( nm !== 'cb' && nm !== 'subgrid' && nm !== 'rn') {
if($t.p.autoencode) { tmp = $.jgrid.htmlDecode(tmp); }
//svr[nm]=tmp;
if(cm[i].editable===true) {
svr[nm]=tmp;
if(focus===null) { focus = i; }
if (treeg) { $("span:first",this).html(""); }
else { $(this).html(""); }
var opt = $.extend({},cm[i].editoptions || {},{id:rowid+"_"+nm,name:nm,rowId:rowid, oper:'edit', module : 'inline'});
if(!cm[i].edittype) { cm[i].edittype = "text"; }
if(tmp === " " || tmp === " " || (tmp !== null && tmp.length===1 && tmp.charCodeAt(0)===160) ) {tmp='';}
var elc = $.jgrid.createEl.call($t,cm[i].edittype,opt,tmp,true,$.extend({},$.jgrid.ajaxOptions,$t.p.ajaxSelectOptions || {}));
$(elc).addClass("editable inline-edit-cell");
if( $.inArray(cm[i].edittype, ['text','textarea','password','select']) > -1) {
$(elc).addClass( inpclass );
}
if(treeg) { $("span:first",this).append(elc); }
else { $(this).append(elc); }
$.jgrid.bindEv.call($t, elc, opt);
//Again IE
if(cm[i].edittype === "select" && cm[i].editoptions!==undefined && cm[i].editoptions.multiple===true && cm[i].editoptions.dataUrl===undefined && $.jgrid.msie()) {
$(elc).width($(elc).width());
}
cnt++;
}
}
});
if(cnt > 0) {
svr.id = rowid; $t.p.savedRow.push(svr);
$(ind).attr("editable","1");
if(o.focusField ) {
if(typeof o.focusField === 'number' && parseInt(o.focusField,10) <= cm.length) {
focus = o.focusField;
}
setTimeout(function(){
var fe = $("td:eq("+focus+") :input:visible",ind).not(":disabled");
if(fe.length > 0) {
fe.focus();
}
},0);
}
if(o.keys===true) {
$(ind).on( o.keyevent ,function(e) {
if (e.keyCode === 27) {
if($.isFunction( o.onEscape )) {
o.onEscape.call($t, rowid, o, e);
return true;
}
$($t).jqGrid("restoreRow",rowid, o);
if($t.p.inlineNav) {
try {
$($t).jqGrid('showAddEditButtons');
} catch (eer1) {}
}
return false;
}
if (e.keyCode === 13) {
var ta = e.target;
if(ta.tagName === 'TEXTAREA') { return true; }
if($.isFunction( o.onEnter )) {
o.onEnter.call($t, rowid, o, e);
return true;
}
if( $($t).jqGrid("saveRow", rowid, o ) ) {
if($t.p.inlineNav) {
try {
$($t).jqGrid('showAddEditButtons');
} catch (eer2) {}
}
}
return false;
}
});
}
$($t).triggerHandler("jqGridInlineEditRow", [rowid, o]);
if( $.isFunction(o.oneditfunc)) { o.oneditfunc.call($t, rowid); }
}
}
});
},
saveRow : function(rowid, successfunc, url, extraparam, aftersavefunc,errorfunc, afterrestorefunc) {
// Compatible mode old versions
var args = $.makeArray(arguments).slice(1), o = {}, $t = this[0];
if( $.type(args[0]) === "object" ) {
o = args[0];
} else {
if ($.isFunction(successfunc)) { o.successfunc = successfunc; }
if (url !== undefined) { o.url = url; }
if (extraparam !== undefined) { o.extraparam = extraparam; }
if ($.isFunction(aftersavefunc)) { o.aftersavefunc = aftersavefunc; }
if ($.isFunction(errorfunc)) { o.errorfunc = errorfunc; }
if ($.isFunction(afterrestorefunc)) { o.afterrestorefunc = afterrestorefunc; }
}
o = $.extend(true, {
successfunc: null,
url: null,
extraparam: {},
aftersavefunc: null,
errorfunc: null,
afterrestorefunc: null,
restoreAfterError: true,
mtype: "POST",
saveui : "enable",
savetext : $.jgrid.getRegional($t,'defaults.savetext')
}, $.jgrid.inlineEdit, o );
// End compatible
var success = false, nm, tmp={}, tmp2={}, tmp3= {}, editable, fr, cv, ind, nullIfEmpty=false,
error = $.trim( $($t).jqGrid('getStyleUI', $t.p.styleUI+'.common', 'error', true) );
if (!$t.grid ) { return success; }
ind = $($t).jqGrid("getInd",rowid,true);
if(ind === false) {return success;}
var errors = $.jgrid.getRegional($t, 'errors'),
edit =$.jgrid.getRegional($t, 'edit'),
bfsr = $.isFunction( o.beforeSaveRow ) ? o.beforeSaveRow.call($t,o, rowid) : undefined;
if( bfsr === undefined ) {
bfsr = true;
}
if(!bfsr) { return; }
editable = $(ind).attr("editable");
o.url = o.url || $t.p.editurl;
if (editable==="1") {
var cm, index, elem;
$(ind).children('td[role="gridcell"]').each(function(i) {
cm = $t.p.colModel[i];
nm = cm.name;
elem = "";
if ( nm !== 'cb' && nm !== 'subgrid' && cm.editable===true && nm !== 'rn' && !$(this).hasClass('not-editable-cell')) {
switch (cm.edittype) {
case "checkbox":
var cbv = ["Yes","No"];
if(cm.editoptions && cm.editoptions.value) {
cbv = cm.editoptions.value.split(":");
}
tmp[nm]= $("input",this).is(":checked") ? cbv[0] : cbv[1];
elem = $("input",this);
break;
case 'text':
case 'password':
case 'textarea':
case "button" :
tmp[nm]=$("input, textarea",this).val();
elem = $("input, textarea",this);
break;
case 'select':
if(!cm.editoptions.multiple) {
tmp[nm] = $("select option:selected",this).val();
tmp2[nm] = $("select option:selected", this).text();
} else {
var sel = $("select",this), selectedText = [];
tmp[nm] = $(sel).val();
if(tmp[nm]) { tmp[nm]= tmp[nm].join(","); } else { tmp[nm] =""; }
$("select option:selected",this).each(
function(i,selected){
selectedText[i] = $(selected).text();
}
);
tmp2[nm] = selectedText.join(",");
}
if(cm.formatter && cm.formatter === 'select') { tmp2={}; }
elem = $("select",this);
break;
case 'custom' :
try {
if(cm.editoptions && $.isFunction(cm.editoptions.custom_value)) {
tmp[nm] = cm.editoptions.custom_value.call($t, $(".customelement",this),'get');
if (tmp[nm] === undefined) { throw "e2"; }
} else { throw "e1"; }
} catch (e) {
if (e==="e1") { $.jgrid.info_dialog(errors.errcap,"function 'custom_value' "+edit.msg.nodefined,edit.bClose, {styleUI : $t.p.styleUI }); }
else { $.jgrid.info_dialog(errors.errcap,e.message,edit.bClose, {styleUI : $t.p.styleUI }); }
}
break;
}
cv = $.jgrid.checkValues.call($t,tmp[nm],i);
if(cv[0] === false) {
index = i;
return false;
}
if($t.p.autoencode) { tmp[nm] = $.jgrid.htmlEncode(tmp[nm]); }
if(o.url !== 'clientArray' && cm.editoptions && cm.editoptions.NullIfEmpty === true) {
if(tmp[nm] === "") {
tmp3[nm] = 'null';
nullIfEmpty = true;
}
}
}
});
if (cv[0] === false){
try {
if( $.isFunction($t.p.validationCell) ) {
$t.p.validationCell.call($t, elem, cv[1], ind.rowIndex, index);
} else {
var tr = $($t).jqGrid('getGridRowById', rowid),
positions = $.jgrid.findPos(tr);
$.jgrid.info_dialog(errors.errcap,cv[1],edit.bClose,{
left:positions[0],
top:positions[1]+$(tr).outerHeight(),
styleUI : $t.p.styleUI,
onClose: function(){
if(index >= 0 ) {
$("#"+rowid+"_" +$t.p.colModel[index].name).focus();
}
}
});
}
} catch (e) {
alert(cv[1]);
}
return success;
}
var idname, opers = $t.p.prmNames, oldRowId = rowid;
if ($t.p.keyName === false) {
idname = opers.id;
} else {
idname = $t.p.keyName;
}
if(tmp) {
tmp[opers.oper] = opers.editoper;
if (tmp[idname] === undefined || tmp[idname]==="") {
tmp[idname] = rowid;
} else if (ind.id !== $t.p.idPrefix + tmp[idname]) {
// rename rowid
var oldid = $.jgrid.stripPref($t.p.idPrefix, rowid);
if ($t.p._index[oldid] !== undefined) {
$t.p._index[tmp[idname]] = $t.p._index[oldid];
delete $t.p._index[oldid];
}
rowid = $t.p.idPrefix + tmp[idname];
$(ind).attr("id", rowid);
if ($t.p.selrow === oldRowId) {
$t.p.selrow = rowid;
}
if ($.isArray($t.p.selarrrow)) {
var i = $.inArray(oldRowId, $t.p.selarrrow);
if (i>=0) {
$t.p.selarrrow[i] = rowid;
}
}
if ($t.p.multiselect) {
var newCboxId = "jqg_" + $t.p.id + "_" + rowid;
$("input.cbox",ind)
.attr("id", newCboxId)
.attr("name", newCboxId);
}
// TODO: to test the case of frozen columns
}
if($t.p.inlineData === undefined) { $t.p.inlineData ={}; }
tmp = $.extend({},tmp,$t.p.inlineData,o.extraparam);
}
if (o.url === 'clientArray') {
tmp = $.extend({},tmp, tmp2);
if($t.p.autoencode) {
$.each(tmp,function(n,v){
tmp[n] = $.jgrid.htmlDecode(v);
});
}
tmp = $.isFunction($t.p.serializeRowData) ? $t.p.serializeRowData.call($t, tmp) : tmp;
var k, resp = $($t).jqGrid("setRowData",rowid,tmp);
$(ind).attr("editable","0");
for(k=0;k<$t.p.savedRow.length;k++) {
if( String($t.p.savedRow[k].id) === String(oldRowId)) {fr = k; break;}
}
$($t).triggerHandler("jqGridInlineAfterSaveRow", [rowid, resp, tmp, o]);
if( $.isFunction(o.aftersavefunc) ) { o.aftersavefunc.call($t, rowid, resp, tmp, o); }
if(fr >= 0) { $t.p.savedRow.splice(fr,1); }
success = true;
$(ind).removeClass("jqgrid-new-row").off("keydown");
} else {
$($t).jqGrid("progressBar", {method:"show", loadtype : o.saveui, htmlcontent: o.savetext });
tmp3 = $.extend({},tmp,tmp3);
tmp3[idname] = $.jgrid.stripPref($t.p.idPrefix, tmp3[idname]);
$.ajax($.extend({
url:o.url,
data: $.isFunction($t.p.serializeRowData) ? $t.p.serializeRowData.call($t, tmp3) : tmp3,
type: o.mtype,
async : false, //?!?
complete: function(res,stat){
$($t).jqGrid("progressBar", {method:"hide", loadtype : o.saveui, htmlcontent: o.savetext});
if (stat === "success"){
var ret = true, sucret, k;
sucret = $($t).triggerHandler("jqGridInlineSuccessSaveRow", [res, rowid, o]);
if (!$.isArray(sucret)) {sucret = [true, tmp3];}
if (sucret[0] && $.isFunction(o.successfunc)) {sucret = o.successfunc.call($t, res);}
if($.isArray(sucret)) {
// expect array - status, data, rowid
ret = sucret[0];
tmp = sucret[1] || tmp;
} else {
ret = sucret;
}
if (ret===true) {
if($t.p.autoencode) {
$.each(tmp,function(n,v){
tmp[n] = $.jgrid.htmlDecode(v);
});
}
if(nullIfEmpty) {
$.each(tmp,function( n ){
if(tmp[n] === 'null' ) {
tmp[n] = '';
}
});
}
tmp = $.extend({},tmp, tmp2);
$($t).jqGrid("setRowData",rowid,tmp);
$(ind).attr("editable","0");
for(k=0;k<$t.p.savedRow.length;k++) {
if( String($t.p.savedRow[k].id) === String(rowid)) {fr = k; break;}
}
$($t).triggerHandler("jqGridInlineAfterSaveRow", [rowid, res, tmp, o]);
if( $.isFunction(o.aftersavefunc) ) { o.aftersavefunc.call($t, rowid, res, tmp, o); }
if(fr >= 0) { $t.p.savedRow.splice(fr,1); }
success = true;
$(ind).removeClass("jqgrid-new-row").off("keydown");
} else {
$($t).triggerHandler("jqGridInlineErrorSaveRow", [rowid, res, stat, null, o]);
if($.isFunction(o.errorfunc) ) {
o.errorfunc.call($t, rowid, res, stat, null);
}
if(o.restoreAfterError === true) {
$($t).jqGrid("restoreRow",rowid, o);
}
}
}
},
error:function(res,stat,err){
$("#lui_"+$.jgrid.jqID($t.p.id)).hide();
$($t).triggerHandler("jqGridInlineErrorSaveRow", [rowid, res, stat, err, o]);
if($.isFunction(o.errorfunc) ) {
o.errorfunc.call($t, rowid, res, stat, err);
} else {
var rT = res.responseText || res.statusText;
try {
$.jgrid.info_dialog(errors.errcap,'<div class="'+error+'">'+ rT +'</div>', edit.bClose, {buttonalign:'right', styleUI : $t.p.styleUI });
} catch(e) {
alert(rT);
}
}
if(o.restoreAfterError === true) {
$($t).jqGrid("restoreRow",rowid, o);
}
}
}, $.jgrid.ajaxOptions, $t.p.ajaxRowOptions || {}));
}
}
return success;
},
restoreRow : function(rowid, afterrestorefunc) {
// Compatible mode old versions
var args = $.makeArray(arguments).slice(1), o={};
if( $.type(args[0]) === "object" ) {
o = args[0];
} else {
if ($.isFunction(afterrestorefunc)) { o.afterrestorefunc = afterrestorefunc; }
}
o = $.extend(true, {}, $.jgrid.inlineEdit, o );
// End compatible
return this.each(function(){
var $t= this, fr=-1, ind, ares={}, k;
if (!$t.grid ) { return; }
ind = $($t).jqGrid("getInd",rowid,true);
if(ind === false) {return;}
var bfcr = $.isFunction( o.beforeCancelRow ) ? o.beforeCancelRow.call($t, o, rowid) : undefined;
if( bfcr === undefined ) {
bfcr = true;
}
if(!bfcr) { return; }
for(k=0;k<$t.p.savedRow.length;k++) {
if( String($t.p.savedRow[k].id) === String(rowid)) {fr = k; break;}
}
if(fr >= 0) {
if($.isFunction($.fn.datepicker)) {
try {
$("input.hasDatepicker","#"+$.jgrid.jqID(ind.id)).datepicker('hide');
} catch (e) {}
}
$.each($t.p.colModel, function(){
if( $t.p.savedRow[fr].hasOwnProperty(this.name)) {
ares[this.name] = $t.p.savedRow[fr][this.name];
}
});
$($t).jqGrid("setRowData",rowid,ares);
$(ind).attr("editable","0").off("keydown");
$t.p.savedRow.splice(fr,1);
if($("#"+$.jgrid.jqID(rowid), "#"+$.jgrid.jqID($t.p.id)).hasClass("jqgrid-new-row")){
setTimeout(function(){
$($t).jqGrid("delRowData",rowid);
$($t).jqGrid('showAddEditButtons');
},0);
}
}
$($t).triggerHandler("jqGridInlineAfterRestoreRow", [rowid]);
if ($.isFunction(o.afterrestorefunc))
{
o.afterrestorefunc.call($t, rowid);
}
});
},
addRow : function ( p ) {
p = $.extend(true, {
rowID : null,
initdata : {},
position :"first",
useDefValues : true,
useFormatter : false,
addRowParams : {extraparam:{}}
},p || {});
return this.each(function(){
if (!this.grid ) { return; }
var $t = this;
$t.p.beforeAction = true;
var bfar = $.isFunction( p.beforeAddRow ) ? p.beforeAddRow.call($t,p.addRowParams) : undefined;
if( bfar === undefined ) {
bfar = true;
}
if(!bfar) {
$t.p.beforeAction = false;
return;
}
p.rowID = $.isFunction(p.rowID) ? p.rowID.call($t, p) : ( (p.rowID != null) ? p.rowID : $.jgrid.randId());
if(p.useDefValues === true) {
$($t.p.colModel).each(function(){
if( this.editoptions && this.editoptions.defaultValue ) {
var opt = this.editoptions.defaultValue,
tmp = $.isFunction(opt) ? opt.call($t) : opt;
p.initdata[this.name] = tmp;
}
});
}
$($t).jqGrid('addRowData', p.rowID, p.initdata, p.position);
p.rowID = $t.p.idPrefix + p.rowID;
$("#"+$.jgrid.jqID(p.rowID), "#"+$.jgrid.jqID($t.p.id)).addClass("jqgrid-new-row");
if(p.useFormatter) {
$("#"+$.jgrid.jqID(p.rowID)+" .ui-inline-edit", "#"+$.jgrid.jqID($t.p.id)).click();
} else {
var opers = $t.p.prmNames,
oper = opers.oper;
p.addRowParams.extraparam[oper] = opers.addoper;
$($t).jqGrid('editRow', p.rowID, p.addRowParams);
$($t).jqGrid('setSelection', p.rowID);
}
});
},
inlineNav : function (elem, o) {
var $t = this[0],
regional = $.jgrid.getRegional($t, 'nav'),
icons = $.jgrid.styleUI[$t.p.styleUI].inlinedit;
o = $.extend(true,{
edit: true,
editicon: icons.icon_edit_nav,
add: true,
addicon:icons.icon_add_nav,
save: true,
saveicon: icons.icon_save_nav,
cancel: true,
cancelicon: icons.icon_cancel_nav,
addParams : {addRowParams: {extraparam: {}}},
editParams : {},
restoreAfterSelect : true,
saveAfterSelect : false
}, regional, o ||{});
return this.each(function(){
if (!this.grid || this.p.inlineNav) { return; }
var gID = $.jgrid.jqID($t.p.id),
disabled = $.trim( $($t).jqGrid('getStyleUI', $t.p.styleUI+'.common', 'disabled', true) );
// check to see if navgrid is started, if not call it with all false parameters.
if(!$t.p.navGrid) {
$($t).jqGrid('navGrid',elem, {refresh:false, edit: false, add: false, del: false, search: false, view: false});
}
if(!$($t).data('inlineNav')) {
$($t).data('inlineNav',o);
}
if($t.p.force_regional) {
o = $.extend(o, regional);
}
$t.p.inlineNav = true;
// detect the formatactions column
if(o.addParams.useFormatter === true) {
var cm = $t.p.colModel,i;
for (i = 0; i<cm.length; i++) {
if(cm[i].formatter && cm[i].formatter === "actions" ) {
if(cm[i].formatoptions) {
var defaults = {
keys:false,
onEdit : null,
onSuccess: null,
afterSave:null,
onError: null,
afterRestore: null,
extraparam: {},
url: null
},
ap = $.extend( defaults, cm[i].formatoptions );
o.addParams.addRowParams = {
"keys" : ap.keys,
"oneditfunc" : ap.onEdit,
"successfunc" : ap.onSuccess,
"url" : ap.url,
"extraparam" : ap.extraparam,
"aftersavefunc" : ap.afterSave,
"errorfunc": ap.onError,
"afterrestorefunc" : ap.afterRestore
};
}
break;
}
}
}
if(o.add) {
$($t).jqGrid('navButtonAdd', elem,{
caption : o.addtext,
title : o.addtitle,
buttonicon : o.addicon,
id : $t.p.id+"_iladd",
internal : true,
onClickButton : function () {
if($t.p.beforeAction === undefined) {
$t.p.beforeAction = true;
}
$($t).jqGrid('addRow', o.addParams);
if(!o.addParams.useFormatter && $t.p.beforeAction) {
$("#"+gID+"_ilsave").removeClass( disabled );
$("#"+gID+"_ilcancel").removeClass( disabled );
$("#"+gID+"_iladd").addClass( disabled );
$("#"+gID+"_iledit").addClass( disabled );
}
}
});
}
if(o.edit) {
$($t).jqGrid('navButtonAdd', elem,{
caption : o.edittext,
title : o.edittitle,
buttonicon : o.editicon,
id : $t.p.id+"_iledit",
internal : true,
onClickButton : function () {
var sr = $($t).jqGrid('getGridParam','selrow');
if(sr) {
if($t.p.beforeAction === undefined) {
$t.p.beforeAction = true;
}
$($t).jqGrid('editRow', sr, o.editParams);
if($t.p.beforeAction) {
$("#"+gID+"_ilsave").removeClass( disabled );
$("#"+gID+"_ilcancel").removeClass( disabled );
$("#"+gID+"_iladd").addClass( disabled );
$("#"+gID+"_iledit").addClass( disabled );
}
} else {
$.jgrid.viewModal("#alertmod_"+gID, {gbox:"#gbox_"+gID,jqm:true});$("#jqg_alrt").focus();
}
}
});
}
if(o.save) {
$($t).jqGrid('navButtonAdd', elem,{
caption : o.savetext || '',
title : o.savetitle || 'Save row',
buttonicon : o.saveicon,
id : $t.p.id+"_ilsave",
internal : true,
onClickButton : function () {
var sr = $t.p.savedRow[0].id;
if(sr) {
var opers = $t.p.prmNames,
oper = opers.oper, tmpParams = o.editParams;
if($("#"+$.jgrid.jqID(sr), "#"+gID ).hasClass("jqgrid-new-row")) {
o.addParams.addRowParams.extraparam[oper] = opers.addoper;
tmpParams = o.addParams.addRowParams;
} else {
if(!o.editParams.extraparam) {
o.editParams.extraparam = {};
}
o.editParams.extraparam[oper] = opers.editoper;
}
if( $($t).jqGrid('saveRow', sr, tmpParams) ) {
$($t).jqGrid('showAddEditButtons');
}
} else {
$.jgrid.viewModal("#alertmod_"+gID, {gbox:"#gbox_"+gID,jqm:true});$("#jqg_alrt").focus();
}
}
});
$("#"+gID+"_ilsave").addClass( disabled );
}
if(o.cancel) {
$($t).jqGrid('navButtonAdd', elem,{
caption : o.canceltext || '',
title : o.canceltitle || 'Cancel row editing',
buttonicon : o.cancelicon,
id : $t.p.id+"_ilcancel",
internal : true,
onClickButton : function () {
var sr = $t.p.savedRow[0].id, cancelPrm = o.editParams;
if(sr) {
if($("#"+$.jgrid.jqID(sr), "#"+gID ).hasClass("jqgrid-new-row")) {
cancelPrm = o.addParams.addRowParams;
}
$($t).jqGrid('restoreRow', sr, cancelPrm);
$($t).jqGrid('showAddEditButtons');
} else {
$.jgrid.viewModal("#alertmod",{gbox:"#gbox_"+gID,jqm:true});$("#jqg_alrt").focus();
}
}
});
$("#"+gID+"_ilcancel").addClass( disabled );
}
if(o.restoreAfterSelect === true || o.saveAfterSelect === true) {
$($t).on("jqGridBeforeSelectRow.inlineNav", function( event, id ) {
if($t.p.savedRow.length > 0 && $t.p.inlineNav===true && ( id !== $t.p.selrow && $t.p.selrow !==null) ) {
var success = true;
if($t.p.selrow === o.addParams.rowID ) {
$($t).jqGrid('delRowData', $t.p.selrow);
} else {
if(o.restoreAfterSelect === true) {
$($t).jqGrid('restoreRow', $t.p.selrow, o.editParams);
} else {
success = $($t).jqGrid('saveRow', $t.p.selrow, o.editParams);
}
}
if(success) {
$($t).jqGrid('showAddEditButtons');
}
}
});
}
});
},
showAddEditButtons : function() {
return this.each(function(){
if (!this.grid ) { return; }
var gID = $.jgrid.jqID(this.p.id),
disabled = $.trim( $(this).jqGrid('getStyleUI', this.p.styleUI+'.common', 'disabled', true) );
$("#"+gID+"_ilsave").addClass( disabled );
$("#"+gID+"_ilcancel").addClass( disabled );
$("#"+gID+"_iladd").removeClass( disabled );
$("#"+gID+"_iledit").removeClass( disabled );
});
},
showSaveCancelButtons : function() {
return this.each(function(){
if (!this.grid ) { return; }
var gID = $.jgrid.jqID(this.p.id),
disabled = $.trim( $(this).jqGrid('getStyleUI', this.p.styleUI+'.common', 'disabled', true) );
$("#"+gID+"_ilsave").removeClass( disabled );
$("#"+gID+"_ilcancel").removeClass( disabled );
$("#"+gID+"_iladd").addClass( disabled );
$("#"+gID+"_iledit").addClass( disabled );
});
}
//end inline edit
});
//module begin
if ($.jgrid.msie() && $.jgrid.msiever()===8) {
$.expr[":"].hidden = function(elem) {
return elem.offsetWidth === 0 || elem.offsetHeight === 0 ||
elem.style.display === "none";
};
}
// requiere load multiselect before grid
$.jgrid._multiselect = false;
if($.ui) {
if ($.ui.multiselect ) {
if($.ui.multiselect.prototype._setSelected) {
var setSelected = $.ui.multiselect.prototype._setSelected;
$.ui.multiselect.prototype._setSelected = function(item,selected) {
var ret = setSelected.call(this,item,selected);
if (selected && this.selectedList) {
var elt = this.element;
this.selectedList.find('li').each(function() {
if ($(this).data('optionLink')) {
$(this).data('optionLink').remove().appendTo(elt);
}
});
}
return ret;
};
}
if($.ui.multiselect.prototype.destroy) {
$.ui.multiselect.prototype.destroy = function() {
this.element.show();
this.container.remove();
if ($.Widget === undefined) {
$.widget.prototype.destroy.apply(this, arguments);
} else {
$.Widget.prototype.destroy.apply(this, arguments);
}
};
}
$.jgrid._multiselect = true;
}
}
$.jgrid.extend({
sortableColumns : function (tblrow)
{
return this.each(function (){
var ts = this, tid= $.jgrid.jqID( ts.p.id ), frozen = false;
function start() {
ts.p.disableClick = true;
if(ts.p.frozenColumns) {
$(ts).jqGrid("destroyFrozenColumns");
frozen = true;
}
}
function stop() {
setTimeout(function () {
ts.p.disableClick = false;
if(frozen) {
$(ts).jqGrid("setFrozenColumns");
frozen = false;
}
}, 50);
}
var sortable_opts = {
"tolerance" : "pointer",
"axis" : "x",
"scrollSensitivity": "1",
"items": '>th:not(:has(#jqgh_'+tid+'_cb'+',#jqgh_'+tid+'_rn'+',#jqgh_'+tid+'_subgrid),:hidden)',
"placeholder": {
element: function(item) {
var el = $(document.createElement(item[0].nodeName))
.addClass(item[0].className+" ui-sortable-placeholder ui-state-highlight")
.removeClass("ui-sortable-helper")[0];
return el;
},
update: function(self, p) {
p.height(self.currentItem.innerHeight() - parseInt(self.currentItem.css('paddingTop')||0, 10) - parseInt(self.currentItem.css('paddingBottom')||0, 10));
p.width(self.currentItem.innerWidth() - parseInt(self.currentItem.css('paddingLeft')||0, 10) - parseInt(self.currentItem.css('paddingRight')||0, 10));
}
},
"update": function(event, ui) {
var p = $(ui.item).parent(),
th = $(">th", p),
colModel = ts.p.colModel,
cmMap = {}, tid= ts.p.id+"_";
$.each(colModel, function(i) { cmMap[this.name]=i; });
var permutation = [];
th.each(function() {
var id = $(">div", this).get(0).id.replace(/^jqgh_/, "").replace(tid,"");
if (cmMap.hasOwnProperty(id)) {
permutation.push(cmMap[id]);
}
});
$(ts).jqGrid("remapColumns",permutation, true, true);
if ($.isFunction(ts.p.sortable.update)) {
ts.p.sortable.update(permutation);
}
}
};
if (ts.p.sortable.options) {
$.extend(sortable_opts, ts.p.sortable.options);
} else if ($.isFunction(ts.p.sortable)) {
ts.p.sortable = { "update" : ts.p.sortable };
}
if (sortable_opts.start) {
var s = sortable_opts.start;
sortable_opts.start = function(e,ui) {
start();
s.call(this,e,ui);
};
} else {
sortable_opts.start = start;
}
if (sortable_opts.stop) {
var st = sortable_opts.stop;
sortable_opts.stop = function(e,ui) {
stop();
st.call(this,e,ui);
};
} else {
sortable_opts.stop = stop;
}
if (ts.p.sortable.exclude) {
sortable_opts.items += ":not("+ts.p.sortable.exclude+")";
}
var $e = tblrow.sortable(sortable_opts), dataObj = $e.data("sortable") || $e.data("uiSortable");
if (dataObj != null) {
dataObj.data("sortable").floating = true;
}
});
},
columnChooser : function(opts) {
var self = this, selector, select, colMap = {}, fixedCols = [], dopts, mopts, $dialogContent, multiselectData, listHeight,
colModel = self.jqGrid("getGridParam", "colModel"),
colNames = self.jqGrid("getGridParam", "colNames"),
getMultiselectWidgetData = function ($elem) {
return ($.ui.multiselect.prototype && $elem.data($.ui.multiselect.prototype.widgetFullName || $.ui.multiselect.prototype.widgetName)) ||
$elem.data("ui-multiselect") || $elem.data("multiselect");
},
regional = $.jgrid.getRegional(this[0], 'col');
if ($("#colchooser_" + $.jgrid.jqID(self[0].p.id)).length) { return; }
selector = $('<div id="colchooser_'+self[0].p.id+'" style="position:relative;overflow:hidden"><div><select multiple="multiple"></select></div></div>');
select = $('select', selector);
function insert(perm,i,v) {
var a, b;
if(i>=0){
a = perm.slice();
b = a.splice(i,Math.max(perm.length-i,i));
if(i>perm.length) { i = perm.length; }
a[i] = v;
return a.concat(b);
}
return perm;
}
function call(fn, obj) {
if (!fn) { return; }
if (typeof fn === 'string') {
if ($.fn[fn]) {
$.fn[fn].apply(obj, $.makeArray(arguments).slice(2));
}
} else if ($.isFunction(fn)) {
fn.apply(obj, $.makeArray(arguments).slice(2));
}
}
function resize_select() {
var widgetData = getMultiselectWidgetData(select),
$thisDialogContent = widgetData.container.closest(".ui-dialog-content");
if ($thisDialogContent.length > 0 && typeof $thisDialogContent[0].style === "object") {
$thisDialogContent[0].style.width = "";
} else {
$thisDialogContent.css("width", ""); // or just remove width style
}
widgetData.selectedList.height(Math.max(widgetData.selectedContainer.height() - widgetData.selectedActions.outerHeight() -1, 1));
widgetData.availableList.height(Math.max(widgetData.availableContainer.height() - widgetData.availableActions.outerHeight() -1, 1));
}
opts = $.extend({
width : 400,
height : 240,
classname : null,
done : function(perm) { if (perm) { self.jqGrid("remapColumns", perm, true); } },
/* msel is either the name of a ui widget class that
extends a multiselect, or a function that supports
creating a multiselect object (with no argument,
or when passed an object), and destroying it (when
passed the string "destroy"). */
msel : "multiselect",
/* "msel_opts" : {}, */
/* dlog is either the name of a ui widget class that
behaves in a dialog-like way, or a function, that
supports creating a dialog (when passed dlog_opts)
or destroying a dialog (when passed the string
"destroy")
*/
dlog : "dialog",
dialog_opts : {
minWidth: 470,
dialogClass: "ui-jqdialog"
},
/* dlog_opts is either an option object to be passed
to "dlog", or (more likely) a function that creates
the options object.
The default produces a suitable options object for
ui.dialog */
dlog_opts : function(options) {
var buttons = {};
buttons[options.bSubmit] = function() {
options.apply_perm();
options.cleanup(false);
};
buttons[options.bCancel] = function() {
options.cleanup(true);
};
return $.extend(true, {
buttons: buttons,
close: function() {
options.cleanup(true);
},
modal: options.modal || false,
resizable: options.resizable || true,
width: options.width + 70,
resize: resize_select
}, options.dialog_opts || {});
},
/* Function to get the permutation array, and pass it to the
"done" function */
apply_perm : function() {
var perm = [];
$('option',select).each(function() {
if ($(this).is(":selected")) {
self.jqGrid("showCol", colModel[this.value].name);
} else {
self.jqGrid("hideCol", colModel[this.value].name);
}
});
//fixedCols.slice(0);
$('option[selected]',select).each(function() { perm.push(parseInt(this.value,10)); });
$.each(perm, function() { delete colMap[colModel[parseInt(this,10)].name]; });
$.each(colMap, function() {
var ti = parseInt(this,10);
perm = insert(perm,ti,ti);
});
if (opts.done) {
opts.done.call(self, perm);
}
self.jqGrid("setGridWidth", self[0].p.width, self[0].p.shrinkToFit);
},
/* Function to cleanup the dialog, and select. Also calls the
done function with no permutation (to indicate that the
columnChooser was aborted */
cleanup : function(calldone) {
call(opts.dlog, selector, 'destroy');
call(opts.msel, select, 'destroy');
selector.remove();
if (calldone && opts.done) {
opts.done.call(self);
}
},
msel_opts : {}
}, regional, opts || {} );
if($.ui) {
if ($.ui.multiselect && $.ui.multiselect.defaults) {
if (!$.jgrid._multiselect) {
// should be in language file
alert("Multiselect plugin loaded after jqGrid. Please load the plugin before the jqGrid!");
return;
}
// ??? the next line uses $.ui.multiselect.defaults which will be typically undefined
opts.msel_opts = $.extend($.ui.multiselect.defaults, opts.msel_opts);
}
}
if (opts.caption) {
selector.attr("title", opts.caption);
}
if (opts.classname) {
selector.addClass(opts.classname);
select.addClass(opts.classname);
}
if (opts.width) {
$(">div",selector).css({width: opts.width,margin:"0 auto"});
select.css("width", opts.width);
}
if (opts.height) {
$(">div",selector).css("height", opts.height);
select.css("height", opts.height - 10);
}
select.empty();
$.each(colModel, function(i) {
colMap[this.name] = i;
if (this.hidedlg) {
if (!this.hidden) {
fixedCols.push(i);
}
return;
}
select.append("<option value='"+i+"' "+
(this.hidden?"":"selected='selected'")+">"+$.jgrid.stripHtml(colNames[i])+"</option>");
});
dopts = $.isFunction(opts.dlog_opts) ? opts.dlog_opts.call(self, opts) : opts.dlog_opts;
call(opts.dlog, selector, dopts);
mopts = $.isFunction(opts.msel_opts) ? opts.msel_opts.call(self, opts) : opts.msel_opts;
call(opts.msel, select, mopts);
// fix height of elements of the multiselect widget
$dialogContent = $("#colchooser_" + $.jgrid.jqID(self[0].p.id));
// fix fontsize
var fs = $('.ui-jqgrid').css('font-size') || '11px';
$dialogContent.parent().css("font-size",fs);
$dialogContent.css({ margin: "auto" });
$dialogContent.find(">div").css({ width: "100%", height: "100%", margin: "auto" });
multiselectData = getMultiselectWidgetData(select);
multiselectData.container.css({ width: "100%", height: "100%", margin: "auto" });
multiselectData.selectedContainer.css({ width: multiselectData.options.dividerLocation * 100 + "%", height: "100%", margin: "auto", boxSizing: "border-box" });
multiselectData.availableContainer.css({ width: (100 - multiselectData.options.dividerLocation * 100) + "%", height: "100%", margin: "auto", boxSizing: "border-box" });
// set height for both selectedList and availableList
multiselectData.selectedList.css("height", "auto");
multiselectData.availableList.css("height", "auto");
listHeight = Math.max(multiselectData.selectedList.height(), multiselectData.availableList.height());
listHeight = Math.min(listHeight, $(window).height());
multiselectData.selectedList.css("height", listHeight);
multiselectData.availableList.css("height", listHeight);
resize_select();
},
sortableRows : function (opts) {
// Can accept all sortable options and events
return this.each(function(){
var $t = this;
if(!$t.grid) { return; }
// Currently we disable a treeGrid sortable
if($t.p.treeGrid) { return; }
if($.fn.sortable) {
opts = $.extend({
"cursor":"move",
"axis" : "y",
"items": " > .jqgrow"
},
opts || {});
if(opts.start && $.isFunction(opts.start)) {
opts._start_ = opts.start;
delete opts.start;
} else {opts._start_=false;}
if(opts.update && $.isFunction(opts.update)) {
opts._update_ = opts.update;
delete opts.update;
} else {opts._update_ = false;}
opts.start = function(ev,ui) {
$(ui.item).css("border-width","0");
$("td",ui.item).each(function(i){
this.style.width = $t.grid.cols[i].style.width;
});
if($t.p.subGrid) {
var subgid = $(ui.item).attr("id");
try {
$($t).jqGrid('collapseSubGridRow',subgid);
} catch (e) {}
}
if(opts._start_) {
opts._start_.apply(this,[ev,ui]);
}
};
opts.update = function (ev,ui) {
$(ui.item).css("border-width","");
if($t.p.rownumbers === true) {
$("td.jqgrid-rownum",$t.rows).each(function( i ){
$(this).html( i+1+(parseInt($t.p.page,10)-1)*parseInt($t.p.rowNum,10) );
});
}
if(opts._update_) {
opts._update_.apply(this,[ev,ui]);
}
};
$("tbody:first",$t).sortable(opts);
$("tbody:first > .jqgrow",$t).disableSelection();
}
});
},
gridDnD : function(opts) {
return this.each(function(){
var $t = this, i, cn;
if(!$t.grid) { return; }
// Currently we disable a treeGrid drag and drop
if($t.p.treeGrid) { return; }
if(!$.fn.draggable || !$.fn.droppable) { return; }
function updateDnD ()
{
var datadnd = $.data($t,"dnd");
$("tr.jqgrow:not(.ui-draggable)",$t).draggable($.isFunction(datadnd.drag) ? datadnd.drag.call($($t),datadnd) : datadnd.drag);
}
var appender = "<table id='jqgrid_dnd' class='ui-jqgrid-dnd'></table>";
if($("#jqgrid_dnd")[0] === undefined) {
$('body').append(appender);
}
if(typeof opts === 'string' && opts === 'updateDnD' && $t.p.jqgdnd===true) {
updateDnD();
return;
}
var tid;
opts = $.extend({
"drag" : function (opts) {
return $.extend({
start : function (ev, ui) {
var i, subgid;
// if we are in subgrid mode try to collapse the node
if($t.p.subGrid) {
subgid = $(ui.helper).attr("id");
try {
$($t).jqGrid('collapseSubGridRow',subgid);
} catch (e) {}
}
// hack
// drag and drop does not insert tr in table, when the table has no rows
// we try to insert new empty row on the target(s)
for (i=0;i<$.data($t,"dnd").connectWith.length;i++){
if($($.data($t,"dnd").connectWith[i]).jqGrid('getGridParam','reccount') === 0 ){
$($.data($t,"dnd").connectWith[i]).jqGrid('addRowData','jqg_empty_row',{});
}
}
ui.helper.addClass("ui-state-highlight");
$("td",ui.helper).each(function(i) {
this.style.width = $t.grid.headers[i].width+"px";
});
if(opts.onstart && $.isFunction(opts.onstart) ) { opts.onstart.call($($t),ev,ui); }
},
stop :function(ev,ui) {
var i, ids;
if(ui.helper.dropped && !opts.dragcopy) {
ids = $(ui.helper).attr("id");
if(ids === undefined) { ids = $(this).attr("id"); }
$($t).jqGrid('delRowData',ids );
}
// if we have a empty row inserted from start event try to delete it
for (i=0;i<$.data($t,"dnd").connectWith.length;i++){
$($.data($t,"dnd").connectWith[i]).jqGrid('delRowData','jqg_empty_row');
}
if(opts.onstop && $.isFunction(opts.onstop) ) { opts.onstop.call($($t),ev,ui); }
}
},opts.drag_opts || {});
},
"drop" : function (opts) {
return $.extend({
accept: function(d) {
if (!$(d).hasClass('jqgrow')) { return d;}
tid = $(d).closest("table.ui-jqgrid-btable");
var target = $(this).find('table.ui-jqgrid-btable:first')[0];
if(tid.length > 0 && $.data(tid[0],"dnd") !== undefined) {
var cn = $.data(tid[0],"dnd").connectWith;
return $.inArray('#'+$.jgrid.jqID(target.id),cn) !== -1 ? true : false;
}
return false;
},
drop: function(ev, ui) {
if (!$(ui.draggable).hasClass('jqgrow')) {
return;
}
var accept = $(ui.draggable).attr("id"),
getdata = ui.draggable.parent().parent().jqGrid('getRowData',accept),
keysd = [],
target = $(this).find('table.ui-jqgrid-btable:first')[0];
if($.isPlainObject( getdata)) {
keysd = Object.keys(getdata);
}
if(!opts.dropbyname) {
var j, tmpdata = {}, nm, ki=0;
var dropmodel = $("#"+$.jgrid.jqID(target.id)).jqGrid('getGridParam','colModel');
try {
for(j=0;j<dropmodel.length;j++) {
nm = dropmodel[j].name;
if( !(nm === 'cb' || nm === 'rn' || nm === 'subgrid' )) {
if (keysd[ki] !== undefined) {
tmpdata[nm] = getdata[keysd[ki]];
}
ki++;
}
}
getdata = tmpdata;
} catch (e) {}
}
ui.helper.dropped = true;
if($.data(tid[0],"dnd").beforedrop && $.isFunction($.data(tid[0],"dnd").beforedrop) ) {
//parameters to this callback - event, element, data to be inserted, sender, reciever
// should return object which will be inserted into the reciever
var datatoinsert = $.data(tid[0],"dnd").beforedrop.call(target,ev,ui,getdata,$(tid[0]),$(target));
if (datatoinsert !== undefined && datatoinsert !== null && typeof datatoinsert === "object") { getdata = datatoinsert; }
}
if(ui.helper.dropped) {
var grid;
if(opts.autoid) {
if($.isFunction(opts.autoid)) {
grid = opts.autoid.call(target,getdata);
} else {
grid = Math.ceil(Math.random()*1000);
grid = opts.autoidprefix+grid;
}
}
// NULL is interpreted as undefined while null as object
$("#"+$.jgrid.jqID(target.id)).jqGrid('addRowData',grid,getdata,opts.droppos);
}
if(opts.ondrop && $.isFunction(opts.ondrop) ) { opts.ondrop.call(target,ev,ui, getdata); }
}}, opts.drop_opts || {});
},
"onstart" : null,
"onstop" : null,
"beforedrop": null,
"ondrop" : null,
"drop_opts" : {
"activeClass": "ui-state-active",
"hoverClass": "ui-state-hover",
"tolerance": "intersect"
},
"drag_opts" : {
"revert": "invalid",
"helper": "clone",
"cursor": "move",
"appendTo" : "#jqgrid_dnd",
"zIndex": 5000
},
"dragcopy": false,
"dropbyname" : false,
"droppos" : "first",
"autoid" : true,
"autoidprefix" : "dnd_"
}, opts || {});
if(!opts.connectWith) { return; }
opts.connectWith = opts.connectWith.split(",");
opts.connectWith = $.map(opts.connectWith,function(n){return $.trim(n);});
$.data($t,"dnd",opts);
if($t.p.reccount !== 0 && !$t.p.jqgdnd) {
updateDnD();
}
$t.p.jqgdnd = true;
for (i=0;i<opts.connectWith.length;i++){
cn =opts.connectWith[i];
$(cn).closest('.ui-jqgrid-bdiv').droppable($.isFunction(opts.drop) ? opts.drop.call($($t),opts) : opts.drop);
}
});
},
gridResize : function(opts) {
return this.each(function(){
var $t = this, gID = $.jgrid.jqID($t.p.id), req;
if(!$t.grid || !$.fn.resizable) { return; }
opts = $.extend({}, opts || {});
if(opts.alsoResize ) {
opts._alsoResize_ = opts.alsoResize;
delete opts.alsoResize;
} else {
opts._alsoResize_ = false;
}
if(opts.stop && $.isFunction(opts.stop)) {
opts._stop_ = opts.stop;
delete opts.stop;
} else {
opts._stop_ = false;
}
opts.stop = function (ev, ui) {
$($t).jqGrid('setGridParam',{height:$("#gview_"+gID+" .ui-jqgrid-bdiv").height()});
$($t).jqGrid('setGridWidth',ui.size.width,opts.shrinkToFit);
if(opts._stop_) { opts._stop_.call($t,ev,ui); }
if($t.p.caption) {
$("#gbox_"+ gID).css({ 'height': 'auto' });
}
if($t.p.frozenColumns) {
if (req ) clearTimeout(req);
req = setTimeout(function(){
if (req ) clearTimeout(req);
$("#" + gID).jqGrid("destroyFrozenColumns");
$("#" + gID).jqGrid("setFrozenColumns");
});
}
};
if(opts._alsoResize_) {
var optstest = "{\'#gview_"+gID+" .ui-jqgrid-bdiv\':true,'" +opts._alsoResize_+"':true}";
opts.alsoResize = eval('('+optstest+')'); // the only way that I found to do this
} else {
opts.alsoResize = $(".ui-jqgrid-bdiv","#gview_"+gID);
}
delete opts._alsoResize_;
$("#gbox_"+gID).resizable(opts);
});
}
});
//module begin
function _pivotfilter (fn, context) {
/*jshint validthis: true */
var i,
value,
result = [],
length;
if (!this || typeof fn !== 'function' || (fn instanceof RegExp)) {
throw new TypeError();
}
length = this.length;
for (i = 0; i < length; i++) {
if (this.hasOwnProperty(i)) {
value = this[i];
if (fn.call(context, value, i, this)) {
result.push(value);
// We need break in order to cancel loop
// in case the row is found
break;
}
}
}
return result;
}
$.assocArraySize = function(obj) {
// http://stackoverflow.com/a/6700/11236
var size = 0, key;
for (key in obj) {
if (obj.hasOwnProperty(key)) {
size++;
}
}
return size;
};
$.jgrid.extend({
pivotSetup : function( data, options ){
// data should come in json format
// The function return the new colModel and the transformed data
// again with group setup options which then will be passed to the grid
var columns =[],
pivotrows =[],
summaries = [],
member=[],
labels=[],
groupOptions = {
grouping : true,
groupingView : {
groupField : [],
groupSummary: [],
groupSummaryPos:[]
}
},
headers = [],
o = $.extend ( {
rowTotals : false,
rowTotalsText : 'Total',
// summary columns
colTotals : false,
groupSummary : true,
groupSummaryPos : 'header',
frozenStaticCols : false
}, options || {});
this.each(function(){
var
$t = this,
row,
rowindex,
i,
rowlen = data.length,
xlen, ylen, aggrlen,
tmp,
newObj,
r=0;
// utility funcs
/*
* Filter the data to a given criteria. Return the firt occurance
*/
function find(ar, fun, extra) {
var res;
res = _pivotfilter.call(ar, fun, extra);
return res.length > 0 ? res[0] : null;
}
/*
* Check if the grouped row column exist (See find)
* If the row is not find in pivot rows retun null,
* otherviese the column
*/
function findGroup(item, index) {
/*jshint validthis: true */
var j = 0, ret = true, i;
for(i in item) {
if( item.hasOwnProperty(i) ) {
if(item[i] != this[j]) {
ret = false;
break;
}
j++;
if(j>=this.length) {
break;
}
}
}
if(ret) {
rowindex = index;
}
return ret;
}
/*
* Perform calculations of the pivot values.
*/
function calculation(oper, v, field, rc, _cnt) {
var ret;
if( $.isFunction(oper)) {
ret = oper.call($t, v, field, rc);
} else {
switch (oper) {
case "sum" :
ret = parseFloat(v||0) + parseFloat((rc[field]||0));
break;
case "count" :
if(v==="" || v == null) {
v=0;
}
if(rc.hasOwnProperty(field)) {
ret = v+1;
} else {
ret = 0;
}
break;
case "min" :
if(v==="" || v == null) {
ret = parseFloat(rc[field]||0);
} else {
ret =Math.min(parseFloat(v),parseFloat(rc[field]||0));
}
break;
case "max" :
if(v==="" || v == null) {
ret = parseFloat(rc[field]||0);
} else {
ret = Math.max(parseFloat(v),parseFloat(rc[field]||0));
}
break;
case "avg" : //avg grouping
ret = (parseFloat(v||0) * (_cnt -1) + parseFloat(rc[field]||0) ) /_cnt;
break;
}
}
return ret;
}
/*
* The function agragates the values of the pivot grid.
* Return the current row with pivot summary values
*/
function agregateFunc ( row, aggr, value, curr) {
// default is sum
var arrln = aggr.length, i, label, j, jv, mainval="",swapvals=[], swapstr, _cntavg = 1, lbl;
if($.isArray(value)) {
jv = value.length;
swapvals = value;
} else {
jv = 1;
swapvals[0]=value;
}
member = [];
labels = [];
member.root = 0;
for(j=0;j<jv;j++) {
var tmpmember = [], vl;
for(i=0; i < arrln; i++) {
swapstr = typeof aggr[i].aggregator === 'string' ? aggr[i].aggregator : 'cust';
if(value == null) {
label = $.trim(aggr[i].member)+"_" + swapstr;
vl = label;
swapvals[0]= aggr[i].label || (swapstr + " " +$.trim(aggr[i].member));
} else {
vl = value[j].replace(/\s+/g, '');
try {
label = (arrln === 1 ? mainval + vl : mainval + vl + "_" + swapstr + "_" + String(i));
} catch(e) {}
swapvals[j] = value[j];
}
//if(j<=1 && vl !== '_r_Totals' && mainval === "") { // this does not fix full the problem
//mainval = vl;
//}
label = !isNaN(parseInt(label,10)) ? label + " " : label;
if(aggr[i].aggregator === 'avg') {
lbl = rowindex === -1 ? pivotrows.length+"_"+label : rowindex+"_"+label;
if(!_avg[lbl]) {
_avg[lbl] = 1;
} else {
_avg[lbl]++;
}
_cntavg = _avg[lbl];
}
curr[label] = tmpmember[label] = calculation( aggr[i].aggregator, curr[label], aggr[i].member, row, _cntavg);
}
mainval += (value && value[j] != null) ? value[j].replace(/\s+/g, '') : '';
//vl = !isNaN(parseInt(vl,10)) ? vl + " " : vl;
member[label] = tmpmember;
labels[label] = swapvals[j];
}
return curr;
}
// Making the row totals without to add in yDimension
if(o.rowTotals && o.yDimension.length > 0) {
var dn = o.yDimension[0].dataName;
o.yDimension.splice(0,0,{dataName:dn});
o.yDimension[0].converter = function(){ return '_r_Totals'; };
}
// build initial columns (colModel) from xDimension
xlen = $.isArray(o.xDimension) ? o.xDimension.length : 0;
ylen = o.yDimension.length;
aggrlen = $.isArray(o.aggregates) ? o.aggregates.length : 0;
if(xlen === 0 || aggrlen === 0) {
throw("xDimension or aggregates optiona are not set!");
}
var colc;
for(i = 0; i< xlen; i++) {
colc = {name:o.xDimension[i].dataName, frozen: o.frozenStaticCols};
if(o.xDimension[i].isGroupField == null) {
o.xDimension[i].isGroupField = true;
}
colc = $.extend(true, colc, o.xDimension[i]);
columns.push( colc );
}
var groupfields = xlen - 1, tree={}, _avg=[];
//tree = { text: 'root', leaf: false, children: [] };
//loop over alll the source data
while( r < rowlen ) {
row = data[r];
var xValue = [];
var yValue = [];
tmp = {};
i = 0;
// build the data from xDimension
do {
xValue[i] = $.trim(row[o.xDimension[i].dataName]);
tmp[o.xDimension[i].dataName] = xValue[i];
i++;
} while( i < xlen );
var k = 0;
rowindex = -1;
// check to see if the row is in our new pivotrow set
newObj = find(pivotrows, findGroup, xValue);
if(!newObj) {
// if the row is not in our set
k = 0;
// if yDimension is set
if(ylen>=1) {
// build the cols set in yDimension
for(k=0;k<ylen;k++) {
yValue[k] = $.trim(row[o.yDimension[k].dataName]);
// Check to see if we have user defined conditions
if(o.yDimension[k].converter && $.isFunction(o.yDimension[k].converter)) {
yValue[k] = o.yDimension[k].converter.call(this, yValue[k], xValue, yValue);
}
}
// make the colums based on aggregates definition
// and return the members for late calculation
tmp = agregateFunc( row, o.aggregates, yValue, tmp );
} else if( ylen === 0 ) {
// if not set use direct the aggregates
tmp = agregateFunc( row, o.aggregates, null, tmp );
}
// add the result in pivot rows
pivotrows.push( tmp );
} else {
// the pivot exists
if( rowindex >= 0) {
k = 0;
// make the recalculations
if(ylen>=1) {
for(k=0;k<ylen;k++) {
yValue[k] = $.trim(row[o.yDimension[k].dataName]);
if(o.yDimension[k].converter && $.isFunction(o.yDimension[k].converter)) {
yValue[k] = o.yDimension[k].converter.call(this, yValue[k], xValue, yValue);
}
}
newObj = agregateFunc( row, o.aggregates, yValue, newObj );
} else if( ylen === 0 ) {
newObj = agregateFunc( row, o.aggregates, null, newObj );
}
// update the row
pivotrows[rowindex] = newObj;
}
}
var kj=0, current = null,existing = null, kk;
// Build a JSON tree from the member (see aggregateFunc)
// to make later the columns
//
for (kk in member) {
if(member.hasOwnProperty( kk )) {
if(kj === 0) {
if (!tree.children||tree.children === undefined){
tree = { text: kk, level : 0, children: [], label: kk };
}
current = tree.children;
} else {
existing = null;
for (i=0; i < current.length; i++) {
if (current[i].text === kk) {
//current[i].fields=member[kk];
existing = current[i];
break;
}
}
if (existing) {
current = existing.children;
} else {
current.push({ children: [], text: kk, level: kj, fields: member[kk], label: labels[kk] });
current = current[current.length - 1].children;
}
}
kj++;
}
}
r++;
}
_avg = null; // free mem
var lastval=[], initColLen = columns.length, swaplen = initColLen;
if(ylen>0) {
headers[ylen-1] = { useColSpanStyle: false, groupHeaders: []};
}
/*
* Recursive function which uses the tree to build the
* columns from the pivot values and set the group Headers
*/
function list(items) {
var l, j, key, k, col;
for (key in items) { // iterate
if (items.hasOwnProperty(key)) {
// write amount of spaces according to level
// and write name and newline
if(typeof items[key] !== "object") {
// If not a object build the header of the appropriate level
if( key === 'level') {
if(lastval[items.level] === undefined) {
lastval[items.level] ='';
if(items.level>0 && items.text.indexOf('_r_Totals') === -1) {
headers[items.level-1] = {
useColSpanStyle: false,
groupHeaders: []
};
}
}
if(lastval[items.level] !== items.text && items.children.length && items.text.indexOf('_r_Totals') === -1 ) {
if(items.level>0) {
headers[items.level-1].groupHeaders.push({
titleText: items.label,
numberOfColumns : 0
});
var collen = headers[items.level-1].groupHeaders.length-1,
colpos = collen === 0 ? swaplen : initColLen;//+aggrlen;
if(items.level-1=== (o.rowTotals ? 1 : 0)) {
if(collen>0) {
var l1=0;
for(var kk=0; kk<collen; kk++) {
l1 += headers[items.level-1].groupHeaders[kk].numberOfColumns;
}
if(l1) {
colpos = l1 + xlen;
}
}
}
if(columns[colpos]) {
headers[items.level-1].groupHeaders[collen].startColumnName = columns[colpos].name;
headers[items.level-1].groupHeaders[collen].numberOfColumns = columns.length - colpos;
}
initColLen = columns.length;
}
}
lastval[items.level] = items.text;
}
// This is in case when the member contain more than one summary item
if(items.level === ylen && key==='level' && ylen >0) {
if( aggrlen > 1){
var ll=1;
for( l in items.fields) {
if(items.fields.hasOwnProperty(l)) {
if(ll===1) {
headers[ylen-1].groupHeaders.push({startColumnName: l, numberOfColumns: 1, titleText: items.label || items.text});
}
ll++;
}
}
headers[ylen-1].groupHeaders[headers[ylen-1].groupHeaders.length-1].numberOfColumns = ll-1;
} else {
headers.splice(ylen-1,1);
}
}
}
// if object, call recursively
if (items[key] != null && typeof items[key] === "object") {
list(items[key]);
}
// Finally build the columns
if( key === 'level') {
if( items.level > 0 && (items.level === (ylen===0?items.level:ylen) || lastval[items.level].indexOf('_r_Totals') !== -1 ) ){
j=0;
for(l in items.fields) {
if(items.fields.hasOwnProperty( l ) ) {
col = {};
for(k in o.aggregates[j]) {
if(o.aggregates[j].hasOwnProperty(k)) {
switch( k ) {
case 'member':
case 'label':
case 'aggregator':
break;
default:
col[k] = o.aggregates[j][k];
}
}
}
if(aggrlen > 1) {
col.name = l;
col.label = o.aggregates[j].label || items.label;
} else {
col.name = items.text;
col.label = items.text==='_r_Totals' ? o.rowTotalsText : items.label;
}
columns.push (col);
j++;
}
}
}
}
}
}
}
list( tree );
var nm;
// loop again trougth the pivot rows in order to build grand total
if(o.colTotals) {
var plen = pivotrows.length;
while(plen--) {
for(i=xlen;i<columns.length;i++) {
nm = columns[i].name;
if(!summaries[nm]) {
summaries[nm] = parseFloat(pivotrows[plen][nm] || 0);
} else {
summaries[nm] += parseFloat(pivotrows[plen][nm] || 0);
}
}
}
}
// based on xDimension levels build grouping
if( groupfields > 0) {
for(i=0;i<groupfields;i++) {
if(columns[i].isGroupField) {
groupOptions.groupingView.groupField.push(columns[i].name);
groupOptions.groupingView.groupSummary.push(o.groupSummary);
groupOptions.groupingView.groupSummaryPos.push(o.groupSummaryPos);
}
}
} else {
// no grouping is needed
groupOptions.grouping = false;
}
groupOptions.sortname = columns[groupfields].name;
groupOptions.groupingView.hideFirstGroupCol = true;
});
// return the final result.
return { "colModel" : columns, "rows": pivotrows, "groupOptions" : groupOptions, "groupHeaders" : headers, summary : summaries };
},
jqPivot : function( data, pivotOpt, gridOpt, ajaxOpt) {
return this.each(function(){
var $t = this,
regional = gridOpt.regional ? gridOpt.regional : "en";
if(pivotOpt.loadMsg === undefined) {
pivotOpt.loadMsg = true;
}
if(pivotOpt.loadMsg) {
$("<div class='loading_pivot ui-state-default ui-state-active row'>"+$.jgrid.getRegional($t, "regional."+regional+".defaults.loadtext")+"</div>").insertBefore($t).show();
}
function pivot( data) {
if( $.isFunction( pivotOpt.onInitPivot ) ) {
pivotOpt.onInitPivot.call( $t );
}
if(!$.isArray(data)) {
//throw "data provides is not an array";
data = [];
}
var pivotGrid = jQuery($t).jqGrid('pivotSetup',data, pivotOpt),
footerrow = $.assocArraySize(pivotGrid.summary) > 0 ? true : false,
query= $.jgrid.from.call($t, pivotGrid.rows), i, so, st, len;
if(pivotOpt.ignoreCase) {
query = query.ignoreCase();
}
for(i=0; i< pivotGrid.groupOptions.groupingView.groupField.length; i++) {
so = pivotOpt.xDimension[i].sortorder ? pivotOpt.xDimension[i].sortorder : 'asc';
st = pivotOpt.xDimension[i].sorttype ? pivotOpt.xDimension[i].sorttype : 'text';
query.orderBy(pivotGrid.groupOptions.groupingView.groupField[i], so, st, '', st);
}
len = pivotOpt.xDimension.length;
if(gridOpt.sortname) { // should be a part of xDimension
so = gridOpt.sortorder ? gridOpt.sortorder : 'asc';
st = 'text';
for( i=0; i< len; i++) {
if(pivotOpt.xDimension[i].dataName === gridOpt.sortname) {
st = pivotOpt.xDimension[i].sorttype ? pivotOpt.xDimension[i].sorttype : 'text';
break;
}
}
query.orderBy(gridOpt.sortname, so, st, '', st);
} else {
if(pivotGrid.groupOptions.sortname && len) {
so = pivotOpt.xDimension[len-1].sortorder ? pivotOpt.xDimension[len-1].sortorder : 'asc';
st = pivotOpt.xDimension[len-1].sorttype ? pivotOpt.xDimension[len-1].sorttype : 'text';
query.orderBy(pivotGrid.groupOptions.sortname, so, st, '', st);
}
}
jQuery($t).jqGrid($.extend(true, {
datastr: $.extend(query.select(),footerrow ? {userdata:pivotGrid.summary} : {}),
datatype: "jsonstring",
footerrow : footerrow,
userDataOnFooter: footerrow,
colModel: pivotGrid.colModel,
viewrecords: true,
formatFooterData : pivotOpt.colTotals === true ? true : false,
sortname: pivotOpt.xDimension[0].dataName // ?????
}, pivotGrid.groupOptions, gridOpt || {}));
var gHead = pivotGrid.groupHeaders;
if(gHead.length) {
for( i = 0;i < gHead.length ; i++) {
if(gHead[i] && gHead[i].groupHeaders.length) {
jQuery($t).jqGrid('setGroupHeaders',gHead[i]);
}
}
}
if(pivotOpt.frozenStaticCols) {
jQuery($t).jqGrid("setFrozenColumns");
}
if( $.isFunction( pivotOpt.onCompletePivot ) ) {
pivotOpt.onCompletePivot.call( $t );
}
if(pivotOpt.loadMsg) {
$(".loading_pivot").remove();
}
}
if(typeof data === "string") {
$.ajax($.extend({
url : data,
dataType: 'json',
success : function(response) {
pivot($.jgrid.getAccessor(response, ajaxOpt && ajaxOpt.reader ? ajaxOpt.reader: 'rows') );
}
}, ajaxOpt || {}) );
} else {
pivot( data );
}
});
}
});
//module begin
$.jgrid.extend({
setSubGrid : function () {
return this.each(function (){
var $t = this, cm, i,
classes = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].subgrid,
suboptions = {
plusicon : classes.icon_plus,
minusicon : classes.icon_minus,
openicon: classes.icon_open,
expandOnLoad: false,
selectOnExpand : false,
selectOnCollapse : false,
reloadOnExpand : true
};
$t.p.subGridOptions = $.extend(suboptions, $t.p.subGridOptions || {});
$t.p.colNames.unshift("");
$t.p.colModel.unshift({name:'subgrid',width: $.jgrid.cell_width ? $t.p.subGridWidth+$t.p.cellLayout : $t.p.subGridWidth,sortable: false,resizable:false,hidedlg:true,search:false,fixed:true});
cm = $t.p.subGridModel;
if(cm[0]) {
cm[0].align = $.extend([],cm[0].align || []);
for(i=0;i<cm[0].name.length;i++) { cm[0].align[i] = cm[0].align[i] || 'left';}
}
});
},
addSubGridCell :function (pos,iRow) {
var prp='', ic, sid, icb ;
this.each(function(){
prp = this.formatCol(pos,iRow);
sid= this.p.id;
ic = this.p.subGridOptions.plusicon;
icb = $.jgrid.styleUI[(this.p.styleUI || 'jQueryUI')].common;
});
return "<td role=\"gridcell\" aria-describedby=\""+sid+"_subgrid\" class=\"ui-sgcollapsed sgcollapsed\" "+prp+"><a style='cursor:pointer;' class='ui-sghref'><span class='" + icb.icon_base +" "+ic+"'></span></a></td>";
},
addSubGrid : function( pos, sind ) {
return this.each(function(){
var ts = this;
if (!ts.grid ) { return; }
var base = $.jgrid.styleUI[(ts.p.styleUI || 'jQueryUI')].base,
common = $.jgrid.styleUI[(ts.p.styleUI || 'jQueryUI')].common;
//-------------------------
var subGridCell = function(trdiv,cell,pos)
{
var tddiv = $("<td align='"+ts.p.subGridModel[0].align[pos]+"'></td>").html(cell);
$(trdiv).append(tddiv);
};
var subGridXml = function(sjxml, sbid){
var tddiv, i, sgmap,
dummy = $("<table class='" + base.rowTable + " ui-common-table'><tbody></tbody></table>"),
trdiv = $("<tr></tr>");
for (i = 0; i<ts.p.subGridModel[0].name.length; i++) {
tddiv = $("<th class='" + base.headerBox+" ui-th-subgrid ui-th-column ui-th-"+ts.p.direction+"'></th>");
$(tddiv).html(ts.p.subGridModel[0].name[i]);
$(tddiv).width( ts.p.subGridModel[0].width[i]);
$(trdiv).append(tddiv);
}
$(dummy).append(trdiv);
if (sjxml){
sgmap = ts.p.xmlReader.subgrid;
$(sgmap.root+" "+sgmap.row, sjxml).each( function(){
trdiv = $("<tr class='" + common.content+" ui-subtblcell'></tr>");
if(sgmap.repeatitems === true) {
$(sgmap.cell,this).each( function(i) {
subGridCell(trdiv, $(this).text() || ' ',i);
});
} else {
var f = ts.p.subGridModel[0].mapping || ts.p.subGridModel[0].name;
if (f) {
for (i=0;i<f.length;i++) {
subGridCell(trdiv, $.jgrid.getXmlData(this, f[i]) || ' ',i);
}
}
}
$(dummy).append(trdiv);
});
}
var pID = $("table:first",ts.grid.bDiv).attr("id")+"_";
$("#"+$.jgrid.jqID(pID+sbid)).append(dummy);
ts.grid.hDiv.loading = false;
$("#load_"+$.jgrid.jqID(ts.p.id)).hide();
return false;
};
var subGridJson = function(sjxml, sbid){
var tddiv,result,i,cur, sgmap,j,
dummy = $("<table class='" + base.rowTable + " ui-common-table'><tbody></tbody></table>"),
trdiv = $("<tr></tr>");
for (i = 0; i<ts.p.subGridModel[0].name.length; i++) {
tddiv = $("<th class='" + base.headerBox + " ui-th-subgrid ui-th-column ui-th-"+ts.p.direction+"'></th>");
$(tddiv).html(ts.p.subGridModel[0].name[i]);
$(tddiv).width( ts.p.subGridModel[0].width[i]);
$(trdiv).append(tddiv);
}
$(dummy).append(trdiv);
if (sjxml){
sgmap = ts.p.jsonReader.subgrid;
result = $.jgrid.getAccessor(sjxml, sgmap.root);
if ( result !== undefined ) {
for (i=0;i<result.length;i++) {
cur = result[i];
trdiv = $("<tr class='" + common.content+" ui-subtblcell'></tr>");
if(sgmap.repeatitems === true) {
if(sgmap.cell) { cur=cur[sgmap.cell]; }
for (j=0;j<cur.length;j++) {
subGridCell(trdiv, cur[j] || ' ',j);
}
} else {
var f = ts.p.subGridModel[0].mapping || ts.p.subGridModel[0].name;
if(f.length) {
for (j=0;j<f.length;j++) {
subGridCell(trdiv, $.jgrid.getAccessor(cur, f[j] ) || ' ',j);
}
}
}
$(dummy).append(trdiv);
}
}
}
var pID = $("table:first",ts.grid.bDiv).attr("id")+"_";
$("#"+$.jgrid.jqID(pID+sbid)).append(dummy);
ts.grid.hDiv.loading = false;
$("#load_"+$.jgrid.jqID(ts.p.id)).hide();
return false;
};
var populatesubgrid = function( rd )
{
var sid,dp, i, j;
sid = $(rd).attr("id");
dp = {nd_: (new Date().getTime())};
dp[ts.p.prmNames.subgridid]=sid;
if(!ts.p.subGridModel[0]) { return false; }
if(ts.p.subGridModel[0].params) {
for(j=0; j < ts.p.subGridModel[0].params.length; j++) {
for(i=0; i<ts.p.colModel.length; i++) {
if(ts.p.colModel[i].name === ts.p.subGridModel[0].params[j]) {
dp[ts.p.colModel[i].name]= $("td:eq("+i+")",rd).text().replace(/\ \;/ig,'');
}
}
}
}
if(!ts.grid.hDiv.loading) {
ts.grid.hDiv.loading = true;
$("#load_"+$.jgrid.jqID(ts.p.id)).show();
if(!ts.p.subgridtype) { ts.p.subgridtype = ts.p.datatype; }
if($.isFunction(ts.p.subgridtype)) {
ts.p.subgridtype.call(ts, dp);
} else {
ts.p.subgridtype = ts.p.subgridtype.toLowerCase();
}
switch(ts.p.subgridtype) {
case "xml":
case "json":
$.ajax($.extend({
type:ts.p.mtype,
url: $.isFunction(ts.p.subGridUrl) ? ts.p.subGridUrl.call(ts, dp) : ts.p.subGridUrl,
dataType:ts.p.subgridtype,
data: $.isFunction(ts.p.serializeSubGridData)? ts.p.serializeSubGridData.call(ts, dp) : dp,
complete: function(sxml) {
if(ts.p.subgridtype === "xml") {
subGridXml(sxml.responseXML, sid);
} else {
subGridJson($.jgrid.parse(sxml.responseText), sid);
}
sxml=null;
}
}, $.jgrid.ajaxOptions, ts.p.ajaxSubgridOptions || {}));
break;
}
}
return false;
};
var _id, pID,atd, nhc=0, bfsc, $r;
$.each(ts.p.colModel,function(){
if(this.hidden === true || this.name === 'rn' || this.name === 'cb') {
nhc++;
}
});
var len = ts.rows.length, i=1,hsret, ishsg = $.isFunction(ts.p.isHasSubGrid);
if( sind !== undefined && sind > 0) {
i = sind;
len = sind+1;
}
while(i < len) {
if($(ts.rows[i]).hasClass('jqgrow')) {
if(ts.p.scroll) {
$(ts.rows[i].cells[pos]).off('click');
}
hsret = null;
if(ishsg) {
hsret = ts.p.isHasSubGrid.call(ts, ts.rows[i].id);
}
if(hsret === false) {
ts.rows[i].cells[pos].innerHTML = "";
} else {
$(ts.rows[i].cells[pos]).on('click', function() {
var tr = $(this).parent("tr")[0];
pID = ts.p.id;
_id = tr.id;
$r = $("#" + pID + "_" + _id + "_expandedContent");
if($(this).hasClass("sgcollapsed")) {
bfsc = $(ts).triggerHandler("jqGridSubGridBeforeExpand", [pID + "_" + _id, _id]);
bfsc = (bfsc === false || bfsc === 'stop') ? false : true;
if(bfsc && $.isFunction(ts.p.subGridBeforeExpand)) {
bfsc = ts.p.subGridBeforeExpand.call(ts, pID+"_"+_id,_id);
}
if(bfsc === false) {return false;}
if(ts.p.subGridOptions.reloadOnExpand === true || ( ts.p.subGridOptions.reloadOnExpand === false && !$r.hasClass('ui-subgrid') ) ) {
atd = pos >=1 ? "<td colspan='"+pos+"'> </td>":"";
$(tr).after( "<tr role='row' id='" + pID + "_" + _id + "_expandedContent" + "' class='ui-subgrid ui-sg-expanded'>"+atd+"<td class='" + common.content +" subgrid-cell'><span class='" + common.icon_base +" "+ts.p.subGridOptions.openicon+"'></span></td><td colspan='"+parseInt(ts.p.colNames.length-1-nhc,10)+"' class='" + common.content +" subgrid-data'><div id="+pID+"_"+_id+" class='tablediv'></div></td></tr>" );
$(ts).triggerHandler("jqGridSubGridRowExpanded", [pID + "_" + _id, _id]);
if( $.isFunction(ts.p.subGridRowExpanded)) {
ts.p.subGridRowExpanded.call(ts, pID+"_"+ _id,_id);
} else {
populatesubgrid(tr);
}
} else {
$r.show().removeClass("ui-sg-collapsed").addClass("ui-sg-expanded");
}
$(this).html("<a style='cursor:pointer;' class='ui-sghref'><span class='" + common.icon_base +" "+ts.p.subGridOptions.minusicon+"'></span></a>").removeClass("sgcollapsed").addClass("sgexpanded");
if(ts.p.subGridOptions.selectOnExpand) {
$(ts).jqGrid('setSelection',_id);
}
} else if($(this).hasClass("sgexpanded")) {
bfsc = $(ts).triggerHandler("jqGridSubGridRowColapsed", [pID + "_" + _id, _id]);
bfsc = (bfsc === false || bfsc === 'stop') ? false : true;
if( bfsc && $.isFunction(ts.p.subGridRowColapsed)) {
bfsc = ts.p.subGridRowColapsed.call(ts, pID+"_"+_id,_id );
}
if(bfsc===false) {return false;}
if(ts.p.subGridOptions.reloadOnExpand === true) {
$r.remove(".ui-subgrid");
} else if($r.hasClass('ui-subgrid')) { // incase of dynamic deleting
$r.hide().addClass("ui-sg-collapsed").removeClass("ui-sg-expanded");
}
$(this).html("<a style='cursor:pointer;' class='ui-sghref'><span class='"+common.icon_base +" "+ts.p.subGridOptions.plusicon+"'></span></a>").removeClass("sgexpanded").addClass("sgcollapsed");
if(ts.p.subGridOptions.selectOnCollapse) {
$(ts).jqGrid('setSelection',_id);
}
}
return false;
});
}
}
i++;
}
if(ts.p.subGridOptions.expandOnLoad === true) {
var offset = 0;
if(ts.p.multiselect) { offset++;}
if(ts.p.rownumbers) { offset++;}
$(ts.rows).filter('.jqgrow').each(function(index,row){
$(row.cells[offset]).click();
});
}
ts.subGridXml = function(xml,sid) {subGridXml(xml,sid);};
ts.subGridJson = function(json,sid) {subGridJson(json,sid);};
});
},
expandSubGridRow : function(rowid) {
return this.each(function () {
var $t = this;
if(!$t.grid && !rowid) {return;}
if($t.p.subGrid===true) {
var rc = $(this).jqGrid("getInd",rowid,true);
if(rc) {
var sgc = $("td.sgcollapsed",rc)[0];
if(sgc) {
$(sgc).trigger("click");
}
}
}
});
},
collapseSubGridRow : function(rowid) {
return this.each(function () {
var $t = this;
if(!$t.grid && !rowid) {return;}
if($t.p.subGrid===true) {
var rc = $(this).jqGrid("getInd",rowid,true);
if(rc) {
var sgc = $("td.sgexpanded",rc)[0];
if(sgc) {
$(sgc).trigger("click");
}
}
}
});
},
toggleSubGridRow : function(rowid) {
return this.each(function () {
var $t = this;
if(!$t.grid && !rowid) {return;}
if($t.p.subGrid===true) {
var rc = $(this).jqGrid("getInd",rowid,true);
if(rc) {
var sgc = $("td.sgcollapsed",rc)[0];
if(sgc) {
$(sgc).trigger("click");
} else {
sgc = $("td.sgexpanded",rc)[0];
if(sgc) {
$(sgc).trigger("click");
}
}
}
}
});
}
});
//module begin
$.jgrid.extend({
setTreeNode : function(i, len){
return this.each(function(){
var $t = this;
if( !$t.grid || !$t.p.treeGrid ) {return;}
var expCol = $t.p.expColInd,
expanded = $t.p.treeReader.expanded_field,
isLeaf = $t.p.treeReader.leaf_field,
level = $t.p.treeReader.level_field,
icon = $t.p.treeReader.icon_field,
loaded = $t.p.treeReader.loaded, lft, rgt, curLevel, ident,lftpos, twrap,
ldat, lf,
common = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].common,
index = i;
$($t).triggerHandler("jqGridBeforeSetTreeNode", [index, len]);
if($.isFunction($t.p.beforeSetTreeNode)) {
$t.p.beforeSetTreeNode.call($t, index, len);
}
while(i<len) {
var ind = $.jgrid.stripPref($t.p.idPrefix, $t.rows[i].id), dind = $t.p._index[ind], expan;
ldat = $t.p.data[dind];
//$t.rows[i].level = ldat[level];
if($t.p.treeGridModel === 'nested') {
if(!ldat[isLeaf]) {
lft = parseInt(ldat[$t.p.treeReader.left_field],10);
rgt = parseInt(ldat[$t.p.treeReader.right_field],10);
// NS Model
ldat[isLeaf] = (rgt === lft+1) ? 'true' : 'false';
$t.rows[i].cells[$t.p._treeleafpos].innerHTML = ldat[isLeaf];
}
}
//else {
//row.parent_id = rd[$t.p.treeReader.parent_id_field];
//}
curLevel = parseInt(ldat[level],10);
if($t.p.tree_root_level === 0) {
ident = curLevel+1;
lftpos = curLevel;
} else {
ident = curLevel;
lftpos = curLevel -1;
}
twrap = "<div class='tree-wrap tree-wrap-"+$t.p.direction+"' style='width:"+(ident*18)+"px;'>";
twrap += "<div style='"+($t.p.direction==="rtl" ? "right:" : "left:")+(lftpos*18)+"px;' class='"+common.icon_base+" ";
if(ldat[loaded] !== undefined) {
if(ldat[loaded]==="true" || ldat[loaded]===true) {
ldat[loaded] = true;
} else {
ldat[loaded] = false;
}
}
if(ldat[isLeaf] === "true" || ldat[isLeaf] === true) {
twrap += ((ldat[icon] !== undefined && ldat[icon] !== "") ? ldat[icon] : $t.p.treeIcons.leaf)+" tree-leaf treeclick";
ldat[isLeaf] = true;
lf="leaf";
} else {
ldat[isLeaf] = false;
lf="";
}
ldat[expanded] = ((ldat[expanded] === "true" || ldat[expanded] === true) ? true : false) && (ldat[loaded] || ldat[loaded] === undefined);
if(ldat[expanded] === false) {
twrap += ((ldat[isLeaf] === true) ? "'" : $t.p.treeIcons.plus+" tree-plus treeclick'");
} else {
twrap += ((ldat[isLeaf] === true) ? "'" : $t.p.treeIcons.minus+" tree-minus treeclick'");
}
twrap += "></div></div>";
$($t.rows[i].cells[expCol]).wrapInner("<span class='cell-wrapper"+lf+"'></span>").prepend(twrap);
if(curLevel !== parseInt($t.p.tree_root_level,10)) {
//var pn = $($t).jqGrid('getNodeParent',ldat);
//expan = pn && pn.hasOwnProperty(expanded) ? pn[expanded] : true;
expan = $($t).jqGrid('isVisibleNode',ldat); // overhead
if( !expan ){
$($t.rows[i]).css("display","none");
}
}
$($t.rows[i].cells[expCol])
.find("div.treeclick")
.on("click",function(e){
var target = e.target || e.srcElement,
ind2 =$.jgrid.stripPref($t.p.idPrefix,$(target,$t.rows).closest("tr.jqgrow")[0].id),
pos = $t.p._index[ind2];
if(!$t.p.data[pos][isLeaf]){
if($t.p.data[pos][expanded]){
$($t).jqGrid("collapseRow",$t.p.data[pos]);
$($t).jqGrid("collapseNode",$t.p.data[pos]);
} else {
$($t).jqGrid("expandRow",$t.p.data[pos]);
$($t).jqGrid("expandNode",$t.p.data[pos]);
}
}
return false;
});
if($t.p.ExpandColClick === true) {
$($t.rows[i].cells[expCol])
.find("span.cell-wrapper")
.css("cursor","pointer")
.on("click",function(e) {
var target = e.target || e.srcElement,
ind2 =$.jgrid.stripPref($t.p.idPrefix,$(target,$t.rows).closest("tr.jqgrow")[0].id),
pos = $t.p._index[ind2];
if(!$t.p.data[pos][isLeaf]){
if($t.p.data[pos][expanded]){
$($t).jqGrid("collapseRow",$t.p.data[pos]);
$($t).jqGrid("collapseNode",$t.p.data[pos]);
} else {
$($t).jqGrid("expandRow",$t.p.data[pos]);
$($t).jqGrid("expandNode",$t.p.data[pos]);
}
}
$($t).jqGrid("setSelection",ind2);
return false;
});
}
i++;
}
$($t).triggerHandler("jqGridAfterSetTreeNode", [index, len]);
if($.isFunction($t.p.afterSetTreeNode)) {
$t.p.afterSetTreeNode.call($t, index, len);
}
});
},
setTreeGrid : function() {
return this.each(function (){
var $t = this, i=0, pico, ecol = false, nm, key, tkey, dupcols=[],
classes = $.jgrid.styleUI[($t.p.styleUI || 'jQueryUI')].treegrid;
if(!$t.p.treeGrid) {return;}
if(!$t.p.treedatatype ) {$.extend($t.p,{treedatatype: $t.p.datatype});}
if($t.p.loadonce) { $t.p.treedatatype = 'local'; }
$t.p.subGrid = false;$t.p.altRows =false;
//bvn
if (!$t.p.treeGrid_bigData) {
$t.p.pgbuttons = false;
$t.p.pginput = false;
$t.p.rowList = [];
}
$t.p.gridview = true;
//bvn
if($t.p.rowTotal === null && !$t.p.treeGrid_bigData ) { $t.p.rowNum = 10000; }
$t.p.multiselect = false;
// $t.p.rowList = [];
$t.p.expColInd = 0;
pico = classes.icon_plus;
if($t.p.styleUI === 'jQueryUI') {
pico += ($t.p.direction==="rtl" ? 'w' : 'e');
}
$t.p.treeIcons = $.extend({plus:pico, minus: classes.icon_minus, leaf: classes.icon_leaf},$t.p.treeIcons || {});
if($t.p.treeGridModel === 'nested') {
$t.p.treeReader = $.extend({
level_field: "level",
left_field:"lft",
right_field: "rgt",
leaf_field: "isLeaf",
expanded_field: "expanded",
loaded: "loaded",
icon_field: "icon"
},$t.p.treeReader);
} else if($t.p.treeGridModel === 'adjacency') {
$t.p.treeReader = $.extend({
level_field: "level",
parent_id_field: "parent",
leaf_field: "isLeaf",
expanded_field: "expanded",
loaded: "loaded",
icon_field: "icon"
},$t.p.treeReader );
}
for ( key in $t.p.colModel){
if($t.p.colModel.hasOwnProperty(key)) {
nm = $t.p.colModel[key].name;
if( nm === $t.p.ExpandColumn && !ecol ) {
ecol = true;
$t.p.expColInd = i;
}
i++;
//
if( nm === $t.p.treeReader.level_field || nm === $t.p.treeReader.left_field || nm === $t.p.treeReader.right_field) {
$t.p.colModel[key].sorttype = "integer";
}
for(tkey in $t.p.treeReader) {
if($t.p.treeReader.hasOwnProperty(tkey) && $t.p.treeReader[tkey] === nm) {
dupcols.push(nm);
}
}
}
}
$.each($t.p.treeReader,function(j,n){
if(n && $.inArray(n, dupcols) === -1){
if(j==='leaf_field') { $t.p._treeleafpos= i; }
i++;
$t.p.colNames.push(n);
$t.p.colModel.push({name:n,width:1,hidden:true,sortable:false,resizable:false,hidedlg:true,editable:true,search:false});
}
});
});
},
expandRow: function (record){
this.each(function(){
var $t = this;
//bvn
if (!$t.p.treeGrid_bigData) {
var $rootpages = $t.p.lastpage;
}
if(!$t.grid || !$t.p.treeGrid) {return;}
var childern = $($t).jqGrid("getNodeChildren",record),
//if ($($t).jqGrid("isVisibleNode",record)) {
expanded = $t.p.treeReader.expanded_field,
rowid = record[$t.p.localReader.id],
ret = $($t).triggerHandler("jqGridBeforeExpandTreeGridRow", [rowid, record, childern]);
if(ret === undefined ) {
ret = true;
}
if(ret && $.isFunction($t.p.beforeExpandTreeGridRow)) {
ret = $t.p.beforeExpandTreeGridRow.call($t, rowid, record, childern);
}
if( ret === false ) { return; }
$(childern).each(function(){
var id = $t.p.idPrefix + $.jgrid.getAccessor(this,$t.p.localReader.id);
$($($t).jqGrid('getGridRowById', id)).css("display","");
if(this[expanded]) {
$($t).jqGrid("expandRow",this);
}
});
$($t).triggerHandler("jqGridAfterExpandTreeGridRow", [rowid, record, childern]);
if($.isFunction($t.p.afterExpandTreeGridRow)) {
$t.p.afterExpandTreeGridRow.call($t, rowid, record, childern);
}
//bvn
if (!$t.p.treeGrid_bigData) {
$t.p.lastpage = $rootpages;
}
//}
});
},
collapseRow : function (record) {
this.each(function(){
var $t = this;
if(!$t.grid || !$t.p.treeGrid) {return;}
var childern = $($t).jqGrid("getNodeChildren",record),
expanded = $t.p.treeReader.expanded_field,
rowid = record[$t.p.localReader.id],
ret = $($t).triggerHandler("jqGridBeforeCollapseTreeGridRow", [rowid, record, childern]);
if(ret === undefined ) {
ret = true;
}
if(ret && $.isFunction($t.p.beforeCollapseTreeGridRow)) {
ret = $t.p.beforeCollapseTreeGridRow.call($t, rowid, record, childern);
}
if( ret === false ) { return; }
$(childern).each(function(){
var id = $t.p.idPrefix + $.jgrid.getAccessor(this,$t.p.localReader.id);
$($($t).jqGrid('getGridRowById', id)).css("display","none");
if(this[expanded]){
$($t).jqGrid("collapseRow",this);
}
});
$($t).triggerHandler("jqGridAfterCollapseTreeGridRow", [rowid, record, childern]);
if($.isFunction($t.p.afterCollapseTreeGridRow)) {
$t.p.afterCollapseTreeGridRow.call($t, rowid, record, childern);
}
});
},
// NS ,adjacency models
getRootNodes : function() {
var result = [];
this.each(function(){
var $t = this, level, parent_id, view = $t.p.data;
if(!$t.grid || !$t.p.treeGrid) {return;}
switch ($t.p.treeGridModel) {
case 'nested' :
level = $t.p.treeReader.level_field;
$(view).each(function() {
if(parseInt(this[level],10) === parseInt($t.p.tree_root_level,10)) {
result.push(this);
}
});
break;
case 'adjacency' :
parent_id = $t.p.treeReader.parent_id_field;
$(view).each(function(){
if(this[parent_id] === null || String(this[parent_id]).toLowerCase() === "null") {
result.push(this);
}
});
break;
}
});
return result;
},
getNodeDepth : function(rc) {
var ret = null;
this.each(function(){
if(!this.grid || !this.p.treeGrid) {return;}
var $t = this;
switch ($t.p.treeGridModel) {
case 'nested' :
var level = $t.p.treeReader.level_field;
ret = parseInt(rc[level],10) - parseInt($t.p.tree_root_level,10);
break;
case 'adjacency' :
ret = $($t).jqGrid("getNodeAncestors",rc).length;
break;
}
});
return ret;
},
getNodeParent : function(rc) {
var result = null;
this.each(function(){
var $t = this;
if(!$t.grid || !$t.p.treeGrid) {return;}
switch ($t.p.treeGridModel) {
case 'nested' :
var lftc = $t.p.treeReader.left_field,
rgtc = $t.p.treeReader.right_field,
levelc = $t.p.treeReader.level_field,
lft = parseInt(rc[lftc],10), rgt = parseInt(rc[rgtc],10), level = parseInt(rc[levelc],10);
$(this.p.data).each(function(){
if(parseInt(this[levelc],10) === level-1 && parseInt(this[lftc],10) < lft && parseInt(this[rgtc],10) > rgt) {
result = this;
return false;
}
});
break;
case 'adjacency' :
var parent_id = $t.p.treeReader.parent_id_field,
dtid = $t.p.localReader.id,
ind = rc[dtid], pos = $t.p._index[ind];
while(pos--) {
if( String( $t.p.data[pos][dtid]) === String( $.jgrid.stripPref($t.p.idPrefix, rc[parent_id]) ) ) {
result = $t.p.data[pos];
break;
}
}
break;
}
});
return result;
},
getNodeChildren : function(rc ) {
var result = [];
this.each(function(){
var $t = this;
if(!$t.grid || !$t.p.treeGrid) {return;}
var i, len = this.p.data.length, row;
switch ($t.p.treeGridModel) {
case 'nested' :
var lftc = $t.p.treeReader.left_field,
rgtc = $t.p.treeReader.right_field,
levelc = $t.p.treeReader.level_field,
lft = parseInt(rc[lftc],10), rgt = parseInt(rc[rgtc],10), level = parseInt(rc[levelc],10);
for(i=0; i < len; i++) {
row = $t.p.data[i];
if(row && parseInt(row[levelc],10) === level+1 && parseInt(row[lftc],10) > lft && parseInt(row[rgtc],10) < rgt) {
result.push(row);
}
}
break;
case 'adjacency' :
var parent_id = $t.p.treeReader.parent_id_field,
dtid = $t.p.localReader.id;
for(i=0; i < len; i++) {
row = $t.p.data[i];
if(row && String(row[parent_id]) === String( $.jgrid.stripPref($t.p.idPrefix, rc[dtid]) ) ) {
result.push(row);
}
}
break;
}
});
return result;
},
getFullTreeNode : function(rc, expand) {
var result = [];
this.each(function(){
var $t = this, len,expanded = $t.p.treeReader.expanded_field;
if(!$t.grid || !$t.p.treeGrid) {return;}
if(expand == null || typeof expand !== 'boolean') {
expand = false;
}
switch ($t.p.treeGridModel) {
case 'nested' :
var lftc = $t.p.treeReader.left_field,
rgtc = $t.p.treeReader.right_field,
levelc = $t.p.treeReader.level_field,
lft = parseInt(rc[lftc],10), rgt = parseInt(rc[rgtc],10), level = parseInt(rc[levelc],10);
$(this.p.data).each(function(){
if(parseInt(this[levelc],10) >= level && parseInt(this[lftc],10) >= lft && parseInt(this[lftc],10) <= rgt) {
if(expand) { this[expanded] = true; }
result.push(this);
}
});
break;
case 'adjacency' :
if(rc) {
result.push(rc);
var parent_id = $t.p.treeReader.parent_id_field,
dtid = $t.p.localReader.id;
$(this.p.data).each(function(i){
len = result.length;
for (i = 0; i < len; i++) {
if ( String( $.jgrid.stripPref($t.p.idPrefix, result[i][dtid]) ) === String( this[parent_id] ) ) {
if(expand) { this[expanded] = true; }
result.push(this);
break;
}
}
});
}
break;
}
});
return result;
},
// End NS, adjacency Model
getNodeAncestors : function(rc, reverse, expanded) {
var ancestors = [];
if(reverse === undefined ) {
reverse = false;
}
this.each(function(){
if(!this.grid || !this.p.treeGrid) {return;}
if(expanded === undefined ) {
expanded = false;
} else {
expanded = this.p.treeReader.expanded_field;
}
var parent = $(this).jqGrid("getNodeParent",rc);
while (parent) {
if(expanded) {
try{
parent[expanded] = true;
} catch (etn) {}
}
if(reverse) {
ancestors.unshift(parent);
} else {
ancestors.push(parent);
}
parent = $(this).jqGrid("getNodeParent",parent);
}
});
return ancestors;
},
isVisibleNode : function(rc) {
var result = true;
this.each(function(){
var $t = this;
if(!$t.grid || !$t.p.treeGrid) {return;}
var ancestors = $($t).jqGrid("getNodeAncestors",rc),
expanded = $t.p.treeReader.expanded_field;
$(ancestors).each(function(){
result = result && this[expanded];
if(!result) {return false;}
});
});
return result;
},
isNodeLoaded : function(rc) {
var result;
this.each(function(){
var $t = this;
if(!$t.grid || !$t.p.treeGrid) {return;}
var isLeaf = $t.p.treeReader.leaf_field,
loaded = $t.p.treeReader.loaded;
if(rc !== undefined ) {
if(rc[loaded] !== undefined) {
result = rc[loaded];
} else if( rc[isLeaf] || $($t).jqGrid("getNodeChildren",rc).length > 0){
result = true;
} else {
result = false;
}
} else {
result = false;
}
});
return result;
},
setLeaf : function (rc, state, collapsed) {
return this.each(function(){
var id = $.jgrid.getAccessor(rc,this.p.localReader.id),
rc1 = $("#"+id,this.grid.bDiv)[0],
isLeaf = this.p.treeReader.leaf_field;
try {
var dr = this.p._index[id];
if(dr != null) {
this.p.data[dr][isLeaf] = state;
}
} catch(E){}
if(state === true) {
// set it in data
$("div.treeclick",rc1).removeClass(this.p.treeIcons.minus+" tree-minus "+this.p.treeIcons.plus+" tree-plus").addClass(this.p.treeIcons.leaf +" tree-leaf");
} else if(state === false) {
var ico = this.p.treeIcons.minus+" tree-minus";
if(collapsed) {
ico = this.p.treeIcons.plus+" tree-plus";
}
$("div.treeclick",rc1).removeClass(this.p.treeIcons.leaf +" tree-leaf").addClass( ico );
}
});
},
reloadNode: function(rc, reloadcurrent) {
return this.each(function(){
if(!this.grid || !this.p.treeGrid) {return;}
var rid = this.p.localReader.id,
currselection = this.p.selrow;
$(this).jqGrid("delChildren", rc[rid]);
if(reloadcurrent=== undefined) {
reloadcurrent = false;
}
if(!reloadcurrent) {
if(!jQuery._data( this, "events" ).jqGridAfterSetTreeNode) {
$(this).on("jqGridAfterSetTreeNode.reloadNode", function(){
var isLeaf = this.p.treeReader.leaf_field;
if(this.p.reloadnode ) {
var rc = this.p.reloadnode,
chld = $(this).jqGrid('getNodeChildren', rc);
if(rc[isLeaf] && chld.length) {
$(this).jqGrid('setLeaf', rc, false);
} else if(!rc[isLeaf] && chld.length === 0) {
$(this).jqGrid('setLeaf', rc, true);
}
}
this.p.reloadnode = false;
});
}
}
var expanded = this.p.treeReader.expanded_field,
parent = this.p.treeReader.parent_id_field,
loaded = this.p.treeReader.loaded,
level = this.p.treeReader.level_field,
isLeaf = this.p.treeReader.leaf_field,
lft = this.p.treeReader.left_field,
rgt = this.p.treeReader.right_field;
var id = $.jgrid.getAccessor(rc,this.p.localReader.id),
rc1 = $("#"+id,this.grid.bDiv)[0];
rc[expanded] = true;
if(!rc[isLeaf]) {
$("div.treeclick",rc1).removeClass(this.p.treeIcons.plus+" tree-plus").addClass(this.p.treeIcons.minus+" tree-minus");
}
this.p.treeANode = rc1.rowIndex;
this.p.datatype = this.p.treedatatype;
this.p.reloadnode = rc;
if(reloadcurrent) {
this.p.treeANode = rc1.rowIndex > 0 ? rc1.rowIndex - 1 : 1;
$(this).jqGrid('delRowData', id);
}
if(this.p.treeGridModel === 'nested') {
$(this).jqGrid("setGridParam",{postData:{nodeid:id,n_left:rc[lft],n_right:rc[rgt],n_level:rc[level]}});
} else {
$(this).jqGrid("setGridParam",{postData:{nodeid:id,parentid:rc[parent],n_level:rc[level]}} );
}
$(this).trigger("reloadGrid");
rc[loaded] = true;
if(this.p.treeGridModel === 'nested') {
$(this).jqGrid("setGridParam",{selrow: currselection, postData:{nodeid:'',n_left:'',n_right:'',n_level:''}});
} else {
$(this).jqGrid("setGridParam",{selrow: currselection, postData:{nodeid:'',parentid:'',n_level:''}});
}
});
},
expandNode : function(rc) {
return this.each(function(){
if(!this.grid || !this.p.treeGrid) {return;}
var $t = this,
expanded = this.p.treeReader.expanded_field,
parent = this.p.treeReader.parent_id_field,
loaded = this.p.treeReader.loaded,
level = this.p.treeReader.level_field,
lft = this.p.treeReader.left_field,
rgt = this.p.treeReader.right_field;
if(!rc[expanded]) {
var id = $.jgrid.getAccessor(rc,this.p.localReader.id),
rc1 = $("#" + this.p.idPrefix + $.jgrid.jqID(id),this.grid.bDiv)[0],
position = this.p._index[id],
ret = $($t).triggerHandler("jqGridBeforeExpandTreeGridNode", [id, rc]);
if(ret === undefined ) {
ret = true;
}
if( ret && $.isFunction(this.p.beforeExpandTreeGridNode) ) {
ret = this.p.beforeExpandTreeGridNode.call(this, id, rc );
}
if( ret === false ) { return; }
if( $(this).jqGrid("isNodeLoaded",this.p.data[position]) ) {
rc[expanded] = true;
$("div.treeclick",rc1).removeClass(this.p.treeIcons.plus+" tree-plus").addClass(this.p.treeIcons.minus+" tree-minus");
} else if (!this.grid.hDiv.loading) {
rc[expanded] = true;
$("div.treeclick",rc1).removeClass(this.p.treeIcons.plus+" tree-plus").addClass(this.p.treeIcons.minus+" tree-minus");
this.p.treeANode = rc1.rowIndex;
this.p.datatype = this.p.treedatatype;
if(this.p.treeGridModel === 'nested') {
$(this).jqGrid("setGridParam",{postData:{nodeid:id,n_left:rc[lft],n_right:rc[rgt],n_level:rc[level]}});
} else {
$(this).jqGrid("setGridParam",{postData:{nodeid:id,parentid:rc[parent],n_level:rc[level]}} );
}
$(this).trigger("reloadGrid");
rc[loaded] = true;
if(this.p.treeGridModel === 'nested') {
$(this).jqGrid("setGridParam",{postData:{nodeid:'',n_left:'',n_right:'',n_level:''}});
} else {
$(this).jqGrid("setGridParam",{postData:{nodeid:'',parentid:'',n_level:''}});
}
}
$($t).triggerHandler("jqGridAfterExpandTreeGridNode", [id, rc]);
if($.isFunction(this.p.afterExpandTreeGridNode)) {
this.p.afterExpandTreeGridNode.call(this, id, rc );
}
}
});
},
collapseNode : function(rc) {
return this.each(function(){
if(!this.grid || !this.p.treeGrid) {return;}
var expanded = this.p.treeReader.expanded_field,
$t = this;
if(rc[expanded]) {
var id = $.jgrid.getAccessor(rc,this.p.localReader.id),
rc1 = $("#" + this.p.idPrefix + $.jgrid.jqID(id),this.grid.bDiv)[0],
ret = $($t).triggerHandler("jqGridBeforeCollapseTreeGridNode", [id, rc]);
if(ret === undefined ) {
ret = true;
}
if( ret && $.isFunction(this.p.beforeCollapseTreeGridNode) ) {
ret = this.p.beforeCollapseTreeGridNode.call(this, id, rc );
}
rc[expanded] = false;
if( ret === false ) { return; }
$("div.treeclick",rc1).removeClass(this.p.treeIcons.minus+" tree-minus").addClass(this.p.treeIcons.plus+" tree-plus");
$($t).triggerHandler("jqGridAfterCollapseTreeGridNode", [id, rc]);
if($.isFunction(this.p.afterCollapseTreeGridNode)) {
this.p.afterCollapseTreeGridNode.call(this, id, rc );
}
}
});
},
SortTree : function( sortname, newDir, st, datefmt) {
return this.each(function(){
if(!this.grid || !this.p.treeGrid) {return;}
var i, len,
rec, records = [], $t = this, query, roots,
rt = $(this).jqGrid("getRootNodes", $t.p.search);
// Sorting roots
query = $.jgrid.from.call(this, rt);
// sort tree by node type
if( Boolean($t.p.sortTreeByNodeType)) {
var ord = ($t.p.sortTreeNodeOrder && $t.p.sortTreeNodeOrder.toLowerCase() === 'desc') ? 'd' : 'a';
query.orderBy($t.p.treeReader.leaf_field, ord, st, datefmt);
}
query.orderBy(sortname, newDir, st, datefmt);
roots = query.select();
// Sorting children
for (i = 0, len = roots.length; i < len; i++) {
rec = roots[i];
records.push(rec);
$(this).jqGrid("collectChildrenSortTree",records, rec, sortname, newDir, st, datefmt);
}
var ids = $(this).jqGrid("getDataIDs"), j=1;
$.each(records, function(index) {
var id = $.jgrid.getAccessor(this, $t.p.localReader.id);
if($.inArray(id, ids) !== -1) {
$('#'+$.jgrid.jqID($t.p.id)+ ' tbody tr:eq('+(j)+')').after($('#'+$.jgrid.jqID($t.p.id)+' tbody tr#'+$.jgrid.jqID(id)));
j++;
}
});
query = null;roots=null;records=null;
});
},
searchTree : function ( recs ) {
var n = recs.length || 0, ancestors=[], lid, roots=[], result=[],tid, alen, rlen, j, k, i;
this.each(function(){
if(!this.grid || !this.p.treeGrid) {
return;
}
if(n) {
lid = this.p.localReader.id;
//while( i-- ) { // reverse
for( i=0; i<n; i++ ) {
ancestors = $(this).jqGrid('getNodeAncestors', recs[i], true, true);
//add the searched item
if( Boolean(this.p.FullTreeSearchResult) ) {
var fnode = $(this).jqGrid('getFullTreeNode', recs[i], true);
ancestors = ancestors.concat(fnode);
} else {
ancestors.push(recs[i]);
}
tid = ancestors[0][lid];
if($.inArray(tid, roots ) !== -1) { // ignore repeated, but add missing
for( j = 0, alen = ancestors.length; j < alen; j++) {
//$.inArray ?!?
var found = false;
for( k=0, rlen = result.length; k < rlen; k++) {
if(ancestors[j][lid] === result[k][lid]) {
found = true;
break;
}
}
if(!found) {
result.push(ancestors[j]);
}
}
continue;
} else {
roots.push( tid );
}
result = result.concat( ancestors );
}
}
});
return result;
},
collectChildrenSortTree : function(records, rec, sortname, newDir,st, datefmt) {
return this.each(function(){
if(!this.grid || !this.p.treeGrid) {return;}
var i, len,
child, ch, query, children;
ch = $(this).jqGrid("getNodeChildren",rec, this.p.search);
query = $.jgrid.from.call(this, ch);
query.orderBy(sortname, newDir, st, datefmt);
children = query.select();
for (i = 0, len = children.length; i < len; i++) {
child = children[i];
records.push(child);
$(this).jqGrid("collectChildrenSortTree",records, child, sortname, newDir, st, datefmt);
}
});
},
// experimental
setTreeRow : function(rowid, data) {
var success=false;
this.each(function(){
var t = this;
if(!t.grid || !t.p.treeGrid) {return;}
success = $(t).jqGrid("setRowData", rowid, data);
});
return success;
},
delTreeNode : function (rowid) {
return this.each(function () {
var $t = this, rid = $t.p.localReader.id, i,
left = $t.p.treeReader.left_field,
right = $t.p.treeReader.right_field, myright, width, res, key;
if(!$t.grid || !$t.p.treeGrid) {return;}
rowid = $.jgrid.stripPref($t.p.idPrefix, rowid);
var rc = $t.p._index[rowid];
if (rc !== undefined) {
// nested
myright = parseInt($t.p.data[rc][right],10);
width = myright - parseInt($t.p.data[rc][left],10) + 1;
var dr = $($t).jqGrid("getFullTreeNode",$t.p.data[rc]);
if(dr.length>0){
for (i=0;i<dr.length;i++){
$($t).jqGrid("delRowData", $t.p.idPrefix + dr[i][rid]);
}
}
if( $t.p.treeGridModel === "nested") {
// ToDo - update grid data
res = $.jgrid.from.call($t, $t.p.data)
.greater(left,myright,{stype:'integer'})
.select();
if(res.length) {
for( key in res) {
if(res.hasOwnProperty(key)) {
res[key][left] = parseInt(res[key][left],10) - width ;
}
}
}
res = $.jgrid.from.call($t, $t.p.data)
.greater(right,myright,{stype:'integer'})
.select();
if(res.length) {
for( key in res) {
if(res.hasOwnProperty(key)) {
res[key][right] = parseInt(res[key][right],10) - width ;
}
}
}
}
}
});
},
delChildren : function (rowid) {
return this.each(function () {
var $t = this, rid = $t.p.localReader.id,
left = $t.p.treeReader.left_field,
right = $t.p.treeReader.right_field, myright, width, res, key;
if(!$t.grid || !$t.p.treeGrid) {return;}
rowid = $.jgrid.stripPref($t.p.idPrefix, rowid);
var rc = $t.p._index[rowid];
if (rc !== undefined) {
// nested
myright = parseInt($t.p.data[rc][right],10);
width = myright - parseInt($t.p.data[rc][left],10) + 1;
var dr = $($t).jqGrid("getFullTreeNode",$t.p.data[rc]);
if(dr.length>0){
for (var i=0;i<dr.length;i++){
if(dr[i][rid] !== rowid)
$($t).jqGrid("delRowData", $t.p.idPrefix + dr[i][rid]);
}
}
if( $t.p.treeGridModel === "nested") {
// ToDo - update grid data
res = $.jgrid.from($t.p.data)
.greater(left,myright,{stype:'integer'})
.select();
if(res.length) {
for( key in res) {
if(res.hasOwnProperty(key)) {
res[key][left] = parseInt(res[key][left],10) - width ;
}
}
}
res = $.jgrid.from($t.p.data)
.greater(right,myright,{stype:'integer'})
.select();
if(res.length) {
for( key in res) {
if(res.hasOwnProperty(key)) {
res[key][right] = parseInt(res[key][right],10) - width ;
}
}
}
}
}
});
},
addChildNode : function( nodeid, parentid, data, expandData ) {
//return this.each(function(){
var $t = this[0];
if(data) {
// we suppose tha the id is autoincremet and
var expanded = $t.p.treeReader.expanded_field,
isLeaf = $t.p.treeReader.leaf_field,
level = $t.p.treeReader.level_field,
//icon = $t.p.treeReader.icon_field,
parent = $t.p.treeReader.parent_id_field,
left = $t.p.treeReader.left_field,
right = $t.p.treeReader.right_field,
loaded = $t.p.treeReader.loaded,
method, parentindex, parentdata, parentlevel, i, len, max=0, rowind = parentid, leaf, maxright;
if(expandData===undefined) {expandData = false;}
if ( nodeid == null ) {
i = $t.p.data.length-1;
if( i>= 0 ) {
while(i>=0){max = Math.max(max, parseInt($t.p.data[i][$t.p.localReader.id],10)); i--;}
}
nodeid = max+1;
}
var prow = $($t).jqGrid('getInd', parentid);
leaf = false;
// if not a parent we assume root
if ( parentid === undefined || parentid === null || parentid==="") {
parentid = null;
rowind = null;
method = 'last';
parentlevel = $t.p.tree_root_level;
i = $t.p.data.length+1;
} else {
method = 'after';
var mid = $.jgrid.stripPref($t.p.idPrefix, parentid);
parentindex = $t.p._index[mid];
parentdata = $t.p.data[parentindex];
parentid = parentdata[$t.p.localReader.id];
parentlevel = parseInt(parentdata[level],10)+1;
var childs = $($t).jqGrid('getFullTreeNode', parentdata);
// if there are child nodes get the last index of it
if(childs.length) {
i = childs[childs.length-1][$t.p.localReader.id];
rowind = i;
i = $($t).jqGrid('getInd', $t.p.idPrefix + rowind);
} else {
i = $($t).jqGrid('getInd', $t.p.idPrefix + parentid);
}
// if the node is leaf
if(parentdata[isLeaf]) {
leaf = true;
parentdata[expanded] = true;
//var prow = $($t).jqGrid('getInd', parentid);
$($t.rows[prow])
.find("span.cell-wrapperleaf").removeClass("cell-wrapperleaf").addClass("cell-wrapper")
.end()
.find("div.tree-leaf").removeClass($t.p.treeIcons.leaf+" tree-leaf").addClass($t.p.treeIcons.minus+" tree-minus");
$t.p.data[parentindex][isLeaf] = false;
parentdata[loaded] = true;
}
// incremet th index of child to be inserted
if( i === false ) {
throw "Parent item with id: " + rowind + " ("+ parentid+") can't be found";
return;
} else {
i++;
}
}
len = i+1;
if( data[expanded]===undefined) {data[expanded]= false;}
if( data[loaded]===undefined ) { data[loaded] = false;}
data[level] = parentlevel;
if( data[isLeaf]===undefined) {data[isLeaf]= true;}
if( $t.p.treeGridModel === "adjacency") {
data[parent] = parentid;
}
if( $t.p.treeGridModel === "nested") {
// this method requiere more attention
var query, res, key;
//maxright = parseInt(maxright,10);
// ToDo - update grid data
if(parentid !== null) {
maxright = parseInt(parentdata[right],10);
query = $.jgrid.from.call($t, $t.p.data);
query = query.greaterOrEquals(right,maxright,{stype:'integer'});
res = query.select();
if(res.length) {
for( key in res) {
if(res.hasOwnProperty(key)) {
res[key][left] = res[key][left] > maxright ? parseInt(res[key][left],10) +2 : res[key][left];
res[key][right] = res[key][right] >= maxright ? parseInt(res[key][right],10) +2 : res[key][right];
}
}
}
data[left] = maxright;
data[right]= maxright+1;
} else {
maxright = parseInt( $($t).jqGrid('getCol', right, false, 'max'), 10);
res = $.jgrid.from.call($t, $t.p.data)
.greater(left,maxright,{stype:'integer'})
.select();
if(res.length) {
for( key in res) {
if(res.hasOwnProperty(key)) {
res[key][left] = parseInt(res[key][left],10) +2 ;
}
}
}
res = $.jgrid.from.call($t, $t.p.data)
.greater(right,maxright,{stype:'integer'})
.select();
if(res.length) {
for( key in res) {
if(res.hasOwnProperty(key)) {
res[key][right] = parseInt(res[key][right],10) +2 ;
}
}
}
data[left] = maxright+1;
data[right] = maxright + 2;
}
}
if( parentid === null || $($t).jqGrid("isNodeLoaded",parentdata) || leaf ) {
$($t).jqGrid('addRowData', nodeid, data, method, $t.p.idPrefix + rowind);
$($t).jqGrid('setTreeNode', i, len);
}
if(parentdata && !parentdata[expanded] && expandData) {
$($t.rows[prow])
.find("div.treeclick")
.click();
}
}
//});
}
});
//module begin
$.fn.jqDrag=function(h){return i(this,h,'d');};
$.fn.jqResize=function(h,ar){return i(this,h,'r',ar);};
$.jqDnR={
dnr:{},
e:0,
drag:function(v){
if(M.k == 'd'){E.css({left:M.X+v.pageX-M.pX,top:M.Y+v.pageY-M.pY});}
else {
E.css({width:Math.max(v.pageX-M.pX+M.W,0),height:Math.max(v.pageY-M.pY+M.H,0)});
if(M1){E1.css({width:Math.max(v.pageX-M1.pX+M1.W,0),height:Math.max(v.pageY-M1.pY+M1.H,0)});}
}
return false;
},
stop:function(){
//E.css('opacity',M.o);
$(document).off('mousemove',J.drag).off('mouseup',J.stop);
}
};
var J=$.jqDnR,M=J.dnr,E=J.e,E1,M1,
i=function(e,h,k,aR){
return e.each(function(){
h=(h)?$(h,e):e;
h.on('mousedown',{e:e,k:k},function(v){
var d=v.data,p={};E=d.e;E1 = aR ? $(aR) : false;
// attempt utilization of dimensions plugin to fix IE issues
if(E.css('position') != 'relative'){try{E.position(p);}catch(e){}}
M={
X:p.left||f('left')||0,
Y:p.top||f('top')||0,
W:f('width')||E[0].scrollWidth||0,
H:f('height')||E[0].scrollHeight||0,
pX:v.pageX,
pY:v.pageY,
k:d.k
//o:E.css('opacity')
};
// also resize
if(E1 && d.k != 'd'){
M1={
X:p.left||f1('left')||0,
Y:p.top||f1('top')||0,
W:E1[0].offsetWidth||f1('width')||0,
H:E1[0].offsetHeight||f1('height')||0,
pX:v.pageX,
pY:v.pageY,
k:d.k
};
} else {M1 = false;}
//E.css({opacity:0.8});
if($("input.hasDatepicker",E[0])[0]) {
try {$("input.hasDatepicker",E[0]).datepicker('hide');}catch (dpe){}
}
$(document).mousemove($.jqDnR.drag).mouseup($.jqDnR.stop);
return false;
});
});
},
f=function(k){return parseInt(E.css(k),10)||false;},
f1=function(k){return parseInt(E1.css(k),10)||false;};
/*
jQuery tinyDraggable v1.0.2
Copyright (c) 2014 Simon Steinberger / Pixabay
GitHub: https://github.com/Pixabay/jQuery-tinyDraggable
More info: https://pixabay.com/blog/posts/p-52/
License: http://www.opensource.org/licenses/mit-license.php
*/
$.fn.tinyDraggable = function(options){
var settings = $.extend({ handle: 0, exclude: 0 }, options);
return this.each(function(){
var dx, dy, el = $(this), handle = settings.handle ? $(settings.handle, el) : el;
handle.on({
mousedown: function(e){
if (settings.exclude && ~$.inArray(e.target, $(settings.exclude, el))) { return; }
e.preventDefault();
var os = el.offset(); dx = e.pageX-os.left, dy = e.pageY-os.top;
$(document).on('mousemove.drag', function(e){ el.offset({top: e.pageY-dy, left: e.pageX-dx}); });
},
mouseup: function(e){ $(document).off('mousemove.drag'); }
});
});
};
//module begin
$.fn.jqm=function(o){
var p={
overlay: 50,
closeoverlay : true,
overlayClass: 'jqmOverlay',
closeClass: 'jqmClose',
trigger: '.jqModal',
ajax: F,
ajaxText: '',
target: F,
modal: F,
toTop: F,
onShow: F,
onHide: F,
onLoad: F
};
return this.each(function(){if(this._jqm){ return H[this._jqm].c=$.extend({},H[this._jqm].c,o);} s++;this._jqm=s;
H[s]={c:$.extend(p,$.jqm.params,o),a:F,w:$(this).addClass('jqmID'+s),s:s};
if(p.trigger){$(this).jqmAddTrigger(p.trigger);}
});};
$.fn.jqmAddClose=function(e){return hs(this,e,'jqmHide');};
$.fn.jqmAddTrigger=function(e){return hs(this,e,'jqmShow');};
$.fn.jqmShow=function(t){return this.each(function(){$.jqm.open(this._jqm,t);});};
$.fn.jqmHide=function(t){return this.each(function(){$.jqm.close(this._jqm,t);});};
$.jqm = {
hash:{},
open:function(s,t){var h=H[s],c=h.c,cc='.'+c.closeClass,z=(parseInt(h.w.css('z-index')));z=(z>0)?z:3000;var o=$('<div></div>').css({height:'100%',width:'100%',position:'fixed',left:0,top:0,'z-index':z-1,opacity:c.overlay/100});if(h.a){return F;} h.t=t;h.a=true;h.w.css('z-index',z);
if(c.modal) {if(!A[0]){setTimeout(function(){ new L('bind');},1); }A.push(s);}
else if(c.overlay > 0) {if(c.closeoverlay) {h.w.jqmAddClose(o);}}
else {o=F;}
h.o=(o)?o.addClass(c.overlayClass).prependTo('body'):F;
if(c.ajax) {var r=c.target||h.w,u=c.ajax;r=(typeof r === 'string')?$(r,h.w):$(r);u=(u.substr(0,1) === '@')?$(t).attr(u.substring(1)):u;
r.html(c.ajaxText).load(u,function(){if(c.onLoad){c.onLoad.call(this,h);}if(cc){h.w.jqmAddClose($(cc,h.w));}e(h);});}
else if(cc){h.w.jqmAddClose($(cc,h.w));}
if(c.toTop&&h.o){h.w.before('<span id="jqmP'+h.w[0]._jqm+'"></span>').insertAfter(h.o);}
(c.onShow)?c.onShow(h):h.w.show();e(h);return F;
},
close:function(s){var h=H[s];if(!h.a){return F;}h.a=F;
if(A[0]){A.pop();if(!A[0]){new L('unbind');}}
if(h.c.toTop&&h.o){$('#jqmP'+h.w[0]._jqm).after(h.w).remove();}
if(h.c.onHide){h.c.onHide(h);}else{h.w.hide();if(h.o){h.o.remove();}} return F;
},
params:{}};
var s=0,H=$.jqm.hash,A=[],F=false,
e=function(h){ if(h.c.focusField===undefined) {h.c.focusField = 0;}if(h.c.focusField >=0 ) {f(h);} },
f=function(h){try{$(':input:visible',h.w)[parseInt(h.c.focusField,10)].focus(); }catch(_){}},
L=function(t){$(document)[t]("keypress",m)[t]("keydown",m)[t]("mousedown",m);},
m=function(e){var h=H[A[A.length-1]],r=(!$(e.target).parents('.jqmID'+h.s)[0]);if(r){$('.jqmID'+h.s).each(function(){var $self=$(this),offset=$self.offset();if(offset.top<=e.pageY && e.pageY<=offset.top+$self.height() && offset.left<=e.pageX && e.pageX<=offset.left+$self.width() ){r=false;return false;}});/*f(h);*/}return !r;},
hs=function(w,t,c){return w.each(function(){var s=this._jqm;$(t).each(function() {
if(!this[c]){this[c]=[];$(this).click(function(){for(var i in {jqmShow:1,jqmHide:1}){for(var s in this[i]){if(H[this[i][s]]){H[this[i][s]].w[i](this);}}}return F;});}
this[c].push(s);});});};
//module begin
$.fmatter = {};
//opts can be id:row id for the row, rowdata:the data for the row, colmodel:the column model for this column
//example {id:1234,}
$.extend($.fmatter,{
isBoolean : function(o) {
return typeof o === 'boolean';
},
isObject : function(o) {
return (o && (typeof o === 'object' || $.isFunction(o))) || false;
},
isString : function(o) {
return typeof o === 'string';
},
isNumber : function(o) {
return typeof o === 'number' && isFinite(o);
},
isValue : function (o) {
return (this.isObject(o) || this.isString(o) || this.isNumber(o) || this.isBoolean(o));
},
isEmpty : function(o) {
if(!this.isString(o) && this.isValue(o)) {
return false;
}
if (!this.isValue(o)){
return true;
}
o = $.trim(o).replace(/\ \;/ig,'').replace(/\ \;/ig,'');
return o==="";
}
});
$.fn.fmatter = function(formatType, cellval, opts, rwd, act) {
// build main options before element iteration
var v=cellval;
opts = $.extend({}, $.jgrid.getRegional(this, 'formatter') , opts);
try {
v = $.fn.fmatter[formatType].call(this, cellval, opts, rwd, act);
} catch(fe){}
return v;
};
$.fmatter.util = {
// Taken from YAHOO utils
NumberFormat : function(nData,opts) {
if(!$.fmatter.isNumber(nData)) {
nData *= 1;
}
if($.fmatter.isNumber(nData)) {
var bNegative = (nData < 0);
var sOutput = String(nData);
var sDecimalSeparator = opts.decimalSeparator || ".";
var nDotIndex;
if($.fmatter.isNumber(opts.decimalPlaces)) {
// Round to the correct decimal place
var nDecimalPlaces = opts.decimalPlaces;
//var nDecimal = Math.pow(10, nDecimalPlaces);
//sOutput = String(Math.round(nData*nDecimal)/nDecimal);
// see http://www.jacklmoore.com/notes/rounding-in-javascript/
sOutput = String(Number(Math.round(nData+'e'+nDecimalPlaces)+'e-'+nDecimalPlaces));
nDotIndex = sOutput.lastIndexOf(".");
if(nDecimalPlaces > 0) {
// Add the decimal separator
if(nDotIndex < 0) {
sOutput += sDecimalSeparator;
nDotIndex = sOutput.length-1;
}
// Replace the "."
else if(sDecimalSeparator !== "."){
sOutput = sOutput.replace(".",sDecimalSeparator);
}
// Add missing zeros
while((sOutput.length - 1 - nDotIndex) < nDecimalPlaces) {
sOutput += "0";
}
}
}
if(opts.thousandsSeparator) {
var sThousandsSeparator = opts.thousandsSeparator;
nDotIndex = sOutput.lastIndexOf(sDecimalSeparator);
nDotIndex = (nDotIndex > -1) ? nDotIndex : sOutput.length;
var sNewOutput = sOutput.substring(nDotIndex);
var nCount = -1, i;
for (i=nDotIndex; i>0; i--) {
nCount++;
if ((nCount%3 === 0) && (i !== nDotIndex) && (!bNegative || (i > 1))) {
sNewOutput = sThousandsSeparator + sNewOutput;
}
sNewOutput = sOutput.charAt(i-1) + sNewOutput;
}
sOutput = sNewOutput;
}
// Prepend prefix
sOutput = (opts.prefix) ? opts.prefix + sOutput : sOutput;
// Append suffix
sOutput = (opts.suffix) ? sOutput + opts.suffix : sOutput;
return sOutput;
}
return nData;
}
};
$.fn.fmatter.defaultFormat = function(cellval, opts) {
return ($.fmatter.isValue(cellval) && cellval!=="" ) ? cellval : opts.defaultValue || " ";
};
$.fn.fmatter.email = function(cellval, opts) {
if(!$.fmatter.isEmpty(cellval)) {
return "<a href=\"mailto:" + cellval + "\">" + cellval + "</a>";
}
return $.fn.fmatter.defaultFormat(cellval,opts );
};
$.fn.fmatter.checkbox =function(cval, opts) {
var op = $.extend({},opts.checkbox), ds;
if(opts.colModel !== undefined && opts.colModel.formatoptions !== undefined) {
op = $.extend({},op,opts.colModel.formatoptions);
}
if(op.disabled===true) {ds = "disabled=\"disabled\"";} else {ds="";}
if($.fmatter.isEmpty(cval) || cval === undefined ) {cval = $.fn.fmatter.defaultFormat(cval,op);}
cval=String(cval);
cval=(cval+"").toLowerCase();
var bchk = cval.search(/(false|f|0|no|n|off|undefined)/i)<0 ? " checked='checked' " : "";
return "<input type=\"checkbox\" " + bchk + " value=\""+ cval+"\" offval=\"no\" "+ds+ "/>";
};
$.fn.fmatter.link = function(cellval, opts) {
var op = {target:opts.target};
var target = "";
if(opts.colModel !== undefined && opts.colModel.formatoptions !== undefined) {
op = $.extend({},op,opts.colModel.formatoptions);
}
if(op.target) {target = 'target=' + op.target;}
if(!$.fmatter.isEmpty(cellval)) {
return "<a "+target+" href=\"" + cellval + "\">" + cellval + "</a>";
}
return $.fn.fmatter.defaultFormat(cellval,opts);
};
$.fn.fmatter.showlink = function(cellval, opts) {
var op = {baseLinkUrl: opts.baseLinkUrl,showAction:opts.showAction, addParam: opts.addParam || "", target: opts.target, idName: opts.idName},
target = "", idUrl;
if(opts.colModel !== undefined && opts.colModel.formatoptions !== undefined) {
op = $.extend({},op,opts.colModel.formatoptions);
}
if(op.target) {target = 'target=' + op.target;}
idUrl = op.baseLinkUrl+op.showAction + '?'+ op.idName+'='+opts.rowId+op.addParam;
if($.fmatter.isString(cellval) || $.fmatter.isNumber(cellval)) { //add this one even if its blank string
return "<a "+target+" href=\"" + idUrl + "\">" + cellval + "</a>";
}
return $.fn.fmatter.defaultFormat(cellval,opts);
};
$.fn.fmatter.integer = function(cellval, opts) {
var op = $.extend({},opts.integer);
if(opts.colModel !== undefined && opts.colModel.formatoptions !== undefined) {
op = $.extend({},op,opts.colModel.formatoptions);
}
if($.fmatter.isEmpty(cellval)) {
return op.defaultValue;
}
return $.fmatter.util.NumberFormat(cellval,op);
};
$.fn.fmatter.number = function (cellval, opts) {
var op = $.extend({},opts.number);
if(opts.colModel !== undefined && opts.colModel.formatoptions !== undefined) {
op = $.extend({},op,opts.colModel.formatoptions);
}
if($.fmatter.isEmpty(cellval)) {
return op.defaultValue;
}
return $.fmatter.util.NumberFormat(cellval,op);
};
$.fn.fmatter.currency = function (cellval, opts) {
var op = $.extend({},opts.currency);
if(opts.colModel !== undefined && opts.colModel.formatoptions !== undefined) {
op = $.extend({},op,opts.colModel.formatoptions);
}
if($.fmatter.isEmpty(cellval)) {
return op.defaultValue;
}
return $.fmatter.util.NumberFormat(cellval,op);
};
$.fn.fmatter.date = function (cellval, opts, rwd, act) {
var op = $.extend({},opts.date);
if(opts.colModel !== undefined && opts.colModel.formatoptions !== undefined) {
op = $.extend({},op,opts.colModel.formatoptions);
}
if(!op.reformatAfterEdit && act === 'edit'){
return $.fn.fmatter.defaultFormat(cellval, opts);
}
if(!$.fmatter.isEmpty(cellval)) {
return $.jgrid.parseDate.call(this, op.srcformat,cellval,op.newformat,op);
}
return $.fn.fmatter.defaultFormat(cellval, opts);
};
$.fn.fmatter.select = function (cellval,opts) {
// jqGrid specific
cellval = String(cellval);
var oSelect = false, ret=[], sep, delim;
if(opts.colModel.formatoptions !== undefined){
oSelect= opts.colModel.formatoptions.value;
sep = opts.colModel.formatoptions.separator === undefined ? ":" : opts.colModel.formatoptions.separator;
delim = opts.colModel.formatoptions.delimiter === undefined ? ";" : opts.colModel.formatoptions.delimiter;
} else if(opts.colModel.editoptions !== undefined){
oSelect= opts.colModel.editoptions.value;
sep = opts.colModel.editoptions.separator === undefined ? ":" : opts.colModel.editoptions.separator;
delim = opts.colModel.editoptions.delimiter === undefined ? ";" : opts.colModel.editoptions.delimiter;
}
if (oSelect) {
var msl = (opts.colModel.editoptions != null && opts.colModel.editoptions.multiple === true) === true ? true : false,
scell = [], sv;
if(msl) {scell = cellval.split(",");scell = $.map(scell,function(n){return $.trim(n);});}
if ($.fmatter.isString(oSelect)) {
// mybe here we can use some caching with care ????
var so = oSelect.split(delim), j=0, i;
for(i=0; i<so.length;i++){
sv = so[i].split(sep);
if(sv.length > 2 ) {
sv[1] = $.map(sv,function(n,i){if(i>0) {return n;}}).join(sep);
}
if(msl) {
if($.inArray(sv[0],scell)>-1) {
ret[j] = sv[1];
j++;
}
} else if($.trim(sv[0]) === $.trim(cellval)) {
ret[0] = sv[1];
break;
}
}
} else if($.fmatter.isObject(oSelect)) {
// this is quicker
if(msl) {
ret = $.map(scell, function(n){
return oSelect[n];
});
} else {
ret[0] = oSelect[cellval] || "";
}
}
}
cellval = ret.join(", ");
return cellval === "" ? $.fn.fmatter.defaultFormat(cellval,opts) : cellval;
};
$.fn.fmatter.rowactions = function(act) {
var $tr = $(this).closest("tr.jqgrow"),
rid = $tr.attr("id"),
$id = $(this).closest("table.ui-jqgrid-btable").attr('id').replace(/_frozen([^_]*)$/,'$1'),
$grid = $("#"+$id),
$t = $grid[0],
p = $t.p,
cm = p.colModel[$.jgrid.getCellIndex(this)],
$actionsDiv = cm.frozen ? $("tr#"+rid+" td:eq("+$.jgrid.getCellIndex(this)+") > div",$grid) :$(this).parent(),
op = {
extraparam: {}
},
saverow = function(rowid, res) {
if($.isFunction(op.afterSave)) { op.afterSave.call($t, rowid, res); }
$actionsDiv.find("div.ui-inline-edit,div.ui-inline-del").show();
$actionsDiv.find("div.ui-inline-save,div.ui-inline-cancel").hide();
},
restorerow = function(rowid) {
if($.isFunction(op.afterRestore)) { op.afterRestore.call($t, rowid); }
$actionsDiv.find("div.ui-inline-edit,div.ui-inline-del").show();
$actionsDiv.find("div.ui-inline-save,div.ui-inline-cancel").hide();
};
if (cm.formatoptions !== undefined) {
// Deep clone before copying over to op, to avoid creating unintentional references.
// Otherwise, the assignment of op.extraparam[p.prmNames.oper] below may persist into the colModel config.
var formatoptionsClone = $.extend(true, {}, cm.formatoptions);
op = $.extend(op, formatoptionsClone);
}
if (p.editOptions !== undefined) {
op.editOptions = p.editOptions;
}
if (p.delOptions !== undefined) {
op.delOptions = p.delOptions;
}
if ($tr.hasClass("jqgrid-new-row")){
op.extraparam[p.prmNames.oper] = p.prmNames.addoper;
}
var actop = {
keys: op.keys,
oneditfunc: op.onEdit,
successfunc: op.onSuccess,
url: op.url,
extraparam: op.extraparam,
aftersavefunc: saverow,
errorfunc: op.onError,
afterrestorefunc: restorerow,
restoreAfterError: op.restoreAfterError,
mtype: op.mtype
};
switch(act)
{
case 'edit':
$grid.jqGrid('editRow', rid, actop);
$actionsDiv.find("div.ui-inline-edit,div.ui-inline-del").hide();
$actionsDiv.find("div.ui-inline-save,div.ui-inline-cancel").show();
$grid.triggerHandler("jqGridAfterGridComplete");
break;
case 'save':
if ($grid.jqGrid('saveRow', rid, actop)) {
$actionsDiv.find("div.ui-inline-edit,div.ui-inline-del").show();
$actionsDiv.find("div.ui-inline-save,div.ui-inline-cancel").hide();
$grid.triggerHandler("jqGridAfterGridComplete");
}
break;
case 'cancel' :
$grid.jqGrid('restoreRow', rid, restorerow);
$actionsDiv.find("div.ui-inline-edit,div.ui-inline-del").show();
$actionsDiv.find("div.ui-inline-save,div.ui-inline-cancel").hide();
$grid.triggerHandler("jqGridAfterGridComplete");
break;
case 'del':
$grid.jqGrid('delGridRow', rid, op.delOptions);
break;
case 'formedit':
$grid.jqGrid('setSelection', rid);
$grid.jqGrid('editGridRow', rid, op.editOptions);
break;
}
};
$.fn.fmatter.actions = function(cellval,opts) {
var op={keys:false, editbutton:true, delbutton:true, editformbutton: false},
rowid=opts.rowId, str="",ocl,
nav = $.jgrid.getRegional(this, 'nav'),
classes = $.jgrid.styleUI[(opts.styleUI || 'jQueryUI')].fmatter,
common = $.jgrid.styleUI[(opts.styleUI || 'jQueryUI')].common;
if(opts.colModel.formatoptions !== undefined) {
op = $.extend(op,opts.colModel.formatoptions);
}
if(rowid === undefined || $.fmatter.isEmpty(rowid)) {return "";}
var hover = "onmouseover=jQuery(this).addClass('" + common.hover +"'); onmouseout=jQuery(this).removeClass('" + common.hover +"'); ";
if(op.editformbutton){
ocl = "id='jEditButton_"+rowid+"' onclick=jQuery.fn.fmatter.rowactions.call(this,'formedit'); " + hover;
str += "<div title='"+nav.edittitle+"' style='float:left;cursor:pointer;' class='ui-pg-div ui-inline-edit' "+ocl+"><span class='" + common.icon_base +" "+classes.icon_edit +"'></span></div>";
} else if(op.editbutton){
ocl = "id='jEditButton_"+rowid+"' onclick=jQuery.fn.fmatter.rowactions.call(this,'edit'); " + hover;
str += "<div title='"+nav.edittitle+"' style='float:left;cursor:pointer;' class='ui-pg-div ui-inline-edit' "+ocl+"><span class='" + common.icon_base +" "+classes.icon_edit +"'></span></div>";
}
if(op.delbutton) {
ocl = "id='jDeleteButton_"+rowid+"' onclick=jQuery.fn.fmatter.rowactions.call(this,'del'); " + hover;
str += "<div title='"+nav.deltitle+"' style='float:left;' class='ui-pg-div ui-inline-del' "+ocl+"><span class='" + common.icon_base +" "+classes.icon_del +"'></span></div>";
}
ocl = "id='jSaveButton_"+rowid+"' onclick=jQuery.fn.fmatter.rowactions.call(this,'save'); " + hover;
str += "<div title='"+nav.savetitle+"' style='float:left;display:none' class='ui-pg-div ui-inline-save' "+ocl+"><span class='" + common.icon_base +" "+classes.icon_save +"'></span></div>";
ocl = "id='jCancelButton_"+rowid+"' onclick=jQuery.fn.fmatter.rowactions.call(this,'cancel'); " + hover;
str += "<div title='"+nav.canceltitle+"' style='float:left;display:none;' class='ui-pg-div ui-inline-cancel' "+ocl+"><span class='" + common.icon_base +" "+classes.icon_cancel +"'></span></div>";
return "<div style='margin-left:8px;'>" + str + "</div>";
};
$.unformat = function (cellval,options,pos,cnt) {
// specific for jqGrid only
var ret, formatType = options.colModel.formatter,
op =options.colModel.formatoptions || {}, sep,
re = /([\.\*\_\'\(\)\{\}\+\?\\])/g,
unformatFunc = options.colModel.unformat||($.fn.fmatter[formatType] && $.fn.fmatter[formatType].unformat);
if(unformatFunc !== undefined && $.isFunction(unformatFunc) ) {
ret = unformatFunc.call(this, $(cellval).text(), options, cellval);
} else if(formatType !== undefined && $.fmatter.isString(formatType) ) {
var opts = $.jgrid.getRegional(this, 'formatter') || {}, stripTag;
switch(formatType) {
case 'integer' :
op = $.extend({},opts.integer,op);
sep = op.thousandsSeparator.replace(re,"\\$1");
stripTag = new RegExp(sep, "g");
ret = $(cellval).text().replace(stripTag,'');
break;
case 'number' :
op = $.extend({},opts.number,op);
sep = op.thousandsSeparator.replace(re,"\\$1");
stripTag = new RegExp(sep, "g");
ret = $(cellval).text().replace(stripTag,"").replace(op.decimalSeparator,'.');
break;
case 'currency':
op = $.extend({},opts.currency,op);
sep = op.thousandsSeparator.replace(re,"\\$1");
stripTag = new RegExp(sep, "g");
ret = $(cellval).text();
if (op.prefix && op.prefix.length) {
ret = ret.substr(op.prefix.length);
}
if (op.suffix && op.suffix.length) {
ret = ret.substr(0, ret.length - op.suffix.length);
}
ret = ret.replace(stripTag,'').replace(op.decimalSeparator,'.');
break;
case 'checkbox':
var cbv = (options.colModel.editoptions) ? options.colModel.editoptions.value.split(":") : ["Yes","No"];
ret = $('input',cellval).is(":checked") ? cbv[0] : cbv[1];
break;
case 'select' :
ret = $.unformat.select(cellval,options,pos,cnt);
break;
case 'actions':
return "";
default:
ret= $(cellval).text();
}
}
return ret !== undefined ? ret : cnt===true ? $(cellval).text() : $.jgrid.htmlDecode($(cellval).html());
};
$.unformat.select = function (cellval,options,pos,cnt) {
// Spacial case when we have local data and perform a sort
// cnt is set to true only in sortDataArray
var ret = [];
var cell = $(cellval).text();
if(cnt===true) {return cell;}
var op = $.extend({}, options.colModel.formatoptions !== undefined ? options.colModel.formatoptions: options.colModel.editoptions),
sep = op.separator === undefined ? ":" : op.separator,
delim = op.delimiter === undefined ? ";" : op.delimiter;
if(op.value){
var oSelect = op.value,
msl = op.multiple === true ? true : false,
scell = [], sv;
if(msl) {scell = cell.split(",");scell = $.map(scell,function(n){return $.trim(n);});}
if ($.fmatter.isString(oSelect)) {
var so = oSelect.split(delim), j=0, i;
for(i=0; i<so.length;i++){
sv = so[i].split(sep);
if(sv.length > 2 ) {
sv[1] = $.map(sv,function(n,i){if(i>0) {return n;}}).join(sep);
}
if(op.decodeValue && op.decodeValue===true) {
sv[1] = $.jgrid.htmlDecode(sv[1]);
}
if(msl) {
if($.inArray($.trim(sv[1]),scell)>-1) {
ret[j] = sv[0];
j++;
}
} else if($.trim(sv[1]) === $.trim(cell)) {
ret[0] = sv[0];
break;
}
}
} else if($.fmatter.isObject(oSelect) || $.isArray(oSelect) ){
if(!msl) {scell[0] = cell;}
ret = $.map(scell, function(n){
var rv;
$.each(oSelect, function(i,val){
if (val === n) {
rv = i;
return false;
}
});
if( rv !== undefined ) {return rv;}
});
}
return ret.join(", ");
}
return cell || "";
};
$.unformat.date = function (cellval, opts) {
var op = $.jgrid.getRegional(this, 'formatter.date') || {};
if(opts.formatoptions !== undefined) {
op = $.extend({},op,opts.formatoptions);
}
if(!$.fmatter.isEmpty(cellval)) {
return $.jgrid.parseDate.call(this, op.newformat,cellval,op.srcformat,op);
}
return $.fn.fmatter.defaultFormat(cellval, opts);
};
//module begin
var dragging, placeholders = $();
$.fn.html5sortable = function(options) {
var method = String(options);
options = $.extend({
connectWith: false
}, options);
return this.each(function() {
var items;
if (/^enable|disable|destroy$/.test(method)) {
items = $(this).children($(this).data('items')).attr('draggable', method === 'enable');
if (method === 'destroy') {
items.add(this).removeData('connectWith items')
.off('dragstart.h5s dragend.h5s selectstart.h5s dragover.h5s dragenter.h5s drop.h5s');
}
return;
}
var isHandle, index;
items = $(this).children(options.items);
var placeholder = $('<' + (/^ul|ol$/i.test(this.tagName) ? 'li' : /^tbody$/i.test(this.tagName) ? 'tr' : 'div') +
' class="sortable-placeholder ' + options.placeholderClass + '">').html(' ');
items.find(options.handle).mousedown(function() {
isHandle = true;
}).mouseup(function() {
isHandle = false;
});
$(this).data('items', options.items);
placeholders = placeholders.add(placeholder);
if (options.connectWith) {
$(options.connectWith).add(this).data('connectWith', options.connectWith);
}
items.attr('draggable', 'true').on('dragstart.h5s', function(e) {
if (options.handle && !isHandle) {
return false;
}
isHandle = false;
var dt = e.originalEvent.dataTransfer;
dt.effectAllowed = 'move';
dt.setData('Text', 'dummy');
index = (dragging = $(this)).addClass('sortable-dragging').index();
}).on('dragend.h5s', function() {
if (!dragging) {
return;
}
dragging.removeClass('sortable-dragging').show();
placeholders.detach();
if (index !== dragging.index()) {
dragging.parent().trigger('sortupdate', {item: dragging, startindex: index, endindex: dragging.index()});
}
dragging = null;
}).not('a[href], img').on('selectstart.h5s', function() {
this.dragDrop && this.dragDrop();
return false;
}).end().add([this, placeholder]).on('dragover.h5s dragenter.h5s drop.h5s', function(e) {
if (!items.is(dragging) && options.connectWith !== $(dragging).parent().data('connectWith')) {
return true;
}
if (e.type === 'drop') {
e.stopPropagation();
placeholders.filter(':visible').after(dragging);
dragging.trigger('dragend.h5s');
return false;
}
e.preventDefault();
e.originalEvent.dataTransfer.dropEffect = 'move';
if (items.is(this)) {
if (options.forcePlaceholderSize) {
placeholder.height(dragging.outerHeight());
}
dragging.hide();
$(this)[placeholder.index() < $(this).index() ? 'after' : 'before'](placeholder);
placeholders.not(placeholder).detach();
} else if (!placeholders.is(this) && !$(this).children(options.items).length) {
placeholders.detach();
$(this).append(placeholder);
}
return false;
});
});
};
//module begin
$.extend($.jgrid,{
//window.jqGridUtils = {
stringify : function(obj) {
return JSON.stringify(obj,function(key, value){
return (typeof value === 'function' ) ? value.toString() : value;
});
},
parseFunc : function(str) {
return JSON.parse(str,function(key, value){
if(typeof value === "string" && value.indexOf("function") !== -1) {
var sv = value.split(" ");
sv[0] = $.trim( sv[0].toLowerCase() );
if( (sv[0].indexOf('function') === 0) && value.trim().slice(-1) === "}") {
return eval('('+value+')');
} else {
return value;
}
}
return value;
});
},
encode : function ( text ) { // repeated, but should not depend on grid
return String(text).replace(/&/g,'&').replace(/</g,'<').replace(/>/g,'>').replace(/"/g,'"');
},
jsonToXML : function ( tree, options ) {
var o = $.extend( {
xmlDecl : '<?xml version="1.0" encoding="UTF-8" ?>\n',
attr_prefix : '-',
encode : true
}, options || {}),
that = this,
scalarToxml = function ( name, text ) {
if ( name === "#text" ) {
return (o.encode ? that.encode(text) : text);
} else if(typeof(text) ==='function') {
return "<"+name+"><![CDATA["+ text +"]]></"+name+">\n";
} if(text === "") {
return "<"+name+">__EMPTY_STRING_</"+name+">\n";
} else {
return "<"+name+">"+(o.encode ? that.encode(text) : text )+"</"+name+">\n";
}
},
arrayToxml = function ( name, array ) {
var out = [];
for( var i=0; i<array.length; i++ ) {
var val = array[i];
if ( typeof(val) === "undefined" || val == null ) {
out[out.length] = "<"+name+" />";
} else if ( typeof(val) === "object" && val.constructor == Array ) {
out[out.length] = arrayToxml( name, val );
} else if ( typeof(val) === "object" ) {
out[out.length] = hashToxml( name, val );
} else {
out[out.length] = scalarToxml( name, val );
}
}
if(!out.length) {
out[0] = "<"+ name+">__EMPTY_ARRAY_</"+name+">\n";
}
return out.join("");
},
hashToxml = function ( name, tree ) {
var elem = [];
var attr = [];
for( var key in tree ) {
if ( ! tree.hasOwnProperty(key) ) continue;
var val = tree[key];
if ( key.charAt(0) !== o.attr_prefix ) {
if ( val == null ) { // null or undefined
elem[elem.length] = "<"+key+" />";
} else if ( typeof(val) === "object" && val.constructor === Array ) {
elem[elem.length] = arrayToxml( key, val );
} else if ( typeof(val) === "object" ) {
elem[elem.length] = hashToxml( key, val );
} else {
elem[elem.length] = scalarToxml( key, val );
}
} else {
attr[attr.length] = " "+(key.substring(1))+'="'+(o.encode ? that.encode( val ) : val)+'"';
}
}
var jattr = attr.join("");
var jelem = elem.join("");
if ( name == null ) { // null or undefined
// no tag
} else if ( elem.length > 0 ) {
if ( jelem.match( /\n/ )) {
jelem = "<"+name+jattr+">\n"+jelem+"</"+name+">\n";
} else {
jelem = "<"+name+jattr+">" +jelem+"</"+name+">\n";
}
} else {
jelem = "<"+name+jattr+" />\n";
}
return jelem;
};
var xml = hashToxml( null, tree );
return o.xmlDecl + xml;
},
xmlToJSON : function ( root, options ) {
var o = $.extend ( {
force_array : [], //[ "rdf:li", "item", "-xmlns" ];
attr_prefix : '-'
}, options || {} );
if(!root) { return; }
var __force_array = {};
if ( o.force_array ) {
for( var i=0; i< o.force_array.length; i++ ) {
__force_array[o.force_array[i]] = 1;
}
}
if(typeof root === 'string') {
root = $.parseXML(root);
}
if(root.documentElement) {
root = root.documentElement;
}
var addNode = function ( hash, key, cnts, val ) {
if(typeof val === 'string') {
if( val.indexOf('function') !== -1) {
val = eval( '(' + val +')'); // we need this in our implement
} else {
switch(val) {
case '__EMPTY_ARRAY_' :
val = [];
break;
case '__EMPTY_STRING_':
val = "";
break;
case "false" :
val = false;
break;
case "true":
val = true;
break;
}
}
}
if ( __force_array[key] ) {
if ( cnts === 1 ) {
hash[key] = [];
}
hash[key][hash[key].length] = val; // push
} else if ( cnts === 1 ) { // 1st sibling
hash[key] = val;
} else if ( cnts === 2 ) { // 2nd sibling
hash[key] = [ hash[key], val ];
} else { // 3rd sibling and more
hash[key][hash[key].length] = val;
}
},
parseElement = function ( elem ) {
// COMMENT_NODE
if ( elem.nodeType === 7 ) {
return;
}
// TEXT_NODE CDATA_SECTION_NODE
if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
var bool = elem.nodeValue.match( /[^\x00-\x20]/ );
if ( bool == null ) return; // ignore white spaces
return elem.nodeValue;
}
var retval, cnt = {}, i, key, val;
// parse attributes
if ( elem.attributes && elem.attributes.length ) {
retval = {};
for ( i=0; i<elem.attributes.length; i++ ) {
key = elem.attributes[i].nodeName;
if ( typeof(key) !== "string" ) {
continue;
}
val = elem.attributes[i].nodeValue;
if ( ! val ) {
continue;
}
key = o.attr_prefix + key;
if ( typeof(cnt[key]) === "undefined" ) {
cnt[key] = 0;
}
cnt[key] ++;
addNode( retval, key, cnt[key], val );
}
}
// parse child nodes (recursive)
if ( elem.childNodes && elem.childNodes.length ) {
var textonly = true;
if ( retval ) {
textonly = false;
} // some attributes exists
for ( i=0; i<elem.childNodes.length && textonly; i++ ) {
var ntype = elem.childNodes[i].nodeType;
if ( ntype === 3 || ntype === 4 ) {
continue;
}
textonly = false;
}
if ( textonly ) {
if ( ! retval ) {
retval = "";
}
for ( i=0; i<elem.childNodes.length; i++ ) {
retval += elem.childNodes[i].nodeValue;
}
} else {
if ( ! retval ) {
retval = {};
}
for ( i=0; i<elem.childNodes.length; i++ ) {
key = elem.childNodes[i].nodeName;
if ( typeof(key) !== "string" ) {
continue;
}
val = parseElement( elem.childNodes[i] );
if ( !val ) {
continue;
}
if ( typeof(cnt[key]) === "undefined" ) {
cnt[key] = 0;
}
cnt[key] ++;
addNode( retval, key, cnt[key], val );
}
}
}
return retval;
};
var json = parseElement( root ); // parse root node
if ( __force_array[root.nodeName] ) {
json = [ json ];
}
if ( root.nodeType !== 11 ) { // DOCUMENT_FRAGMENT_NODE
var tmp = {};
tmp[root.nodeName] = json; // root nodeName
json = tmp;
}
return json;
},
saveAs : function (data, fname, opts) {
opts = $.extend(true,{
type : 'plain/text;charset=utf-8'
}, opts || {});
var file, url, tmp = [];
fname = fname == null || fname === '' ? 'jqGridFile.txt' : fname;
if(!$.isArray(data) ) {
tmp[0]= data ;
} else {
tmp = data;
}
try {
file = new File(tmp, fname, opts);
} catch (e) {
file = new Blob(tmp, opts);
}
if ( window.navigator && window.navigator.msSaveOrOpenBlob) {
window.navigator.msSaveOrOpenBlob( file , fname );
} else {
url = URL.createObjectURL(file);
var a = document.createElement("a");
a.href = url;
a.download = fname;
document.body.appendChild(a);
a.click();
setTimeout(function() {
document.body.removeChild(a);
window.URL.revokeObjectURL(url);
}, 0);
}
}
});
//module begin
$.jgrid = $.jgrid || {};
$.extend($.jgrid,{
formatCell : function ( cellval , colpos, rwdat, cm, $t, etype){
var v;
if(cm.formatter !== undefined) {
var opts= {rowId: '', colModel:cm, gid: $t.p.id, pos:colpos, styleUI: '', isExported : true, exporttype : etype };
if($.isFunction( cm.formatter ) ) {
v = cm.formatter.call($t,cellval,opts,rwdat);
} else if($.fmatter){
v = $.fn.fmatter.call($t,cm.formatter,cellval,opts,rwdat);
} else {
v = cellval;
}
} else {
v = cellval;
}
return v;
},
formatCellCsv : function (v, p) {
v = v == null ? '' : String(v);
try {
v = $.jgrid.stripHtml( v.replace(p._regexsep ,p.separatorReplace).replace(/\r\n/g, p.replaceNewLine).replace(/\n/g, p.replaceNewLine));
} catch (_e) {
v="";
}
if(p.escquote) {
v = v.replace(p._regexquot, p.escquote + p.quote);
}
if( v.indexOf(p.separator) === -1 || v.indexOf(p.qoute) === -1) {
v = p.quote + v + p.quote;
}
return v;
},
excelCellPos : function ( n ){
var ordA = 'A'.charCodeAt(0),
ordZ = 'Z'.charCodeAt(0),
len = ordZ - ordA + 1,
s = "";
while( n >= 0 ) {
s = String.fromCharCode(n % len + ordA) + s;
n = Math.floor(n / len) - 1;
}
return s;
},
makeNode : function ( root, elemName, options ) {
var currNode = root.createElement( elemName );
if ( options ) {
if ( options.attr ) {
$(currNode).attr( options.attr );
}
if( options.children ) {
$.each( options.children, function ( key, value ) {
currNode.appendChild( value );
});
}
if( options.hasOwnProperty('text') ) {
currNode.appendChild( root.createTextNode( options.text ) );
}
}
return currNode;
},
xmlToZip : function ( zip, obj ) {
var $t = this,
xmlserialiser = new XMLSerializer(),
// IE >= 9
ieExcel = xmlserialiser.serializeToString(
$.parseXML( $.jgrid.excelStrings['xl/worksheets/sheet1.xml'] ) )
.indexOf( 'xmlns:r' ) === -1,
newDir, worksheet, i, ien, attr, attrs = [], str;
$.each( obj, function ( name, val ) {
if ( $.isPlainObject( val ) ) {
newDir = zip.folder( name );
$t.xmlToZip( newDir, val );
} else {
if ( ieExcel ) {
worksheet = val.childNodes[0];
for ( i=worksheet.attributes.length-1 ; i>=0 ; i-- ) {
var attrName = worksheet.attributes[i].nodeName;
var attrValue = worksheet.attributes[i].nodeValue;
if ( attrName.indexOf( ':' ) !== -1 ) {
attrs.push( { name: attrName, value: attrValue } );
worksheet.removeAttribute( attrName );
}
}
for ( i=0, ien=attrs.length ; i<ien ; i++ ) {
attr = val.createAttribute( attrs[i].name.replace( ':', '_dt_b_namespace_token_' ) );
attr.value = attrs[i].value;
worksheet.setAttributeNode( attr );
}
}
// suuport of all browsers
str = xmlserialiser.serializeToString(val);
// Fix IE's XML
if ( ieExcel ) {
if ( str.indexOf( '<?xml' ) === -1 ) {
str = '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'+str;
}
str = str.replace( /_dt_b_namespace_token_/g, ':' );
}
str = str
.replace( /<row xmlns="" /g, '<row ' )
.replace( /<cols xmlns="">/g, '<cols>' )
.replace( /<mergeCells xmlns="" /g, '<mergeCells ' )
.replace( /<numFmt xmlns="" /g, '<numFmt ' )
.replace( /<xf xmlns="" /g, '<xf ' );
zip.file( name, str );
}
} );
},
excelStrings : {
"_rels/.rels":
'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'+
'<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'+
'<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>'+
'</Relationships>',
"xl/_rels/workbook.xml.rels":
'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'+
'<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">'+
'<Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/>'+
'<Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>'+
'</Relationships>',
"[Content_Types].xml":
'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'+
'<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">'+
'<Default Extension="xml" ContentType="application/xml" />'+
'<Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml" />'+
'<Default Extension="jpeg" ContentType="image/jpeg" />'+
'<Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml" />'+
'<Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" />'+
'<Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml" />'+
'</Types>',
"xl/workbook.xml":
'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'+
'<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">'+
'<fileVersion appName="xl" lastEdited="5" lowestEdited="5" rupBuild="24816"/>'+
'<workbookPr showInkAnnotation="0" autoCompressPictures="0"/>'+
'<bookViews>'+
'<workbookView xWindow="0" yWindow="0" windowWidth="25600" windowHeight="19020" tabRatio="500"/>'+
'</bookViews>'+
'<sheets>'+
'<sheet name="Sheet1" sheetId="1" r:id="rId1"/>'+
'</sheets>'+
'</workbook>',
"xl/worksheets/sheet1.xml":
'<?xml version="1.0" encoding="UTF-8" standalone="yes"?>'+
'<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="x14ac" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac">'+
'<sheetData/>'+
'</worksheet>',
"xl/styles.xml":
'<?xml version="1.0" encoding="UTF-8"?>'+
'<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" mc:Ignorable="x14ac" xmlns:x14ac="http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac">'+
'<numFmts count="7">'+
'<numFmt numFmtId="164" formatCode="#,##0.00_-\ [$$-45C]"/>'+
'<numFmt numFmtId="165" formatCode=""£"#,##0.00"/>'+
'<numFmt numFmtId="166" formatCode="[$€-2]\ #,##0.00"/>'+
'<numFmt numFmtId="167" formatCode="0.0%"/>'+
'<numFmt numFmtId="168" formatCode="#,##0;(#,##0)"/>'+
'<numFmt numFmtId="169" formatCode="#,##0.00;(#,##0.00)"/>'+
'<numFmt numFmtId="170" formatCode="yyyy/mm/dd;@"/>'+
'</numFmts>'+
'<fonts count="5" x14ac:knownFonts="1">'+
'<font>'+
'<sz val="11" />'+
'<name val="Calibri" />'+
'</font>'+
'<font>'+
'<sz val="11" />'+
'<name val="Calibri" />'+
'<color rgb="FFFFFFFF" />'+
'</font>'+
'<font>'+
'<sz val="11" />'+
'<name val="Calibri" />'+
'<b />'+
'</font>'+
'<font>'+
'<sz val="11" />'+
'<name val="Calibri" />'+
'<i />'+
'</font>'+
'<font>'+
'<sz val="11" />'+
'<name val="Calibri" />'+
'<u />'+
'</font>'+
'</fonts>'+
'<fills count="6">'+
'<fill>'+
'<patternFill patternType="none" />'+
'</fill>'+
'<fill/>'+
'<fill>'+
'<patternFill patternType="solid">'+
'<fgColor rgb="FFD9D9D9" />'+
'<bgColor indexed="64" />'+
'</patternFill>'+
'</fill>'+
'<fill>'+
'<patternFill patternType="solid">'+
'<fgColor rgb="FFD99795" />'+
'<bgColor indexed="64" />'+
'</patternFill>'+
'</fill>'+
'<fill>'+
'<patternFill patternType="solid">'+
'<fgColor rgb="ffc6efce" />'+
'<bgColor indexed="64" />'+
'</patternFill>'+
'</fill>'+
'<fill>'+
'<patternFill patternType="solid">'+
'<fgColor rgb="ffc6cfef" />'+
'<bgColor indexed="64" />'+
'</patternFill>'+
'</fill>'+
'</fills>'+
'<borders count="2">'+
'<border>'+
'<left />'+
'<right />'+
'<top />'+
'<bottom />'+
'<diagonal />'+
'</border>'+
'<border diagonalUp="false" diagonalDown="false">'+
'<left style="thin">'+
'<color auto="1" />'+
'</left>'+
'<right style="thin">'+
'<color auto="1" />'+
'</right>'+
'<top style="thin">'+
'<color auto="1" />'+
'</top>'+
'<bottom style="thin">'+
'<color auto="1" />'+
'</bottom>'+
'<diagonal />'+
'</border>'+
'</borders>'+
'<cellStyleXfs count="1">'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" />'+
'</cellStyleXfs>'+
'<cellXfs count="67">'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="2" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="2" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="2" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="2" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="2" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="3" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="3" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="3" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="3" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="3" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="4" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="4" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="4" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="4" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="4" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="5" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="5" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="5" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="5" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="5" borderId="0" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="0" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="0" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="0" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="0" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="2" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="2" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="2" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="2" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="2" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="3" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="3" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="3" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="3" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="3" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="4" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="4" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="4" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="4" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="4" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="5" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="1" fillId="5" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="2" fillId="5" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="3" fillId="5" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="4" fillId="5" borderId="1" applyFont="1" applyFill="1" applyBorder="1"/>'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyAlignment="1">'+
'<alignment horizontal="left"/>'+
'</xf>'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyAlignment="1">'+
'<alignment horizontal="center"/>'+
'</xf>'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyAlignment="1">'+
'<alignment horizontal="right"/>'+
'</xf>'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyAlignment="1">'+
'<alignment horizontal="fill"/>'+
'</xf>'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyAlignment="1">'+
'<alignment textRotation="90"/>'+
'</xf>'+
'<xf numFmtId="0" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyAlignment="1">'+
'<alignment wrapText="1"/>'+
'</xf>'+
'<xf numFmtId="9" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="164" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="165" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="166" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="167" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="168" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="169" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="3" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="4" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="1" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="2" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'<xf numFmtId="170" fontId="0" fillId="0" borderId="0" applyFont="1" applyFill="1" applyBorder="1" xfId="0" applyNumberFormat="1"/>'+
'</cellXfs>'+
'<cellStyles count="1">'+
'<cellStyle name="Normal" xfId="0" builtinId="0" />'+
'</cellStyles>'+
'<dxfs count="0" />'+
'<tableStyles count="0" defaultTableStyle="TableStyleMedium9" defaultPivotStyle="PivotStyleMedium4" />'+
'</styleSheet>'
},
excelParsers : [
{ match: /^\-?\d+\.\d%$/, style: 60, fmt: function (d) { return d/100; } }, // Precent with d.p.
{ match: /^\-?\d+\.?\d*%$/, style: 56, fmt: function (d) { return d/100; } }, // Percent
{ match: /^\-?\$[\d,]+.?\d*$/, style: 57 }, // Dollars
{ match: /^\-?£[\d,]+.?\d*$/, style: 58 }, // Pounds
{ match: /^\-?€[\d,]+.?\d*$/, style: 59 }, // Euros
{ match: /^\-?\d+$/, style: 65 }, // Numbers without thousand separators
{ match: /^\-?\d+\.\d{2}$/, style: 66 }, // Numbers 2 d.p. without thousands separators
{ match: /^\([\d,]+\)$/, style: 61, fmt: function (d) { return -1 * d.replace(/[\(\)]/g, ''); } }, // Negative numbers indicated by brackets
{ match: /^\([\d,]+\.\d{2}\)$/, style: 62, fmt: function (d) { return -1 * d.replace(/[\(\)]/g, ''); } }, // Negative numbers indicated by brackets - 2d.p.
{ match: /^\-?[\d,]+$/, style: 63 }, // Numbers with thousand separators
{ match: /^\-?[\d,]+\.\d{2}$/, style: 64 }, // Numbers with 2 d.p. and thousands separators
{ match: /^\d{4}\-\d{2}\-\d{2}$/, style: 67 }, // Dates
{ match: /(https?:\/\/(?:www\.|(?!www))[^\s\.]+\.[^\s]{2,}|www\.[^\s]+\.[^\s]{2,})/gi, style : 4} // hyperlink
]
});
/********************************************************************
*
* due to speed, every export method will have separate module
* to collect grouped data
*
*********************************************************************/
$.jgrid.extend({
exportToCsv : function ( p ) {
p = $.extend(true, {
separator: ",",
separatorReplace : " ",
quote : '"',
escquote : '"',
newLine : "\r\n", // navigator.userAgent.match(/Windows/) ? '\r\n' : '\n';
replaceNewLine : " ",
includeCaption : true,
includeLabels : true,
includeGroupHeader : true,
includeFooter: true,
includeHeader: true,
fileName : "jqGridExport.csv",
mimetype : "text/csv;charset=utf-8",
returnAsString : false,
onBeforeExport : null,
treeindent : ' ',
loadIndicator : true // can be a function
}, p || {});
var ret ="";
this.each(function(){
p._regexsep = new RegExp(p.separator, "g");
p._regexquot = new RegExp(p.quote, "g");
var $t = this,
// get the filtered data
data1 = $t.p.treeGrid ? $($t).jqGrid('getRowData', null, true, p.treeindent) : $t.addLocalData( true ), //this.addLocalData( true ),
dlen = data1.length,
cm = $t.p.colModel,
cmlen = cm.length,
clbl = $t.p.colNames,
i, j=0, row, str = '' , tmp, k,
cap = "", hdr = "", ftr="", lbl="", albl=[], htr="";
function groupToCsv (grdata, p) {
var str="",
grp = $t.p.groupingView,
cp=[], len =grp.groupField.length,
cm = $t.p.colModel,
colspans = cm.length,
toEnd = 0;
$.each(cm, function (i,n){
var ii;
for(ii=0;ii<len;ii++) {
if(grp.groupField[ii] === n.name ) {
cp[ii] = i;
break;
}
}
});
function findGroupIdx( ind , offset, grp) {
var ret = false, i;
if(offset===0) {
ret = grp[ind];
} else {
var id = grp[ind].idx;
if(id===0) {
ret = grp[ind];
} else {
for(i=ind;i >= 0; i--) {
if(grp[i].idx === id-offset) {
ret = grp[i];
break;
}
}
}
}
return ret;
}
function buildSummaryTd(i, ik, grp, foffset) {
var fdata = findGroupIdx(i, ik, grp),
//cm = $t.p.colModel,
vv, grlen = fdata.cnt, k, retarr= new Array(p.collen), j=0;
for(k=foffset; k<colspans;k++) {
if(!cm[k]._excol) {
continue;
}
var tplfld = "{0}";
$.each(fdata.summary,function(){
if(this.nm === cm[k].name) {
if(cm[k].summaryTpl) {
tplfld = cm[k].summaryTpl;
}
if(typeof this.st === 'string' && this.st.toLowerCase() === 'avg') {
if(this.sd && this.vd) {
this.v = (this.v/this.vd);
} else if(this.v && grlen > 0) {
this.v = (this.v/grlen);
}
}
try {
this.groupCount = fdata.cnt;
this.groupIndex = fdata.dataIndex;
this.groupValue = fdata.value;
//vv = $t.formatter('', this.v, k, this);
vv = this.v;
} catch (ef) {
vv = this.v;
}
retarr[j] =
$.jgrid.formatCellCsv(
$.jgrid.stripHtml(
$.jgrid.template(tplfld,vv)
), p ) ;
return false;
}
});
j++;
}
return retarr;
}
var sumreverse = $.makeArray(grp.groupSummary), gv, k;
sumreverse.reverse();
if($t.p.datatype === 'local' && !$t.p.loadonce) {
$($t).jqGrid('groupingSetup');
var groupingPrepare = $.jgrid.getMethod("groupingPrepare");
for(var ll=0; ll < dlen; ll++) {
groupingPrepare.call($($t), data1[ll], ll);
}
}
$.each(grp.groups,function(i,n){
toEnd++;
try {
if ($.isArray(grp.formatDisplayField) && $.isFunction(grp.formatDisplayField[n.idx])) {
gv = grp.formatDisplayField[n.idx].call($t, n.displayValue, n.value, $t.p.colModel[cp[n.idx]], n.idx, grp);
} else {
gv = $t.formatter('', n.displayValue, cp[n.idx], n.value );
}
} catch (egv) {
gv = n.displayValue;
}
var grpTextStr = '';
if($.isFunction(grp.groupText[n.idx])) {
grpTextStr = grp.groupText[n.idx].call($t, gv, n.cnt, n.summary);
} else {
grpTextStr = $.jgrid.template(grp.groupText[n.idx], gv, n.cnt, n.summary);
}
if( !(typeof grpTextStr ==='string' || typeof grpTextStr ==='number' ) ) {
grpTextStr = gv;
}
var arr;
if(grp.groupSummaryPos[n.idx] === 'header') {
arr = buildSummaryTd(i, 0, grp.groups, 0 /*grp.groupColumnShow[n.idx] === false ? (mul ==="" ? 2 : 3) : ((mul ==="") ? 1 : 2)*/ );
} else {
arr = new Array(p.collen);
}
arr[0] = $.jgrid.formatCellCsv( $.jgrid.stripHtml( grpTextStr ), p);
str += arr.join( p.separator ) + p.newLine;
var leaf = len-1 === n.idx;
if( leaf ) {
var gg = grp.groups[i+1], kk, ik, offset = 0, sgr = n.startRow, to,
end = gg !== undefined ? gg.startRow : grp.groups[i].startRow + grp.groups[i].cnt;
for(kk=sgr;kk<end;kk++) {
if(!grdata[kk - offset]) { break; }
to = grdata[kk - offset];
k = 0;
for(ik = 0; ik < cm.length; ik++) {
if(cm[ik]._expcol) {
arr[k] = $.jgrid.formatCellCsv(
$.jgrid.formatCell( $.jgrid.getAccessor(to, cm[ik].name), ik, to, cm[ik], $t, 'csv' ) , p);
k++;
}
}
str += arr.join( p.separator ) + p.newLine;
}
if(grp.groupSummaryPos[n.idx] !== 'header') {
var jj;
if (gg !== undefined) {
for (jj = 0; jj < grp.groupField.length; jj++) {
if (gg.dataIndex === grp.groupField[jj]) {
break;
}
}
toEnd = grp.groupField.length - jj;
}
for (ik = 0; ik < toEnd; ik++) {
if(!sumreverse[ik]) { continue; }
arr = buildSummaryTd(i, ik, grp.groups, 0);
str += arr.join( p.separator ) + p.newLine;
}
toEnd = jj;
}
}
});
return str;
}
if( $.isFunction( p.loadIndicator )) {
p.loadIndicator('show');
} else if(p.loadIndicator) {
$($t).jqGrid("progressBar", {method:"show", loadtype : $t.p.loadui, htmlcontent: $.jgrid.getRegional($t,'defaults.loadtext') });
}
// end group function
var def = [], key;
$.each(cm,function(i,n) {
n._expcol = true;
if(n.exportcol === undefined) {
if(n.hidden) {
n._expcol = false;
}
} else {
n._expcol = n.exportcol;
}
if(n.name === 'cb' || n.name === 'rn' || n.name === 'subgrid') {
n._expcol = false;
}
if(n._expcol) {
albl.push( $.jgrid.formatCellCsv( clbl[i], p) );
def.push( n.name ); // clbl[i];
}
});
if(p.includeLabels) {
lbl = albl.join( p.separator ) + p.newLine;
}
p.collen = albl.length;
if( $t.p.grouping ) {
var savlcgr = $t.p.groupingView._locgr ? true : false;
$t.p.groupingView._locgr = false;
str += groupToCsv(data1, p);
$t.p.groupingView._locgr = savlcgr;
} else {
while(j < dlen) {
row = data1[j];
tmp = [];
k =0;
for(i = 0; i < cmlen; i++) {
if(cm[i]._expcol) {
tmp[k] = $.jgrid.formatCellCsv( $.jgrid.formatCell( $.jgrid.getAccessor(row, cm[i].name) , i, row, cm[i], $t, 'csv' ), p );
k++;
}
}
str += tmp.join( p.separator ) + p.newLine;
j++;
}
}
data1 = null; // free
// get the column length.
tmp = new Array(p.collen);
if(p.includeCaption && $t.p.caption) {
j=p.collen;
while(--j) {tmp[j]="";}
tmp[0] = $.jgrid.formatCellCsv( $t.p.caption, p );
cap += tmp.join( p.separator ) + p.newLine;
}
if(p.includeGroupHeader && $($t).jqGrid('isGroupHeaderOn')) {
var gh = $t.p.groupHeader;
for (i=0;i < gh.length; i++) {
var ghdata = gh[i].groupHeaders;
j = 0; tmp = [];
for(key=0; key<def.length; key++ ) {
//if(!def.hasOwnProperty( key )) {
// continue;
//}
tmp[j] = '';
for(k=0;k<ghdata.length;k++) {
if(ghdata[k].startColumnName === def[key]) {
tmp[j]= $.jgrid.formatCellCsv( ghdata[k].titleText, p);
}
}
j++;
}
hdr += tmp.join( p.separator ) + p.newLine;
}
}
if(p.includeFooter && $t.p.footerrow) {
// already formated
var foot = $(".ui-jqgrid-ftable", this.sDiv);
if(foot.length) {
var frows = $($t).jqGrid('footerData', 'get');
i=0; tmp=[];
while(i < p.collen){
var fc = def[i];
if(frows.hasOwnProperty(fc) ) {
tmp.push( $.jgrid.formatCellCsv( $.jgrid.stripHtml( frows[fc] ), p ) );
}
i++;
}
ftr += tmp.join( p.separator ) + p.newLine;
}
}
if(p.includeHeader && $t.p.headerrow) {
var hrows = $($t).jqGrid('headerData', 'get');
i=0; tmp=[];
while(i < p.collen){
var hc = def[i];
if(hrows.hasOwnProperty(hc) ) {
tmp.push( $.jgrid.formatCellCsv( $.jgrid.stripHtml( hrows[hc] ), p ) );
}
i++;
}
htr += tmp.join( p.separator ) + p.newLine;
}
ret = cap + hdr + lbl + htr + str + ftr;
if( $.isFunction( p.loadIndicator )) {
p.loadIndicator('hide');
} else if(p.loadIndicator) {
$($t).jqGrid("progressBar", {method:"hide", loadtype : $t.p.loadui });
}
});
if (p.returnAsString) {
return ret;
} else {
// add BOM fix Excel
if(p.mimetype.toUpperCase().indexOf("UTF-8") !== -1) {
ret = '\ufeff' + ret;
}
if($.isFunction( p.onBeforeExport) ) {
ret = p.onBeforeExport(ret);
if(!ret) {
throw "Before export does not return data!";
}
}
$.jgrid.saveAs( ret, p.fileName, { type : p.mimetype });
}
},
/*
*
* @param object o - settings for the export
* @returns excel 2007 document
* The method requiere jsZip lib in order to create excel document
*/
exportToExcel : function ( o ) {
o = $.extend(true, {
includeLabels : true,
includeGroupHeader : true,
includeFooter: true,
includeHeader: true,
fileName : "jqGridExport.xlsx",
mimetype : "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
maxlength : 40, // maxlength for visible string data
onBeforeExport : null,
replaceStr : null,
treeindent : ' ',
loadIndicator : true // can be a function
}, o || {} );
this.each(function() {
var $t = this,
es = $.jgrid.excelStrings,
rowPos = 0,
rels = $.parseXML( es['xl/worksheets/sheet1.xml']),
relsGet = rels.getElementsByTagName( "sheetData" )[0],
styleSh = $.parseXML( es['xl/styles.xml']), //xlsx.xl["styles.xml"];
formats = styleSh.getElementsByTagName("numFmts")[0],
fmnt = $(formats.getElementsByTagName("numFmt")),
celsX = styleSh.getElementsByTagName("cellXfs")[0],
xlsx = {
_rels: {
".rels": $.parseXML( es['_rels/.rels'])
},
xl: {
_rels: {
"workbook.xml.rels": $.parseXML( es['xl/_rels/workbook.xml.rels'])
},
"workbook.xml": $.parseXML( es['xl/workbook.xml']),
"styles.xml": styleSh, //$.parseXML( es['xl/styles.xml']),
"worksheets": {
"sheet1.xml": rels
}
},
"[Content_Types].xml": $.parseXML( es['[Content_Types].xml'])
},
cm = $t.p.colModel,
i=0, j, ien,
data = {
body : $t.p.treeGrid ? $($t).jqGrid('getRowData', null, true, o.treeindent) : $t.addLocalData( true ),
header : [],
footer : [],
width : [],
map : [],
parser :[]
};
var addStyle = function ( eo ) {
if( $.isEmptyObject( eo )) {
eo.excel_parsers = true;
} else if( eo.excel_format && !eo.excel_style){
// add the sformatter
var count = 0,
maxfmtid =0;
$.each(fmnt, function(i,n) {
count++;
maxfmtid = Math.max(maxfmtid, parseInt( $(n).attr("numFmtId"), 10) );
});
var mycell = $.jgrid.makeNode( styleSh , "numFmt", {attr: {numFmtId : maxfmtid + 1, formatCode : eo.excel_format} });
formats.appendChild( mycell );
$(formats).attr("count", count + 1);
count = 0;
mycell = $.jgrid.makeNode( styleSh , "xf", { attr:{
numFmtId : maxfmtid + 1 +"",
fontId: "0",
fillId: "0",
borderId: "0",
applyFont:"1",
applyFill:"1",
applyBorder:"1",
xfId:"0",
applyNumberFormat:"1"
} });
celsX.appendChild( mycell );
count = parseInt( $(celsX).attr("count"), 10);
$(celsX).attr("count", count + 1);
eo.excel_style = count+1;
}
return eo;
};
for ( j=0, ien=cm.length ; j<ien ; j++ ) {
cm[j]._expcol = true;
if(cm[j].exportcol === undefined) {
if(cm[j].hidden) {
cm[j]._expcol = false;
}
} else {
cm[j]._expcol = cm[j].exportcol;
}
if( cm[j].name === 'cb' || cm[j].name === 'rn' || cm[j].name === 'subgrid' || !cm[j]._expcol) {
continue;
}
data.header[i] = cm[j].name;
data.width[ i ] = 5;
data.map[i] = j;
data.parser[j] = addStyle( cm[j].hasOwnProperty('exportoptions') ? cm[j].exportoptions : {} );
i++;
}
function _replStrFunc (v) {
return v.replace(/</g, '<')
.replace(/>/g, '>')
.replace(/[\x00-\x09\x0B\x0C\x0E-\x1F\x7F-\x9F]/g, '');
}
function _makeCellSpecial ( p, v ) {
return $.jgrid.makeNode(
rels,
'c',
{
attr: p,
children: [ $.jgrid.makeNode( rels, 'v', { text: v } ) ]
});
}
function _makeCellFunction ( p, v ) {
return $.jgrid.makeNode(
rels,
'c',
{
attr: p,
children: [ $.jgrid.makeNode( rels, 'f', { text: v } ) ]
});
}
function _makeCellString ( cellId, text ) {
return $.jgrid.makeNode(
rels,
'c',
{
attr: { t: 'inlineStr', r: cellId },
children:{ row: $.jgrid.makeNode( rels, 'is',
{
children: {
row: $.jgrid.makeNode( rels, 't', { text: text} )
}
})
}
} );
}
function linkParse(strLinkHTML) {
var oDiv, oNode;
(oDiv = document.createElement('div')).innerHTML = strLinkHTML;
var oNode = oDiv.firstChild;
if(oNode.nodeName === 'A' ) {
return [oNode.href,oNode.text];
} else if (oNode.nodeName === '#text') {
return [oNode.textContent,oNode.textContent];
}
return false;
}
var _replStr = $.isFunction(o.replaceStr) ? o.replaceStr : _replStrFunc,
currentRow, rowNode,
addRow = function ( row, header ) {
currentRow = rowPos+1;
rowNode = $.jgrid.makeNode( rels, "row", { attr: {r:currentRow} } );
var maxieenum = 15, text;
for ( var i =0; i < data.header.length; i++) {
// key = cm[i].name;
// Concat both the Cell Columns as a letter and the Row of the cell.
var cellId = $.jgrid.excelCellPos(i) + '' + currentRow,
cell,
match,
v= ($.isArray(row) && header) ? $t.p.colNames[data.map[i]] : $.jgrid.getAccessor( row, data.header[i] );
if ( v == null ) {
v = '';
}
if(!header) {
v = $.jgrid.formatCell( v, data.map[i], row, cm[data.map[i]], $t, 'excel');
}
data.width[i] = Math.max(data.width[i], Math.min(parseInt(v.toString().length,10), o.maxlength) );
cell = null;
var expo = data.parser[data.map[i]];
if( expo.excel_parsers === true ) {
for ( var j=0, jen=$.jgrid.excelParsers.length ; j<jen ; j++ ) {
var special = $.jgrid.excelParsers[j];
if ( v.match && ! v.match(/^0\d+/) && v.match( special.match ) ) {
var a = v;
v = v.replace(/[^\d\.\-]/g, '');
if ( special.fmt ) {
v = special.fmt( v );
}
if(special.style === 67) { //Dates
cell = _makeCellSpecial( { t: 'd', r: cellId, s: special.style }, v);
} else if(special.style === 4) { // hyperlink
v = linkParse (a);
if(v) {
cell = _makeCellFunction( { t: 'str', r: cellId, s: special.style }, 'HYPERLINK(\"'+v[0]+'\",\"'+v[1]+'\")');
} else {
cell = _makeCellString( cellId, a);
}
} else {
if( $.inArray( special.style, ["63", "64", "65", "66"]) ) { // Numbers
if( v.toString().length > maxieenum ) {
text = ! a.replace ? a : _replStr(a);
cell = _makeCellString( cellId, text);
rowNode.appendChild( cell );
break;
}
}
cell = _makeCellSpecial( {r: cellId,s: special.style}, v );
}
rowNode.appendChild( cell );
break;
}
}
} else if( expo.excel_format !== undefined && expo.excel_style !== undefined && !header && !cell) {
if(expo.replace_format) {
v = expo.replace_format(v);
}
cell = _makeCellSpecial( {r: cellId,s: expo.excel_style}, v );
rowNode.appendChild( cell );
}
if( ! cell ) {
// Detect numbers - don't match numbers with leading zeros or a negative
if(v.match) {
match = v.match(/^-?([1-9]\d+)(\.(\d+))?$/);
}
if ( (typeof v === 'number' && v.toString().length <= maxieenum) || (
match &&
(match[1].length + (match[2] ? match[3].length : 0) <= maxieenum))
) {
cell = _makeCellSpecial( {t: 'n', r: cellId }, v );
} else {
// Replace non standard characters for text output
text = ! v.replace ? v : _replStr(v);
cell = _makeCellString( cellId, text);
}
rowNode.appendChild( cell );
}
}
relsGet.appendChild(rowNode);
rowPos++;
};
//=========================================================================
function groupToExcel ( grdata ) {
var grp = $t.p.groupingView,
cp=[], len =grp.groupField.length,
colspans = cm.length,
toEnd = 0;
$.each(cm, function (i,n){
var ii;
for(ii=0;ii<len;ii++) {
if(grp.groupField[ii] === n.name ) {
cp[ii] = i;
break;
}
}
});
function findGroupIdx( ind , offset, grp) {
var ret = false, i;
if(offset===0) {
ret = grp[ind];
} else {
var id = grp[ind].idx;
if(id===0) {
ret = grp[ind];
} else {
for(i=ind;i >= 0; i--) {
if(grp[i].idx === id-offset) {
ret = grp[i];
break;
}
}
}
}
return ret;
}
function buildSummaryTd(i, ik, grp, foffset) {
var fdata = findGroupIdx(i, ik, grp),
//cm = $t.p.colModel,
vv, grlen = fdata.cnt, k, retarr = emptyData(data.header);
for(k=foffset; k<colspans;k++) {
if(!cm[k]._expcol) {
continue;
}
var tplfld = "{0}";
$.each(fdata.summary,function(){
if(this.nm === cm[k].name) {
if(cm[k].summaryTpl) {
tplfld = cm[k].summaryTpl;
}
if(typeof this.st === 'string' && this.st.toLowerCase() === 'avg') {
if(this.sd && this.vd) {
this.v = (this.v/this.vd);
} else if(this.v && grlen > 0) {
this.v = (this.v/grlen);
}
}
try {
this.groupCount = fdata.cnt;
this.groupIndex = fdata.dataIndex;
this.groupValue = fdata.value;
//vv = $t.formatter('', this.v, k, this);
vv = this.v;
} catch (ef) {
vv = this.v;
}
retarr[this.nm] = $.jgrid.stripHtml( $.jgrid.template(tplfld,vv) );
return false;
}
});
}
return retarr;
}
function emptyData ( d ) {
var clone = {};
for(var key=0;key<d.length; key++ ) {
clone[ d[key] ] = "";
}
return clone;
}
var sumreverse = $.makeArray(grp.groupSummary), gv;
sumreverse.reverse();
if($t.p.datatype === 'local' && !$t.p.loadonce) {
$($t).jqGrid('groupingSetup');
var groupingPrepare = $.jgrid.getMethod("groupingPrepare");
for(var ll=0; ll < data.body.length; ll++) {
groupingPrepare.call($($t), data.body[ll], ll);
}
}
$.each(grp.groups,function(i,n){
toEnd++;
try {
if ($.isArray(grp.formatDisplayField) && $.isFunction(grp.formatDisplayField[n.idx])) {
gv = grp.formatDisplayField[n.idx].call($t, n.displayValue, n.value, $t.p.colModel[cp[n.idx]], n.idx, grp);
} else {
gv = $t.formatter('', n.displayValue, cp[n.idx], n.value );
}
} catch (egv) {
gv = n.displayValue;
}
var grpTextStr = '';
if($.isFunction(grp.groupText[n.idx])) {
grpTextStr = grp.groupText[n.idx].call($t, gv, n.cnt, n.summary);
} else {
grpTextStr = $.jgrid.template(grp.groupText[n.idx], gv, n.cnt, n.summary);
}
if( !(typeof grpTextStr ==='string' || typeof grpTextStr ==='number' ) ) {
grpTextStr = gv;
}
var arr;
if(grp.groupSummaryPos[n.idx] === 'header') {
arr = buildSummaryTd(i, 0, grp.groups, 0 /*grp.groupColumnShow[n.idx] === false ? (mul ==="" ? 2 : 3) : ((mul ==="") ? 1 : 2)*/ );
} else {
arr = emptyData(data.header);
}
var fkey = Object.keys(arr);
arr[fkey[0]] = $.jgrid.stripHtml( new Array(n.idx*5).join(' ') + grpTextStr );
addRow( arr, false );
var leaf = len-1 === n.idx;
if( leaf ) {
var gg = grp.groups[i+1], kk, ik, offset = 0, sgr = n.startRow,
end = gg !== undefined ? gg.startRow : grp.groups[i].startRow + grp.groups[i].cnt;
for(kk=sgr;kk<end;kk++) {
if(!grdata[kk - offset]) { break; }
var to = grdata[kk - offset];
addRow( to, false );
}
if(grp.groupSummaryPos[n.idx] !== 'header') {
var jj;
if (gg !== undefined) {
for (jj = 0; jj < grp.groupField.length; jj++) {
if (gg.dataIndex === grp.groupField[jj]) {
break;
}
}
toEnd = grp.groupField.length - jj;
}
for (ik = 0; ik < toEnd; ik++) {
if(!sumreverse[ik]) { continue; }
arr = buildSummaryTd(i, ik, grp.groups, 0);
addRow( arr, false );
}
toEnd = jj;
}
}
});
}
//============================================================================
if( $.isFunction( o.loadIndicator )) {
o.loadIndicator('show');
} else if(o.loadIndicator) {
$($t).jqGrid("progressBar", {method:"show", loadtype : $t.p.loadui, htmlcontent: $.jgrid.getRegional($t,'defaults.loadtext') });
}
$( 'sheets sheet', xlsx.xl['workbook.xml'] ).attr( 'name', o.sheetName );
if(o.includeGroupHeader && $($t).jqGrid('isGroupHeaderOn') ) {
var gh = $t.p.groupHeader, mergecell=[],
mrow = 0, key, l;
for (l = 0; l < gh.length; l++) {
var ghdata = gh[l].groupHeaders, clone ={};
mrow++; j=0;
for(j = 0; j < data.header.length; j++ ) {
key = data.header[j];
clone[key] = "";
for(var k = 0; k < ghdata.length; k++) {
if(ghdata[k].startColumnName === key) {
clone[key] = ghdata[k].titleText;
var start = $.jgrid.excelCellPos(j) + mrow,
end = $.jgrid.excelCellPos(j+ghdata[k].numberOfColumns -1) + mrow;
mergecell.push({ ref: start+":"+end });
}
}
}
addRow( clone, true );
}
$('row c', rels).attr( 's', '2' ); // bold
var merge = $.jgrid.makeNode( rels, 'mergeCells', {
attr : {
count : mergecell.length
}
});
$('worksheet', rels).append( merge );
for(i=0;i<mergecell.length;i++) {
merge.appendChild($.jgrid.makeNode(rels, 'mergeCell',{
attr: mergecell[i]
}));
}
}
if ( o.includeLabels ) {
addRow( data.header, true );
$('row:last c', rels).attr( 's', '2' ); // bold
}
if ( o.includeHeader || $t.p.headerrow) {
var hdata = $($t).jqGrid('headerData', 'get');
for( i in hdata) {
if(hdata.hasOwnProperty(i)) {
hdata[i] = $.jgrid.stripHtml(hdata[i]);
}
}
if(!$.isEmptyObject(hdata)) {
addRow( hdata, true );
$('row:last c', rels).attr( 's', '2' ); // bold
}
}
if( $t.p.grouping ) {
var savlcgr = $t.p.groupingView._locgr ? true : false;
$t.p.groupingView._locgr = false;
groupToExcel(data.body);
$t.p.groupingView._locgr = savlcgr;
} else {
for ( var n=0, ie=data.body.length ; n<ie ; n++ ) {
addRow( data.body[n], false );
}
}
if ( o.includeFooter || $t.p.footerrow) {
data.footer = $($t).jqGrid('footerData', 'get');
for( i in data.footer) {
if(data.footer.hasOwnProperty(i)) {
data.footer[i] = $.jgrid.stripHtml(data.footer[i]);
}
}
if(!$.isEmptyObject(data.footer)) {
addRow( data.footer, true );
$('row:last c', rels).attr( 's', '2' ); // bold
}
}
// Set column widths
var cols = $.jgrid.makeNode( rels, 'cols' );
$('worksheet', rels).prepend( cols );
for ( i=0, ien=data.width.length ; i<ien ; i++ ) {
cols.appendChild( $.jgrid.makeNode( rels, 'col', {
attr: {
min: i+1,
max: i+1,
width: data.width[i],
customWidth: 1
}
} ) );
}
if($.isFunction( o.onBeforeExport) ) {
o.onBeforeExport( xlsx, rowPos );
}
data = null; // free memory
try {
var zip = new JSZip();
var zipConfig = {
type: 'blob',
mimeType: o.mimetype
};
$.jgrid.xmlToZip( zip, xlsx );
if ( zip.generateAsync ) {
// JSZip 3+
zip.generateAsync( zipConfig )
.then( function ( blob ) {
$.jgrid.saveAs( blob, o.fileName, { type : o.mimetype } );
});
} else {
// JSZip 2.5
$.jgrid.saveAs( zip.generate( zipConfig ), o.fileName, { type : o.mimetype } ); }
} catch(e) {
throw e;
} finally {
if( $.isFunction( o.loadIndicator )) {
o.loadIndicator('hide');
} else if(o.loadIndicator) {
$($t).jqGrid("progressBar", {method:"hide", loadtype : $t.p.loadui });
}
}
});
},
exportToPdf : function (o) {
o = $.extend(true,{
title: null,
orientation: 'portrait',
pageSize: 'A4',
description: null,
onBeforeExport: null,
download: 'download',
includeLabels : true,
includeGroupHeader : true,
includeFooter : true,
includeHeader : true,
fileName : "jqGridExport.pdf",
mimetype : "application/pdf",
treeindent : "-",
loadIndicator : true // can be a function
}, o || {} );
return this.each(function() {
var $t = this, rows = [], j, cm = $t.p.colModel, ien, obj = {}, key,
data = $t.p.treeGrid ? $($t).jqGrid('getRowData', null, true, o.treeindent) : $t.addLocalData( true ), def = [], i=0, map=[], test=[], widths = [], align={};
// Group function
function groupToPdf ( grdata ) {
var grp = $t.p.groupingView,
cp=[], len =grp.groupField.length,
cm = $t.p.colModel,
colspans = cm.length,
toEnd = 0;
$.each(cm, function (i,n){
var ii;
for(ii=0;ii<len;ii++) {
if(grp.groupField[ii] === n.name ) {
cp[ii] = i;
break;
}
}
});
function constructRow( row, fmt ) {
var k =0, test=[];
//row = data[i];
for( var key=0; key < def.length; key++ ) {
obj = {
text: row[def[key]] == null ? '' : (fmt ? $.jgrid.formatCell( row[def[key]] + '', map[k], data[i], cm[map[k]], $t, 'pdf') : row[def[key]]),
alignment : align[key],
style : 'tableBody'
};
test.push(obj);
k++;
}
return test;
}
function findGroupIdx( ind , offset, grp) {
var ret = false, i;
if(offset===0) {
ret = grp[ind];
} else {
var id = grp[ind].idx;
if(id===0) {
ret = grp[ind];
} else {
for(i=ind;i >= 0; i--) {
if(grp[i].idx === id-offset) {
ret = grp[i];
break;
}
}
}
}
return ret;
}
function buildSummaryTd(i, ik, grp, foffset) {
var fdata = findGroupIdx(i, ik, grp),
//cm = $t.p.colModel,
vv, grlen = fdata.cnt, k, retarr = emptyData(def);
for(k=foffset; k<colspans;k++) {
if(!cm[k]._expcol) {
continue;
}
var tplfld = "{0}";
$.each(fdata.summary,function(){
if(this.nm === cm[k].name) {
if(cm[k].summaryTpl) {
tplfld = cm[k].summaryTpl;
}
if(typeof this.st === 'string' && this.st.toLowerCase() === 'avg') {
if(this.sd && this.vd) {
this.v = (this.v/this.vd);
} else if(this.v && grlen > 0) {
this.v = (this.v/grlen);
}
}
try {
this.groupCount = fdata.cnt;
this.groupIndex = fdata.dataIndex;
this.groupValue = fdata.value;
//vv = $t.formatter('', this.v, k, this);
vv = this.v;
} catch (ef) {
vv = this.v;
}
retarr[this.nm] = $.jgrid.stripHtml( $.jgrid.template(tplfld,vv) );
return false;
}
});
}
return retarr;
}
function emptyData ( d ) {
var clone = {};
for(var key = 0; key< d.length; key++ ) {
clone[d[key]] = "";
}
return clone;
}
var sumreverse = $.makeArray(grp.groupSummary), gv;
sumreverse.reverse();
if($t.p.datatype === 'local' && !$t.p.loadonce) {
$($t).jqGrid('groupingSetup');
var groupingPrepare = $.jgrid.getMethod("groupingPrepare");
for(var ll=0; ll < data.length; ll++) {
groupingPrepare.call($($t), data[ll], ll);
}
}
$.each(grp.groups,function(i,n){
toEnd++;
try {
if ($.isArray(grp.formatDisplayField) && $.isFunction(grp.formatDisplayField[n.idx])) {
gv = grp.formatDisplayField[n.idx].call($t, n.displayValue, n.value, $t.p.colModel[cp[n.idx]], n.idx, grp);
} else {
gv = $t.formatter('', n.displayValue, cp[n.idx], n.value );
}
} catch (egv) {
gv = n.displayValue;
}
var grpTextStr = '';
if($.isFunction(grp.groupText[n.idx])) {
grpTextStr = grp.groupText[n.idx].call($t, gv, n.cnt, n.summary);
} else {
grpTextStr = $.jgrid.template(grp.groupText[n.idx], gv, n.cnt, n.summary);
}
if( !(typeof grpTextStr ==='string' || typeof grpTextStr ==='number' ) ) {
grpTextStr = gv;
}
var arr;
if(grp.groupSummaryPos[n.idx] === 'header') {
arr = buildSummaryTd(i, 0, grp.groups, 0 /*grp.groupColumnShow[n.idx] === false ? (mul ==="" ? 2 : 3) : ((mul ==="") ? 1 : 2)*/ );
} else {
arr = emptyData(def);
}
var fkey = Object.keys(arr);
arr[fkey[0]] = $.jgrid.stripHtml( new Array(n.idx*5).join(' ') + grpTextStr );
rows.push( constructRow (arr, true) );
var leaf = len-1 === n.idx;
if( leaf ) {
var gg = grp.groups[i+1], kk, ik, offset = 0, sgr = n.startRow,
end = gg !== undefined ? gg.startRow : grp.groups[i].startRow + grp.groups[i].cnt;
for(kk=sgr;kk<end;kk++) {
if(!grdata[kk - offset]) { break; }
var to = grdata[kk - offset];
rows.push( constructRow (to, true) );
}
if(grp.groupSummaryPos[n.idx] !== 'header') {
var jj;
if (gg !== undefined) {
for (jj = 0; jj < grp.groupField.length; jj++) {
if (gg.dataIndex === grp.groupField[jj]) {
break;
}
}
toEnd = grp.groupField.length - jj;
}
for (ik = 0; ik < toEnd; ik++) {
if(!sumreverse[ik]) { continue; }
arr = buildSummaryTd(i, ik, grp.groups, 0);
rows.push( constructRow (arr, true) );
}
toEnd = jj;
}
}
});
}
//============================================================================
if( $.isFunction( o.loadIndicator )) {
o.loadIndicator('show');
} else if(o.loadIndicator) {
$($t).jqGrid("progressBar", {method:"show", loadtype : $t.p.loadui, htmlcontent: $.jgrid.getRegional($t,'defaults.loadtext') });
}
var k;
for ( j=0, ien=cm.length ; j<ien ; j++ ) {
cm[j]._expcol = true;
if(cm[j].exportcol === undefined ) {
if(cm[j].hidden) {
cm[j]._expcol = false;
}
} else {
cm[j]._expcol = cm[j].exportcol;
}
if(cm[j].name === 'cb' || cm[j].name === 'rn' || cm[j].name === 'subgrid' || !cm[j]._expcol) {
continue;
}
obj = { text: $t.p.colNames[j], style: 'tableHeader' };
test.push( obj );
def[i] = cm[j].name;
map[i] = j;
widths.push(cm[j].width);
align[cm[j].name] = cm[j].align || 'left';
i++;
}
var gh;
if(o.includeGroupHeader && $($t).jqGrid('isGroupHeaderOn') ) {
gh = $t.p.groupHeader;
for (i=0;i < gh.length; i++) {
var clone = [],
ghdata = gh[i].groupHeaders;
for(key=0; key < def.length; key++ ) {
obj = {text:'', style: 'tableHeader'};
for(k=0;k<ghdata.length;k++) {
if(ghdata[k].startColumnName === def[key]) {
obj = {
text : ghdata[k].titleText,
colSpan: ghdata[k].numberOfColumns,
style: 'tableHeader'
};
}
}
clone.push(obj);
j++;
}
rows.push(clone);
}
}
if(o.includeLabels) {
rows.push( test );
}
if ( o.includeHeader && $t.p.headerrow) {
var hdata = $($t).jqGrid('headerData', 'get');
test=[];
for( key =0; key< def.length; key++) {
obj = {
text : $.jgrid.stripHtml( $.jgrid.getAccessor(hdata, def[key]) ),
style : 'tableFooter',
alignment : align[def[key]]
};
test.push( obj );
}
rows.push( test );
}
if($t.p.grouping) {
var savlcgr = $t.p.groupingView._locgr ? true : false;
$t.p.groupingView._locgr = false;
groupToPdf(data);
$t.p.groupingView._locgr = savlcgr;
} else {
var row;
for ( i=0, ien=data.length ; i<ien ; i++ ) {
k =0;
test=[];
row = data[i];
for( key = 0;key < def.length; key++ ) {
obj = {
text: row[def[key]] == null ? '' : $.jgrid.stripHtml($.jgrid.formatCell( $.jgrid.getAccessor(row, def[key]) + '', map[k], data[i], cm[map[k]], $t, 'pdf')),
alignment : align[def[key]],
style : 'tableBody'
};
test.push(obj);
k++;
}
rows.push(test);
}
}
if ( o.includeFooter && $t.p.footerrow) {
var fdata = $($t).jqGrid('footerData', 'get');
test=[];
for( key =0; key< def.length; key++) {
obj = {
text : $.jgrid.stripHtml( $.jgrid.getAccessor(fdata, def[key]) ),
style : 'tableFooter',
alignment : align[def[key]]
};
test.push( obj );
}
rows.push( test );
}
var doc = {
pageSize: o.pageSize,
pageOrientation: o.orientation,
content: [
{
style : 'tableExample',
widths : widths,
table: {
headerRows: (gh!=null) ? 0 : 1,
body: rows
}
}
],
styles: {
tableHeader: {
bold: true,
fontSize: 11,
color: '#2e6e9e',
fillColor: '#dfeffc',
alignment: 'center'
},
tableBody: {
fontSize: 10
},
tableFooter: {
bold: true,
fontSize: 11,
color: '#2e6e9e',
fillColor: '#dfeffc'
},
title: {
alignment: 'center',
fontSize: 15
},
description: {}
},
defaultStyle: {
fontSize: 10
}
};
if ( o.description ) {
doc.content.unshift( {
text: o.description,
style: 'description',
margin: [ 0, 0, 0, 12 ]
} );
}
if ( o.title ) {
doc.content.unshift( {
text: o.title,
style: 'title',
margin: [ 0, 0, 0, 12 ]
} );
}
if( $.isFunction( o.onBeforeExport ) ) {
o.onBeforeExport.call($t, doc);
}
try {
var pdf = pdfMake.createPdf( doc );
pdf.getDataUrl(function(url) {
if( $.isFunction( o.loadIndicator )) {
o.loadIndicator('hide');
} else if(o.loadIndicator) {
$($t).jqGrid("progressBar", {method:"hide", loadtype : $t.p.loadui });
}
});
if ( o.download === 'open' ) {
pdf.open();
} else {
pdf.getBuffer( function (buffer) {
$.jgrid.saveAs( buffer, o.fileName, {type: o.mimetype } );
} );
}
} catch(e) {
throw e;
}
});
},
exportToHtml : function ( o ) {
o = $.extend(true,{
title: '',
onBeforeExport: null,
includeLabels : true,
includeGroupHeader : true,
includeFooter: true,
includeHeader: true,
tableClass : 'jqgridprint',
autoPrint : false,
topText : '',
bottomText : '',
returnAsString : false,
treeindent : ' ',
loadIndicator : true // can be a function
}, o || {} );
var ret;
this.each(function() {
var $t = this,
cm = $t.p.colModel,
i=0, j, ien, //obj={},
data = {
body : $t.p.treeGrid ? $($t).jqGrid('getRowData', null, true, o.treeindent) : $t.addLocalData( true ),
header : [],
footer : [],
width : [],
map : [],
align:[]
};
for ( j=0, ien=cm.length ; j<ien ; j++ ) {
cm[j]._expcol = true;
if(cm[j].exportcol === undefined) {
if(cm[j].hidden) {
cm[j]._expcol = false;
}
} else {
cm[j]._expcol = cm[j].exportcol;
}
if( cm[j].name === 'cb' || cm[j].name === 'rn' || cm[j].name === 'subgrid' || !cm[j]._expcol) {
continue;
}
data.header[i] = cm[j].name;
data.width[ i ] = cm[j].width;
data.map[i] = j;
data.align[i] = cm[j].align || 'left';
i++;
}
var _link = document.createElement( 'a' );
var _styleToAbs = function( el ) {
var clone = $(el).clone()[0];
if ( clone.nodeName.toLowerCase() === 'link' ) {
clone.href = _relToAbs( clone.href );
}
return clone.outerHTML;
};
var _relToAbs = function( href ) {
// Assign to a link on the original page so the browser will do all the
// hard work of figuring out where the file actually is
_link.href = href;
var linkHost = _link.host;
// IE doesn't have a trailing slash on the host
// Chrome has it on the pathname
if ( linkHost.indexOf('/') === -1 && _link.pathname.indexOf('/') !== 0) {
linkHost += '/';
}
return _link.protocol+"//"+linkHost+_link.pathname+_link.search;
};
var addRow = function ( d, tag , style ) {
var str = '<tr>', stl;
for ( var i=0, ien=d.length ; i<ien ; i++ ) {
stl = (style === true ? " style=width:"+data.width[i]+"px;":"");
str += '<'+tag+stl+'>'+$t.p.colNames[data.map[i]]+'</'+tag+'>';
}
return str + '</tr>';
};
var addBodyRow = function ( d, tag, frm, style, colsp) {
var str = '<tr>', f, stl;
//style = true;
for ( var i=0, ien = data.header.length; i< ien; i++ ) {
if(colsp) {
stl = ' colspan= "'+ (data.header.length) +'"' + " style=text-align:left";
} else {
stl = (style === true ? " style=width:"+data.width[i]+"px;text-align:"+data.align[i]+";" : " style=text-align:"+data.align[i]+";");
}
f= data.header[i];
if (d.hasOwnProperty(f) ) {
str += '<'+tag+stl+'>'+ (frm ? $.jgrid.formatCell( $.jgrid.getAccessor( d, f ), data.map[i], d, cm[data.map[i]], $t, 'html') : d[f])+'</'+tag+'>';
}
if(colsp) {
break;
}
}
return str + '</tr>';
};
//=========================================================================
function groupToHtml ( grdata ) {
var grp = $t.p.groupingView,
cp=[], len =grp.groupField.length,
colspans = cm.length,
toEnd = 0, retstr="";
$.each(cm, function (i,n){
var ii;
for(ii=0;ii<len;ii++) {
if(grp.groupField[ii] === n.name ) {
cp[ii] = i;
break;
}
}
});
function findGroupIdx( ind , offset, grp) {
var ret = false, i;
if(offset===0) {
ret = grp[ind];
} else {
var id = grp[ind].idx;
if(id===0) {
ret = grp[ind];
} else {
for(i=ind;i >= 0; i--) {
if(grp[i].idx === id-offset) {
ret = grp[i];
break;
}
}
}
}
return ret;
}
function buildSummaryTd(i, ik, grp, foffset) {
var fdata = findGroupIdx(i, ik, grp),
//cm = $t.p.colModel,
vv, grlen = fdata.cnt, k, retarr = emptyData(data.header);
for(k=foffset; k<colspans;k++) {
if(!cm[k]._expcol) {
continue;
}
var tplfld = "{0}";
$.each(fdata.summary,function(){
if(this.nm === cm[k].name) {
if(cm[k].summaryTpl) {
tplfld = cm[k].summaryTpl;
}
if(typeof this.st === 'string' && this.st.toLowerCase() === 'avg') {
if(this.sd && this.vd) {
this.v = (this.v/this.vd);
} else if(this.v && grlen > 0) {
this.v = (this.v/grlen);
}
}
try {
this.groupCount = fdata.cnt;
this.groupIndex = fdata.dataIndex;
this.groupValue = fdata.value;
//vv = $t.formatter('', this.v, k, this);
vv = this.v;
} catch (ef) {
vv = this.v;
}
retarr[this.nm] = $.jgrid.stripHtml( $.jgrid.template(tplfld,vv) );
return false;
}
});
}
return retarr;
}
function emptyData ( d ) {
var clone = {};
for(var key=0;key<d.length; key++ ) {
clone[ d[key] ] = "";
}
return clone;
}
var sumreverse = $.makeArray(grp.groupSummary), gv;
sumreverse.reverse();
if($t.p.datatype === 'local' && !$t.p.loadonce) {
$($t).jqGrid('groupingSetup');
var groupingPrepare = $.jgrid.getMethod("groupingPrepare");
for(var ll=0; ll < data.body.length; ll++) {
groupingPrepare.call($($t), data.body[ll], ll);
}
}
$.each(grp.groups,function(i,n){
toEnd++;
try {
if ($.isArray(grp.formatDisplayField) && $.isFunction(grp.formatDisplayField[n.idx])) {
gv = grp.formatDisplayField[n.idx].call($t, n.displayValue, n.value, $t.p.colModel[cp[n.idx]], n.idx, grp);
} else {
gv = $t.formatter('', n.displayValue, cp[n.idx], n.value );
}
} catch (egv) {
gv = n.displayValue;
}
var grpTextStr = '';
if($.isFunction(grp.groupText[n.idx])) {
grpTextStr = grp.groupText[n.idx].call($t, gv, n.cnt, n.summary);
} else {
grpTextStr = $.jgrid.template(grp.groupText[n.idx], gv, n.cnt, n.summary);
}
if( !(typeof grpTextStr ==='string' || typeof grpTextStr ==='number' ) ) {
grpTextStr = gv;
}
var arr, colSpan = false;
if(grp.groupSummaryPos[n.idx] === 'header') {
arr = buildSummaryTd(i, 0, grp.groups, 0 /*grp.groupColumnShow[n.idx] === false ? (mul ==="" ? 2 : 3) : ((mul ==="") ? 1 : 2)*/ );
} else {
arr = emptyData(data.header);
colSpan = true;
}
var fkey = Object.keys(arr);
arr[fkey[0]] = new Array(n.idx*5).join(' ') + grpTextStr ;
retstr += addBodyRow( arr, 'td', true, toEnd === 1, colSpan );
var leaf = len-1 === n.idx;
if( leaf ) {
var gg = grp.groups[i+1], kk, ik, offset = 0, sgr = n.startRow,
end = gg !== undefined ? gg.startRow : grp.groups[i].startRow + grp.groups[i].cnt;
for(kk=sgr;kk<end;kk++) {
if(!grdata[kk - offset]) { break; }
var to = grdata[kk - offset];
retstr += addBodyRow( to, 'td', true );
//addRow( to, false );
}
if(grp.groupSummaryPos[n.idx] !== 'header') {
var jj;
if (gg !== undefined) {
for (jj = 0; jj < grp.groupField.length; jj++) {
if (gg.dataIndex === grp.groupField[jj]) {
break;
}
}
toEnd = grp.groupField.length - jj;
}
for (ik = 0; ik < toEnd; ik++) {
if(!sumreverse[ik]) { continue; }
arr = buildSummaryTd(i, ik, grp.groups, 0);
retstr += addBodyRow( arr, 'td', true );
//addRow( arr, true );
}
toEnd = jj;
}
}
});
return retstr;
}
if( $.isFunction( o.loadIndicator )) {
o.loadIndicator('show');
} else if(o.loadIndicator) {
$($t).jqGrid("progressBar", {method:"show", loadtype : $t.p.loadui, htmlcontent: $.jgrid.getRegional($t,'defaults.loadtext') });
}
var html = '<table class="'+o.tableClass+'">';
if ( o.includeLabels ) {
html += '<thead>'+ addRow( data.header, 'th', true ) +'</thead>';
}
html += '<tbody>';
if ( o.includeHeader && $t.p.headerrow ) {
var hdata = $($t).jqGrid('headerData', 'get', null, false);
html += addBodyRow( hdata, 'td' , false);
}
if( $t.p.grouping ) {
var savlcgr = $t.p.groupingView._locgr ? true : false;
$t.p.groupingView._locgr = false;
html += groupToHtml(data.body);
$t.p.groupingView._locgr = savlcgr;
} else {
for ( var i=0, ien=data.body.length ; i<ien ; i++ ) {
html += addBodyRow( data.body[i], 'td', true, (i===0?true:false) );
}
}
if ( o.includeFooter && $t.p.footerrow ) {
data.footer = $($t).jqGrid('footerData', 'get', null, false);
html += addBodyRow( data.footer, 'td' , false);
}
html += '</tbody>';
html += '</table>';
if (o.returnAsString ) {
ret = html;
} else {
// Open a new window for the printable table
var win = window.open( '', '' );
win.document.close();
var head = o.title ? '<title>'+o.title+'</title>' : '';
$('style, link').each( function () {
head += _styleToAbs( this );
} );
try {
win.document.head.innerHTML = head; // Work around for Edge
}
catch (e) {
$(win.document.head).html( head ); // Old IE
}
win.document.body.innerHTML =
(o.title ? '<h1>'+o.title+'</h1>' : '') +
'<div>'+(o.topText || '')+'</div>'+
html+
'<div>'+(o.bottomText || '')+'</div>';
$(win.document.body).addClass('html-view');
$('img', win.document.body).each( function ( i, img ) {
img.setAttribute( 'src', _relToAbs( img.getAttribute('src') ) );
} );
if ( o.onBeforeExport ) {
o.onBeforeExport( win );
}
if(Boolean(win.chrome)) {
if ( o.autoPrint ) {
win.print();
win.close();
}
} else {
setTimeout( function () {
if ( o.autoPrint ) {
win.print();
win.close();
}
}, 1000 );
}
}
if( $.isFunction( o.loadIndicator )) {
o.loadIndicator('hide');
} else if(o.loadIndicator) {
$($t).jqGrid("progressBar", {method:"hide", loadtype : $t.p.loadui });
}
});
return ret;
}
});
//module begin
$.extend($.jgrid,{
focusableElementsList : [
'>a[href]',
'>button:not([disabled])',
'>area[href]',
'>input:not([disabled])',
'>select:not([disabled])',
'>textarea:not([disabled])',
'>iframe',
'>object',
'>embed',
'>*[tabindex]',
'>*[contenteditable]'
]
});
$.jgrid.extend({
ariaBodyGrid : function ( p ) {
var o = $.extend({
onEnterCell : null
}, p || {});
return this.each(function (){
var $t = this,
getstyle = $.jgrid.getMethod("getStyleUI"),
highlight = getstyle($t.p.styleUI+'.common','highlight', true);
// basic functions
function isValidCell(row, col) {
return (
!isNaN(row) &&
!isNaN(col) &&
row >= 0 &&
col >= 0 &&
$t.rows.length &&
row < $t.rows.length &&
col < $t.p.colModel.length
);
};
function getNextCell( dirX, dirY) {
var row = $t.p.iRow + dirY; // set the default one when initialize grid
var col = $t.p.iCol + dirX; // set the default .................
var rowCount = $t.rows.length;
var isLeftRight = dirX !== 0;
if (!rowCount) {
return false;
}
var colCount = $t.p.colModel.length;
if (isLeftRight) {
if (col < 0 && row >= 2) {
col = colCount - 1;
row--;
}
if (col >= colCount) {
col = 0;
row++;
}
}
if (!isLeftRight) {
if (row < 1) {
col--;
row = rowCount - 1;
if ($t.rows[row] && col >= 0 && !$t.rows[row].cells[col]) {
// Sometimes the bottom row is not completely filled in. In this case,
// jump to the next filled in cell.
row--;
}
}
else if (row >= rowCount || !$t.rows[row].cells[col]) {
row = 1;
col++;
}
}
if (isValidCell(row, col)) {
return {
row: row,
col: col
};
} else if (isValidCell($t.p.iRow, $t.p.iCol)) {
return {
row: $t.p.iRow,
col: $t.p.iCol
};
} else {
return false;
}
}
function getNextVisibleCell(dirX, dirY) {
var nextCell = getNextCell( dirX, dirY);
if (!nextCell) {
return false;
}
while ( $($t.rows[nextCell.row].cells[nextCell.col]).is(":hidden") ) {
$t.p.iRow = nextCell.row;
$t.p.iCol = nextCell.col;
nextCell = getNextCell(dirX, dirY);
if ($t.p.iRow === nextCell.row && $t.p.iCol === nextCell.col) {
// There are no more cells to try if getNextCell returns the current cell
return false;
}
}
if( dirY !== 0 ) {
$($t).jqGrid('setSelection', $t.rows[nextCell.row].id, false, null, false);
}
return nextCell;
}
function movePage ( dir ) {
var curpage = $t.p.page, last =$t.p.lastpage;
curpage = curpage + dir;
if( curpage <= 0) {
curpage = 1;
}
if( curpage > last ) {
curpage = last;
}
if( $t.p.page === curpage ) {
return;
}
$t.p.page = curpage;
$t.grid.populate();
}
var focusableElementsSelector = $.jgrid.focusableElementsList.join();
function hasFocusableChild( el) {
return $(focusableElementsSelector, el)[0];
}
$($t).removeAttr("tabindex");
$($t).on('jqGridAfterGridComplete.setAriaGrid', function( e ) {
//var grid = e.target;
$("tbody:first>tr:not(.jqgfirstrow)>td:not(:hidden, :has("+focusableElementsSelector+"))", $t).attr("tabindex", -1);
$("tbody:first>tr:not(.jqgfirstrow)", $t).removeAttr("tabindex");
if($t.p.iRow !== undefined && $t.p.iCol !== undefined) {
if($t.rows[$t.p.iRow]) {
$($t.rows[$t.p.iRow].cells[$t.p.iCol])
.attr('tabindex', 0)
.focus( function() { $(this).addClass(highlight);})
.blur( function () { $(this).removeClass(highlight);});
}
}
});
$t.p.iRow = 1;
$t.p.iCol = $.jgrid.getFirstVisibleCol( $t );
var focusRow=0, focusCol=0; // set the dafualt one
$($t).on('keydown', function(e) {
if($t.p.navigationDisabled && $t.p.navigationDisabled === true) {
return;
}
var key = e.which || e.keyCode, nextCell;
switch(key) {
case (38) :
nextCell = getNextVisibleCell(0, -1);
focusRow = nextCell.row;
focusCol = nextCell.col;
e.preventDefault();
break;
case (40) :
nextCell = getNextVisibleCell(0, 1);
focusRow = nextCell.row;
focusCol = nextCell.col;
e.preventDefault();
break;
case (37) :
nextCell = getNextVisibleCell(-1, 0);
focusRow = nextCell.row;
focusCol = nextCell.col;
e.preventDefault();
break;
case (39) :
nextCell = getNextVisibleCell(1, 0);
focusRow = nextCell.row;
focusCol = nextCell.col;
e.preventDefault();
break;
case 36 : // HOME
if(e.ctrlKey) {
focusRow = 1;
} else {
focusRow = $t.p.iRow;
}
focusCol = 0;
e.preventDefault();
break;
case 35 : //END
if(e.ctrlKey) {
focusRow = $t.rows.length - 1;
} else {
focusRow = $t.p.iRow;
}
focusCol = $t.p.colModel.length - 1;
e.preventDefault();
break;
case 33 : // PAGEUP
movePage( -1 );
focusCol = $t.p.iCol;
focusRow = $t.p.iRow;
e.preventDefault();
break;
case 34 : // PAGEDOWN
movePage( 1 );
focusCol = $t.p.iCol;
focusRow = $t.p.iRow;
if(focusRow > $t.rows.length-1) {
focusRow = $t.rows.length-1;
$t.p.iRow = $t.rows.length-1;
}
e.preventDefault();
break;
case 13 : //Enter
if( $.isFunction( o.onEnterCell )) {
o.onEnterCell.call( $t, $t.rows[$t.p.iRow].id ,$t.p.iRow, $t.p.iCol, e);
e.preventDefault();
}
return;
default:
return;
}
$($t).jqGrid("focusBodyCell", focusRow, focusCol, getstyle, highlight);
});
$($t).on('jqGridBeforeSelectRow.ariaGridClick',function() {
return false;
});
$($t).on('jqGridCellSelect.ariaGridClick', function(el1, id, status,tdhtml, e) {
var el = e.target;
if($t.p.iRow > 0 && $t.p.iCol >=0) {
$($t.rows[$t.p.iRow].cells[$t.p.iCol]).attr("tabindex", -1);
}
if($(el).is("td") || $(el).is("th")) {
$t.p.iCol = el.cellIndex;
} else {
return;
}
var row = $(el).closest("tr.jqgrow");
$t.p.iRow = row[0].rowIndex;
$(el).attr("tabindex", 0)
.addClass(highlight)
.focus()
.blur(function(){$(this).removeClass(highlight);});
});
});
},
focusBodyCell : function(focusRow, focusCol, _s, _h) {
return this.each(function (){
var $t = this,
getstyle = !_s ? $.jgrid.getMethod("getStyleUI") : _s,
highlight = !_h ? getstyle($t.p.styleUI+'.common','highlight', true) : _h,
focusableElementsSelector = $.jgrid.focusableElementsList.join(),
fe;
function hasFocusableChild( el) {
return $(focusableElementsSelector, el)[0];
}
if(focusRow !== undefined && focusCol !== undefined) {
if (!isNaN($t.p.iRow) && !isNaN($t.p.iCol) && $t.p.iCol >= 0) {
fe = hasFocusableChild($t.rows[$t.p.iRow].cells[$t.p.iCol]);
if( fe ) {
$(fe).attr('tabindex', -1);
} else {
$($t.rows[$t.p.iRow].cells[$t.p.iCol]).attr('tabindex', -1);
}
}
} else {
focusRow = $t.p.iRow;
focusCol = $t.p.iCol;
}
focusRow = parseInt(focusRow, 10);
focusCol = parseInt(focusCol, 10);
if(focusRow > 0 && focusCol >=0) {
fe = hasFocusableChild($t.rows[focusRow].cells[focusCol]);
if( fe ) {
$(fe).attr('tabindex', 0)
.addClass(highlight)
.focus()
.blur( function () { $(this).removeClass(highlight); });
} else {
$($t.rows[focusRow].cells[focusCol])
.attr('tabindex', 0)
.addClass(highlight)
.focus()
.blur(function () { $(this).removeClass(highlight); });
}
$t.p.iRow = focusRow;
$t.p.iCol = focusCol;
}
});
},
resetAriaBody : function() {
return this.each(function(){
var $t = this;
$($t).attr("tabindex","0")
.off('keydown')
.off('jqGridBeforeSelectRow.ariaGridClick')
.off('jqGridCellSelect.ariaGridClick')
.off('jqGridAfterGridComplete.setAriaGrid');
var focusableElementsSelector = $.jgrid.focusableElementsList.join();
$("tbody:first>tr:not(.jqgfirstrow)>td:not(:hidden, :has("+focusableElementsSelector+"))", $t).removeAttr("tabindex").off("focus");
$("tbody:first>tr:not(.jqgfirstrow)", $t).attr("tabindex", -1);
});
},
ariaHeaderGrid : function() {
return this.each(function (){
var $t = this,
getstyle = $.jgrid.getMethod("getStyleUI"),
highlight = getstyle($t.p.styleUI+'.common','highlight', true),
htable = $(".ui-jqgrid-hbox>table:first", "#gbox_"+$t.p.id);
$('tr.ui-jqgrid-labels', htable).on("keydown", function(e) {
var currindex = $t.p.selHeadInd;
var key = e.which || e.keyCode;
var len = $t.grid.headers.length;
switch (key) {
case 37: // left
if(currindex-1 >= 0) {
currindex--;
while( $($t.grid.headers[currindex].el).is(':hidden') && currindex-1 >= 0) {
currindex--;
if(currindex < 0) {
break;
}
}
if(currindex >= 0) {
$($t.grid.headers[currindex].el).focus();
$($t.grid.headers[$t.p.selHeadInd].el).attr("tabindex", "-1");
$t.p.selHeadInd = currindex;
e.preventDefault();
}
}
break;
case 39: // right
if(currindex+1 < len) {
currindex++;
while( $($t.grid.headers[currindex].el).is(':hidden') && currindex+1 <len) {
currindex++;
if( currindex > len-1) {
break;
}
}
if( currindex < len) {
$($t.grid.headers[currindex].el).focus();
$($t.grid.headers[$t.p.selHeadInd].el).attr("tabindex", "-1");
$t.p.selHeadInd = currindex;
e.preventDefault();
}
}
break;
case 13: // enter
$("div:first",$t.grid.headers[currindex].el).trigger('click');
e.preventDefault();
break;
default:
return;
}
});
$('tr.ui-jqgrid-labels>th:not(:hidden)', htable).attr("tabindex", -1).focus(function(){
$(this).addClass(highlight).attr("tabindex", "0");
}).blur(function(){
$(this).removeClass(highlight);
});
$t.p.selHeadInd = $.jgrid.getFirstVisibleCol( $t );
$($t.grid.headers[$t.p.selHeadInd].el).attr("tabindex","0");
});
},
focusHeaderCell : function( index) {
return this.each( function(){
var $t = this;
if(index === undefined) {
index = $t.p.selHeadInd;
}
if(index >= 0 && index < $t.p.colModel.length) {
$($t.grid.headers[$t.p.selHeadInd].el).attr("tabindex", "-1");
$($t.grid.headers[index].el).focus();
$t.p.selHeadInd = index;
}
});
},
resetAriaHeader : function() {
return this.each(function(){
var htable = $(".ui-jqgrid-hbox>table:first", "#gbox_" + this.p.id);
$('tr.ui-jqgrid-labels', htable).off("keydown");
$('tr.ui-jqgrid-labels>th:not(:hidden)', htable).removeAttr("tabindex").off("focus blur");
});
},
ariaPagerGrid : function () {
return this.each( function(){
var $t = this,
getstyle = $.jgrid.getMethod("getStyleUI"),
highlight = getstyle($t.p.styleUI+'.common','highlight', true),
disabled = "."+getstyle($t.p.styleUI+'.common','disabled', true),
cels = $(".ui-pg-button",$t.p.pager),
len = cels.length;
cels.attr("tabindex","-1").focus(function(){
$(this).addClass(highlight);
}).blur(function(){
$(this).removeClass(highlight);
});
$t.p.navIndex = 0;
setTimeout( function() { // make another decision here
var navIndex = cels.not(disabled).first().attr("tabindex", "0");
$t.p.navIndex = navIndex[0].cellIndex ? navIndex[0].cellIndex-1 : 0;
}, 100);
$("table.ui-pager-table tr:first", $t.p.pager).on("keydown", function(e) {
var key = e.which || e.keyCode;
var indexa = $t.p.navIndex;//currindex;
switch (key) {
case 37: // left
if(indexa-1 >= 0) {
indexa--;
while( $(cels[indexa]).is(disabled) && indexa-1 >= 0) {
indexa--;
if(indexa < 0) {
break;
}
}
if(indexa >= 0) {
$(cels[$t.p.navIndex]).attr("tabindex","-1");
$(cels[indexa]).attr("tabindex","0").focus();
$t.p.navIndex = indexa;
}
e.preventDefault();
}
break;
case 39: // right
if(indexa+1 < len) {
indexa++;
while( $(cels[indexa]).is(disabled) && indexa+1 < len + 1) {
indexa++;
if( indexa > len-1) {
break;
}
}
if( indexa < len) {
$(cels[$t.p.navIndex]).attr("tabindex","-1");
$(cels[indexa]).attr("tabindex","0").focus();
$t.p.navIndex = indexa;
}
e.preventDefault();
}
break;
case 13: // enter
$(cels[indexa]).trigger('click');
e.preventDefault();
break;
default:
return;
}
});
});
},
focusPagerCell : function( index) {
return this.each( function(){
var $t = this,
cels = $(".ui-pg-button",$t.p.pager),
len = cels.length;
if(index === undefined) {
index = $t.p.navIndex;
}
if(index >= 0 && index < len) {
$(cels[$t.p.navIndex]).attr("tabindex","-1");
$(cels[index]).attr("tabindex","0").focus();
$t.p.navIndex = index;
}
});
},
resetAriaPager : function() {
return this.each(function(){
$(".ui-pg-button",this.p.pager).removeAttr("tabindex").off("focus");;
$("table.ui-pager-table tr:first", this.p.pager).off("keydown");
});
},
setAriaGrid : function ( p ) {
var o = $.extend({
header : true,
body : true,
pager : true,
onEnterCell : null
}, p || {});
return this.each(function(){
if( o.header ) {
$(this).jqGrid('ariaHeaderGrid');
}
if( o.body ) {
$(this).jqGrid('ariaBodyGrid', {onEnterCell : o.onEnterCell});
}
if( o.pager ) {
$(this).jqGrid('ariaPagerGrid');
}
});
},
resetAriaGrid : function( p ) {
var o = $.extend({
header : true,
body : true,
pager : true
}, p || {});
return this.each(function(){
var $t = this;
if( o.body ) {
$($t).jqGrid('resetAriaBody');
}
if( o.header ) {
$($t).jqGrid('resetAriaHeader');
}
if( o.pager ) {
$($t).jqGrid('resetAriaPager');
}
});
}
// end aria grid
});
})); |
/**
* @license Highcharts JS v9.3.1 (2021-11-05)
* @module highcharts/modules/wordcloud
* @requires highcharts
*
* (c) 2016-2021 Highsoft AS
* Authors: Jon Arild Nygard
*
* License: www.highcharts.com/license
*/
'use strict';
import '../../Series/Wordcloud/WordcloudSeries.js';
|
var read = require('../lib/read.js')
if (process.argv[2] === 'child') {
return child()
}
var tap = require('tap')
var CLOSE = 'close'
if (process.version.match(/^v0\.6/)) {
CLOSE = 'exit'
}
var spawn = require('child_process').spawn
tap.test('basic', function (t) {
var child = spawn(process.execPath, [__filename, 'child'])
var output = ''
var write = child.stdin.write.bind(child.stdin)
child.stdout.on('data', function (c) {
console.error('data %s', c)
output += c
if (output.match(/Username: \(test-user\) $/)) {
process.nextTick(write.bind(null, 'a user\n'))
} else if (output.match(/Password: \(<default hidden>\) $/)) {
process.nextTick(write.bind(null, 'a password\n'))
} else if (output.match(/Password again: \(<default hidden>\) $/)) {
process.nextTick(write.bind(null, 'a password\n'))
} else {
console.error('prompts done, output=%j', output)
}
})
var result = ''
child.stderr.on('data', function (c) {
result += c
console.error('result %j', c.toString())
})
child.on(CLOSE, function () {
result = JSON.parse(result)
t.same(result, {"user":"a user","pass":"a password","verify":"a password","passMatch":true})
t.equal(output, 'Username: (test-user) Password: (<default hidden>) Password again: (<default hidden>) ')
t.end()
})
})
function child () {
read({prompt: "Username: ", default: "test-user" }, function (er, user) {
read({prompt: "Password: ", default: "test-pass", silent: true }, function (er, pass) {
read({prompt: "Password again: ", default: "test-pass", silent: true }, function (er, pass2) {
console.error(JSON.stringify({user: user,
pass: pass,
verify: pass2,
passMatch: (pass === pass2)}))
if (process.stdin.unref)
process.stdin.unref()
})
})
})
}
|
import a from "./a";
import b from "./b";
import d from "./d";
import f from "./f";
import h from "./h";
import j from "./j";
it("should fire the correct events", (done) => {
var events = [];
var options = {
ignoreUnaccepted: true,
ignoreDeclined: true,
ignoreErrored: true,
onDeclined(data) { events.push(data); },
onUnaccepted(data) { events.push(data); },
onAccepted(data) { events.push(data); },
onErrored(data) { events.push(data); }
};
function waitForUpdate(fn) {
NEXT(require("../../update")(done, options, () => {
try {
fn();
} catch(e) {
done(e);
}
}));
}
waitForUpdate(() => {
expect(events).toEqual([
{
type: "unaccepted",
moduleId: "./index.js",
chain: [ "./a.js", "./index.js" ],
},
{
type: "accepted",
moduleId: "./c.js",
outdatedDependencies: { "./b.js": [ "./c.js" ] },
outdatedModules: [ "./c.js" ],
},
{
type: "self-declined",
moduleId: "./d.js",
chain: [ "./e.js", "./d.js" ],
},
{
type: "declined",
moduleId: "./g.js",
parentId: "./f.js",
chain: [ "./g.js", "./f.js" ],
},
{
type: "accepted",
moduleId: "./i.js",
outdatedDependencies: { "./h.js": [ "./i.js" ] },
outdatedModules: [ "./i.js" ],
},
{
type: "accepted",
moduleId: "./j.js",
outdatedDependencies: {},
outdatedModules: [ "./j.js" ],
},
{
type: "accept-errored",
moduleId: "./h.js",
dependencyId: "./i.js",
error: new Error("Error while loading module h")
},
{
type: "self-accept-errored",
moduleId: "./j.js",
error: new Error("Error while loading module j")
},
]);
done();
});
});
|
//>>built
define("dojox/date/umalqura",["dojox/main","dojo/_base/lang","dojo/date","./umalqura/Date"],function(l,m,n,k){var g=m.getObject("date.umalqura",!0,l);g.getDaysInMonth=function(a){return a.getDaysInIslamicMonth(a.getMonth(),a.getFullYear())};g.compare=function(a,e,c){a instanceof k&&(a=a.toGregorian());e instanceof k&&(e=e.toGregorian());return n.compare.apply(null,arguments)};g.add=function(a,e,c){var d=new k(a);switch(e){case "day":d.setDate(a.getDate()+c);break;case "weekday":var b=a.getDay();if(5>
b+c&&0<b+c)d.setDate(a.getDate()+c);else{var f=e=0;5==b?(b=4,f=0<c?-1:1):6==b&&(b=4,f=0<c?-2:2);var b=0<c?5-b-1:-b,h=c-b,g=parseInt(h/5);0!=h%5&&(e=0<c?2:-2);d.setDate(a.getDate()+(e+7*g+h%5+b)+f)}break;case "year":d.setFullYear(a.getFullYear()+c);break;case "week":d.setDate(a.getDate()+7*c);break;case "month":a=a.getMonth();d.setMonth(a+c);break;case "hour":d.setHours(a.getHours()+c);break;case "minute":d._addMinutes(c);break;case "second":d._addSeconds(c);break;case "millisecond":d._addMilliseconds(c)}return d};
g.difference=function(a,e,c){e=e||new k;c=c||"day";var d=e.getFullYear()-a.getFullYear(),b=1;switch(c){case "weekday":d=Math.round(g.difference(a,e,"day"));b=parseInt(g.difference(a,e,"week"));c=d%7;if(0==c)d=5*b;else{var f=0,h=a.getDay();e=e.getDay();b=parseInt(d/7);c=d%7;a=new k(a);a.setDate(a.getDate()+7*b);a=a.getDay();if(0<d)switch(!0){case 5==h:f=-1;break;case 6==h:f=0;break;case 5==e:f=-1;break;case 6==e:f=-2;break;case 5<a+c:f=-2}else if(0>d)switch(!0){case 5==h:f=0;break;case 6==h:f=1;break;
case 5==e:f=2;break;case 6==e:f=1;break;case 0>a+c:f=2}d=d+f-2*b}b=d;break;case "year":b=d;break;case "month":c=e.toGregorian()>a.toGregorian()?e:a;f=e.toGregorian()>a.toGregorian()?a:e;b=c.getMonth();h=f.getMonth();if(0==d)b=c.getMonth()-f.getMonth();else{b=12-h+b;d=f.getFullYear()+1;c=c.getFullYear();for(d;d<c;d++)b+=12}e.toGregorian()<a.toGregorian()&&(b=-b);break;case "week":b=parseInt(g.difference(a,e,"day")/7);break;case "day":b/=24;case "hour":b/=60;case "minute":b/=60;case "second":b/=1E3;
case "millisecond":b*=e.toGregorian().getTime()-a.toGregorian().getTime()}return Math.round(b)};return g}); |
import { declare } from "@babel/helper-plugin-utils";
import helper from "@babel/helper-builder-react-jsx";
import { types as t } from "@babel/core";
export default declare(api => {
api.assertVersion(7);
function hasRefOrSpread(attrs) {
for (let i = 0; i < attrs.length; i++) {
const attr = attrs[i];
if (t.isJSXSpreadAttribute(attr)) return true;
if (isJSXAttributeOfName(attr, "ref")) return true;
}
return false;
}
function isJSXAttributeOfName(attr, name) {
return (
t.isJSXAttribute(attr) && t.isJSXIdentifier(attr.name, { name: name })
);
}
const visitor = helper({
filter(node) {
return (
// Regular JSX nodes have an `openingElement`. JSX fragments, however, don't have an
// `openingElement` which causes `node.openingElement.attributes` to throw.
node.openingElement && !hasRefOrSpread(node.openingElement.attributes)
);
},
pre(state) {
const tagName = state.tagName;
const args = state.args;
if (t.react.isCompatTag(tagName)) {
args.push(t.stringLiteral(tagName));
} else {
args.push(state.tagExpr);
}
},
post(state, pass) {
state.callee = pass.addHelper("jsx");
// NOTE: The arguments passed to the "jsx" helper are:
// (element, props, key, ...children) or (element, props)
// The argument generated by the helper are:
// (element, { ...props, key }, ...children)
const props = state.args[1];
let hasKey = false;
if (t.isObjectExpression(props)) {
const keyIndex = props.properties.findIndex(prop =>
t.isIdentifier(prop.key, { name: "key" }),
);
if (keyIndex > -1) {
state.args.splice(2, 0, props.properties[keyIndex].value);
props.properties.splice(keyIndex, 1);
hasKey = true;
}
} else if (t.isNullLiteral(props)) {
state.args.splice(1, 1, t.objectExpression([]));
}
if (!hasKey && state.args.length > 2) {
state.args.splice(2, 0, t.unaryExpression("void", t.numericLiteral(0)));
}
},
});
return {
name: "transform-react-inline-elements",
visitor,
};
});
|
'use strict';
const player = require('./player');
/*
* Play MP4 without video stream.
*/
player.playVideo({
//Note: TCP stream needed (UDP timeout, retrying with TCP)
src: 'http://www.opticodec.com/test/tropic.mp4'
}, (_err, _video) => {
//empty
}); |
'use strict';
angular.module('angularApp', [
'ngRoute'
])
.config(function ($routeProvider, $locationProvider) {
$routeProvider
.when('/', {
templateUrl: 'views/main.html',
controller: 'MainCtrl'
})
.when('/about', {
templateUrl: 'views/about.html'
})
.when('/contact', {
templateUrl: 'views/contact.html'
})
.otherwise({
redirectTo: '/'
});
// static way, full hashbang '#!'
$locationProvider.html5Mode(false);
$locationProvider.hashPrefix('!');
});
|
'use strict';
var odin = { model:{}, view:{}, ctrl:{} }; |
import { bind } from "mousetrap";
import { setActiveTab } from "./ducks/comment_id_panel";
import { setMediaViewerState, toggleMediaViewer } from "./ducks/media_viewer";
const bindShortcut = ( shortcut, callback ) => {
bind( shortcut, ( ) => {
callback( );
return false;
} );
};
const focusCommentIDInput = ( ) => {
let input = $( ".comment_id_panel .active input:visible" ).filter( ":text" ).first( );
input = input.length > 0 ? input : $( ".comment_id_panel .active textarea:visible" ).first( );
input.focus( );
};
const setupKeyboardShortcuts = dispatch => {
bindShortcut( "i", ( ) => {
dispatch( setMediaViewerState( { show: false } ) );
dispatch( setActiveTab( "add_id" ) );
setTimeout( focusCommentIDInput, 300 );
} );
bindShortcut( "c", ( ) => {
dispatch( setMediaViewerState( { show: false } ) );
dispatch( setActiveTab( "comment" ) );
setTimeout( focusCommentIDInput, 300 );
} );
bindShortcut( "z", ( ) => {
dispatch( toggleMediaViewer( ) );
} );
};
export default setupKeyboardShortcuts;
|
Subsets and Splits