redeyed-jekyll-theme 0.1.0

data/assets/js/fetch.js

@@ -0,0 +1,458 @@
+(function(self) {
+    'use strict';
+
+    if (self.fetch) {
+        return
+    }
+
+    var support = {
+        searchParams: 'URLSearchParams' in self,
+        iterable: 'Symbol' in self && 'iterator' in Symbol,
+        blob: 'FileReader' in self && 'Blob' in self && (function() {
+            try {
+                new Blob()
+                return true
+            } catch(e) {
+                return false
+            }
+        })(),
+        formData: 'FormData' in self,
+        arrayBuffer: 'ArrayBuffer' in self
+    }
+
+    if (support.arrayBuffer) {
+        var viewClasses = [
+            '[object Int8Array]',
+            '[object Uint8Array]',
+            '[object Uint8ClampedArray]',
+            '[object Int16Array]',
+            '[object Uint16Array]',
+            '[object Int32Array]',
+            '[object Uint32Array]',
+            '[object Float32Array]',
+            '[object Float64Array]'
+        ]
+
+        var isDataView = function(obj) {
+            return obj && DataView.prototype.isPrototypeOf(obj)
+        }
+
+        var isArrayBufferView = ArrayBuffer.isView || function(obj) {
+            return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1
+        }
+    }
+
+    function normalizeName(name) {
+        if (typeof name !== 'string') {
+            name = String(name)
+        }
+        if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) {
+            throw new TypeError('Invalid character in header field name')
+        }
+        return name.toLowerCase()
+    }
+
+    function normalizeValue(value) {
+        if (typeof value !== 'string') {
+            value = String(value)
+        }
+        return value
+    }
+
+    // Build a destructive iterator for the value list
+    function iteratorFor(items) {
+        var iterator = {
+            next: function() {
+                var value = items.shift()
+                return {done: value === undefined, value: value}
+            }
+        }
+
+        if (support.iterable) {
+            iterator[Symbol.iterator] = function() {
+                return iterator
+            }
+        }
+
+        return iterator
+    }
+
+    function Headers(headers) {
+        this.map = {}
+
+        if (headers instanceof Headers) {
+            headers.forEach(function(value, name) {
+                this.append(name, value)
+            }, this)
+
+        } else if (headers) {
+            Object.getOwnPropertyNames(headers).forEach(function(name) {
+                this.append(name, headers[name])
+            }, this)
+        }
+    }
+
+    Headers.prototype.append = function(name, value) {
+        name = normalizeName(name)
+        value = normalizeValue(value)
+        var oldValue = this.map[name]
+        this.map[name] = oldValue ? oldValue+','+value : value
+    }
+
+    Headers.prototype['delete'] = function(name) {
+        delete this.map[normalizeName(name)]
+    }
+
+    Headers.prototype.get = function(name) {
+        name = normalizeName(name)
+        return this.has(name) ? this.map[name] : null
+    }
+
+    Headers.prototype.has = function(name) {
+        return this.map.hasOwnProperty(normalizeName(name))
+    }
+
+    Headers.prototype.set = function(name, value) {
+        this.map[normalizeName(name)] = normalizeValue(value)
+    }
+
+    Headers.prototype.forEach = function(callback, thisArg) {
+        for (var name in this.map) {
+            if (this.map.hasOwnProperty(name)) {
+                callback.call(thisArg, this.map[name], name, this)
+            }
+        }
+    }
+
+    Headers.prototype.keys = function() {
+        var items = []
+        this.forEach(function(value, name) { items.push(name) })
+        return iteratorFor(items)
+    }
+
+    Headers.prototype.values = function() {
+        var items = []
+        this.forEach(function(value) { items.push(value) })
+        return iteratorFor(items)
+    }
+
+    Headers.prototype.entries = function() {
+        var items = []
+        this.forEach(function(value, name) { items.push([name, value]) })
+        return iteratorFor(items)
+    }
+
+    if (support.iterable) {
+        Headers.prototype[Symbol.iterator] = Headers.prototype.entries
+    }
+
+    function consumed(body) {
+        if (body.bodyUsed) {
+            return Promise.reject(new TypeError('Already read'))
+        }
+        body.bodyUsed = true
+    }
+
+    function fileReaderReady(reader) {
+        return new Promise(function(resolve, reject) {
+            reader.onload = function() {
+                resolve(reader.result)
+            }
+            reader.onerror = function() {
+                reject(reader.error)
+            }
+        })
+    }
+
+    function readBlobAsArrayBuffer(blob) {
+        var reader = new FileReader()
+        var promise = fileReaderReady(reader)
+        reader.readAsArrayBuffer(blob)
+        return promise
+    }
+
+    function readBlobAsText(blob) {
+        var reader = new FileReader()
+        var promise = fileReaderReady(reader)
+        reader.readAsText(blob)
+        return promise
+    }
+
+    function readArrayBufferAsText(buf) {
+        var view = new Uint8Array(buf)
+        var chars = new Array(view.length)
+
+        for (var i = 0; i < view.length; i++) {
+            chars[i] = String.fromCharCode(view[i])
+        }
+        return chars.join('')
+    }
+
+    function bufferClone(buf) {
+        if (buf.slice) {
+            return buf.slice(0)
+        } else {
+            var view = new Uint8Array(buf.byteLength)
+            view.set(new Uint8Array(buf))
+            return view.buffer
+        }
+    }
+
+    function Body() {
+        this.bodyUsed = false
+
+        this._initBody = function(body) {
+            this._bodyInit = body
+            if (!body) {
+                this._bodyText = ''
+            } else if (typeof body === 'string') {
+                this._bodyText = body
+            } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {
+                this._bodyBlob = body
+            } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {
+                this._bodyFormData = body
+            } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+                this._bodyText = body.toString()
+            } else if (support.arrayBuffer && support.blob && isDataView(body)) {
+                this._bodyArrayBuffer = bufferClone(body.buffer)
+                // IE 10-11 can't handle a DataView body.
+                this._bodyInit = new Blob([this._bodyArrayBuffer])
+            } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {
+                this._bodyArrayBuffer = bufferClone(body)
+            } else {
+                throw new Error('unsupported BodyInit type')
+            }
+
+            if (!this.headers.get('content-type')) {
+                if (typeof body === 'string') {
+                    this.headers.set('content-type', 'text/plain;charset=UTF-8')
+                } else if (this._bodyBlob && this._bodyBlob.type) {
+                    this.headers.set('content-type', this._bodyBlob.type)
+                } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {
+                    this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8')
+                }
+            }
+        }
+
+        if (support.blob) {
+            this.blob = function() {
+                var rejected = consumed(this)
+                if (rejected) {
+                    return rejected
+                }
+
+                if (this._bodyBlob) {
+                    return Promise.resolve(this._bodyBlob)
+                } else if (this._bodyArrayBuffer) {
+                    return Promise.resolve(new Blob([this._bodyArrayBuffer]))
+                } else if (this._bodyFormData) {
+                    throw new Error('could not read FormData body as blob')
+                } else {
+                    return Promise.resolve(new Blob([this._bodyText]))
+                }
+            }
+
+            this.arrayBuffer = function() {
+                if (this._bodyArrayBuffer) {
+                    return consumed(this) || Promise.resolve(this._bodyArrayBuffer)
+                } else {
+                    return this.blob().then(readBlobAsArrayBuffer)
+                }
+            }
+        }
+
+        this.text = function() {
+            var rejected = consumed(this)
+            if (rejected) {
+                return rejected
+            }
+
+            if (this._bodyBlob) {
+                return readBlobAsText(this._bodyBlob)
+            } else if (this._bodyArrayBuffer) {
+                return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))
+            } else if (this._bodyFormData) {
+                throw new Error('could not read FormData body as text')
+            } else {
+                return Promise.resolve(this._bodyText)
+            }
+        }
+
+        if (support.formData) {
+            this.formData = function() {
+                return this.text().then(decode)
+            }
+        }
+
+        this.json = function() {
+            return this.text().then(JSON.parse)
+        }
+
+        return this
+    }
+
+    // HTTP methods whose capitalization should be normalized
+    var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']
+
+    function normalizeMethod(method) {
+        var upcased = method.toUpperCase()
+        return (methods.indexOf(upcased) > -1) ? upcased : method
+    }
+
+    function Request(input, options) {
+        options = options || {}
+        var body = options.body
+
+        if (input instanceof Request) {
+            if (input.bodyUsed) {
+                throw new TypeError('Already read')
+            }
+            this.url = input.url
+            this.credentials = input.credentials
+            if (!options.headers) {
+                this.headers = new Headers(input.headers)
+            }
+            this.method = input.method
+            this.mode = input.mode
+            if (!body && input._bodyInit != null) {
+                body = input._bodyInit
+                input.bodyUsed = true
+            }
+        } else {
+            this.url = String(input)
+        }
+
+        this.credentials = options.credentials || this.credentials || 'omit'
+        if (options.headers || !this.headers) {
+            this.headers = new Headers(options.headers)
+        }
+        this.method = normalizeMethod(options.method || this.method || 'GET')
+        this.mode = options.mode || this.mode || null
+        this.referrer = null
+
+        if ((this.method === 'GET' || this.method === 'HEAD') && body) {
+            throw new TypeError('Body not allowed for GET or HEAD requests')
+        }
+        this._initBody(body)
+    }
+
+    Request.prototype.clone = function() {
+        return new Request(this, { body: this._bodyInit })
+    }
+
+    function decode(body) {
+        var form = new FormData()
+        body.trim().split('&').forEach(function(bytes) {
+            if (bytes) {
+                var split = bytes.split('=')
+                var name = split.shift().replace(/\+/g, ' ')
+                var value = split.join('=').replace(/\+/g, ' ')
+                form.append(decodeURIComponent(name), decodeURIComponent(value))
+            }
+        })
+        return form
+    }
+
+    function parseHeaders(rawHeaders) {
+        var headers = new Headers()
+        rawHeaders.split(/\r?\n/).forEach(function(line) {
+            var parts = line.split(':')
+            var key = parts.shift().trim()
+            if (key) {
+                var value = parts.join(':').trim()
+                headers.append(key, value)
+            }
+        })
+        return headers
+    }
+
+    Body.call(Request.prototype)
+
+    function Response(bodyInit, options) {
+        if (!options) {
+            options = {}
+        }
+
+        this.type = 'default'
+        this.status = 'status' in options ? options.status : 200
+        this.ok = this.status >= 200 && this.status < 300
+        this.statusText = 'statusText' in options ? options.statusText : 'OK'
+        this.headers = new Headers(options.headers)
+        this.url = options.url || ''
+        this._initBody(bodyInit)
+    }
+
+    Body.call(Response.prototype)
+
+    Response.prototype.clone = function() {
+        return new Response(this._bodyInit, {
+            status: this.status,
+            statusText: this.statusText,
+            headers: new Headers(this.headers),
+            url: this.url
+        })
+    }
+
+    Response.error = function() {
+        var response = new Response(null, {status: 0, statusText: ''})
+        response.type = 'error'
+        return response
+    }
+
+    var redirectStatuses = [301, 302, 303, 307, 308]
+
+    Response.redirect = function(url, status) {
+        if (redirectStatuses.indexOf(status) === -1) {
+            throw new RangeError('Invalid status code')
+        }
+
+        return new Response(null, {status: status, headers: {location: url}})
+    }
+
+    self.Headers = Headers
+    self.Request = Request
+    self.Response = Response
+
+    self.fetch = function(input, init) {
+        return new Promise(function(resolve, reject) {
+            var request = new Request(input, init)
+            var xhr = new XMLHttpRequest()
+
+            xhr.onload = function() {
+                var options = {
+                    status: xhr.status,
+                    statusText: xhr.statusText,
+                    headers: parseHeaders(xhr.getAllResponseHeaders() || '')
+                }
+                options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL')
+                var body = 'response' in xhr ? xhr.response : xhr.responseText
+                resolve(new Response(body, options))
+            }
+
+            xhr.onerror = function() {
+                reject(new TypeError('Network request failed'))
+            }
+
+            xhr.ontimeout = function() {
+                reject(new TypeError('Network request failed'))
+            }
+
+            xhr.open(request.method, request.url, true)
+
+            if (request.credentials === 'include') {
+                xhr.withCredentials = true
+            }
+
+            if ('responseType' in xhr && support.blob) {
+                xhr.responseType = 'blob'
+            }
+
+            request.headers.forEach(function(value, name) {
+                xhr.setRequestHeader(name, value)
+            })
+
+            xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit)
+        })
+    }
+    self.fetch.polyfill = true
+})(typeof self !== 'undefined' ? self : this);

