hexo-theme-shokax 0.2.10 → 0.3.0

package/source/js/_app/globals/themeColor.js

@@ -0,0 +1,48 @@
+const changeTheme = (type) => {
+    const btn = $dom('.theme .ic');
+    if (type === 'dark') {
+        HTML.attr('data-theme', type);
+        btn.removeClass('i-sun');
+        btn.addClass('i-moon');
+    }
+    else {
+        HTML.attr('data-theme', null);
+        btn.removeClass('i-moon');
+        btn.addClass('i-sun');
+    }
+};
+const autoDarkmode = () => {
+    if (CONFIG.auto_dark.enable) {
+        if (new Date().getHours() >= CONFIG.auto_dark.start || new Date().getHours() <= CONFIG.auto_dark.end) {
+            changeTheme('dark');
+        }
+        else {
+            changeTheme();
+        }
+    }
+};
+const changeMetaTheme = (color) => {
+    if (HTML.attr('data-theme') === 'dark') {
+        color = '#222';
+    }
+    $dom('meta[name="theme-color"]').attr('content', color);
+};
+const themeColorListener = () => {
+    window.matchMedia('(prefers-color-scheme: dark)').addEventListener('change', (mediaQueryList) => {
+        if (mediaQueryList.matches) {
+            changeTheme('dark');
+        }
+        else {
+            changeTheme();
+        }
+    });
+    const t = $storage.get('theme');
+    if (t) {
+        changeTheme(t);
+    }
+    else {
+        if (CONFIG.darkmode) {
+            changeTheme('dark');
+        }
+    }
+};

package/source/js/_app/globals/thirdparty.js

@@ -0,0 +1,60 @@
+const lazyload = lozad('img, [data-background-image]', {
+    loaded(el) {
+        el.addClass('lozaded');
+    }
+});
+const Loader = {
+    timer: undefined,
+    lock: false,
+    show() {
+        clearTimeout(this.timer);
+        document.body.removeClass('loaded');
+        loadCat.attr('style', 'display:block');
+        Loader.lock = false;
+    },
+    hide(sec) {
+        if (!CONFIG.loader.start) {
+            sec = -1;
+        }
+        this.timer = setTimeout(this.vanish, sec || 3000);
+    },
+    vanish() {
+        if (Loader.lock) {
+            return;
+        }
+        if (CONFIG.loader.start) {
+            transition(loadCat, 0);
+        }
+        document.body.addClass('loaded');
+        Loader.lock = true;
+    }
+};
+const isOutime = () => {
+    let updateTime;
+    if (CONFIG.outime.enable && LOCAL.outime) {
+        const times = document.getElementsByTagName('time');
+        if (times.length === 0) {
+            return;
+        }
+        const posts = document.getElementsByClassName('body md');
+        if (posts.length === 0) {
+            return;
+        }
+        const now = Date.now();
+        const pubTime = new Date(times[0].dateTime);
+        if (times.length === 1) {
+            updateTime = pubTime;
+        }
+        else {
+            updateTime = new Date(times[1].dateTime);
+        }
+        const interval = parseInt(String(now - updateTime));
+        const days = parseInt(String(CONFIG.outime.days)) || 30;
+        if (interval > (days * 86400000)) {
+            const publish = parseInt(String((now - pubTime) / 86400000));
+            const updated = parseInt(String(interval / 86400000));
+            const template = LOCAL.template.replace('{{publish}}', String(publish)).replace('{{updated}}', String(updated));
+            posts[0].insertAdjacentHTML('afterbegin', template);
+        }
+    }
+};

package/source/js/_app/globals/tools.js

