jekyll-calculus-theme 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 32cc802a73fbd787aca0fed3c5022c013b5f33ebef53abc93f468a4be57bcd36
-  data.tar.gz: 1e2b994a71d8bc4b2d1d047d916a89b9185d5bcce2057610605ac5d2b191b116
+  metadata.gz: 475d7f3c38371b348b2b3d79dd97caffeed21336037b20dc3a1432812bf297f4
+  data.tar.gz: 1fcddedb24c6b5175a46e7e343abd1d4389704dda4a592633ccf323dec4ff3f9
 SHA512:
-  metadata.gz: 69d8b1bea5be9677689f07b7f734c1484f276d24e0079daa43ad6a80366096fc0c95498d4a1df8745fb9f5b42843b9dd3afc0c249e9350c3816e632eb19beec5
-  data.tar.gz: df15b79248ea21a0102ff0026e340dcd52f8f3c5011fe89f985f8bd8bc030b24720a141ffbae2ca72823ed60425e890c0dbb5b4db0cb0517a27f8e38535c8ec9
+  metadata.gz: d13c691f8f86659643c860e24fe3bc64c46d2eb59a2e3c8e2e7ceec7d35c00a4ca69c608fdcb2f125747727d810aa02b2a55a1b32e7af39fba064740992c3bce
+  data.tar.gz: e5e7a6b3c500dfd80ae4b663807eed5f0cd9545ac7ec029c6a7c09b5fef309c3b6e58fb05082e68c9d548ca3d56f5104c9ffb270d16d6ec50e897aa1fdba6bc7

data/_sass/_main.scss

@@ -9,7 +9,7 @@
 }
 
 html {
-	font-size: 15px;
+	font-size: 16px;
 }
 
 #theme-toggle {

data/assets/js/simple-jekyll-search.js