data/assets/js/pwa/app.js

@@ -0,0 +1,47 @@
+---
+layout: compress
+permalink: '/app.js'
+---
+
+const $notification = $('#notification');
+const $btnRefresh = $('#notification .toast-body>button');
+
+if ('serviceWorker' in navigator) {
+    /* Registering Service Worker */
+    navigator.serviceWorker.register('{{ "/sw.js" | relative_url }}')
+        .then(registration => {
+
+                /* in case the user ignores the notification */
+                if (registration.waiting) {
+                    $notification.toast('show');
+                }
+
+                registration.addEventListener('updatefound', () => {
+                    registration.installing.addEventListener('statechange', () => {
+                        if (registration.waiting) {
+                            if (navigator.serviceWorker.controller) {
+                                $notification.toast('show');
+                            }
+                        }
+                    });
+                });
+
+                $btnRefresh.click(() => {
+                    if (registration.waiting) {
+                        registration.waiting.postMessage('SKIP_WAITING');
+                    }
+                    $notification.toast('hide');
+                });
+            }
+        );
+
+    let refreshing = false;
+
+    /* Detect controller change and refresh all the opened tabs */
+    navigator.serviceWorker.addEventListener('controllerchange', () => {
+        if (!refreshing) {
+            window.location.reload();
+            refreshing = true;
+        }
+    });
+}

