diff options
Diffstat (limited to 'public/javascripts/bundle.js')
| -rw-r--r-- | public/javascripts/bundle.js | 415 |
1 files changed, 408 insertions, 7 deletions
diff --git a/public/javascripts/bundle.js b/public/javascripts/bundle.js index 1f12e86..76516d9 100644 --- a/public/javascripts/bundle.js +++ b/public/javascripts/bundle.js @@ -1,9 +1,318 @@ (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){ -const frontpage = {}; -const self = frontpage; +/* + * Fuzzy + * https://github.com/myork/fuzzy + * + * Copyright (c) 2012 Matt York + * Licensed under the MIT license. + */ + +(function() { + +var root = this; + +var fuzzy = {}; + +// Use in node or in browser +if (typeof exports !== 'undefined') { + module.exports = fuzzy; +} else { + root.fuzzy = fuzzy; +} + +// Return all elements of `array` that have a fuzzy +// match against `pattern`. +fuzzy.simpleFilter = function(pattern, array) { + return array.filter(function(string) { + return fuzzy.test(pattern, string); + }); +}; + +// Does `pattern` fuzzy match `string`? +fuzzy.test = function(pattern, string) { + return fuzzy.match(pattern, string) !== null; +}; + +// If `pattern` matches `string`, wrap each matching character +// in `opts.pre` and `opts.post`. If no match, return null +fuzzy.match = function(pattern, string, opts) { + opts = opts || {}; + var patternIdx = 0 + , result = [] + , len = string.length + , totalScore = 0 + , currScore = 0 + // prefix + , pre = opts.pre || '' + // suffix + , post = opts.post || '' + // String to compare against. This might be a lowercase version of the + // raw string + , compareString = opts.caseSensitive && string || string.toLowerCase() + , ch, compareChar; + + pattern = opts.caseSensitive && pattern || pattern.toLowerCase(); + + // For each character in the string, either add it to the result + // or wrap in template if it's the next string in the pattern + for(var idx = 0; idx < len; idx++) { + ch = string[idx]; + if(compareString[idx] === pattern[patternIdx]) { + ch = pre + ch + post; + patternIdx += 1; + + // consecutive characters should increase the score more than linearly + currScore += 1 + currScore; + } else { + currScore = 0; + } + totalScore += currScore; + result[result.length] = ch; + } + + // return rendered string if we have a match for every char + if(patternIdx === pattern.length) { + return {rendered: result.join(''), score: totalScore}; + } + + return null; +}; + +// The normal entry point. Filters `arr` for matches against `pattern`. +// It returns an array with matching values of the type: +// +// [{ +// string: '<b>lah' // The rendered string +// , index: 2 // The index of the element in `arr` +// , original: 'blah' // The original element in `arr` +// }] +// +// `opts` is an optional argument bag. Details: +// +// opts = { +// // string to put before a matching character +// pre: '<b>' +// +// // string to put after matching character +// , post: '</b>' +// +// // Optional function. Input is an entry in the given arr`, +// // output should be the string to test `pattern` against. +// // In this example, if `arr = [{crying: 'koala'}]` we would return +// // 'koala'. +// , extract: function(arg) { return arg.crying; } +// } +fuzzy.filter = function(pattern, arr, opts) { + opts = opts || {}; + return arr + .reduce(function(prev, element, idx, arr) { + var str = element; + if(opts.extract) { + str = opts.extract(element); + } + var rendered = fuzzy.match(pattern, str, opts); + if(rendered != null) { + prev[prev.length] = { + string: rendered.rendered + , score: rendered.score + , index: idx + , original: element + }; + } + return prev; + }, []) + + // Sort by score. Browsers are inconsistent wrt stable/unstable + // sorting, so force stable by using the index in the case of tie. + // See http://ofb.net/~sethml/is-sort-stable.html + .sort(function(a,b) { + var compare = b.score - a.score; + if(compare) return compare; + return a.index - b.index; + }); +}; + + +}()); + + +},{}],2:[function(require,module,exports){ +'use strict'; +module.exports = leftPad; + +var cache = [ + '', + ' ', + ' ', + ' ', + ' ', + ' ', + ' ', + ' ', + ' ', + ' ' +]; + +function leftPad (str, len, ch) { + // convert `str` to `string` + str = str + ''; + // `len` is the `pad`'s length now + len = len - str.length; + // doesn't need to pad + if (len <= 0) return str; + // `ch` defaults to `' '` + if (!ch && ch !== 0) ch = ' '; + // convert `ch` to `string` + ch = ch + ''; + // cache common use cases + if (ch === ' ' && len < 10) return cache[len] + str; + // `pad` starts with an empty string + var pad = ''; + // loop + while (true) { + // add `ch` to `pad` if `len` is odd + if (len & 1) pad += ch; + // devide `len` by 2, ditch the fraction + len >>= 1; + // "double" the `ch` so this operation count grows logarithmically on `len` + // each time `ch` is "doubled", the `len` would need to be "doubled" too + // similar to finding a value in binary search tree, hence O(log(n)) + if (len) ch += ch; + // `len` is 0, exit the loop + else break; + } + // pad `str`! + return pad + str; +} + +},{}],3:[function(require,module,exports){ +/* global USERS */ + +const fuzzy = require('fuzzy'); +const search = require('./search'); + +const self = {}; + +self._items = []; +self._selectedItemIndex = -1; + +self._nodes = { + form: document.querySelector('#search'), + input: document.querySelector('input[type="search"]'), + autocomplete: document.querySelector('.autocomplete') +}; + +self.getSelectedItem = function () { + if (self.getItems() === []) return; + + if (self.getSelectedItemIndex() === -1) { + return self.getItems()[0]; + } else { + return self.getItems()[self.getSelectedItemIndex()]; + } +}; + +self.getSelectedItemIndex = function () { + return self._selectedItemIndex; +}; + +self.getItems = function () { + return self._items; +}; + +self._removeAllItems = function () { + while (self._nodes.autocomplete.firstChild) { + self._nodes.autocomplete.removeChild(self._nodes.autocomplete.firstChild); + } + self._items = []; + self._selectedItemIndex = -1; +}; + +self._addItem = function (item) { + const listItem = document.createElement('li'); + listItem.textContent = item.value; + listItem.addEventListener('click', self._handleItemClick); + self._nodes.autocomplete.appendChild(listItem); + self._items.push(item); +}; + +self._moveSelected = function (shift) { + if (self._selectedItemIndex + shift >= self.getItems().length) { + self._selectedItemIndex = -1; + } else if (self._selectedItemIndex + shift < -1) { + self._selectedItemIndex = self.getItems().length - 1; + } else { + self._selectedItemIndex += shift; + } + + for (let i = 0; i < self.getItems().length; i++) { + self._nodes.autocomplete.children[i].classList.remove('selected'); + } + if (self._selectedItemIndex >= 0) { + self._nodes.autocomplete.children[self._selectedItemIndex].classList.add('selected'); + } +}; + +self._calculate = function (searchTerm) { + const allResults = fuzzy.filter(searchTerm, USERS, { + extract: item => item.value + }); + const firstResults = allResults.slice(0, 7); + + const originalResults = firstResults.map(result => result.original); + + return originalResults; +}; + +self._handleItemClick = function (event) { + const itemIndex = Array.prototype.indexOf.call(self._nodes.autocomplete.children, event.target); + console.log(itemIndex); + self._selectedItemIndex = itemIndex; + console.log(search); + search.submit(); +}; + +self._handleFocus = function () { + self._nodes.autocomplete.style.display = 'block'; +}; + +self._handleBlur = function (event) { + // console.log(document.querySelector(':focus')) + // if (event.target.parentNode === self._nodes.autocomplete) return + // self._nodes.autocomplete.style.display = 'none' +}; + +self._handleTextUpdate = function () { + const results = self._calculate(self._nodes.input.value); + + self._removeAllItems(); + for (let i = 0; i < results.length; i++) { + self._addItem(results[i]); + } +}; + +self._handleKeydown = function (event) { + if (event.key === 'ArrowDown' || event.key === 'ArrowUp') { + event.preventDefault(); + if (event.key === 'ArrowDown') { + self._moveSelected(1); + } else if (event.key === 'ArrowUp') { + self._moveSelected(-1); + } + } +}; + +self._nodes.input.addEventListener('focus', self._handleFocus); +self._nodes.input.addEventListener('blur', self._handleBlur); +self._nodes.input.addEventListener('input', self._handleTextUpdate); +self._nodes.input.addEventListener('keydown', self._handleKeydown); + +module.exports = self; + +},{"./search":9,"fuzzy":1}],4:[function(require,module,exports){ +const self = {}; self._nodes = { - search: document.querySelector('#search'), input: document.querySelector('input[type="search"]') }; @@ -21,14 +330,106 @@ self.hide = function () { self._nodes.input.addEventListener('input', self.hide); -module.exports = frontpage; +module.exports = self; -},{}],2:[function(require,module,exports){ +},{}],5:[function(require,module,exports){ +var leftPad = require('left-pad'); +var getWeek = require('./getWeek'); + +function getURLOfUsers(weekOffset, type, id) { + return `//${ window.location.host }/meetingpointProxy/Roosters-AL%2Fdoc%2Fdagroosters%2F` + `${ getWeek() + weekOffset }%2F${ type }%2F${ type }${ leftPad(id, 5, '0') }.htm`; +} + +module.exports = getURLOfUsers; + +},{"./getWeek":6,"left-pad":2}],6:[function(require,module,exports){ +// copied from http://www.meetingpointmco.nl/Roosters-AL/doc/dagroosters/untisscripts.js, +// were using the same code as they do to be sure that we always get the same +// week number. +function getWeek() { + // Create a copy of this date object + const target = new Date(); + + // ISO week date weeks start on monday + // so correct the day number + const dayNr = (target.getDay() + 6) % 7; + + // ISO 8601 states that week 1 is the week + // with the first thursday of that year. + // Set the target date to the thursday in the target week + target.setDate(target.getDate() - dayNr + 3); + + // Store the millisecond value of the target date + const firstThursday = target.valueOf(); + + // Set the target to the first thursday of the year + // First set the target to january first + target.setMonth(0, 1); + // Not a thursday? Correct the date to the next thursday + if (target.getDay() !== 4) { + target.setMonth(0, 1 + (4 - target.getDay() + 7) % 7); + } + + // The weeknumber is the number of weeks between the + // first thursday of the year and the thursday in the target week + return 1 + Math.ceil((firstThursday - target) / 604800000); // 604800000 = 7 * 24 * 3600 * 1000 +} + +module.exports = getWeek; + +},{}],7:[function(require,module,exports){ +const getURLOfUser = require('./getURLOfUser'); + +const self = {}; + +self._nodes = { + iframe: document.querySelector('iframe') +}; + +self.viewItem = function (offset, selectedUser) { + const url = getURLOfUser(offset, selectedUser.type, selectedUser.index + 1); + self._nodes.iframe.src = url; +}; + +module.exports = self; + +},{"./getURLOfUser":5}],8:[function(require,module,exports){ const frontpage = require('./frontpage'); +require('./search'); frontpage.show(); document.body.style.opacity = 1; -},{"./frontpage":1}]},{},[2]) -//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIm5vZGVfbW9kdWxlcy9icm93c2VyLXBhY2svX3ByZWx1ZGUuanMiLCJwdWJsaWMvamF2YXNjcmlwdHMvZnJvbnRwYWdlLmpzIiwicHVibGljL2phdmFzY3JpcHRzL21haW4uanMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7QUNBQSxNQUFNLFlBQVksRUFBbEI7QUFDQSxNQUFNLE9BQU8sU0FBYjs7QUFFQSxLQUFLLE1BQUwsR0FBYztBQUNaLFVBQVEsU0FBUyxhQUFULENBQXVCLFNBQXZCLENBREk7QUFFWixTQUFPLFNBQVMsYUFBVCxDQUF1QixzQkFBdkI7QUFGSyxDQUFkOztBQUtBLEtBQUssT0FBTCxHQUFlLEtBQWY7O0FBRUEsS0FBSyxJQUFMLEdBQVksWUFBWTtBQUN0QixXQUFTLElBQVQsQ0FBYyxTQUFkLENBQXdCLEdBQXhCLENBQTRCLFVBQTVCO0FBQ0EsT0FBSyxPQUFMLEdBQWUsSUFBZjtBQUNELENBSEQ7O0FBS0EsS0FBSyxJQUFMLEdBQVksWUFBWTtBQUN0QixXQUFTLElBQVQsQ0FBYyxTQUFkLENBQXdCLE1BQXhCLENBQStCLFVBQS9CO0FBQ0EsT0FBSyxPQUFMLEdBQWUsS0FBZjtBQUNELENBSEQ7O0FBS0EsS0FBSyxNQUFMLENBQVksS0FBWixDQUFrQixnQkFBbEIsQ0FBbUMsT0FBbkMsRUFBNEMsS0FBSyxJQUFqRDs7QUFFQSxPQUFPLE9BQVAsR0FBaUIsU0FBakI7OztBQ3RCQSxNQUFNLFlBQVksUUFBUSxhQUFSLENBQWxCOztBQUVBLFVBQVUsSUFBVjs7QUFFQSxTQUFTLElBQVQsQ0FBYyxLQUFkLENBQW9CLE9BQXBCLEdBQThCLENBQTlCIiwiZmlsZSI6ImdlbmVyYXRlZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIoZnVuY3Rpb24gZSh0LG4scil7ZnVuY3Rpb24gcyhvLHUpe2lmKCFuW29dKXtpZighdFtvXSl7dmFyIGE9dHlwZW9mIHJlcXVpcmU9PVwiZnVuY3Rpb25cIiYmcmVxdWlyZTtpZighdSYmYSlyZXR1cm4gYShvLCEwKTtpZihpKXJldHVybiBpKG8sITApO3ZhciBmPW5ldyBFcnJvcihcIkNhbm5vdCBmaW5kIG1vZHVsZSAnXCIrbytcIidcIik7dGhyb3cgZi5jb2RlPVwiTU9EVUxFX05PVF9GT1VORFwiLGZ9dmFyIGw9bltvXT17ZXhwb3J0czp7fX07dFtvXVswXS5jYWxsKGwuZXhwb3J0cyxmdW5jdGlvbihlKXt2YXIgbj10W29dWzFdW2VdO3JldHVybiBzKG4/bjplKX0sbCxsLmV4cG9ydHMsZSx0LG4scil9cmV0dXJuIG5bb10uZXhwb3J0c312YXIgaT10eXBlb2YgcmVxdWlyZT09XCJmdW5jdGlvblwiJiZyZXF1aXJlO2Zvcih2YXIgbz0wO288ci5sZW5ndGg7bysrKXMocltvXSk7cmV0dXJuIHN9KSIsImNvbnN0IGZyb250cGFnZSA9IHt9XG5jb25zdCBzZWxmID0gZnJvbnRwYWdlXG5cbnNlbGYuX25vZGVzID0ge1xuICBzZWFyY2g6IGRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoJyNzZWFyY2gnKSxcbiAgaW5wdXQ6IGRvY3VtZW50LnF1ZXJ5U2VsZWN0b3IoJ2lucHV0W3R5cGU9XCJzZWFyY2hcIl0nKVxufVxuXG5zZWxmLmlzU2hvd24gPSBmYWxzZVxuXG5zZWxmLnNob3cgPSBmdW5jdGlvbiAoKSB7XG4gIGRvY3VtZW50LmJvZHkuY2xhc3NMaXN0LmFkZCgnbm8taW5wdXQnKVxuICBzZWxmLmlzU2hvd24gPSB0cnVlXG59XG5cbnNlbGYuaGlkZSA9IGZ1bmN0aW9uICgpIHtcbiAgZG9jdW1lbnQuYm9keS5jbGFzc0xpc3QucmVtb3ZlKCduby1pbnB1dCcpXG4gIHNlbGYuaXNTaG93biA9IGZhbHNlXG59XG5cbnNlbGYuX25vZGVzLmlucHV0LmFkZEV2ZW50TGlzdGVuZXIoJ2lucHV0Jywgc2VsZi5oaWRlKVxuXG5tb2R1bGUuZXhwb3J0cyA9IGZyb250cGFnZVxuIiwiY29uc3QgZnJvbnRwYWdlID0gcmVxdWlyZSgnLi9mcm9udHBhZ2UnKVxuXG5mcm9udHBhZ2Uuc2hvdygpXG5cbmRvY3VtZW50LmJvZHkuc3R5bGUub3BhY2l0eSA9IDFcbiJdfQ== +},{"./frontpage":4,"./search":9}],9:[function(require,module,exports){ +const autocomplete = require('./autocomplete'); +const iframe = require('./iframe'); + +const self = {}; + +self._nodes = { + search: document.querySelector('#search'), + input: document.querySelector('input[type="search"]') +}; + +self.submit = function () { + self._nodes.input.blur(); + + const selectedItem = autocomplete.getSelectedItem(); + console.log(selectedItem); + iframe.viewItem(0, selectedItem); +}; + +self._handleSubmit = function (event) { + event.preventDefault(); + self.submit(); +}; + +self._nodes.search.addEventListener('submit', self._handleSubmit); + +console.log(self); + +module.exports = self; + +},{"./autocomplete":3,"./iframe":7}]},{},[8]) +//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","node_modules/fuzzy/lib/fuzzy.js","node_modules/left-pad/index.js","public/javascripts/autocomplete.js","public/javascripts/frontpage.js","public/javascripts/getURLOfUser.js","public/javascripts/getWeek.js","public/javascripts/iframe.js","public/javascripts/main.js","public/javascripts/search.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACxIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC/CA;;AAEA,MAAM,QAAQ,QAAQ,OAAR,CAAd;AACA,MAAM,SAAS,QAAQ,UAAR,CAAf;;AAEA,MAAM,OAAO,EAAb;;AAEA,KAAK,MAAL,GAAc,EAAd;AACA,KAAK,kBAAL,GAA0B,CAAC,CAA3B;;AAEA,KAAK,MAAL,GAAc;AACZ,QAAM,SAAS,aAAT,CAAuB,SAAvB,CADM;AAEZ,SAAO,SAAS,aAAT,CAAuB,sBAAvB,CAFK;AAGZ,gBAAc,SAAS,aAAT,CAA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","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","/*\n * Fuzzy\n * https://github.com/myork/fuzzy\n *\n * Copyright (c) 2012 Matt York\n * Licensed under the MIT license.\n */\n\n(function() {\n\nvar root = this;\n\nvar fuzzy = {};\n\n// Use in node or in browser\nif (typeof exports !== 'undefined') {\n  module.exports = fuzzy;\n} else {\n  root.fuzzy = fuzzy;\n}\n\n// Return all elements of `array` that have a fuzzy\n// match against `pattern`.\nfuzzy.simpleFilter = function(pattern, array) {\n  return array.filter(function(string) {\n    return fuzzy.test(pattern, string);\n  });\n};\n\n// Does `pattern` fuzzy match `string`?\nfuzzy.test = function(pattern, string) {\n  return fuzzy.match(pattern, string) !== null;\n};\n\n// If `pattern` matches `string`, wrap each matching character\n// in `opts.pre` and `opts.post`. If no match, return null\nfuzzy.match = function(pattern, string, opts) {\n  opts = opts || {};\n  var patternIdx = 0\n    , result = []\n    , len = string.length\n    , totalScore = 0\n    , currScore = 0\n    // prefix\n    , pre = opts.pre || ''\n    // suffix\n    , post = opts.post || ''\n    // String to compare against. This might be a lowercase version of the\n    // raw string\n    , compareString =  opts.caseSensitive && string || string.toLowerCase()\n    , ch, compareChar;\n\n  pattern = opts.caseSensitive && pattern || pattern.toLowerCase();\n\n  // For each character in the string, either add it to the result\n  // or wrap in template if it's the next string in the pattern\n  for(var idx = 0; idx < len; idx++) {\n    ch = string[idx];\n    if(compareString[idx] === pattern[patternIdx]) {\n      ch = pre + ch + post;\n      patternIdx += 1;\n\n      // consecutive characters should increase the score more than linearly\n      currScore += 1 + currScore;\n    } else {\n      currScore = 0;\n    }\n    totalScore += currScore;\n    result[result.length] = ch;\n  }\n\n  // return rendered string if we have a match for every char\n  if(patternIdx === pattern.length) {\n    return {rendered: result.join(''), score: totalScore};\n  }\n\n  return null;\n};\n\n// The normal entry point. Filters `arr` for matches against `pattern`.\n// It returns an array with matching values of the type:\n//\n//     [{\n//         string:   '<b>lah' // The rendered string\n//       , index:    2        // The index of the element in `arr`\n//       , original: 'blah'   // The original element in `arr`\n//     }]\n//\n// `opts` is an optional argument bag. Details:\n//\n//    opts = {\n//        // string to put before a matching character\n//        pre:     '<b>'\n//\n//        // string to put after matching character\n//      , post:    '</b>'\n//\n//        // Optional function. Input is an entry in the given arr`,\n//        // output should be the string to test `pattern` against.\n//        // In this example, if `arr = [{crying: 'koala'}]` we would return\n//        // 'koala'.\n//      , extract: function(arg) { return arg.crying; }\n//    }\nfuzzy.filter = function(pattern, arr, opts) {\n  opts = opts || {};\n  return arr\n    .reduce(function(prev, element, idx, arr) {\n      var str = element;\n      if(opts.extract) {\n        str = opts.extract(element);\n      }\n      var rendered = fuzzy.match(pattern, str, opts);\n      if(rendered != null) {\n        prev[prev.length] = {\n            string: rendered.rendered\n          , score: rendered.score\n          , index: idx\n          , original: element\n        };\n      }\n      return prev;\n    }, [])\n\n    // Sort by score. Browsers are inconsistent wrt stable/unstable\n    // sorting, so force stable by using the index in the case of tie.\n    // See http://ofb.net/~sethml/is-sort-stable.html\n    .sort(function(a,b) {\n      var compare = b.score - a.score;\n      if(compare) return compare;\n      return a.index - b.index;\n    });\n};\n\n\n}());\n\n","'use strict';\nmodule.exports = leftPad;\n\nvar cache = [\n  '',\n  ' ',\n  '  ',\n  '   ',\n  '    ',\n  '     ',\n  '      ',\n  '       ',\n  '        ',\n  '         '\n];\n\nfunction leftPad (str, len, ch) {\n  // convert `str` to `string`\n  str = str + '';\n  // `len` is the `pad`'s length now\n  len = len - str.length;\n  // doesn't need to pad\n  if (len <= 0) return str;\n  // `ch` defaults to `' '`\n  if (!ch && ch !== 0) ch = ' ';\n  // convert `ch` to `string`\n  ch = ch + '';\n  // cache common use cases\n  if (ch === ' ' && len < 10) return cache[len] + str;\n  // `pad` starts with an empty string\n  var pad = '';\n  // loop\n  while (true) {\n    // add `ch` to `pad` if `len` is odd\n    if (len & 1) pad += ch;\n    // devide `len` by 2, ditch the fraction\n    len >>= 1;\n    // \"double\" the `ch` so this operation count grows logarithmically on `len`\n    // each time `ch` is \"doubled\", the `len` would need to be \"doubled\" too\n    // similar to finding a value in binary search tree, hence O(log(n))\n    if (len) ch += ch;\n    // `len` is 0, exit the loop\n    else break;\n  }\n  // pad `str`!\n  return pad + str;\n}\n","/* global USERS */\n\nconst fuzzy = require('fuzzy')\nconst search = require('./search')\n\nconst self = {}\n\nself._items = []\nself._selectedItemIndex = -1\n\nself._nodes = {\n  form: document.querySelector('#search'),\n  input: document.querySelector('input[type=\"search\"]'),\n  autocomplete: document.querySelector('.autocomplete')\n}\n\nself.getSelectedItem = function () {\n  if (self.getItems() === []) return\n\n  if (self.getSelectedItemIndex() === -1) {\n    return self.getItems()[0]\n  } else {\n    return self.getItems()[self.getSelectedItemIndex()]\n  }\n}\n\nself.getSelectedItemIndex = function () {\n  return self._selectedItemIndex\n}\n\nself.getItems = function () {\n  return self._items\n}\n\nself._removeAllItems = function () {\n  while (self._nodes.autocomplete.firstChild) {\n    self._nodes.autocomplete.removeChild(self._nodes.autocomplete.firstChild)\n  }\n  self._items = []\n  self._selectedItemIndex = -1\n}\n\nself._addItem = function (item) {\n  const listItem = document.createElement('li')\n  listItem.textContent = item.value\n  listItem.addEventListener('click', self._handleItemClick)\n  self._nodes.autocomplete.appendChild(listItem)\n  self._items.push(item)\n}\n\nself._moveSelected = function (shift) {\n  if (self._selectedItemIndex + shift >= self.getItems().length) {\n    self._selectedItemIndex = -1\n  } else if (self._selectedItemIndex + shift < -1) {\n    self._selectedItemIndex = self.getItems().length - 1\n  } else {\n    self._selectedItemIndex += shift\n  }\n\n  for (let i = 0; i < self.getItems().length; i++) {\n    self._nodes.autocomplete.children[i].classList.remove('selected')\n  }\n  if (self._selectedItemIndex >= 0) {\n    self._nodes.autocomplete\n        .children[self._selectedItemIndex].classList.add('selected')\n  }\n}\n\nself._calculate = function (searchTerm) {\n  const allResults = fuzzy.filter(searchTerm, USERS, {\n    extract: item => item.value\n  })\n  const firstResults = allResults.slice(0, 7)\n\n  const originalResults = firstResults.map(result => result.original)\n\n  return originalResults\n}\n\nself._handleItemClick = function (event) {\n  const itemIndex = Array.prototype.indexOf\n      .call(self._nodes.autocomplete.children, event.target)\n  console.log(itemIndex)\n  self._selectedItemIndex = itemIndex\n  console.log(search)\n  search.submit()\n}\n\nself._handleFocus = function () {\n  self._nodes.autocomplete.style.display = 'block'\n}\n\nself._handleBlur = function (event) {\n  // console.log(document.querySelector(':focus'))\n  // if (event.target.parentNode === self._nodes.autocomplete) return\n  // self._nodes.autocomplete.style.display = 'none'\n}\n\nself._handleTextUpdate = function () {\n  const results = self._calculate(self._nodes.input.value)\n\n  self._removeAllItems()\n  for (let i = 0; i < results.length; i++) {\n    self._addItem(results[i])\n  }\n}\n\nself._handleKeydown = function (event) {\n  if (event.key === 'ArrowDown' || event.key === 'ArrowUp') {\n    event.preventDefault()\n    if (event.key === 'ArrowDown') {\n      self._moveSelected(1)\n    } else if (event.key === 'ArrowUp') {\n      self._moveSelected(-1)\n    }\n  }\n}\n\nself._nodes.input.addEventListener('focus', self._handleFocus)\nself._nodes.input.addEventListener('blur', self._handleBlur)\nself._nodes.input.addEventListener('input', self._handleTextUpdate)\nself._nodes.input.addEventListener('keydown', self._handleKeydown)\n\nmodule.exports = self\n","const self = {}\n\nself._nodes = {\n  input: document.querySelector('input[type=\"search\"]')\n}\n\nself.isShown = false\n\nself.show = function () {\n  document.body.classList.add('no-input')\n  self.isShown = true\n}\n\nself.hide = function () {\n  document.body.classList.remove('no-input')\n  self.isShown = false\n}\n\nself._nodes.input.addEventListener('input', self.hide)\n\nmodule.exports = self\n","var leftPad = require('left-pad')\nvar getWeek = require('./getWeek')\n\nfunction getURLOfUsers (weekOffset, type, id) {\n  return `//${window.location.host}/meetingpointProxy/Roosters-AL%2Fdoc%2Fdagroosters%2F` +\n      `${(getWeek() + weekOffset)}%2F${type}%2F${type}${leftPad(id, 5, '0')}.htm`\n}\n\nmodule.exports = getURLOfUsers\n","// copied from http://www.meetingpointmco.nl/Roosters-AL/doc/dagroosters/untisscripts.js,\n// were using the same code as they do to be sure that we always get the same\n// week number.\nfunction getWeek () {\n  // Create a copy of this date object\n  const target = new Date()\n\n  // ISO week date weeks start on monday\n  // so correct the day number\n  const dayNr = (target.getDay() + 6) % 7\n\n  // ISO 8601 states that week 1 is the week\n  // with the first thursday of that year.\n  // Set the target date to the thursday in the target week\n  target.setDate(target.getDate() - dayNr + 3)\n\n  // Store the millisecond value of the target date\n  const firstThursday = target.valueOf()\n\n  // Set the target to the first thursday of the year\n  // First set the target to january first\n  target.setMonth(0, 1)\n  // Not a thursday? Correct the date to the next thursday\n  if (target.getDay() !== 4) {\n    target.setMonth(0, 1 + ((4 - target.getDay()) + 7) % 7)\n  }\n\n  // The weeknumber is the number of weeks between the\n  // first thursday of the year and the thursday in the target week\n  return 1 + Math.ceil((firstThursday - target) / 604800000) // 604800000 = 7 * 24 * 3600 * 1000\n}\n\nmodule.exports = getWeek\n","const getURLOfUser = require('./getURLOfUser')\n\nconst self = {}\n\nself._nodes = {\n  iframe: document.querySelector('iframe')\n}\n\nself.viewItem = function (offset, selectedUser) {\n  const url = getURLOfUser(offset, selectedUser.type, selectedUser.index + 1)\n  self._nodes.iframe.src = url\n}\n\nmodule.exports = self\n","const frontpage = require('./frontpage')\nrequire('./search')\n\nfrontpage.show()\n\ndocument.body.style.opacity = 1\n","const autocomplete = require('./autocomplete')\nconst iframe = require('./iframe')\n\nconst self = {}\n\nself._nodes = {\n  search: document.querySelector('#search'),\n  input: document.querySelector('input[type=\"search\"]')\n}\n\nself.submit = function () {\n  self._nodes.input.blur()\n\n  const selectedItem = autocomplete.getSelectedItem()\n  console.log(selectedItem)\n  iframe.viewItem(0, selectedItem)\n}\n\nself._handleSubmit = function (event) {\n  event.preventDefault()\n  self.submit()\n}\n\nself._nodes.search.addEventListener('submit', self._handleSubmit)\n\nconsole.log(self)\n\nmodule.exports = self\n"]} |