@@ -0,0 +1,75 @@
+const showtip = (msg) => {
+    if (!msg) {
+        return;
+    }
+    const tipbox = BODY.createChild('div', {
+        innerHTML: msg,
+        className: 'tip'
+    });
+    setTimeout(() => {
+        tipbox.addClass('hide');
+        setTimeout(() => {
+            BODY.removeChild(tipbox);
+        }, 300);
+    }, 3000);
+};
+const pagePosition = () => {
+    if (CONFIG.auto_scroll) {
+        $storage.set(LOCAL_URL, String(scrollAction.y));
+    }
+};
+const positionInit = (comment) => {
+    const anchor = window.location.hash;
+    let target = null;
+    if (LOCAL_HASH) {
+        $storage.del(LOCAL_URL);
+        return;
+    }
+    if (anchor) {
+        target = $dom(decodeURI(anchor));
+    }
+    else {
+        target = CONFIG.auto_scroll ? parseInt($storage.get(LOCAL_URL)) : 0;
+    }
+    if (target) {
+        pageScroll(target);
+        LOCAL_HASH = 1;
+    }
+    if (comment && anchor && !LOCAL_HASH) {
+        pageScroll(target);
+        LOCAL_HASH = 1;
+    }
+};
+const clipBoard = (str, callback) => {
+    if (navigator.clipboard && window.isSecureContext) {
+        navigator.clipboard.writeText(str).then(() => {
+            callback && callback(true);
+        }, () => {
+            callback && callback(false);
+        });
+    }
+    else {
+        const ta = BODY.createChild('textarea', {
+            style: {
+                top: window.scrollY + 'px',
+                position: 'absolute',
+                opacity: '0'
+            },
+            readOnly: true,
+            value: str
+        });
+        const selection = document.getSelection();
+        const selected = selection.rangeCount > 0 ? selection.getRangeAt(0) : false;
+        ta.select();
+        ta.setSelectionRange(0, str.length);
+        ta.readOnly = false;
+        const result = document.execCommand('copy');
+        callback && callback(result);
+        ta.blur();
+        if (selected) {
+            selection.removeAllRanges();
+            selection.addRange(selected);
+        }
+        BODY.removeChild(ta);
+    }
+};

package/source/js/_app/library/anime.js

@@ -0,0 +1,85 @@
+const transition = (target, type, complete, begin) => {
+    let animation;
+    let display = 'none';
+    switch (type) {
+        case 0:
+            animation = { opacity: [1, 0] };
+            break;
+        case 1:
+            animation = { opacity: [0, 1] };
+            display = 'block';
+            break;
+        case 'bounceUpIn':
+            animation = {
+                begin(anim) {
+                    target.display('block');
+                },
+                translateY: [
+                    { value: -60, duration: 200 },
+                    { value: 10, duration: 200 },
+                    { value: -5, duration: 200 },
+                    { value: 0, duration: 200 }
+                ],
+                opacity: [0, 1]
+            };
+            display = 'block';
+            break;
+        case 'shrinkIn':
+            animation = {
+                begin(anim) {
+                    target.display('block');
+                },
+                scale: [
+                    { value: 1.1, duration: 300 },
+                    { value: 1, duration: 200 }
+                ],
+                opacity: 1
+            };
+            display = 'block';
+            break;
+        case 'slideRightIn':
+            animation = {
+                begin(anim) {
+                    target.display('block');
+                },
+                translateX: ['100%', '0%'],
+                opacity: [0, 1]
+            };
+            display = 'block';
+            break;
+        case 'slideRightOut':
+            animation = {
+                translateX: ['0%', '100%'],
+                opacity: [1, 0]
+            };
+            break;
+        default:
+            animation = type;
+            display = type.display;
+            break;
+    }
+    anime(Object.assign({
+        targets: target,
+        duration: 200,
+        easing: 'linear',
+        begin() {
+            begin && begin();
+        },
+        complete() {
+            target.display(display);
+            complete && complete();
+        }
+    }, animation)).play();
+};
+const pageScroll = (target, offset, complete) => {
+    const opt = {
+        targets: typeof offset === 'number' ? target.parentNode : document.scrollingElement,
+        duration: 500,
+        easing: 'easeInOutQuad',
+        scrollTop: offset || (typeof target === 'number' ? target : (target ? target.getTop() + document.documentElement.scrollTop - siteNavHeight : 0)),
+        complete() {
+            complete && complete();
+        }
+    };
+    anime(opt).play();
+};

