372 lines
26 KiB
JavaScript
372 lines
26 KiB
JavaScript
(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); throw new Error("Cannot find module '" + o + "'") } var f = n[o] = {exports: {}}; t[o][0].call(f.exports, function (e) { var n = t[o][1][e]; return s(n || e) }, f, f.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) {
|
|
'use strict'
|
|
module.exports = {
|
|
load: load
|
|
}
|
|
|
|
function load (location, callback) {
|
|
var xhr = getXHR()
|
|
xhr.open('GET', location, true)
|
|
xhr.onreadystatechange = createStateChangeListener(xhr, callback)
|
|
xhr.send()
|
|
}
|
|
|
|
function createStateChangeListener (xhr, callback) {
|
|
return function () {
|
|
if (xhr.readyState === 4 && xhr.status === 200) {
|
|
try {
|
|
callback(null, JSON.parse(xhr.responseText))
|
|
} catch (err) {
|
|
callback(err, null)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function getXHR () {
|
|
return (window.XMLHttpRequest) ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP')
|
|
}
|
|
}, {}],
|
|
2: [function (require, module, exports) {
|
|
'use strict'
|
|
module.exports = function OptionsValidator (params) {
|
|
if (!validateParams(params)) {
|
|
throw new Error('-- OptionsValidator: required options missing')
|
|
}
|
|
if (!(this instanceof OptionsValidator)) {
|
|
return new OptionsValidator(params)
|
|
}
|
|
|
|
var requiredOptions = params.required
|
|
|
|
this.getRequiredOptions = function () {
|
|
return requiredOptions
|
|
}
|
|
|
|
this.validate = function (parameters) {
|
|
var errors = []
|
|
requiredOptions.forEach(function (requiredOptionName) {
|
|
if (parameters[requiredOptionName] === undefined) {
|
|
errors.push(requiredOptionName)
|
|
}
|
|
})
|
|
return errors
|
|
}
|
|
|
|
function validateParams (params) {
|
|
if (!params) {
|
|
return false
|
|
}
|
|
return params.required !== undefined && params.required instanceof Array
|
|
}
|
|
}
|
|
}, {}],
|
|
3: [function (require, module, exports) {
|
|
'use strict'
|
|
module.exports = {
|
|
put: put,
|
|
clear: clear,
|
|
get: get,
|
|
search: search,
|
|
setOptions: setOptions
|
|
}
|
|
|
|
var FuzzySearchStrategy = require('./SearchStrategies/FuzzySearchStrategy')
|
|
var LiteralSearchStrategy = require('./SearchStrategies/LiteralSearchStrategy')
|
|
|
|
var data = []
|
|
var opt = {}
|
|
opt.fuzzy = false
|
|
opt.limit = 10
|
|
opt.searchStrategy = opt.fuzzy ? FuzzySearchStrategy : LiteralSearchStrategy
|
|
|
|
function put (data) {
|
|
if (isObject(data)) {
|
|
return addObject(data)
|
|
}
|
|
if (isArray(data)) {
|
|
return addArray(data)
|
|
}
|
|
return undefined
|
|
}
|
|
function clear () {
|
|
data.length = 0
|
|
return data
|
|
}
|
|
|
|
function get () {
|
|
return data
|
|
}
|
|
|
|
function isObject (obj) { return !!obj && Object.prototype.toString.call(obj) === '[object Object]' }
|
|
function isArray (obj) { return !!obj && Object.prototype.toString.call(obj) === '[object Array]' }
|
|
|
|
function addObject (_data) {
|
|
data.push(_data)
|
|
return data
|
|
}
|
|
|
|
function addArray (_data) {
|
|
var added = []
|
|
for (var i = 0; i < _data.length; i++) {
|
|
if (isObject(_data[i])) {
|
|
added.push(addObject(_data[i]))
|
|
}
|
|
}
|
|
return added
|
|
}
|
|
|
|
function search (crit) {
|
|
if (!crit) {
|
|
return []
|
|
}
|
|
return findMatches(data, crit, opt.searchStrategy, opt)
|
|
}
|
|
|
|
function setOptions (_opt) {
|
|
opt = _opt || {}
|
|
|
|
opt.fuzzy = _opt.fuzzy || false
|
|
opt.limit = _opt.limit || 10
|
|
opt.searchStrategy = _opt.fuzzy ? FuzzySearchStrategy : LiteralSearchStrategy
|
|
}
|
|
|
|
function findMatches (data, crit, strategy, opt) {
|
|
var matches = []
|
|
for (var i = 0; i < data.length && matches.length < opt.limit; i++) {
|
|
var match = findMatchesInObject(data[i], crit, strategy, opt)
|
|
if (match) {
|
|
matches.push(match)
|
|
}
|
|
}
|
|
return matches
|
|
}
|
|
|
|
function findMatchesInObject (obj, crit, strategy, opt) {
|
|
for (var key in obj) {
|
|
if (!isExcluded(obj[key], opt.exclude) && strategy.matches(obj[key], crit)) {
|
|
return obj
|
|
}
|
|
}
|
|
}
|
|
|
|
function isExcluded (term, excludedTerms) {
|
|
var excluded = false
|
|
excludedTerms = excludedTerms || []
|
|
for (var i = 0; i < excludedTerms.length; i++) {
|
|
var excludedTerm = excludedTerms[i]
|
|
if (!excluded && new RegExp(term).test(excludedTerm)) {
|
|
excluded = true
|
|
}
|
|
}
|
|
return excluded
|
|
}
|
|
}, {'./SearchStrategies/FuzzySearchStrategy': 4, './SearchStrategies/LiteralSearchStrategy': 5}],
|
|
4: [function (require, module, exports) {
|
|
'use strict'
|
|
module.exports = new FuzzySearchStrategy()
|
|
|
|
function FuzzySearchStrategy () {
|
|
this.matches = function (string, crit) {
|
|
if (typeof string !== 'string' || typeof crit !== 'string') {
|
|
return false
|
|
}
|
|
var fuzzy = fuzzyFrom(crit)
|
|
return !!fuzzy.test(string)
|
|
}
|
|
|
|
function fuzzyFrom (string) {
|
|
var fuzzy = string
|
|
.trim()
|
|
.split('')
|
|
.join('.*?')
|
|
.replace('??', '?')
|
|
return new RegExp(fuzzy, 'gi')
|
|
}
|
|
}
|
|
}, {}],
|
|
5: [function (require, module, exports) {
|
|
'use strict'
|
|
module.exports = new LiteralSearchStrategy()
|
|
|
|
function LiteralSearchStrategy () {
|
|
this.matches = function (string, crit) {
|
|
if (typeof string !== 'string') {
|
|
return false
|
|
}
|
|
string = string.trim()
|
|
return string.toLowerCase().indexOf(crit.toLowerCase()) >= 0
|
|
}
|
|
}
|
|
}, {}],
|
|
6: [function (require, module, exports) {
|
|
'use strict'
|
|
module.exports = {
|
|
compile: compile,
|
|
setOptions: setOptions
|
|
}
|
|
|
|
var options = {}
|
|
options.pattern = /\{(.*?)\}/g
|
|
options.template = ''
|
|
options.middleware = function () {}
|
|
|
|
function setOptions (_options) {
|
|
options.pattern = _options.pattern || options.pattern
|
|
options.template = _options.template || options.template
|
|
if (typeof _options.middleware === 'function') {
|
|
options.middleware = _options.middleware
|
|
}
|
|
}
|
|
|
|
function compile (data) {
|
|
return options.template.replace(options.pattern, function (match, prop) {
|
|
var value = options.middleware(prop, data[prop], options.template)
|
|
if (value !== undefined) {
|
|
return value
|
|
}
|
|
return data[prop] || match
|
|
})
|
|
}
|
|
}, {}],
|
|
7: [function (require, module, exports) {
|
|
;(function (window, document, undefined) {
|
|
'use strict'
|
|
|
|
var options = {
|
|
searchInput: null,
|
|
resultsContainer: null,
|
|
json: [],
|
|
searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
|
|
templateMiddleware: function () {},
|
|
noResultsText: 'No results found',
|
|
limit: 10,
|
|
fuzzy: false,
|
|
exclude: []
|
|
}
|
|
|
|
var requiredOptions = ['searchInput', 'resultsContainer', 'json']
|
|
|
|
var templater = require('./Templater')
|
|
var repository = require('./Repository')
|
|
var jsonLoader = require('./JSONLoader')
|
|
var optionsValidator = require('./OptionsValidator')({
|
|
required: requiredOptions
|
|
})
|
|
var utils = require('./utils')
|
|
|
|
/*
|
|
Public API
|
|
*/
|
|
window.SimpleJekyllSearch = function SimpleJekyllSearch (_options) {
|
|
var errors = optionsValidator.validate(_options)
|
|
if (errors.length > 0) {
|
|
throwError('You must specify the following required options: ' + requiredOptions)
|
|
}
|
|
|
|
options = utils.merge(options, _options)
|
|
|
|
templater.setOptions({
|
|
template: options.searchResultTemplate,
|
|
middleware: options.templateMiddleware
|
|
})
|
|
|
|
repository.setOptions({
|
|
fuzzy: options.fuzzy,
|
|
limit: options.limit
|
|
})
|
|
|
|
if (utils.isJSON(options.json)) {
|
|
initWithJSON(options.json)
|
|
} else {
|
|
initWithURL(options.json)
|
|
}
|
|
}
|
|
|
|
// for backwards compatibility
|
|
window.SimpleJekyllSearch.init = window.SimpleJekyllSearch
|
|
|
|
function initWithJSON (json) {
|
|
repository.put(json)
|
|
registerInput()
|
|
}
|
|
|
|
function initWithURL (url) {
|
|
jsonLoader.load(url, function (err, json) {
|
|
if (err) {
|
|
throwError('failed to get JSON (' + url + ')')
|
|
}
|
|
initWithJSON(json)
|
|
})
|
|
}
|
|
|
|
function emptyResultsContainer () {
|
|
options.resultsContainer.innerHTML = ''
|
|
}
|
|
|
|
function appendToResultsContainer (text) {
|
|
options.resultsContainer.innerHTML += text
|
|
}
|
|
|
|
function registerInput () {
|
|
options.searchInput.addEventListener('keyup', function (e) {
|
|
emptyResultsContainer()
|
|
var key = e.which
|
|
var query = e.target.value
|
|
if (isWhitelistedKey(key) && isValidQuery(query)) {
|
|
render(repository.search(query))
|
|
}
|
|
})
|
|
}
|
|
|
|
function render (results) {
|
|
if (results.length === 0) {
|
|
return appendToResultsContainer(options.noResultsText)
|
|
}
|
|
for (var i = 0; i < results.length; i++) {
|
|
appendToResultsContainer(templater.compile(results[i]))
|
|
}
|
|
}
|
|
|
|
function isValidQuery (query) {
|
|
return query && query.length > 0
|
|
}
|
|
|
|
function isWhitelistedKey (key) {
|
|
return [13, 16, 20, 37, 38, 39, 40, 91].indexOf(key) === -1
|
|
}
|
|
|
|
function throwError (message) { throw new Error('SimpleJekyllSearch --- ' + message) }
|
|
})(window, document)
|
|
}, {'./JSONLoader': 1, './OptionsValidator': 2, './Repository': 3, './Templater': 6, './utils': 8}],
|
|
8: [function (require, module, exports) {
|
|
'use strict'
|
|
module.exports = {
|
|
merge: merge,
|
|
isJSON: isJSON
|
|
}
|
|
|
|
function merge (defaultParams, mergeParams) {
|
|
var mergedOptions = {}
|
|
for (var option in defaultParams) {
|
|
mergedOptions[option] = defaultParams[option]
|
|
if (mergeParams[option] !== undefined) {
|
|
mergedOptions[option] = mergeParams[option]
|
|
}
|
|
}
|
|
return mergedOptions
|
|
}
|
|
|
|
function isJSON (json) {
|
|
try {
|
|
if (json instanceof Object && JSON.parse(JSON.stringify(json))) {
|
|
return true
|
|
}
|
|
return false
|
|
} catch (e) {
|
|
return false
|
|
}
|
|
}
|
|
}, {}]}, {}, [7])
|
|
// # sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/saiph/Documents/playground/Simple-Jekyll-Search/node_modules/browser-pack/_prelude.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/JSONLoader.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/OptionsValidator.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/Repository.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/SearchStrategies/FuzzySearchStrategy.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/SearchStrategies/LiteralSearchStrategy.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/Templater.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/fake_83bee428.js","/Users/saiph/Documents/playground/Simple-Jekyll-Search/src/utils.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;;AC3BA;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/BA;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;;ACvGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACZA;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;;AC5BA;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;;AC7GA;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","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);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.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})","'use strict'\nmodule.exports = {\n  load: load\n}\n\nfunction load(location,callback){\n  var xhr = getXHR()\n  xhr.open('GET', location, true)\n  xhr.onreadystatechange = createStateChangeListener(xhr, callback)\n  xhr.send()\n}\n\nfunction createStateChangeListener(xhr, callback){\n  return function(){\n    if ( xhr.readyState===4 && xhr.status===200 ){\n      try{\n        callback(null, JSON.parse(xhr.responseText) )\n      }catch(err){\n        callback(err, null)\n      }\n    }\n  }\n}\n\nfunction getXHR(){\n  return (window.XMLHttpRequest) ? new XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP')\n}\n","'use strict'\nmodule.exports = function OptionsValidator(params){\n  if( !validateParams(params) ){\n    throw new Error('-- OptionsValidator: required options missing')\n  }\n  if( !(this instanceof OptionsValidator) ){\n    return new OptionsValidator(params)\n  }\n\n  var requiredOptions = params.required\n\n  this.getRequiredOptions = function(){\n    return requiredOptions\n  }\n\n  this.validate = function(parameters){\n    var errors = []\n    requiredOptions.forEach(function(requiredOptionName){\n      if( parameters[requiredOptionName] === undefined ){\n        errors.push(requiredOptionName)\n      }\n    })\n    return errors\n  }\n\n  function validateParams(params){\n    if( !params ) {\n      return false\n    }\n    return params.required !== undefined && params.required instanceof Array\n  }\n}","'use strict'\nmodule.exports = {\n  put:put,\n  clear: clear,\n  get: get,\n  search: search,\n  setOptions: setOptions\n}\n\nvar FuzzySearchStrategy = require('./SearchStrategies/FuzzySearchStrategy')\nvar LiteralSearchStrategy = require('./SearchStrategies/LiteralSearchStrategy')\n\nvar data = []\nvar opt = {}\nopt.fuzzy = false\nopt.limit = 10\nopt.searchStrategy = opt.fuzzy ? FuzzySearchStrategy : LiteralSearchStrategy\n\n\nfunction put(data){\n  if( isObject(data) ){\n    return addObject(data)\n  }\n  if( isArray(data) ){\n    return addArray(data)\n  }\n  return undefined\n}\nfunction clear(){\n  data.length = 0\n  return data\n}\n\nfunction get(){\n  return data\n}\n\n\nfunction isObject(obj){ return !!obj && Object.prototype.toString.call(obj) === '[object Object]' }\nfunction isArray(obj){ return !!obj && Object.prototype.toString.call(obj) === '[object Array]' }\n\nfunction addObject(_data){\n  data.push(_data)\n  return data\n}\n\nfunction addArray(_data){\n  var added = []\n  for (var i = 0; i < _data.length; i++){\n    if( isObject(_data[i]) ){\n      added.push(addObject(_data[i]))\n    }\n  }\n  return added\n}\n\n\n\nfunction search(crit){\n  if( !crit ){\n    return []\n  }\n  return findMatches(data,crit,opt.searchStrategy,opt)\n}\n\nfunction setOptions(_opt){\n  opt = _opt || {}\n\n  opt.fuzzy = _opt.fuzzy || false\n  opt.limit = _opt.limit || 10\n  opt.searchStrategy = _opt.fuzzy ? FuzzySearchStrategy : LiteralSearchStrategy\n}\n\nfunction findMatches(data,crit,strategy,opt){\n  var matches = []\n  for(var i = 0; i < data.length && matches.length < opt.limit; i++) {\n    var match = findMatchesInObject(data[i],crit,strategy,opt)\n    if( match ){\n      matches.push(match)\n    }\n  }\n  return matches\n}\n\nfunction findMatchesInObject(obj,crit,strategy,opt){\n  for(var key in obj) {\n    if( !isExcluded(obj[key], opt.exclude) && strategy.matches(obj[key], crit) ){\n      return obj\n    }\n  }\n}\n\nfunction isExcluded(term, excludedTerms){\n  var excluded = false\n  excludedTerms = excludedTerms || []\n  for (var i = 0; i<excludedTerms.length; i++) {\n    var excludedTerm = excludedTerms[i]\n    if( !excluded && new RegExp(term).test(excludedTerm) ){\n      excluded = true\n    }\n  }\n  return excluded\n}\n","'use strict'\nmodule.exports = new FuzzySearchStrategy()\n\nfunction FuzzySearchStrategy(){\n  this.matches = function(string, crit){\n    if( typeof string !== 'string' || typeof crit !== 'string' ){\n      return false\n    }\n    var fuzzy = fuzzyFrom(crit)\n    return !!fuzzy.test(string)\n  }\n\n  function fuzzyFrom(string){\n    var fuzzy = string\n              .trim()\n              .split('')\n              .join('.*?')\n              .replace('??','?')\n    return new RegExp( fuzzy, 'gi')\n  }\n}\n","'use strict'\nmodule.exports = new LiteralSearchStrategy()\n\nfunction LiteralSearchStrategy(){\n  this.matches = function(string,crit){\n    if( typeof string !== 'string' ){\n      return false\n    }\n    string = string.trim()\n    return string.toLowerCase().indexOf(crit.toLowerCase()) >= 0\n  }\n}\n","'use strict'\nmodule.exports = {\n  compile: compile,\n  setOptions: setOptions\n}\n\nvar options = {}\noptions.pattern = /\\{(.*?)\\}/g\noptions.template = ''\noptions.middleware = function(){}\n\nfunction setOptions(_options){\n  options.pattern = _options.pattern || options.pattern\n  options.template = _options.template || options.template\n  if( typeof _options.middleware === 'function' ){\n    options.middleware = _options.middleware\n  }\n}\n\nfunction compile(data){\n  return options.template.replace(options.pattern, function(match, prop) {\n    var value = options.middleware(prop, data[prop], options.template)\n    if( value !== undefined ){\n      return value\n    }\n    return data[prop] || match\n  })\n}\n",";(function(window, document, undefined){\n  'use strict'\n\n  var options = {\n    searchInput: null,\n    resultsContainer: null,\n    json: [],\n    searchResultTemplate: '<li><a href=\"{url}\" title=\"{desc}\">{title}</a></li>',\n    templateMiddleware: function(){},\n    noResultsText: 'No results found',\n    limit: 10,\n    fuzzy: false,\n    exclude: []\n  }\n\n  var requiredOptions = ['searchInput','resultsContainer','json']\n\n  var templater = require('./Templater')\n  var repository = require('./Repository')\n  var jsonLoader = require('./JSONLoader')\n  var optionsValidator = require('./OptionsValidator')({\n    required: requiredOptions\n  })\n  var utils = require('./utils')\n\n  /*\n    Public API\n  */\n  window.SimpleJekyllSearch = function SimpleJekyllSearch(_options){\n    var errors = optionsValidator.validate(_options)\n    if( errors.length > 0 ){\n      throwError('You must specify the following required options: ' + requiredOptions)\n    }\n\n    options = utils.merge(options, _options)\n\n    templater.setOptions({\n      template: options.searchResultTemplate,\n      middleware: options.templateMiddleware,\n    })\n\n    repository.setOptions({\n      fuzzy: options.fuzzy,\n      limit: options.limit,\n    })\n\n    if( utils.isJSON(options.json) ){\n      initWithJSON(options.json)\n    }else{\n      initWithURL(options.json)\n    }\n  }\n\n  // for backwards compatibility\n  window.SimpleJekyllSearch.init = window.SimpleJekyllSearch\n\n\n  function initWithJSON(json){\n    repository.put(json)\n    registerInput()\n  }\n\n  function initWithURL(url){\n    jsonLoader.load(url, function(err,json){\n      if( err ){\n        throwError('failed to get JSON (' + url + ')')\n      }\n      initWithJSON(json)\n    })\n  }\n\n  function emptyResultsContainer(){\n    options.resultsContainer.innerHTML = ''\n  }\n\n  function appendToResultsContainer(text){\n    options.resultsContainer.innerHTML += text\n  }\n\n  function registerInput(){\n    options.searchInput.addEventListener('keyup', function(e){\n      var key = e.which\n      var query = e.target.value\n      if( isWhitelistedKey(key) && isValidQuery(query) ) {\n        emptyResultsContainer();\n        render( repository.search(query) );\n      }\n    })\n  }\n\n  function render(results) {\n    if( results.length === 0 ){\n      return appendToResultsContainer(options.noResultsText)\n    }\n    for (var i = 0; i < results.length; i++) {\n      appendToResultsContainer( templater.compile(results[i]) )\n    }\n  }\n\n  function isValidQuery(query) {\n    return query && query.length > 0\n  }\n\n  function isWhitelistedKey(key) {\n    return [13,16,20,37,38,39,40,91].indexOf(key) === -1\n  }\n\n  function throwError(message){ throw new Error('SimpleJekyllSearch --- '+ message) }\n})(window, document);\n","'use strict'\nmodule.exports = {\n  merge: merge,\n  isJSON: isJSON,\n}\n\nfunction merge(defaultParams, mergeParams){\n  var mergedOptions = {}\n  for(var option in defaultParams){\n    mergedOptions[option] = defaultParams[option]\n    if( mergeParams[option] !== undefined ){\n      mergedOptions[option] = mergeParams[option]\n    }\n  }\n  return mergedOptions\n}\n\nfunction isJSON(json){\n  try{\n    if( json instanceof Object && JSON.parse(JSON.stringify(json)) ){\n      return true\n    }\n    return false\n  }catch(e){\n    return false\n  }\n}\n"]}
|