@@ -0,0 +1,433 @@
+/*!
+  * Simple-Jekyll-Search
+  * Copyright 2015-2020, Christian Fei
+  * Licensed under the MIT License.
+  */
+
+(function(){
+'use strict'
+
+var _$Templater_7 = {
+  compile: compile,
+  setOptions: setOptions
+}
+
+const 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) {
+    const value = options.middleware(prop, data[prop], options.template)
+    if (typeof value !== 'undefined') {
+      return value
+    }
+    return data[prop] || match
+  })
+}
+
+'use strict';
+
+function fuzzysearch (needle, haystack) {
+  var tlen = haystack.length;
+  var qlen = needle.length;
+  if (qlen > tlen) {
+    return false;
+  }
+  if (qlen === tlen) {
+    return needle === haystack;
+  }
+  outer: for (var i = 0, j = 0; i < qlen; i++) {
+    var nch = needle.charCodeAt(i);
+    while (j < tlen) {
+      if (haystack.charCodeAt(j++) === nch) {
+        continue outer;
+      }
+    }
+    return false;
+  }
+  return true;
+}
+
+var _$fuzzysearch_1 = fuzzysearch;
+
+'use strict'
+
+/* removed: const _$fuzzysearch_1 = require('fuzzysearch') */;
+
+var _$FuzzySearchStrategy_5 = new FuzzySearchStrategy()
+
+function FuzzySearchStrategy () {
+  this.matches = function (string, crit) {
+    return _$fuzzysearch_1(crit.toLowerCase(), string.toLowerCase())
+  }
+}
+
+'use strict'
+
+var _$LiteralSearchStrategy_6 = new LiteralSearchStrategy()
+
+function LiteralSearchStrategy () {
+  this.matches = function (str, crit) {
+    if (!str) return false
+
+    str = str.trim().toLowerCase()
+    crit = crit.trim().toLowerCase()
+
+    return crit.split(' ').filter(function (word) {
+      return str.indexOf(word) >= 0
+    }).length === crit.split(' ').length
+  }
+}
+
+'use strict'
+
+var _$Repository_4 = {
+  put: put,
+  clear: clear,
+  search: search,
+  setOptions: __setOptions_4
+}
+
+/* removed: const _$FuzzySearchStrategy_5 = require('./SearchStrategies/FuzzySearchStrategy') */;
+/* removed: const _$LiteralSearchStrategy_6 = require('./SearchStrategies/LiteralSearchStrategy') */;
+
+function NoSort () {
+  return 0
+}
+
+const data = []
+let opt = {}
+
+opt.fuzzy = false
+opt.limit = 10
+opt.searchStrategy = opt.fuzzy ? _$FuzzySearchStrategy_5 : _$LiteralSearchStrategy_6
+opt.sort = NoSort
+opt.exclude = []
+
+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 isObject (obj) {
+  return Boolean(obj) && Object.prototype.toString.call(obj) === '[object Object]'
+}
+
+function isArray (obj) {
+  return Boolean(obj) && Object.prototype.toString.call(obj) === '[object Array]'
+}
+
+function addObject (_data) {
+  data.push(_data)
+  return data
+}
+
+function addArray (_data) {
+  const added = []
+  clear()
+  for (let i = 0, len = _data.length; i < len; 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).sort(opt.sort)
+}
+
+function __setOptions_4 (_opt) {
+  opt = _opt || {}
+
+  opt.fuzzy = _opt.fuzzy || false
+  opt.limit = _opt.limit || 10
+  opt.searchStrategy = _opt.fuzzy ? _$FuzzySearchStrategy_5 : _$LiteralSearchStrategy_6
+  opt.sort = _opt.sort || NoSort
+  opt.exclude = _opt.exclude || []
+}
+
+function findMatches (data, crit, strategy, opt) {
+  const matches = []
+  for (let i = 0; i < data.length && matches.length < opt.limit; i++) {
+    const match = findMatchesInObject(data[i], crit, strategy, opt)
+    if (match) {
+      matches.push(match)
+    }
+  }
+  return matches
+}
+
+function findMatchesInObject (obj, crit, strategy, opt) {
+  for (const key in obj) {
+    if (!isExcluded(obj[key], opt.exclude) && strategy.matches(obj[key], crit)) {
+      return obj
+    }
+  }
+}
+
+function isExcluded (term, excludedTerms) {
+  for (let i = 0, len = excludedTerms.length; i < len; i++) {
+    const excludedTerm = excludedTerms[i]
+    if (new RegExp(excludedTerm).test(term)) {
+      return true
+    }
+  }
+  return false
+}
+
+/* globals ActiveXObject:false */
+
+'use strict'
+
+var _$JSONLoader_2 = {
+  load: load
+}
+
+function load (location, callback) {
+  const 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 window.XMLHttpRequest() : new ActiveXObject('Microsoft.XMLHTTP')
+}
+
+'use strict'
+
+var _$OptionsValidator_3 = function OptionsValidator (params) {
+  if (!validateParams(params)) {
+    throw new Error('-- OptionsValidator: required options missing')
+  }
+
+  if (!(this instanceof OptionsValidator)) {
+    return new OptionsValidator(params)
+  }
+
+  const requiredOptions = params.required
+
+  this.getRequiredOptions = function () {
+    return requiredOptions
+  }
+
+  this.validate = function (parameters) {
+    const errors = []
+    requiredOptions.forEach(function (requiredOptionName) {
+      if (typeof parameters[requiredOptionName] === 'undefined') {
+        errors.push(requiredOptionName)
+      }
+    })
+    return errors
+  }
+
+  function validateParams (params) {
+    if (!params) {
+      return false
+    }
+    return typeof params.required !== 'undefined' && params.required instanceof Array
+  }
+}
+
+'use strict'
+
+var _$utils_9 = {
+  merge: merge,
+  isJSON: isJSON
+}
+
+function merge (defaultParams, mergeParams) {
+  const mergedOptions = {}
+  for (const option in defaultParams) {
+    mergedOptions[option] = defaultParams[option]
+    if (typeof 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 (err) {
+    return false
+  }
+}
+
+var _$src_8 = {};
+(function (window) {
+  'use strict'
+
+  let options = {
+    searchInput: null,
+    resultsContainer: null,
+    json: [],
+    success: Function.prototype,
+    searchResultTemplate: '<li><a href="{url}" title="{desc}">{title}</a></li>',
+    templateMiddleware: Function.prototype,
+    sortMiddleware: function () {
+      return 0
+    },
+    noResultsText: 'No results found',
+    limit: 10,
+    fuzzy: false,
+    debounceTime: null,
+    exclude: []
+  }
+
+  let debounceTimerHandle
+  const debounce = function (func, delayMillis) {
+    if (delayMillis) {
+      clearTimeout(debounceTimerHandle)
+      debounceTimerHandle = setTimeout(func, delayMillis)
+    } else {
+      func.call()
+    }
+  }
+
+  const requiredOptions = ['searchInput', 'resultsContainer', 'json']
+
+  /* removed: const _$Templater_7 = require('./Templater') */;
+  /* removed: const _$Repository_4 = require('./Repository') */;
+  /* removed: const _$JSONLoader_2 = require('./JSONLoader') */;
+  const optionsValidator = _$OptionsValidator_3({
+    required: requiredOptions
+  })
+  /* removed: const _$utils_9 = require('./utils') */;
+
+  window.SimpleJekyllSearch = function (_options) {
+    const errors = optionsValidator.validate(_options)
+    if (errors.length > 0) {
+      throwError('You must specify the following required options: ' + requiredOptions)
+    }
+
+    options = _$utils_9.merge(options, _options)
+
+    _$Templater_7.setOptions({
+      template: options.searchResultTemplate,
+      middleware: options.templateMiddleware
+    })
+
+    _$Repository_4.setOptions({
+      fuzzy: options.fuzzy,
+      limit: options.limit,
+      sort: options.sortMiddleware,
+      exclude: options.exclude
+    })
+
+    if (_$utils_9.isJSON(options.json)) {
+      initWithJSON(options.json)
+    } else {
+      initWithURL(options.json)
+    }
+
+    const rv = {
+      search: search
+    }
+
+    typeof options.success === 'function' && options.success.call(rv)
+    return rv
+  }
+
+  function initWithJSON (json) {
+    _$Repository_4.put(json)
+    registerInput()
+  }
+
+  function initWithURL (url) {
+    _$JSONLoader_2.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('input', function (e) {
+      if (isWhitelistedKey(e.which)) {
+        emptyResultsContainer()
+        debounce(function () { search(e.target.value) }, options.debounceTime)
+      }
+    })
+  }
+
+  function search (query) {
+    if (isValidQuery(query)) {
+      emptyResultsContainer()
+      render(_$Repository_4.search(query), query)
+    }
+  }
+
+  function render (results, query) {
+    const len = results.length
+    if (len === 0) {
+      return appendToResultsContainer(options.noResultsText)
+    }
+    for (let i = 0; i < len; i++) {
+      results[i].query = query
+      appendToResultsContainer(_$Templater_7.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)
+
+}());

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-calculus-theme
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Jain Basil Aliyas
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-08-08 00:00:00.000000000 Z
+date: 2021-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: jekyll
@@ -46,6 +46,7 @@ files:
 - _layouts/tag.html
 - _sass/_main.scss
 - assets/css/syntax.css
+- assets/js/simple-jekyll-search.js
 homepage: https://jainbasilaliyas.in
 licenses:
 - MIT