package/source/js/_app/library/dom.js

@@ -0,0 +1,22 @@
+const getDocHeight = () => $dom('main > .inner').offsetHeight;
+const $dom = (selector, element = document) => {
+    if (selector[0] === '#') {
+        return element.getElementById(selector.substring(1));
+    }
+    return element.querySelector(selector);
+};
+$dom.all = (selector, element = document) => {
+    return element.querySelectorAll(selector);
+};
+$dom.each = (selector, callback, element) => {
+    $dom.all(selector, element).forEach(callback);
+};
+$dom.asyncify = async (selector, element = document) => {
+    if (selector[0] === '#') {
+        return element.getElementById(selector.substring(1));
+    }
+    return element.querySelector(selector);
+};
+$dom.asyncifyEach = (selector, callback, element) => {
+    $dom.all(selector, element).forEach(callback);
+};

package/source/js/_app/library/loadFile.js

@@ -0,0 +1,32 @@
+const assetUrl = (asset, type) => {
+    const str = CONFIG[asset][type];
+    if (str.includes('gh') || str.includes('combine')) {
+        return `https://cdn.jsdelivr.net/${str}`;
+    }
+    if (str.includes('npm')) {
+        return `https://cdn.jsdelivr.net/${str}`;
+    }
+    if (str.includes('http')) {
+        return str;
+    }
+    return `/${str}`;
+};
+const vendorJs = (type, callback, condition) => {
+    if (LOCAL[type]) {
+        getScript(assetUrl('js', type), callback || function () {
+            window[type] = true;
+        }, condition || window[type]);
+    }
+};
+const vendorCss = (type, condition) => {
+    if (window['css' + type]) {
+        return;
+    }
+    if (LOCAL[type]) {
+        document.head.createChild('link', {
+            rel: 'stylesheet',
+            href: assetUrl('css', type)
+        });
+        window['css' + type] = true;
+    }
+};

package/source/js/_app/library/proto.js

@@ -0,0 +1,105 @@
+Object.assign(HTMLElement.prototype, {
+    createChild(tag, obj, positon) {
+        const child = document.createElement(tag);
+        Object.assign(child, obj);
+        switch (positon) {
+            case 'after':
+                this.insertAfter(child);
+                break;
+            case 'replace':
+                this.innerHTML = '';
+                this.appendChild(child);
+                break;
+            default:
+                this.appendChild(child);
+        }
+        return child;
+    },
+    wrapObject(obj) {
+        const box = document.createElement('div');
+        Object.assign(box, obj);
+        this.parentNode.insertBefore(box, this);
+        this.parentNode.removeChild(this);
+        box.appendChild(this);
+    },
+    changeOrGetHeight(h) {
+        if (h) {
+            this.style.height = typeof h === 'number' ? h + 'rem' : h;
+        }
+        return this.getBoundingClientRect().height;
+    },
+    changeOrGetWidth(w) {
+        if (w) {
+            this.style.width = typeof w === 'number' ? w + 'rem' : w;
+        }
+        return this.getBoundingClientRect().width;
+    },
+    getTop() {
+        return this.getBoundingClientRect().top;
+    },
+    left() {
+        return this.getBoundingClientRect().left;
+    },
+    attr(type, value) {
+        if (value === null) {
+            return this.removeAttribute(type);
+        }
+        if (value) {
+            this.setAttribute(type, value);
+            return this;
+        }
+        else {
+            return this.getAttribute(type);
+        }
+    },
+    insertAfter(element) {
+        const parent = this.parentNode;
+        if (parent.lastChild === this) {
+            parent.appendChild(element);
+        }
+        else {
+            parent.insertBefore(element, this.nextSibling);
+        }
+    },
+    display(d) {
+        if (d == null) {
+            return this.style.display;
+        }
+        else {
+            this.style.display = d;
+            return this;
+        }
+    },
+    child(selector) {
+        return $dom(selector, this);
+    },
+    find(selector) {
+        return $dom.all(selector, this);
+    },
+    _class(type, className, display) {
+        const classNames = className.indexOf(' ') ? className.split(' ') : [className];
+        classNames.forEach((name) => {
+            if (type === 'toggle') {
+                this.classList.toggle(name, display);
+            }
+            else {
+                this.classList[type](name);
+            }
+        });
+    },
+    addClass(className) {
+        this._class('add', className);
+        return this;
+    },
+    removeClass(className) {
+        this._class('remove', className);
+        return this;
+    },
+    toggleClass(className, display) {
+        this._class('toggle', className, display);
+        return this;
+    },
+    hasClass(className) {
+        return this.classList.contains(className);
+    }
+});

