blazer 0.0.1
Sign up to get free protection for your applications and to get access to all the features.
Potentially problematic release.
This version of blazer might be problematic. Click here for more details.
- checksums.yaml +7 -0
- data/.gitignore +14 -0
- data/Gemfile +4 -0
- data/LICENSE.txt +22 -0
- data/README.md +144 -0
- data/Rakefile +2 -0
- data/app/assets/javascripts/blazer/ace/ace.js +11 -0
- data/app/assets/javascripts/blazer/ace/ext-language_tools.js +5 -0
- data/app/assets/javascripts/blazer/ace/mode-sql.js +1 -0
- data/app/assets/javascripts/blazer/ace/snippets/sql.js +1 -0
- data/app/assets/javascripts/blazer/ace/snippets/text.js +1 -0
- data/app/assets/javascripts/blazer/ace/theme-twilight.js +1 -0
- data/app/assets/javascripts/blazer/application.js +15 -0
- data/app/assets/javascripts/blazer/daterangepicker.js +1026 -0
- data/app/assets/javascripts/blazer/highlight.pack.js +1 -0
- data/app/assets/javascripts/blazer/jquery.js +10308 -0
- data/app/assets/javascripts/blazer/jquery.stickytableheaders.js +263 -0
- data/app/assets/javascripts/blazer/jquery_ujs.js +469 -0
- data/app/assets/javascripts/blazer/list.js +1474 -0
- data/app/assets/javascripts/blazer/moment.js +2400 -0
- data/app/assets/javascripts/blazer/selectize.js +3477 -0
- data/app/assets/javascripts/blazer/stupidtable.js +114 -0
- data/app/assets/stylesheets/blazer/application.css +66 -0
- data/app/assets/stylesheets/blazer/bootstrap.css +6203 -0
- data/app/assets/stylesheets/blazer/bootstrap.css.map +1 -0
- data/app/assets/stylesheets/blazer/daterangepicker-bs3.css +267 -0
- data/app/assets/stylesheets/blazer/github.css +126 -0
- data/app/assets/stylesheets/blazer/selectize.default.css +386 -0
- data/app/controllers/blazer/queries_controller.rb +216 -0
- data/app/helpers/blazer/queries_helper.rb +21 -0
- data/app/models/blazer/audit.rb +5 -0
- data/app/models/blazer/connection.rb +5 -0
- data/app/models/blazer/query.rb +13 -0
- data/app/views/blazer/queries/_form.html.erb +84 -0
- data/app/views/blazer/queries/edit.html.erb +1 -0
- data/app/views/blazer/queries/index.html.erb +47 -0
- data/app/views/blazer/queries/new.html.erb +1 -0
- data/app/views/blazer/queries/run.html.erb +50 -0
- data/app/views/blazer/queries/show.html.erb +138 -0
- data/app/views/layouts/blazer/application.html.erb +17 -0
- data/blazer.gemspec +25 -0
- data/config/routes.rb +6 -0
- data/lib/blazer/engine.rb +11 -0
- data/lib/blazer/version.rb +3 -0
- data/lib/blazer.rb +16 -0
- data/lib/generators/blazer/install_generator.rb +33 -0
- data/lib/generators/blazer/templates/config.yml +8 -0
- data/lib/generators/blazer/templates/install.rb +17 -0
- metadata +134 -0
@@ -0,0 +1,1474 @@
|
|
1
|
+
;(function(){
|
2
|
+
|
3
|
+
/**
|
4
|
+
* Require the given path.
|
5
|
+
*
|
6
|
+
* @param {String} path
|
7
|
+
* @return {Object} exports
|
8
|
+
* @api public
|
9
|
+
*/
|
10
|
+
|
11
|
+
function require(path, parent, orig) {
|
12
|
+
var resolved = require.resolve(path);
|
13
|
+
|
14
|
+
// lookup failed
|
15
|
+
if (null == resolved) {
|
16
|
+
orig = orig || path;
|
17
|
+
parent = parent || 'root';
|
18
|
+
var err = new Error('Failed to require "' + orig + '" from "' + parent + '"');
|
19
|
+
err.path = orig;
|
20
|
+
err.parent = parent;
|
21
|
+
err.require = true;
|
22
|
+
throw err;
|
23
|
+
}
|
24
|
+
|
25
|
+
var module = require.modules[resolved];
|
26
|
+
|
27
|
+
// perform real require()
|
28
|
+
// by invoking the module's
|
29
|
+
// registered function
|
30
|
+
if (!module._resolving && !module.exports) {
|
31
|
+
var mod = {};
|
32
|
+
mod.exports = {};
|
33
|
+
mod.client = mod.component = true;
|
34
|
+
module._resolving = true;
|
35
|
+
module.call(this, mod.exports, require.relative(resolved), mod);
|
36
|
+
delete module._resolving;
|
37
|
+
module.exports = mod.exports;
|
38
|
+
}
|
39
|
+
|
40
|
+
return module.exports;
|
41
|
+
}
|
42
|
+
|
43
|
+
/**
|
44
|
+
* Registered modules.
|
45
|
+
*/
|
46
|
+
|
47
|
+
require.modules = {};
|
48
|
+
|
49
|
+
/**
|
50
|
+
* Registered aliases.
|
51
|
+
*/
|
52
|
+
|
53
|
+
require.aliases = {};
|
54
|
+
|
55
|
+
/**
|
56
|
+
* Resolve `path`.
|
57
|
+
*
|
58
|
+
* Lookup:
|
59
|
+
*
|
60
|
+
* - PATH/index.js
|
61
|
+
* - PATH.js
|
62
|
+
* - PATH
|
63
|
+
*
|
64
|
+
* @param {String} path
|
65
|
+
* @return {String} path or null
|
66
|
+
* @api private
|
67
|
+
*/
|
68
|
+
|
69
|
+
require.resolve = function(path) {
|
70
|
+
if (path.charAt(0) === '/') path = path.slice(1);
|
71
|
+
|
72
|
+
var paths = [
|
73
|
+
path,
|
74
|
+
path + '.js',
|
75
|
+
path + '.json',
|
76
|
+
path + '/index.js',
|
77
|
+
path + '/index.json'
|
78
|
+
];
|
79
|
+
|
80
|
+
for (var i = 0; i < paths.length; i++) {
|
81
|
+
var path = paths[i];
|
82
|
+
if (require.modules.hasOwnProperty(path)) return path;
|
83
|
+
if (require.aliases.hasOwnProperty(path)) return require.aliases[path];
|
84
|
+
}
|
85
|
+
};
|
86
|
+
|
87
|
+
/**
|
88
|
+
* Normalize `path` relative to the current path.
|
89
|
+
*
|
90
|
+
* @param {String} curr
|
91
|
+
* @param {String} path
|
92
|
+
* @return {String}
|
93
|
+
* @api private
|
94
|
+
*/
|
95
|
+
|
96
|
+
require.normalize = function(curr, path) {
|
97
|
+
var segs = [];
|
98
|
+
|
99
|
+
if ('.' != path.charAt(0)) return path;
|
100
|
+
|
101
|
+
curr = curr.split('/');
|
102
|
+
path = path.split('/');
|
103
|
+
|
104
|
+
for (var i = 0; i < path.length; ++i) {
|
105
|
+
if ('..' == path[i]) {
|
106
|
+
curr.pop();
|
107
|
+
} else if ('.' != path[i] && '' != path[i]) {
|
108
|
+
segs.push(path[i]);
|
109
|
+
}
|
110
|
+
}
|
111
|
+
|
112
|
+
return curr.concat(segs).join('/');
|
113
|
+
};
|
114
|
+
|
115
|
+
/**
|
116
|
+
* Register module at `path` with callback `definition`.
|
117
|
+
*
|
118
|
+
* @param {String} path
|
119
|
+
* @param {Function} definition
|
120
|
+
* @api private
|
121
|
+
*/
|
122
|
+
|
123
|
+
require.register = function(path, definition) {
|
124
|
+
require.modules[path] = definition;
|
125
|
+
};
|
126
|
+
|
127
|
+
/**
|
128
|
+
* Alias a module definition.
|
129
|
+
*
|
130
|
+
* @param {String} from
|
131
|
+
* @param {String} to
|
132
|
+
* @api private
|
133
|
+
*/
|
134
|
+
|
135
|
+
require.alias = function(from, to) {
|
136
|
+
if (!require.modules.hasOwnProperty(from)) {
|
137
|
+
throw new Error('Failed to alias "' + from + '", it does not exist');
|
138
|
+
}
|
139
|
+
require.aliases[to] = from;
|
140
|
+
};
|
141
|
+
|
142
|
+
/**
|
143
|
+
* Return a require function relative to the `parent` path.
|
144
|
+
*
|
145
|
+
* @param {String} parent
|
146
|
+
* @return {Function}
|
147
|
+
* @api private
|
148
|
+
*/
|
149
|
+
|
150
|
+
require.relative = function(parent) {
|
151
|
+
var p = require.normalize(parent, '..');
|
152
|
+
|
153
|
+
/**
|
154
|
+
* lastIndexOf helper.
|
155
|
+
*/
|
156
|
+
|
157
|
+
function lastIndexOf(arr, obj) {
|
158
|
+
var i = arr.length;
|
159
|
+
while (i--) {
|
160
|
+
if (arr[i] === obj) return i;
|
161
|
+
}
|
162
|
+
return -1;
|
163
|
+
}
|
164
|
+
|
165
|
+
/**
|
166
|
+
* The relative require() itself.
|
167
|
+
*/
|
168
|
+
|
169
|
+
function localRequire(path) {
|
170
|
+
var resolved = localRequire.resolve(path);
|
171
|
+
return require(resolved, parent, path);
|
172
|
+
}
|
173
|
+
|
174
|
+
/**
|
175
|
+
* Resolve relative to the parent.
|
176
|
+
*/
|
177
|
+
|
178
|
+
localRequire.resolve = function(path) {
|
179
|
+
var c = path.charAt(0);
|
180
|
+
if ('/' == c) return path.slice(1);
|
181
|
+
if ('.' == c) return require.normalize(p, path);
|
182
|
+
|
183
|
+
// resolve deps by returning
|
184
|
+
// the dep in the nearest "deps"
|
185
|
+
// directory
|
186
|
+
var segs = parent.split('/');
|
187
|
+
var i = lastIndexOf(segs, 'deps') + 1;
|
188
|
+
if (!i) i = 0;
|
189
|
+
path = segs.slice(0, i + 1).join('/') + '/deps/' + path;
|
190
|
+
return path;
|
191
|
+
};
|
192
|
+
|
193
|
+
/**
|
194
|
+
* Check if module is defined at `path`.
|
195
|
+
*/
|
196
|
+
|
197
|
+
localRequire.exists = function(path) {
|
198
|
+
return require.modules.hasOwnProperty(localRequire.resolve(path));
|
199
|
+
};
|
200
|
+
|
201
|
+
return localRequire;
|
202
|
+
};
|
203
|
+
require.register("component-classes/index.js", function(exports, require, module){
|
204
|
+
/**
|
205
|
+
* Module dependencies.
|
206
|
+
*/
|
207
|
+
|
208
|
+
var index = require('indexof');
|
209
|
+
|
210
|
+
/**
|
211
|
+
* Whitespace regexp.
|
212
|
+
*/
|
213
|
+
|
214
|
+
var re = /\s+/;
|
215
|
+
|
216
|
+
/**
|
217
|
+
* toString reference.
|
218
|
+
*/
|
219
|
+
|
220
|
+
var toString = Object.prototype.toString;
|
221
|
+
|
222
|
+
/**
|
223
|
+
* Wrap `el` in a `ClassList`.
|
224
|
+
*
|
225
|
+
* @param {Element} el
|
226
|
+
* @return {ClassList}
|
227
|
+
* @api public
|
228
|
+
*/
|
229
|
+
|
230
|
+
module.exports = function(el){
|
231
|
+
return new ClassList(el);
|
232
|
+
};
|
233
|
+
|
234
|
+
/**
|
235
|
+
* Initialize a new ClassList for `el`.
|
236
|
+
*
|
237
|
+
* @param {Element} el
|
238
|
+
* @api private
|
239
|
+
*/
|
240
|
+
|
241
|
+
function ClassList(el) {
|
242
|
+
if (!el) throw new Error('A DOM element reference is required');
|
243
|
+
this.el = el;
|
244
|
+
this.list = el.classList;
|
245
|
+
}
|
246
|
+
|
247
|
+
/**
|
248
|
+
* Add class `name` if not already present.
|
249
|
+
*
|
250
|
+
* @param {String} name
|
251
|
+
* @return {ClassList}
|
252
|
+
* @api public
|
253
|
+
*/
|
254
|
+
|
255
|
+
ClassList.prototype.add = function(name){
|
256
|
+
// classList
|
257
|
+
if (this.list) {
|
258
|
+
this.list.add(name);
|
259
|
+
return this;
|
260
|
+
}
|
261
|
+
|
262
|
+
// fallback
|
263
|
+
var arr = this.array();
|
264
|
+
var i = index(arr, name);
|
265
|
+
if (!~i) arr.push(name);
|
266
|
+
this.el.className = arr.join(' ');
|
267
|
+
return this;
|
268
|
+
};
|
269
|
+
|
270
|
+
/**
|
271
|
+
* Remove class `name` when present, or
|
272
|
+
* pass a regular expression to remove
|
273
|
+
* any which match.
|
274
|
+
*
|
275
|
+
* @param {String|RegExp} name
|
276
|
+
* @return {ClassList}
|
277
|
+
* @api public
|
278
|
+
*/
|
279
|
+
|
280
|
+
ClassList.prototype.remove = function(name){
|
281
|
+
if ('[object RegExp]' == toString.call(name)) {
|
282
|
+
return this.removeMatching(name);
|
283
|
+
}
|
284
|
+
|
285
|
+
// classList
|
286
|
+
if (this.list) {
|
287
|
+
this.list.remove(name);
|
288
|
+
return this;
|
289
|
+
}
|
290
|
+
|
291
|
+
// fallback
|
292
|
+
var arr = this.array();
|
293
|
+
var i = index(arr, name);
|
294
|
+
if (~i) arr.splice(i, 1);
|
295
|
+
this.el.className = arr.join(' ');
|
296
|
+
return this;
|
297
|
+
};
|
298
|
+
|
299
|
+
/**
|
300
|
+
* Remove all classes matching `re`.
|
301
|
+
*
|
302
|
+
* @param {RegExp} re
|
303
|
+
* @return {ClassList}
|
304
|
+
* @api private
|
305
|
+
*/
|
306
|
+
|
307
|
+
ClassList.prototype.removeMatching = function(re){
|
308
|
+
var arr = this.array();
|
309
|
+
for (var i = 0; i < arr.length; i++) {
|
310
|
+
if (re.test(arr[i])) {
|
311
|
+
this.remove(arr[i]);
|
312
|
+
}
|
313
|
+
}
|
314
|
+
return this;
|
315
|
+
};
|
316
|
+
|
317
|
+
/**
|
318
|
+
* Toggle class `name`, can force state via `force`.
|
319
|
+
*
|
320
|
+
* For browsers that support classList, but do not support `force` yet,
|
321
|
+
* the mistake will be detected and corrected.
|
322
|
+
*
|
323
|
+
* @param {String} name
|
324
|
+
* @param {Boolean} force
|
325
|
+
* @return {ClassList}
|
326
|
+
* @api public
|
327
|
+
*/
|
328
|
+
|
329
|
+
ClassList.prototype.toggle = function(name, force){
|
330
|
+
// classList
|
331
|
+
if (this.list) {
|
332
|
+
if ("undefined" !== typeof force) {
|
333
|
+
if (force !== this.list.toggle(name, force)) {
|
334
|
+
this.list.toggle(name); // toggle again to correct
|
335
|
+
}
|
336
|
+
} else {
|
337
|
+
this.list.toggle(name);
|
338
|
+
}
|
339
|
+
return this;
|
340
|
+
}
|
341
|
+
|
342
|
+
// fallback
|
343
|
+
if ("undefined" !== typeof force) {
|
344
|
+
if (!force) {
|
345
|
+
this.remove(name);
|
346
|
+
} else {
|
347
|
+
this.add(name);
|
348
|
+
}
|
349
|
+
} else {
|
350
|
+
if (this.has(name)) {
|
351
|
+
this.remove(name);
|
352
|
+
} else {
|
353
|
+
this.add(name);
|
354
|
+
}
|
355
|
+
}
|
356
|
+
|
357
|
+
return this;
|
358
|
+
};
|
359
|
+
|
360
|
+
/**
|
361
|
+
* Return an array of classes.
|
362
|
+
*
|
363
|
+
* @return {Array}
|
364
|
+
* @api public
|
365
|
+
*/
|
366
|
+
|
367
|
+
ClassList.prototype.array = function(){
|
368
|
+
var str = this.el.className.replace(/^\s+|\s+$/g, '');
|
369
|
+
var arr = str.split(re);
|
370
|
+
if ('' === arr[0]) arr.shift();
|
371
|
+
return arr;
|
372
|
+
};
|
373
|
+
|
374
|
+
/**
|
375
|
+
* Check if class `name` is present.
|
376
|
+
*
|
377
|
+
* @param {String} name
|
378
|
+
* @return {ClassList}
|
379
|
+
* @api public
|
380
|
+
*/
|
381
|
+
|
382
|
+
ClassList.prototype.has =
|
383
|
+
ClassList.prototype.contains = function(name){
|
384
|
+
return this.list
|
385
|
+
? this.list.contains(name)
|
386
|
+
: !! ~index(this.array(), name);
|
387
|
+
};
|
388
|
+
|
389
|
+
});
|
390
|
+
require.register("segmentio-extend/index.js", function(exports, require, module){
|
391
|
+
|
392
|
+
module.exports = function extend (object) {
|
393
|
+
// Takes an unlimited number of extenders.
|
394
|
+
var args = Array.prototype.slice.call(arguments, 1);
|
395
|
+
|
396
|
+
// For each extender, copy their properties on our object.
|
397
|
+
for (var i = 0, source; source = args[i]; i++) {
|
398
|
+
if (!source) continue;
|
399
|
+
for (var property in source) {
|
400
|
+
object[property] = source[property];
|
401
|
+
}
|
402
|
+
}
|
403
|
+
|
404
|
+
return object;
|
405
|
+
};
|
406
|
+
});
|
407
|
+
require.register("component-indexof/index.js", function(exports, require, module){
|
408
|
+
module.exports = function(arr, obj){
|
409
|
+
if (arr.indexOf) return arr.indexOf(obj);
|
410
|
+
for (var i = 0; i < arr.length; ++i) {
|
411
|
+
if (arr[i] === obj) return i;
|
412
|
+
}
|
413
|
+
return -1;
|
414
|
+
};
|
415
|
+
});
|
416
|
+
require.register("component-event/index.js", function(exports, require, module){
|
417
|
+
var bind = window.addEventListener ? 'addEventListener' : 'attachEvent',
|
418
|
+
unbind = window.removeEventListener ? 'removeEventListener' : 'detachEvent',
|
419
|
+
prefix = bind !== 'addEventListener' ? 'on' : '';
|
420
|
+
|
421
|
+
/**
|
422
|
+
* Bind `el` event `type` to `fn`.
|
423
|
+
*
|
424
|
+
* @param {Element} el
|
425
|
+
* @param {String} type
|
426
|
+
* @param {Function} fn
|
427
|
+
* @param {Boolean} capture
|
428
|
+
* @return {Function}
|
429
|
+
* @api public
|
430
|
+
*/
|
431
|
+
|
432
|
+
exports.bind = function(el, type, fn, capture){
|
433
|
+
el[bind](prefix + type, fn, capture || false);
|
434
|
+
return fn;
|
435
|
+
};
|
436
|
+
|
437
|
+
/**
|
438
|
+
* Unbind `el` event `type`'s callback `fn`.
|
439
|
+
*
|
440
|
+
* @param {Element} el
|
441
|
+
* @param {String} type
|
442
|
+
* @param {Function} fn
|
443
|
+
* @param {Boolean} capture
|
444
|
+
* @return {Function}
|
445
|
+
* @api public
|
446
|
+
*/
|
447
|
+
|
448
|
+
exports.unbind = function(el, type, fn, capture){
|
449
|
+
el[unbind](prefix + type, fn, capture || false);
|
450
|
+
return fn;
|
451
|
+
};
|
452
|
+
});
|
453
|
+
require.register("timoxley-to-array/index.js", function(exports, require, module){
|
454
|
+
/**
|
455
|
+
* Convert an array-like object into an `Array`.
|
456
|
+
* If `collection` is already an `Array`, then will return a clone of `collection`.
|
457
|
+
*
|
458
|
+
* @param {Array | Mixed} collection An `Array` or array-like object to convert e.g. `arguments` or `NodeList`
|
459
|
+
* @return {Array} Naive conversion of `collection` to a new `Array`.
|
460
|
+
* @api public
|
461
|
+
*/
|
462
|
+
|
463
|
+
module.exports = function toArray(collection) {
|
464
|
+
if (typeof collection === 'undefined') return []
|
465
|
+
if (collection === null) return [null]
|
466
|
+
if (collection === window) return [window]
|
467
|
+
if (typeof collection === 'string') return [collection]
|
468
|
+
if (isArray(collection)) return collection
|
469
|
+
if (typeof collection.length != 'number') return [collection]
|
470
|
+
if (typeof collection === 'function' && collection instanceof Function) return [collection]
|
471
|
+
|
472
|
+
var arr = []
|
473
|
+
for (var i = 0; i < collection.length; i++) {
|
474
|
+
if (Object.prototype.hasOwnProperty.call(collection, i) || i in collection) {
|
475
|
+
arr.push(collection[i])
|
476
|
+
}
|
477
|
+
}
|
478
|
+
if (!arr.length) return []
|
479
|
+
return arr
|
480
|
+
}
|
481
|
+
|
482
|
+
function isArray(arr) {
|
483
|
+
return Object.prototype.toString.call(arr) === "[object Array]";
|
484
|
+
}
|
485
|
+
|
486
|
+
});
|
487
|
+
require.register("javve-events/index.js", function(exports, require, module){
|
488
|
+
var events = require('event'),
|
489
|
+
toArray = require('to-array');
|
490
|
+
|
491
|
+
/**
|
492
|
+
* Bind `el` event `type` to `fn`.
|
493
|
+
*
|
494
|
+
* @param {Element} el, NodeList, HTMLCollection or Array
|
495
|
+
* @param {String} type
|
496
|
+
* @param {Function} fn
|
497
|
+
* @param {Boolean} capture
|
498
|
+
* @api public
|
499
|
+
*/
|
500
|
+
|
501
|
+
exports.bind = function(el, type, fn, capture){
|
502
|
+
el = toArray(el);
|
503
|
+
for ( var i = 0; i < el.length; i++ ) {
|
504
|
+
events.bind(el[i], type, fn, capture);
|
505
|
+
}
|
506
|
+
};
|
507
|
+
|
508
|
+
/**
|
509
|
+
* Unbind `el` event `type`'s callback `fn`.
|
510
|
+
*
|
511
|
+
* @param {Element} el, NodeList, HTMLCollection or Array
|
512
|
+
* @param {String} type
|
513
|
+
* @param {Function} fn
|
514
|
+
* @param {Boolean} capture
|
515
|
+
* @api public
|
516
|
+
*/
|
517
|
+
|
518
|
+
exports.unbind = function(el, type, fn, capture){
|
519
|
+
el = toArray(el);
|
520
|
+
for ( var i = 0; i < el.length; i++ ) {
|
521
|
+
events.unbind(el[i], type, fn, capture);
|
522
|
+
}
|
523
|
+
};
|
524
|
+
|
525
|
+
});
|
526
|
+
require.register("javve-get-by-class/index.js", function(exports, require, module){
|
527
|
+
/**
|
528
|
+
* Find all elements with class `className` inside `container`.
|
529
|
+
* Use `single = true` to increase performance in older browsers
|
530
|
+
* when only one element is needed.
|
531
|
+
*
|
532
|
+
* @param {String} className
|
533
|
+
* @param {Element} container
|
534
|
+
* @param {Boolean} single
|
535
|
+
* @api public
|
536
|
+
*/
|
537
|
+
|
538
|
+
module.exports = (function() {
|
539
|
+
if (document.getElementsByClassName) {
|
540
|
+
return function(container, className, single) {
|
541
|
+
if (single) {
|
542
|
+
return container.getElementsByClassName(className)[0];
|
543
|
+
} else {
|
544
|
+
return container.getElementsByClassName(className);
|
545
|
+
}
|
546
|
+
};
|
547
|
+
} else if (document.querySelector) {
|
548
|
+
return function(container, className, single) {
|
549
|
+
className = '.' + className;
|
550
|
+
if (single) {
|
551
|
+
return container.querySelector(className);
|
552
|
+
} else {
|
553
|
+
return container.querySelectorAll(className);
|
554
|
+
}
|
555
|
+
};
|
556
|
+
} else {
|
557
|
+
return function(container, className, single) {
|
558
|
+
var classElements = [],
|
559
|
+
tag = '*';
|
560
|
+
if (container == null) {
|
561
|
+
container = document;
|
562
|
+
}
|
563
|
+
var els = container.getElementsByTagName(tag);
|
564
|
+
var elsLen = els.length;
|
565
|
+
var pattern = new RegExp("(^|\\s)"+className+"(\\s|$)");
|
566
|
+
for (var i = 0, j = 0; i < elsLen; i++) {
|
567
|
+
if ( pattern.test(els[i].className) ) {
|
568
|
+
if (single) {
|
569
|
+
return els[i];
|
570
|
+
} else {
|
571
|
+
classElements[j] = els[i];
|
572
|
+
j++;
|
573
|
+
}
|
574
|
+
}
|
575
|
+
}
|
576
|
+
return classElements;
|
577
|
+
};
|
578
|
+
}
|
579
|
+
})();
|
580
|
+
|
581
|
+
});
|
582
|
+
require.register("javve-get-attribute/index.js", function(exports, require, module){
|
583
|
+
/**
|
584
|
+
* Return the value for `attr` at `element`.
|
585
|
+
*
|
586
|
+
* @param {Element} el
|
587
|
+
* @param {String} attr
|
588
|
+
* @api public
|
589
|
+
*/
|
590
|
+
|
591
|
+
module.exports = function(el, attr) {
|
592
|
+
var result = (el.getAttribute && el.getAttribute(attr)) || null;
|
593
|
+
if( !result ) {
|
594
|
+
var attrs = el.attributes;
|
595
|
+
var length = attrs.length;
|
596
|
+
for(var i = 0; i < length; i++) {
|
597
|
+
if (attr[i] !== undefined) {
|
598
|
+
if(attr[i].nodeName === attr) {
|
599
|
+
result = attr[i].nodeValue;
|
600
|
+
}
|
601
|
+
}
|
602
|
+
}
|
603
|
+
}
|
604
|
+
return result;
|
605
|
+
}
|
606
|
+
});
|
607
|
+
require.register("javve-natural-sort/index.js", function(exports, require, module){
|
608
|
+
/*
|
609
|
+
* Natural Sort algorithm for Javascript - Version 0.7 - Released under MIT license
|
610
|
+
* Author: Jim Palmer (based on chunking idea from Dave Koelle)
|
611
|
+
*/
|
612
|
+
|
613
|
+
module.exports = function(a, b, options) {
|
614
|
+
var re = /(^-?[0-9]+(\.?[0-9]*)[df]?e?[0-9]?$|^0x[0-9a-f]+$|[0-9]+)/gi,
|
615
|
+
sre = /(^[ ]*|[ ]*$)/g,
|
616
|
+
dre = /(^([\w ]+,?[\w ]+)?[\w ]+,?[\w ]+\d+:\d+(:\d+)?[\w ]?|^\d{1,4}[\/\-]\d{1,4}[\/\-]\d{1,4}|^\w+, \w+ \d+, \d{4})/,
|
617
|
+
hre = /^0x[0-9a-f]+$/i,
|
618
|
+
ore = /^0/,
|
619
|
+
options = options || {},
|
620
|
+
i = function(s) { return options.insensitive && (''+s).toLowerCase() || ''+s },
|
621
|
+
// convert all to strings strip whitespace
|
622
|
+
x = i(a).replace(sre, '') || '',
|
623
|
+
y = i(b).replace(sre, '') || '',
|
624
|
+
// chunk/tokenize
|
625
|
+
xN = x.replace(re, '\0$1\0').replace(/\0$/,'').replace(/^\0/,'').split('\0'),
|
626
|
+
yN = y.replace(re, '\0$1\0').replace(/\0$/,'').replace(/^\0/,'').split('\0'),
|
627
|
+
// numeric, hex or date detection
|
628
|
+
xD = parseInt(x.match(hre)) || (xN.length != 1 && x.match(dre) && Date.parse(x)),
|
629
|
+
yD = parseInt(y.match(hre)) || xD && y.match(dre) && Date.parse(y) || null,
|
630
|
+
oFxNcL, oFyNcL,
|
631
|
+
mult = options.desc ? -1 : 1;
|
632
|
+
// first try and sort Hex codes or Dates
|
633
|
+
if (yD)
|
634
|
+
if ( xD < yD ) return -1 * mult;
|
635
|
+
else if ( xD > yD ) return 1 * mult;
|
636
|
+
// natural sorting through split numeric strings and default strings
|
637
|
+
for(var cLoc=0, numS=Math.max(xN.length, yN.length); cLoc < numS; cLoc++) {
|
638
|
+
// find floats not starting with '0', string or 0 if not defined (Clint Priest)
|
639
|
+
oFxNcL = !(xN[cLoc] || '').match(ore) && parseFloat(xN[cLoc]) || xN[cLoc] || 0;
|
640
|
+
oFyNcL = !(yN[cLoc] || '').match(ore) && parseFloat(yN[cLoc]) || yN[cLoc] || 0;
|
641
|
+
// handle numeric vs string comparison - number < string - (Kyle Adams)
|
642
|
+
if (isNaN(oFxNcL) !== isNaN(oFyNcL)) { return (isNaN(oFxNcL)) ? 1 : -1; }
|
643
|
+
// rely on string comparison if different types - i.e. '02' < 2 != '02' < '2'
|
644
|
+
else if (typeof oFxNcL !== typeof oFyNcL) {
|
645
|
+
oFxNcL += '';
|
646
|
+
oFyNcL += '';
|
647
|
+
}
|
648
|
+
if (oFxNcL < oFyNcL) return -1 * mult;
|
649
|
+
if (oFxNcL > oFyNcL) return 1 * mult;
|
650
|
+
}
|
651
|
+
return 0;
|
652
|
+
};
|
653
|
+
|
654
|
+
/*
|
655
|
+
var defaultSort = getSortFunction();
|
656
|
+
|
657
|
+
module.exports = function(a, b, options) {
|
658
|
+
if (arguments.length == 1) {
|
659
|
+
options = a;
|
660
|
+
return getSortFunction(options);
|
661
|
+
} else {
|
662
|
+
return defaultSort(a,b);
|
663
|
+
}
|
664
|
+
}
|
665
|
+
*/
|
666
|
+
});
|
667
|
+
require.register("javve-to-string/index.js", function(exports, require, module){
|
668
|
+
module.exports = function(s) {
|
669
|
+
s = (s === undefined) ? "" : s;
|
670
|
+
s = (s === null) ? "" : s;
|
671
|
+
s = s.toString();
|
672
|
+
return s;
|
673
|
+
};
|
674
|
+
|
675
|
+
});
|
676
|
+
require.register("component-type/index.js", function(exports, require, module){
|
677
|
+
/**
|
678
|
+
* toString ref.
|
679
|
+
*/
|
680
|
+
|
681
|
+
var toString = Object.prototype.toString;
|
682
|
+
|
683
|
+
/**
|
684
|
+
* Return the type of `val`.
|
685
|
+
*
|
686
|
+
* @param {Mixed} val
|
687
|
+
* @return {String}
|
688
|
+
* @api public
|
689
|
+
*/
|
690
|
+
|
691
|
+
module.exports = function(val){
|
692
|
+
switch (toString.call(val)) {
|
693
|
+
case '[object Date]': return 'date';
|
694
|
+
case '[object RegExp]': return 'regexp';
|
695
|
+
case '[object Arguments]': return 'arguments';
|
696
|
+
case '[object Array]': return 'array';
|
697
|
+
case '[object Error]': return 'error';
|
698
|
+
}
|
699
|
+
|
700
|
+
if (val === null) return 'null';
|
701
|
+
if (val === undefined) return 'undefined';
|
702
|
+
if (val !== val) return 'nan';
|
703
|
+
if (val && val.nodeType === 1) return 'element';
|
704
|
+
|
705
|
+
return typeof val.valueOf();
|
706
|
+
};
|
707
|
+
|
708
|
+
});
|
709
|
+
require.register("list.js/index.js", function(exports, require, module){
|
710
|
+
/*
|
711
|
+
ListJS with beta 1.0.0
|
712
|
+
By Jonny Strömberg (www.jonnystromberg.com, www.listjs.com)
|
713
|
+
*/
|
714
|
+
(function( window, undefined ) {
|
715
|
+
"use strict";
|
716
|
+
|
717
|
+
var document = window.document,
|
718
|
+
getByClass = require('get-by-class'),
|
719
|
+
extend = require('extend'),
|
720
|
+
indexOf = require('indexof');
|
721
|
+
|
722
|
+
var List = function(id, options, values) {
|
723
|
+
|
724
|
+
var self = this,
|
725
|
+
init,
|
726
|
+
Item = require('./src/item')(self),
|
727
|
+
addAsync = require('./src/add-async')(self),
|
728
|
+
parse = require('./src/parse')(self);
|
729
|
+
|
730
|
+
init = {
|
731
|
+
start: function() {
|
732
|
+
self.listClass = "list";
|
733
|
+
self.searchClass = "search";
|
734
|
+
self.sortClass = "sort";
|
735
|
+
self.page = 1024;
|
736
|
+
self.i = 1;
|
737
|
+
self.items = [];
|
738
|
+
self.visibleItems = [];
|
739
|
+
self.matchingItems = [];
|
740
|
+
self.searched = false;
|
741
|
+
self.filtered = false;
|
742
|
+
self.handlers = { 'updated': [] };
|
743
|
+
self.plugins = {};
|
744
|
+
self.helpers = {
|
745
|
+
getByClass: getByClass,
|
746
|
+
extend: extend,
|
747
|
+
indexOf: indexOf
|
748
|
+
};
|
749
|
+
|
750
|
+
extend(self, options);
|
751
|
+
|
752
|
+
self.listContainer = (typeof(id) === 'string') ? document.getElementById(id) : id;
|
753
|
+
if (!self.listContainer) { return; }
|
754
|
+
self.list = getByClass(self.listContainer, self.listClass, true);
|
755
|
+
|
756
|
+
self.templater = require('./src/templater')(self);
|
757
|
+
self.search = require('./src/search')(self);
|
758
|
+
self.filter = require('./src/filter')(self);
|
759
|
+
self.sort = require('./src/sort')(self);
|
760
|
+
|
761
|
+
this.items();
|
762
|
+
self.update();
|
763
|
+
this.plugins();
|
764
|
+
},
|
765
|
+
items: function() {
|
766
|
+
parse(self.list);
|
767
|
+
if (values !== undefined) {
|
768
|
+
self.add(values);
|
769
|
+
}
|
770
|
+
},
|
771
|
+
plugins: function() {
|
772
|
+
for (var i = 0; i < self.plugins.length; i++) {
|
773
|
+
var plugin = self.plugins[i];
|
774
|
+
self[plugin.name] = plugin;
|
775
|
+
plugin.init(self);
|
776
|
+
}
|
777
|
+
}
|
778
|
+
};
|
779
|
+
|
780
|
+
|
781
|
+
/*
|
782
|
+
* Add object to list
|
783
|
+
*/
|
784
|
+
this.add = function(values, callback) {
|
785
|
+
if (callback) {
|
786
|
+
addAsync(values, callback);
|
787
|
+
return;
|
788
|
+
}
|
789
|
+
var added = [],
|
790
|
+
notCreate = false;
|
791
|
+
if (values[0] === undefined){
|
792
|
+
values = [values];
|
793
|
+
}
|
794
|
+
for (var i = 0, il = values.length; i < il; i++) {
|
795
|
+
var item = null;
|
796
|
+
if (values[i] instanceof Item) {
|
797
|
+
item = values[i];
|
798
|
+
item.reload();
|
799
|
+
} else {
|
800
|
+
notCreate = (self.items.length > self.page) ? true : false;
|
801
|
+
item = new Item(values[i], undefined, notCreate);
|
802
|
+
}
|
803
|
+
self.items.push(item);
|
804
|
+
added.push(item);
|
805
|
+
}
|
806
|
+
self.update();
|
807
|
+
return added;
|
808
|
+
};
|
809
|
+
|
810
|
+
this.show = function(i, page) {
|
811
|
+
this.i = i;
|
812
|
+
this.page = page;
|
813
|
+
self.update();
|
814
|
+
return self;
|
815
|
+
};
|
816
|
+
|
817
|
+
/* Removes object from list.
|
818
|
+
* Loops through the list and removes objects where
|
819
|
+
* property "valuename" === value
|
820
|
+
*/
|
821
|
+
this.remove = function(valueName, value, options) {
|
822
|
+
var found = 0;
|
823
|
+
for (var i = 0, il = self.items.length; i < il; i++) {
|
824
|
+
if (self.items[i].values()[valueName] == value) {
|
825
|
+
self.templater.remove(self.items[i], options);
|
826
|
+
self.items.splice(i,1);
|
827
|
+
il--;
|
828
|
+
i--;
|
829
|
+
found++;
|
830
|
+
}
|
831
|
+
}
|
832
|
+
self.update();
|
833
|
+
return found;
|
834
|
+
};
|
835
|
+
|
836
|
+
/* Gets the objects in the list which
|
837
|
+
* property "valueName" === value
|
838
|
+
*/
|
839
|
+
this.get = function(valueName, value) {
|
840
|
+
var matchedItems = [];
|
841
|
+
for (var i = 0, il = self.items.length; i < il; i++) {
|
842
|
+
var item = self.items[i];
|
843
|
+
if (item.values()[valueName] == value) {
|
844
|
+
matchedItems.push(item);
|
845
|
+
}
|
846
|
+
}
|
847
|
+
return matchedItems;
|
848
|
+
};
|
849
|
+
|
850
|
+
/*
|
851
|
+
* Get size of the list
|
852
|
+
*/
|
853
|
+
this.size = function() {
|
854
|
+
return self.items.length;
|
855
|
+
};
|
856
|
+
|
857
|
+
/*
|
858
|
+
* Removes all items from the list
|
859
|
+
*/
|
860
|
+
this.clear = function() {
|
861
|
+
self.templater.clear();
|
862
|
+
self.items = [];
|
863
|
+
return self;
|
864
|
+
};
|
865
|
+
|
866
|
+
this.on = function(event, callback) {
|
867
|
+
self.handlers[event].push(callback);
|
868
|
+
return self;
|
869
|
+
};
|
870
|
+
|
871
|
+
this.off = function(event, callback) {
|
872
|
+
var e = self.handlers[event];
|
873
|
+
var index = indexOf(e, callback);
|
874
|
+
if (index > -1) {
|
875
|
+
e.splice(index, 1);
|
876
|
+
}
|
877
|
+
return self;
|
878
|
+
};
|
879
|
+
|
880
|
+
this.trigger = function(event) {
|
881
|
+
var i = self.handlers[event].length;
|
882
|
+
while(i--) {
|
883
|
+
self.handlers[event][i](self);
|
884
|
+
}
|
885
|
+
return self;
|
886
|
+
};
|
887
|
+
|
888
|
+
this.reset = {
|
889
|
+
filter: function() {
|
890
|
+
var is = self.items,
|
891
|
+
il = is.length;
|
892
|
+
while (il--) {
|
893
|
+
is[il].filtered = false;
|
894
|
+
}
|
895
|
+
return self;
|
896
|
+
},
|
897
|
+
search: function() {
|
898
|
+
var is = self.items,
|
899
|
+
il = is.length;
|
900
|
+
while (il--) {
|
901
|
+
is[il].found = false;
|
902
|
+
}
|
903
|
+
return self;
|
904
|
+
}
|
905
|
+
};
|
906
|
+
|
907
|
+
this.update = function() {
|
908
|
+
var is = self.items,
|
909
|
+
il = is.length;
|
910
|
+
|
911
|
+
self.visibleItems = [];
|
912
|
+
self.matchingItems = [];
|
913
|
+
self.templater.clear();
|
914
|
+
for (var i = 0; i < il; i++) {
|
915
|
+
if (is[i].matching() && ((self.matchingItems.length+1) >= self.i && self.visibleItems.length < self.page)) {
|
916
|
+
is[i].show();
|
917
|
+
self.visibleItems.push(is[i]);
|
918
|
+
self.matchingItems.push(is[i]);
|
919
|
+
} else if (is[i].matching()) {
|
920
|
+
self.matchingItems.push(is[i]);
|
921
|
+
is[i].hide();
|
922
|
+
} else {
|
923
|
+
is[i].hide();
|
924
|
+
}
|
925
|
+
}
|
926
|
+
self.trigger('updated');
|
927
|
+
return self;
|
928
|
+
};
|
929
|
+
|
930
|
+
init.start();
|
931
|
+
};
|
932
|
+
|
933
|
+
module.exports = List;
|
934
|
+
|
935
|
+
})(window);
|
936
|
+
|
937
|
+
});
|
938
|
+
require.register("list.js/src/search.js", function(exports, require, module){
|
939
|
+
var events = require('events'),
|
940
|
+
getByClass = require('get-by-class'),
|
941
|
+
toString = require('to-string');
|
942
|
+
|
943
|
+
module.exports = function(list) {
|
944
|
+
var item,
|
945
|
+
text,
|
946
|
+
columns,
|
947
|
+
searchString,
|
948
|
+
customSearch;
|
949
|
+
|
950
|
+
var prepare = {
|
951
|
+
resetList: function() {
|
952
|
+
list.i = 1;
|
953
|
+
list.templater.clear();
|
954
|
+
customSearch = undefined;
|
955
|
+
},
|
956
|
+
setOptions: function(args) {
|
957
|
+
if (args.length == 2 && args[1] instanceof Array) {
|
958
|
+
columns = args[1];
|
959
|
+
} else if (args.length == 2 && typeof(args[1]) == "function") {
|
960
|
+
customSearch = args[1];
|
961
|
+
} else if (args.length == 3) {
|
962
|
+
columns = args[1];
|
963
|
+
customSearch = args[2];
|
964
|
+
}
|
965
|
+
},
|
966
|
+
setColumns: function() {
|
967
|
+
columns = (columns === undefined) ? prepare.toArray(list.items[0].values()) : columns;
|
968
|
+
},
|
969
|
+
setSearchString: function(s) {
|
970
|
+
s = toString(s).toLowerCase();
|
971
|
+
s = s.replace(/[-[\]{}()*+?.,\\^$|#]/g, "\\$&"); // Escape regular expression characters
|
972
|
+
searchString = s;
|
973
|
+
},
|
974
|
+
toArray: function(values) {
|
975
|
+
var tmpColumn = [];
|
976
|
+
for (var name in values) {
|
977
|
+
tmpColumn.push(name);
|
978
|
+
}
|
979
|
+
return tmpColumn;
|
980
|
+
}
|
981
|
+
};
|
982
|
+
var search = {
|
983
|
+
list: function() {
|
984
|
+
for (var k = 0, kl = list.items.length; k < kl; k++) {
|
985
|
+
search.item(list.items[k]);
|
986
|
+
}
|
987
|
+
},
|
988
|
+
item: function(item) {
|
989
|
+
item.found = false;
|
990
|
+
for (var j = 0, jl = columns.length; j < jl; j++) {
|
991
|
+
if (search.values(item.values(), columns[j])) {
|
992
|
+
item.found = true;
|
993
|
+
return;
|
994
|
+
}
|
995
|
+
}
|
996
|
+
},
|
997
|
+
values: function(values, column) {
|
998
|
+
if (values.hasOwnProperty(column)) {
|
999
|
+
text = toString(values[column]).toLowerCase();
|
1000
|
+
if ((searchString !== "") && (text.search(searchString) > -1)) {
|
1001
|
+
return true;
|
1002
|
+
}
|
1003
|
+
}
|
1004
|
+
return false;
|
1005
|
+
},
|
1006
|
+
reset: function() {
|
1007
|
+
list.reset.search();
|
1008
|
+
list.searched = false;
|
1009
|
+
}
|
1010
|
+
};
|
1011
|
+
|
1012
|
+
var searchMethod = function(str) {
|
1013
|
+
list.trigger('searchStart');
|
1014
|
+
|
1015
|
+
prepare.resetList();
|
1016
|
+
prepare.setSearchString(str);
|
1017
|
+
prepare.setOptions(arguments); // str, cols|searchFunction, searchFunction
|
1018
|
+
prepare.setColumns();
|
1019
|
+
|
1020
|
+
if (searchString === "" ) {
|
1021
|
+
search.reset();
|
1022
|
+
} else {
|
1023
|
+
list.searched = true;
|
1024
|
+
if (customSearch) {
|
1025
|
+
customSearch(searchString, columns);
|
1026
|
+
} else {
|
1027
|
+
search.list();
|
1028
|
+
}
|
1029
|
+
}
|
1030
|
+
|
1031
|
+
list.update();
|
1032
|
+
list.trigger('searchComplete');
|
1033
|
+
return list.visibleItems;
|
1034
|
+
};
|
1035
|
+
|
1036
|
+
list.handlers.searchStart = list.handlers.searchStart || [];
|
1037
|
+
list.handlers.searchComplete = list.handlers.searchComplete || [];
|
1038
|
+
|
1039
|
+
events.bind(getByClass(list.listContainer, list.searchClass), 'keyup', function(e) {
|
1040
|
+
var target = e.target || e.srcElement, // IE have srcElement
|
1041
|
+
alreadyCleared = (target.value === "" && !list.searched);
|
1042
|
+
if (!alreadyCleared) { // If oninput already have resetted the list, do nothing
|
1043
|
+
searchMethod(target.value);
|
1044
|
+
}
|
1045
|
+
});
|
1046
|
+
|
1047
|
+
// Used to detect click on HTML5 clear button
|
1048
|
+
events.bind(getByClass(list.listContainer, list.searchClass), 'input', function(e) {
|
1049
|
+
var target = e.target || e.srcElement;
|
1050
|
+
if (target.value === "") {
|
1051
|
+
searchMethod('');
|
1052
|
+
}
|
1053
|
+
});
|
1054
|
+
|
1055
|
+
list.helpers.toString = toString;
|
1056
|
+
return searchMethod;
|
1057
|
+
};
|
1058
|
+
|
1059
|
+
});
|
1060
|
+
require.register("list.js/src/sort.js", function(exports, require, module){
|
1061
|
+
var naturalSort = require('natural-sort'),
|
1062
|
+
classes = require('classes'),
|
1063
|
+
events = require('events'),
|
1064
|
+
getByClass = require('get-by-class'),
|
1065
|
+
getAttribute = require('get-attribute');
|
1066
|
+
|
1067
|
+
module.exports = function(list) {
|
1068
|
+
list.sortFunction = list.sortFunction || function(itemA, itemB, options) {
|
1069
|
+
options.desc = options.order == "desc" ? true : false; // Natural sort uses this format
|
1070
|
+
return naturalSort(itemA.values()[options.valueName], itemB.values()[options.valueName], options);
|
1071
|
+
};
|
1072
|
+
|
1073
|
+
var buttons = {
|
1074
|
+
els: undefined,
|
1075
|
+
clear: function() {
|
1076
|
+
for (var i = 0, il = buttons.els.length; i < il; i++) {
|
1077
|
+
classes(buttons.els[i]).remove('asc');
|
1078
|
+
classes(buttons.els[i]).remove('desc');
|
1079
|
+
}
|
1080
|
+
},
|
1081
|
+
getOrder: function(btn) {
|
1082
|
+
var predefinedOrder = getAttribute(btn, 'data-order');
|
1083
|
+
if (predefinedOrder == "asc" || predefinedOrder == "desc") {
|
1084
|
+
return predefinedOrder;
|
1085
|
+
} else if (classes(btn).has('desc')) {
|
1086
|
+
return "asc";
|
1087
|
+
} else if (classes(btn).has('asc')) {
|
1088
|
+
return "desc";
|
1089
|
+
} else {
|
1090
|
+
return "asc";
|
1091
|
+
}
|
1092
|
+
},
|
1093
|
+
getInSensitive: function(btn, options) {
|
1094
|
+
var insensitive = getAttribute(btn, 'data-insensitive');
|
1095
|
+
if (insensitive === "true") {
|
1096
|
+
options.insensitive = true;
|
1097
|
+
} else {
|
1098
|
+
options.insensitive = false;
|
1099
|
+
}
|
1100
|
+
},
|
1101
|
+
setOrder: function(options) {
|
1102
|
+
for (var i = 0, il = buttons.els.length; i < il; i++) {
|
1103
|
+
var btn = buttons.els[i];
|
1104
|
+
if (getAttribute(btn, 'data-sort') !== options.valueName) {
|
1105
|
+
continue;
|
1106
|
+
}
|
1107
|
+
var predefinedOrder = getAttribute(btn, 'data-order');
|
1108
|
+
if (predefinedOrder == "asc" || predefinedOrder == "desc") {
|
1109
|
+
if (predefinedOrder == options.order) {
|
1110
|
+
classes(btn).add(options.order);
|
1111
|
+
}
|
1112
|
+
} else {
|
1113
|
+
classes(btn).add(options.order);
|
1114
|
+
}
|
1115
|
+
}
|
1116
|
+
}
|
1117
|
+
};
|
1118
|
+
var sort = function() {
|
1119
|
+
list.trigger('sortStart');
|
1120
|
+
options = {};
|
1121
|
+
|
1122
|
+
var target = arguments[0].currentTarget || arguments[0].srcElement || undefined;
|
1123
|
+
|
1124
|
+
if (target) {
|
1125
|
+
options.valueName = getAttribute(target, 'data-sort');
|
1126
|
+
buttons.getInSensitive(target, options);
|
1127
|
+
options.order = buttons.getOrder(target);
|
1128
|
+
} else {
|
1129
|
+
options = arguments[1] || options;
|
1130
|
+
options.valueName = arguments[0];
|
1131
|
+
options.order = options.order || "asc";
|
1132
|
+
options.insensitive = (typeof options.insensitive == "undefined") ? true : options.insensitive;
|
1133
|
+
}
|
1134
|
+
buttons.clear();
|
1135
|
+
buttons.setOrder(options);
|
1136
|
+
|
1137
|
+
options.sortFunction = options.sortFunction || list.sortFunction;
|
1138
|
+
list.items.sort(function(a, b) {
|
1139
|
+
return options.sortFunction(a, b, options);
|
1140
|
+
});
|
1141
|
+
list.update();
|
1142
|
+
list.trigger('sortComplete');
|
1143
|
+
};
|
1144
|
+
|
1145
|
+
// Add handlers
|
1146
|
+
list.handlers.sortStart = list.handlers.sortStart || [];
|
1147
|
+
list.handlers.sortComplete = list.handlers.sortComplete || [];
|
1148
|
+
|
1149
|
+
buttons.els = getByClass(list.listContainer, list.sortClass);
|
1150
|
+
events.bind(buttons.els, 'click', sort);
|
1151
|
+
list.on('searchStart', buttons.clear);
|
1152
|
+
list.on('filterStart', buttons.clear);
|
1153
|
+
|
1154
|
+
// Helpers
|
1155
|
+
list.helpers.classes = classes;
|
1156
|
+
list.helpers.naturalSort = naturalSort;
|
1157
|
+
list.helpers.events = events;
|
1158
|
+
list.helpers.getAttribute = getAttribute;
|
1159
|
+
|
1160
|
+
return sort;
|
1161
|
+
};
|
1162
|
+
|
1163
|
+
});
|
1164
|
+
require.register("list.js/src/item.js", function(exports, require, module){
|
1165
|
+
module.exports = function(list) {
|
1166
|
+
return function(initValues, element, notCreate) {
|
1167
|
+
var item = this;
|
1168
|
+
|
1169
|
+
this._values = {};
|
1170
|
+
|
1171
|
+
this.found = false; // Show if list.searched == true and this.found == true
|
1172
|
+
this.filtered = false;// Show if list.filtered == true and this.filtered == true
|
1173
|
+
|
1174
|
+
var init = function(initValues, element, notCreate) {
|
1175
|
+
if (element === undefined) {
|
1176
|
+
if (notCreate) {
|
1177
|
+
item.values(initValues, notCreate);
|
1178
|
+
} else {
|
1179
|
+
item.values(initValues);
|
1180
|
+
}
|
1181
|
+
} else {
|
1182
|
+
item.elm = element;
|
1183
|
+
var values = list.templater.get(item, initValues);
|
1184
|
+
item.values(values);
|
1185
|
+
}
|
1186
|
+
};
|
1187
|
+
this.values = function(newValues, notCreate) {
|
1188
|
+
if (newValues !== undefined) {
|
1189
|
+
for(var name in newValues) {
|
1190
|
+
item._values[name] = newValues[name];
|
1191
|
+
}
|
1192
|
+
if (notCreate !== true) {
|
1193
|
+
list.templater.set(item, item.values());
|
1194
|
+
}
|
1195
|
+
} else {
|
1196
|
+
return item._values;
|
1197
|
+
}
|
1198
|
+
};
|
1199
|
+
this.show = function() {
|
1200
|
+
list.templater.show(item);
|
1201
|
+
};
|
1202
|
+
this.hide = function() {
|
1203
|
+
list.templater.hide(item);
|
1204
|
+
};
|
1205
|
+
this.matching = function() {
|
1206
|
+
return (
|
1207
|
+
(list.filtered && list.searched && item.found && item.filtered) ||
|
1208
|
+
(list.filtered && !list.searched && item.filtered) ||
|
1209
|
+
(!list.filtered && list.searched && item.found) ||
|
1210
|
+
(!list.filtered && !list.searched)
|
1211
|
+
);
|
1212
|
+
};
|
1213
|
+
this.visible = function() {
|
1214
|
+
return (item.elm.parentNode == list.list) ? true : false;
|
1215
|
+
};
|
1216
|
+
init(initValues, element, notCreate);
|
1217
|
+
};
|
1218
|
+
};
|
1219
|
+
|
1220
|
+
});
|
1221
|
+
require.register("list.js/src/templater.js", function(exports, require, module){
|
1222
|
+
var getByClass = require('get-by-class');
|
1223
|
+
|
1224
|
+
var Templater = function(list) {
|
1225
|
+
var itemSource = getItemSource(list.item),
|
1226
|
+
templater = this;
|
1227
|
+
|
1228
|
+
function getItemSource(item) {
|
1229
|
+
if (item === undefined) {
|
1230
|
+
var nodes = list.list.childNodes,
|
1231
|
+
items = [];
|
1232
|
+
|
1233
|
+
for (var i = 0, il = nodes.length; i < il; i++) {
|
1234
|
+
// Only textnodes have a data attribute
|
1235
|
+
if (nodes[i].data === undefined) {
|
1236
|
+
return nodes[i];
|
1237
|
+
}
|
1238
|
+
}
|
1239
|
+
return null;
|
1240
|
+
} else if (item.indexOf("<") !== -1) { // Try create html element of list, do not work for tables!!
|
1241
|
+
var div = document.createElement('div');
|
1242
|
+
div.innerHTML = item;
|
1243
|
+
return div.firstChild;
|
1244
|
+
} else {
|
1245
|
+
return document.getElementById(list.item);
|
1246
|
+
}
|
1247
|
+
}
|
1248
|
+
|
1249
|
+
/* Get values from element */
|
1250
|
+
this.get = function(item, valueNames) {
|
1251
|
+
templater.create(item);
|
1252
|
+
var values = {};
|
1253
|
+
for(var i = 0, il = valueNames.length; i < il; i++) {
|
1254
|
+
var elm = getByClass(item.elm, valueNames[i], true);
|
1255
|
+
values[valueNames[i]] = elm ? elm.innerHTML : "";
|
1256
|
+
}
|
1257
|
+
return values;
|
1258
|
+
};
|
1259
|
+
|
1260
|
+
/* Sets values at element */
|
1261
|
+
this.set = function(item, values) {
|
1262
|
+
if (!templater.create(item)) {
|
1263
|
+
for(var v in values) {
|
1264
|
+
if (values.hasOwnProperty(v)) {
|
1265
|
+
// TODO speed up if possible
|
1266
|
+
var elm = getByClass(item.elm, v, true);
|
1267
|
+
if (elm) {
|
1268
|
+
/* src attribute for image tag & text for other tags */
|
1269
|
+
if (elm.tagName === "IMG" && values[v] !== "") {
|
1270
|
+
elm.src = values[v];
|
1271
|
+
} else {
|
1272
|
+
elm.innerHTML = values[v];
|
1273
|
+
}
|
1274
|
+
}
|
1275
|
+
}
|
1276
|
+
}
|
1277
|
+
}
|
1278
|
+
};
|
1279
|
+
|
1280
|
+
this.create = function(item) {
|
1281
|
+
if (item.elm !== undefined) {
|
1282
|
+
return false;
|
1283
|
+
}
|
1284
|
+
/* If item source does not exists, use the first item in list as
|
1285
|
+
source for new items */
|
1286
|
+
var newItem = itemSource.cloneNode(true);
|
1287
|
+
newItem.removeAttribute('id');
|
1288
|
+
item.elm = newItem;
|
1289
|
+
templater.set(item, item.values());
|
1290
|
+
return true;
|
1291
|
+
};
|
1292
|
+
this.remove = function(item) {
|
1293
|
+
list.list.removeChild(item.elm);
|
1294
|
+
};
|
1295
|
+
this.show = function(item) {
|
1296
|
+
templater.create(item);
|
1297
|
+
list.list.appendChild(item.elm);
|
1298
|
+
};
|
1299
|
+
this.hide = function(item) {
|
1300
|
+
if (item.elm !== undefined && item.elm.parentNode === list.list) {
|
1301
|
+
list.list.removeChild(item.elm);
|
1302
|
+
}
|
1303
|
+
};
|
1304
|
+
this.clear = function() {
|
1305
|
+
/* .innerHTML = ''; fucks up IE */
|
1306
|
+
if (list.list.hasChildNodes()) {
|
1307
|
+
while (list.list.childNodes.length >= 1)
|
1308
|
+
{
|
1309
|
+
list.list.removeChild(list.list.firstChild);
|
1310
|
+
}
|
1311
|
+
}
|
1312
|
+
};
|
1313
|
+
};
|
1314
|
+
|
1315
|
+
module.exports = function(list) {
|
1316
|
+
return new Templater(list);
|
1317
|
+
};
|
1318
|
+
|
1319
|
+
});
|
1320
|
+
require.register("list.js/src/filter.js", function(exports, require, module){
|
1321
|
+
module.exports = function(list) {
|
1322
|
+
|
1323
|
+
// Add handlers
|
1324
|
+
list.handlers.filterStart = list.handlers.filterStart || [];
|
1325
|
+
list.handlers.filterComplete = list.handlers.filterComplete || [];
|
1326
|
+
|
1327
|
+
return function(filterFunction) {
|
1328
|
+
list.trigger('filterStart');
|
1329
|
+
list.i = 1; // Reset paging
|
1330
|
+
list.reset.filter();
|
1331
|
+
if (filterFunction === undefined) {
|
1332
|
+
list.filtered = false;
|
1333
|
+
} else {
|
1334
|
+
list.filtered = true;
|
1335
|
+
var is = list.items;
|
1336
|
+
for (var i = 0, il = is.length; i < il; i++) {
|
1337
|
+
var item = is[i];
|
1338
|
+
if (filterFunction(item)) {
|
1339
|
+
item.filtered = true;
|
1340
|
+
} else {
|
1341
|
+
item.filtered = false;
|
1342
|
+
}
|
1343
|
+
}
|
1344
|
+
}
|
1345
|
+
list.update();
|
1346
|
+
list.trigger('filterComplete');
|
1347
|
+
return list.visibleItems;
|
1348
|
+
};
|
1349
|
+
};
|
1350
|
+
|
1351
|
+
});
|
1352
|
+
require.register("list.js/src/add-async.js", function(exports, require, module){
|
1353
|
+
module.exports = function(list) {
|
1354
|
+
return function(values, callback, items) {
|
1355
|
+
var valuesToAdd = values.splice(0, 100);
|
1356
|
+
items = items || [];
|
1357
|
+
items = items.concat(list.add(valuesToAdd));
|
1358
|
+
if (values.length > 0) {
|
1359
|
+
setTimeout(function() {
|
1360
|
+
addAsync(values, callback, items);
|
1361
|
+
}, 10);
|
1362
|
+
} else {
|
1363
|
+
list.update();
|
1364
|
+
callback(items);
|
1365
|
+
}
|
1366
|
+
};
|
1367
|
+
};
|
1368
|
+
});
|
1369
|
+
require.register("list.js/src/parse.js", function(exports, require, module){
|
1370
|
+
module.exports = function(list) {
|
1371
|
+
|
1372
|
+
var Item = require('./item')(list);
|
1373
|
+
|
1374
|
+
var getChildren = function(parent) {
|
1375
|
+
var nodes = parent.childNodes,
|
1376
|
+
items = [];
|
1377
|
+
for (var i = 0, il = nodes.length; i < il; i++) {
|
1378
|
+
// Only textnodes have a data attribute
|
1379
|
+
if (nodes[i].data === undefined) {
|
1380
|
+
items.push(nodes[i]);
|
1381
|
+
}
|
1382
|
+
}
|
1383
|
+
return items;
|
1384
|
+
};
|
1385
|
+
|
1386
|
+
var parse = function(itemElements, valueNames) {
|
1387
|
+
for (var i = 0, il = itemElements.length; i < il; i++) {
|
1388
|
+
list.items.push(new Item(valueNames, itemElements[i]));
|
1389
|
+
}
|
1390
|
+
};
|
1391
|
+
var parseAsync = function(itemElements, valueNames) {
|
1392
|
+
var itemsToIndex = itemElements.splice(0, 100); // TODO: If < 100 items, what happens in IE etc?
|
1393
|
+
parse(itemsToIndex, valueNames);
|
1394
|
+
if (itemElements.length > 0) {
|
1395
|
+
setTimeout(function() {
|
1396
|
+
init.items.indexAsync(itemElements, valueNames);
|
1397
|
+
}, 10);
|
1398
|
+
} else {
|
1399
|
+
list.update();
|
1400
|
+
// TODO: Add indexed callback
|
1401
|
+
}
|
1402
|
+
};
|
1403
|
+
|
1404
|
+
return function() {
|
1405
|
+
var itemsToIndex = getChildren(list.list),
|
1406
|
+
valueNames = list.valueNames;
|
1407
|
+
|
1408
|
+
if (list.indexAsync) {
|
1409
|
+
parseAsync(itemsToIndex, valueNames);
|
1410
|
+
} else {
|
1411
|
+
parse(itemsToIndex, valueNames);
|
1412
|
+
}
|
1413
|
+
};
|
1414
|
+
};
|
1415
|
+
|
1416
|
+
});
|
1417
|
+
|
1418
|
+
|
1419
|
+
|
1420
|
+
|
1421
|
+
|
1422
|
+
|
1423
|
+
|
1424
|
+
|
1425
|
+
|
1426
|
+
|
1427
|
+
|
1428
|
+
|
1429
|
+
|
1430
|
+
|
1431
|
+
|
1432
|
+
|
1433
|
+
|
1434
|
+
|
1435
|
+
|
1436
|
+
|
1437
|
+
require.alias("component-classes/index.js", "list.js/deps/classes/index.js");
|
1438
|
+
require.alias("component-classes/index.js", "classes/index.js");
|
1439
|
+
require.alias("component-indexof/index.js", "component-classes/deps/indexof/index.js");
|
1440
|
+
|
1441
|
+
require.alias("segmentio-extend/index.js", "list.js/deps/extend/index.js");
|
1442
|
+
require.alias("segmentio-extend/index.js", "extend/index.js");
|
1443
|
+
|
1444
|
+
require.alias("component-indexof/index.js", "list.js/deps/indexof/index.js");
|
1445
|
+
require.alias("component-indexof/index.js", "indexof/index.js");
|
1446
|
+
|
1447
|
+
require.alias("javve-events/index.js", "list.js/deps/events/index.js");
|
1448
|
+
require.alias("javve-events/index.js", "events/index.js");
|
1449
|
+
require.alias("component-event/index.js", "javve-events/deps/event/index.js");
|
1450
|
+
|
1451
|
+
require.alias("timoxley-to-array/index.js", "javve-events/deps/to-array/index.js");
|
1452
|
+
|
1453
|
+
require.alias("javve-get-by-class/index.js", "list.js/deps/get-by-class/index.js");
|
1454
|
+
require.alias("javve-get-by-class/index.js", "get-by-class/index.js");
|
1455
|
+
|
1456
|
+
require.alias("javve-get-attribute/index.js", "list.js/deps/get-attribute/index.js");
|
1457
|
+
require.alias("javve-get-attribute/index.js", "get-attribute/index.js");
|
1458
|
+
|
1459
|
+
require.alias("javve-natural-sort/index.js", "list.js/deps/natural-sort/index.js");
|
1460
|
+
require.alias("javve-natural-sort/index.js", "natural-sort/index.js");
|
1461
|
+
|
1462
|
+
require.alias("javve-to-string/index.js", "list.js/deps/to-string/index.js");
|
1463
|
+
require.alias("javve-to-string/index.js", "list.js/deps/to-string/index.js");
|
1464
|
+
require.alias("javve-to-string/index.js", "to-string/index.js");
|
1465
|
+
require.alias("javve-to-string/index.js", "javve-to-string/index.js");
|
1466
|
+
require.alias("component-type/index.js", "list.js/deps/type/index.js");
|
1467
|
+
require.alias("component-type/index.js", "type/index.js");
|
1468
|
+
if (typeof exports == "object") {
|
1469
|
+
module.exports = require("list.js");
|
1470
|
+
} else if (typeof define == "function" && define.amd) {
|
1471
|
+
define(function(){ return require("list.js"); });
|
1472
|
+
} else {
|
1473
|
+
this["List"] = require("list.js");
|
1474
|
+
}})();
|