data/assets/js/pwa/sw.js

@@ -0,0 +1,89 @@
+---
+layout: compress
+permalink: '/sw.js'
+# PWA service worker
+---
+
+    self.importScripts('{{ "/assets/js/data/swcache.js" | relative_url }}');
+
+const cacheName = 'chirpy-{{ "now" | date: "%Y%m%d.%H%M%S" }}';
+
+function verifyDomain(url) {
+    for (const domain of allowedDomains) {
+        const regex = RegExp(`^http(s)?:\/\/${domain}\/`);
+        if (regex.test(url)) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+function isExcluded(url) {
+    for (const item of denyUrls) {
+        if (url === item) {
+            return true;
+        }
+    }
+    return false;
+}
+
+self.addEventListener('install', event => {
+    event.waitUntil(
+        caches.open(cacheName).then(cache => {
+            return cache.addAll(resource);
+        })
+    );
+});
+
+self.addEventListener('activate', event => {
+    event.waitUntil(
+        caches.keys().then(keyList => {
+            return Promise.all(
+                keyList.map(key => {
+                    if (key !== cacheName) {
+                        return caches.delete(key);
+                    }
+                })
+            );
+        })
+    );
+});
+
+self.addEventListener('message', (event) => {
+    if (event.data === 'SKIP_WAITING') {
+        self.skipWaiting();
+    }
+});
+
+self.addEventListener('fetch', event => {
+    event.respondWith(
+        caches.match(event.request).then(response => {
+            if (response) {
+                return response;
+            }
+
+            return fetch(event.request).then(response => {
+                const url = event.request.url;
+
+                if (event.request.method !== 'GET' ||
+                    !verifyDomain(url) ||
+                    isExcluded(url)) {
+                    return response;
+                }
+
+                /*
+                  see: <https://developers.google.com/web/fundamentals/primers/service-workers#cache_and_return_requests>
+                */
+                let responseToCache = response.clone();
+
+                caches.open(cacheName).then(cache => {
+                    /* console.log('[sw] Caching new resource: ' + event.request.url); */
+                    cache.put(event.request, responseToCache);
+                });
+
+                return response;
+            });
+        })
+    );
+});

data/assets/js/pwa/unregister.js

@@ -0,0 +1,12 @@
+---
+layout: compress
+permalink: '/unregister.js'
+---
+
+if ('serviceWorker' in navigator) {
+    navigator.serviceWorker.getRegistrations().then((registrations) => {
+        for (let reg of registrations) {
+            reg.unregister();
+        }
+    });
+}

data/src/404.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <title>Title</title>
+</head>
+<body>
+
+</body>
+</html>

data/src/feed.xml

@@ -0,0 +1,61 @@
+---
+layout: compress
+permalink: /feed.xml
+# Atom Feed, reference: https://validator.w3.org/feed/docs/atom.html
+---
+
+{% capture source %}
+<feed xmlns="http://www.w3.org/2005/Atom">
+    <id>{{ "/" | absolute_url }}</id>
+    <title>{{ site.title }}</title>
+    <subtitle>{{ site.description }}</subtitle>
+    <updated>{{ site.time | date_to_xmlschema }}</updated>
+    <author>
+        <name>{{ site.social.name }}</name>
+        <uri>{{ "/" | absolute_url }}</uri>
+    </author>
+    <link rel="self" type="application/atom+xml" href="{{ page.url | absolute_url }}"/>
+    <link rel="alternate" type="text/html" hreflang="{{ site.lang }}"
+          href="{{ '/' | absolute_url }}"/>
+    <generator uri="https://jekyllrb.com/" version="{{ jekyll.version }}">Jekyll</generator>
+    <rights> © {{ 'now' | date: '%Y' }} {{ site.social.name }} </rights>
+    <icon>{{ site.baseurl }}/assets/img/favicons/favicon.ico</icon>
+    <logo>{{ site.baseurl }}/assets/img/favicons/favicon-96x96.png</logo>
+
+    {% for post in site.posts limit: 5 %}
+    {% assign post_absolute_url = post.url | absolute_url %}
+    <entry>
+        <title>{{ post.title }}</title>
+        <link href="{{ post_absolute_url }}" rel="alternate" type="text/html" title="{{ post.title }}" />
+        <published>{{ post.date | date_to_xmlschema }}</published>
+        {% if post.last_modified_at %}
+        <updated>{{ post.last_modified_at | date_to_xmlschema }}</updated>
+        {% else %}
+        <updated>{{ post.date | date_to_xmlschema }}</updated>
+        {% endif %}
+        <id>{{ post_absolute_url }}</id>
+        <content src="{{ post_absolute_url }}" />
+        <author>
+            <name>{{ post.author | default: site.social.name }}</name>
+        </author>
+
+        {% if post.categories %}
+        {% for category in post.categories %}
+        <category term="{{ category }}" />
+        {% endfor %}
+        {% endif %}
+
+        {% if post.summary %}
+        <summary>{{ post.summary | strip }}</summary>
+        {% else %}
+        <summary>
+            {% include no-linenos.html content=post.content %}
+            {{ content  | strip_html | truncate: 400 }}
+        </summary>
+        {% endif %}
+
+    </entry>
+    {% endfor %}
+</feed>
+{% endcapture %}
+{{ source | replace: '&', '&amp;' }}

data/src/index.md

@@ -0,0 +1,22 @@
+---
+title: Home
+layout: default
+---
+
+# Welcome
+
+---
+
+## Profiler
+
+| ELEMENT                        | STYLE                                |
+|--------------------------------|--------------------------------------|
+| jekyll.environment             | {{ jekyll.environment }}             |
+| page.layout                    | {{ page.layout }}                    |
+| site.lang                      | {{ site.lang }}                      |
+| site.theme_mode                | {{ site.theme_mode }}                |
+| prefer_mode                    | {{ prefer_mode }}                    |
+| ----------------------------   | ----------------------------         |
+| origin                         | {{ origin }}                         |
+| site.resources.self_hosted     | {{ site.resources.self_hosted }}     |
+| site.data.authors.ragdata.name | {{ site.data.authors.ragdata.name }} |