package/source/js/_app/library/scriptPjax.js

@@ -0,0 +1,57 @@
+let inCloudFlare = true;
+window.addEventListener('DOMContentLoaded', function () {
+    inCloudFlare = false;
+});
+if (document.readyState === 'loading') {
+    window.addEventListener('load', function () {
+        if (inCloudFlare) {
+            window.dispatchEvent(new Event('DOMContentLoaded'));
+            console.log('%c ☁️cloudflare patch ' + '%c running(rocket & minify)', 'color: white; background: #ff8c00; padding: 5px 3px;', 'padding: 4px;border:1px solid #ff8c00');
+        }
+    });
+}
+const getScript = (url, callback, condition) => {
+    if (condition) {
+        callback();
+    }
+    else {
+        let script = document.createElement('script');
+        script.onload = function (_, isAbort) {
+            if (isAbort || !script.readyState) {
+                console.log('abort!');
+                script.onload = null;
+                script = undefined;
+                if (!isAbort && callback)
+                    setTimeout(callback, 0);
+            }
+        };
+        script.src = url;
+        document.head.appendChild(script);
+    }
+};
+const pjaxScript = (element) => {
+    const { text, parentNode, id, className, type, src, dataset } = element;
+    const code = text || element.textContent || element.innerHTML || '';
+    parentNode.removeChild(element);
+    const script = document.createElement('script');
+    if (id) {
+        script.id = id;
+    }
+    if (className) {
+        script.className = className;
+    }
+    if (type) {
+        script.type = type;
+    }
+    if (src) {
+        script.src = src;
+        script.async = false;
+    }
+    if (dataset.pjax !== undefined) {
+        script.dataset.pjax = '';
+    }
+    if (code !== '') {
+        script.appendChild(document.createTextNode(code));
+    }
+    parentNode.appendChild(script);
+};

package/source/js/_app/library/storage.js

@@ -0,0 +1,11 @@
+const $storage = {
+    set(key, value) {
+        localStorage.setItem(key, value);
+    },
+    get(key) {
+        return localStorage.getItem(key);
+    },
+    del(key) {
+        localStorage.removeItem(key);
+    }
+};

package/source/js/_app/page/comment.js

@@ -0,0 +1,19 @@
+const loadComments = () => {
+    const element = $dom('#comments');
+    if (!element) {
+        goToComment.display('none');
+        return;
+    }
+    else {
+        goToComment.display('');
+    }
+    const io = new IntersectionObserver((entries, observer) => {
+        const entry = entries[0];
+        vendorCss('valine');
+        if (entry.isIntersecting || entry.intersectionRatio > 0) {
+            transition($dom('#comments'), 'bounceUpIn');
+            observer.disconnect();
+        }
+    });
+    io.observe(element);
+};

package/source/js/_app/page/common.js

@@ -0,0 +1,57 @@
+const cardActive = () => {
+    if (!$dom('.index.wrap')) {
+        return;
+    }
+    const io = new IntersectionObserver((entries) => {
+        entries.forEach((article) => {
+            if (article.target.hasClass('show')) {
+                io.unobserve(article.target);
+            }
+            else {
+                if (article.isIntersecting || article.intersectionRatio > 0) {
+                    article.target.addClass('show');
+                    io.unobserve(article.target);
+                }
+            }
+        });
+    }, {
+        root: null,
+        threshold: [0.3]
+    });
+    $dom.each('.index.wrap article.item, .index.wrap section.item', (article) => {
+        io.observe(article);
+    });
+    $dom('.index.wrap .item:first-child').addClass('show');
+    $dom.each('.cards .item', (element) => {
+        ['mouseenter', 'touchstart'].forEach((item) => {
+            element.addEventListener(item, () => {
+                if ($dom('.cards .item.active')) {
+                    $dom('.cards .item.active').removeClass('active');
+                }
+                element.addClass('active');
+            }, { passive: true });
+        });
+        ['mouseleave'].forEach((item) => {
+            element.addEventListener(item, () => {
+                element.removeClass('active');
+            }, { passive: true });
+        });
+    });
+};
+const registerExtURL = () => {
+    $dom.each('span.exturl', (element) => {
+        const link = document.createElement('a');
+        link.href = decodeURIComponent(window.atob(element.dataset.url).split('').map((c) => {
+            return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+        }).join(''));
+        link.rel = 'noopener external nofollow noreferrer';
+        link.target = '_blank';
+        link.className = element.className;
+        link.title = element.title || element.innerText;
+        link.innerHTML = element.innerHTML;
+        if (element.dataset.backgroundImage) {
+            link.dataset.backgroundImage = element.dataset.backgroundImage;
+        }
+        element.parentNode.replaceChild(link, element);
+    });
+};

package/source/js/_app/page/fancybox.js

@@ -0,0 +1,59 @@
+const postFancybox = (p) => {
+    if ($dom(p + ' .md img')) {
+        vendorCss('fancybox');
+        vendorJs('fancybox', () => {
+            const q = jQuery.noConflict();
+            $dom.each(p + ' p.gallery', (element) => {
+                const box = document.createElement('div');
+                box.className = 'gallery';
+                box.attr('data-height', String(element.attr('data-height') || 220));
+                box.innerHTML = element.innerHTML.replace(/<br>/g, '');
+                element.parentNode.insertBefore(box, element);
+                element.remove();
+            });
+            $dom.each(p + ' .md img:not(.emoji):not(.vemoji)', (element) => {
+                const $image = q(element);
+                const imageLink = $image.attr('data-src') || $image.attr('src');
+                const $imageWrapLink = $image.wrap('<a class="fancybox" href="' + imageLink + '" itemscope itemtype="https://schema.org/ImageObject" itemprop="url"></a>').parent('a');
+                let info;
+                let captionClass = 'image-info';
+                if (!$image.is('a img')) {
+                    $image.data('safe-src', imageLink);
+                    if (!$image.is('.gallery img')) {
+                        $imageWrapLink.attr('data-fancybox', 'default').attr('rel', 'default');
+                    }
+                    else {
+                        captionClass = 'jg-caption';
+                    }
+                }
+                if ((info = element.attr('title'))) {
+                    $imageWrapLink.attr('data-caption', info);
+                    const para = document.createElement('span');
+                    const txt = document.createTextNode(info);
+                    para.appendChild(txt);
+                    para.addClass(captionClass);
+                    element.insertAfter(para);
+                }
+            });
+            $dom.each(p + ' div.gallery', (el, i) => {
+                q(el).justifiedGallery({
+                    rowHeight: q(el).data('height') || 120,
+                    rel: 'gallery-' + i
+                }).on('jg.complete', function () {
+                    q(this).find('a').each((k, ele) => {
+                        ele.attr('data-fancybox', 'gallery-' + i);
+                    });
+                });
+            });
+            q.fancybox.defaults.hash = false;
+            q(p + ' .fancybox').fancybox({
+                loop: true,
+                helpers: {
+                    overlay: {
+                        locked: false
+                    }
+                }
+            });
+        }, window.jQuery);
+    }
+};