hexo-component-inferno 4.2.2 → 5.1.0

package/lib/util/consent.js

@@ -0,0 +1,122 @@
+/* eslint-env browser */
+/**
+ * Consent boundary for the theme's explicitly classified analytics integrations.
+ * @module util/consent
+ */
+const {
+  toJs
+} = require('./script');
+
+// Kept self-contained because this function is emitted into the generated page.
+function installConsent(type) {
+  if (window.hexoComponentConsent) {
+    return;
+  }
+  const integrations = Object.create(null);
+  let started = false;
+  const status = (document.cookie.match(/(?:^|;\s*)cookieconsent_status=([^;]*)/) || [])[1];
+  let allowed = type === 'opt-out' ? status !== 'deny' : status === 'allow';
+  let popup = null;
+  function run() {
+    Object.keys(integrations).forEach(id => {
+      const integration = integrations[id];
+      if (allowed && !integration.started) {
+        integration.started = true;
+        started = true;
+        integration.start();
+      }
+    });
+  }
+  window.hexoComponentConsent = {
+    allowed: function () {
+      return allowed;
+    },
+    register: function (id, start, stop) {
+      if (!integrations[id]) {
+        integrations[id] = {
+          start: start,
+          stop: stop,
+          started: false
+        };
+      }
+      run();
+    },
+    setPopup: function (value) {
+      popup = value;
+    },
+    setStatus: function (value) {
+      const previous = allowed;
+      allowed = type === 'opt-out' ? value !== 'deny' : value === 'allow';
+      if (previous && !allowed) {
+        try {
+          Object.keys(integrations).forEach(id => {
+            const integration = integrations[id];
+            if (integration.started && integration.stop) {
+              integration.stop();
+            }
+          });
+        } finally {
+          // A loaded vendor SDK may own timers/listeners that cannot safely be unloaded.
+          // A new document, with the saved denial, is the generic stop boundary.
+          if (started) {
+            window.location.reload();
+          }
+        }
+      } else {
+        run();
+      }
+    },
+    revoke: function () {
+      if (popup) {
+        popup.setStatus('deny');
+      } else {
+        document.cookie = 'cookieconsent_status=deny; Path=/; Max-Age=31536000; SameSite=Lax';
+      }
+      // setStatus on the popup invokes this too; a repeated denial is harmless.
+      this.setStatus('deny');
+    },
+    open: function () {
+      if (popup) {
+        popup.open();
+      }
+    }
+  };
+}
+
+/**
+ * Build the idempotent browser-side consent controller. Info is deliberately not gated.
+ * @param {string} type CookieConsent mode.
+ * @returns {string} Inline JavaScript.
+ */
+function consentRuntime(type) {
+  return `(${installConsent.toString()})(${toJs(type)});`;
+}
+
+/**
+ * Defer all scripts (including inline SDK bootstrap code) until this integration is authorized.
+ * Noscript pixels are intentionally not restored: without JavaScript consent cannot be obtained.
+ * @param {string} id Stable integration ID, shared across PJAX navigations.
+ * @param {string} markup Rendered integration markup containing scripts.
+ * @param {string} type CookieConsent mode.
+ * @returns {string} Inline JavaScript without active external resources before permission.
+ */
+function gateMarkup(id, markup, type) {
+  return `${consentRuntime(type)}
+    window.hexoComponentConsent.register(${toJs(id)}, function () {
+      var template = document.createElement('template');
+      template.innerHTML = ${toJs(markup)};
+      template.content.querySelectorAll('script').forEach(function (source) {
+        if (!window.hexoComponentConsent.allowed()) return;
+        var script = document.createElement('script');
+        Array.prototype.forEach.call(source.attributes, function (attr) {
+          script.setAttribute(attr.name, attr.value);
+        });
+        script.textContent = source.textContent;
+        document.head.appendChild(script);
+      });
+    });`;
+}
+module.exports = {
+  consentRuntime,
+  gateMarkup
+};

package/lib/util/deprecate.js

@@ -13,7 +13,7 @@ const warned = new Set();
  * @param {string} name Name of the component, such as <code>share.addthis</code>.
  * @param {string} message Why the component is deprecated, and what to use instead.
  * @example
- * deprecate('share.addthis', 'AddThis shut down on May 31, 2023. Use AddToAny or ShareThis instead.');
+ * deprecate('share.addthis', 'Service shut down. Use AddToAny or ShareThis.');
  */
 function deprecate(name, message) {
   if (warned.has(name)) {

package/lib/util/gallery.js

@@ -0,0 +1,227 @@
+/**
+ * Inline Gallery installer shared by the standalone component and consuming themes.
+ * Installing it does not enable or download either SDK. Keep it self-contained after Babel so it
+ * can also be used without the Hexo asset generator.
+ * @module util/gallery
+ */
+function installGallery(window) {
+  if (window.HexoGallery) return;
+  const document = window.document;
+  const requests = new Map();
+  const layouts = new Map();
+  const lightboxes = new Map();
+  function destroyLightbox(container) {
+    const state = lightboxes.get(container);
+    if (!state) return;
+    container.removeEventListener('click', state.click);
+    // The SDK removes its container through parentNode, even after a host replaced the body.
+    const dialog = state.instance.$container && state.instance.$container.get();
+    if (dialog && !dialog.parentNode) {
+      dialog.style.display = 'none';
+      document.body.appendChild(dialog);
+    }
+    if (state.instance.lgOpened) {
+      state.instance.settings.startAnimationDuration = 0;
+      state.instance.settings.backdropDuration = 0;
+    }
+    state.instance.destroy();
+    lightboxes.delete(container);
+  }
+  function lightbox(container, enabled) {
+    if (!enabled) {
+      destroyLightbox(container);
+      return;
+    }
+    if (typeof window.lightGallery !== 'function') return;
+    const plugins = (window.HexoGallery.lightGalleryPlugins || []).map(name => window[name]);
+    if (plugins.some(plugin => typeof plugin !== 'function')) return;
+    const items = Array.from(container.querySelectorAll('a.gallery-item[href]'));
+    if (!items.length) {
+      destroyLightbox(container);
+      return;
+    }
+    const elements = items.map(link => {
+      const image = link.querySelector('img');
+      const caption = document.createElement('span');
+      caption.textContent = image ? image.alt : '';
+      return {
+        src: link.href,
+        thumb: image ? image.currentSrc || image.src : link.href,
+        subHtml: caption.innerHTML,
+        alt: caption.innerHTML.replace(/"/g, '"')
+      };
+    });
+    const signature = JSON.stringify(elements);
+    let state = lightboxes.get(container);
+    if (state) {
+      if (!sameItems(state.items, items) || state.signature !== signature) {
+        if (state.instance.lgOpened) {
+          state.instance.updateSlides(elements, Math.min(state.instance.index, elements.length - 1));
+        } else {
+          state.instance.refresh(elements);
+        }
+        state.items = items;
+        state.signature = signature;
+      }
+      return;
+    }
+    const instance = window.lightGallery(container, {
+      dynamic: true,
+      dynamicEl: elements,
+      plugins
+    });
+    state = {
+      instance,
+      items,
+      signature,
+      click: null
+    };
+    state.click = event => {
+      if (event.defaultPrevented || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
+      const link = event.target.closest('a.gallery-item');
+      const index = state.items.indexOf(link);
+      if (index < 0) return;
+      event.preventDefault();
+      instance.openGallery(index, link);
+    };
+    container.addEventListener('click', state.click);
+    lightboxes.set(container, state);
+  }
+  function sameItems(items, current) {
+    return items.length === current.length && Array.from(items).every((item, i) => item === current[i]);
+  }
+  function enhance(container) {
+    container.querySelectorAll('img:not(.not-gallery-item)').forEach(image => {
+      // Third-party SDK icons are controls, not article images. Script-load retries also
+      // scan icons inserted after the article's initial enhancement.
+      if (image.closest('a, .sharethis-inline-share-buttons, .a2a_kit, [data-share-provider]')) return;
+      const link = document.createElement('a');
+      link.className = 'gallery-item';
+      const src = image.getAttribute('src');
+      if (src !== null) link.setAttribute('href', src);
+      image.parentNode.insertBefore(link, image);
+      link.appendChild(image);
+      if (image.alt) {
+        const caption = document.createElement('p');
+        caption.className = 'has-text-centered is-size-6 caption';
+        caption.textContent = image.alt;
+        link.appendChild(caption);
+      }
+    });
+  }
+  function apply(root, options) {
+    const containers = root === document ? root.querySelectorAll('.article') : [root];
+    containers.forEach(enhance);
+    // Do not capture an incomplete article while HTML is still being parsed.
+    if (document.readyState === 'loading') return;
+    containers.forEach(container => lightbox(container, options.lightGallery));
+    if (options.justifiedGallery && typeof window.JustifiedGallery === 'function') {
+      const galleries = Array.from(root.querySelectorAll('.justified-gallery'));
+      if (root !== document && root.matches('.justified-gallery')) galleries.unshift(root);
+      galleries.forEach(gallery => {
+        const paragraphs = new Set(Array.from(gallery.querySelectorAll(':scope > p > .gallery-item'), link => link.parentNode));
+        paragraphs.forEach(paragraph => {
+          paragraph.replaceWith(...paragraph.childNodes);
+        });
+        gallery.querySelectorAll(':scope > .gallery-item > .caption').forEach(caption => {
+          caption.classList.add('jg-caption');
+        });
+        let state = layouts.get(gallery);
+        const items = () => Array.from(gallery.children).filter(item => !item.classList.contains('jg-spinner') && (item.matches(state.instance.settings.selector) || item.matches('div')));
+        if (state) {
+          if (sameItems(state.items, items())) return;
+          // init refreshes entries but starts another width watcher; stop and rewind first.
+          state.instance.widthWatcher.stop();
+          state.instance.stopImgAnalyzerStarter();
+          state.instance.rewind();
+        } else {
+          // The SDK reuses .jg-caption and safely creates captions for pre-existing links.
+          state = {
+            instance: new window.JustifiedGallery(gallery)
+          };
+          layouts.set(gallery, state);
+        }
+        state.instance.init();
+        state.items = items();
+      });
+    }
+  }
+  function prune() {
+    layouts.forEach((state, gallery) => {
+      if (!gallery.isConnected) destroyLayout(gallery);
+    });
+    lightboxes.forEach((state, container) => {
+      if (!container.isConnected) destroyLightbox(container);
+    });
+    requests.forEach((options, root) => {
+      if (root !== document && !root.isConnected) requests.delete(root);
+    });
+  }
+  function destroyLayout(gallery) {
+    const {
+      instance
+    } = layouts.get(gallery);
+    // The SDK's destroy does not stop an active loading spinner.
+    instance.stopLoadingSpinnerAnimation();
+    instance.destroy();
+    layouts.delete(gallery);
+  }
+  function retry() {
+    prune();
+    requests.forEach((options, root) => apply(root, options));
+  }
+  window.HexoGallery = {
+    /**
+     * Enhance images in a content container, optionally initializing the two Gallery SDKs.
+     * Repeated calls reuse existing wrappers, captions and plugin instances. Missing SDKs can be
+     * retried by calling init again; DOM ready, window load and subsequent script loads also retry
+     * connected containers with their latest options. SDK initialization waits for DOM readiness.
+     * Changed item collections refresh their existing SDK instance. Disabling the lightbox destroys
+     * it; the independently managed layout plugin is unchanged.
+     * @param {Document|Element} [root=document] Content container; document targets .article images
+     *     and lightboxes, and all .justified-gallery elements.
+     * @param {Object} [options={}] SDK opt-ins; omitted flags disable plugin initialization.
+     * @param {boolean} [options.lightGallery=false] Initialize lightGallery when available.
+     * @param {boolean} [options.justifiedGallery=false] Initialize justifiedGallery when available.
+     */
+    init: function (root, options) {
+      root = root || document;
+      options = options || {};
+      const enabled = {
+        lightGallery: options.lightGallery === true,
+        justifiedGallery: options.justifiedGallery === true
+      };
+      prune();
+      requests.set(root, enabled);
+      apply(root, enabled);
+    },
+    /** Destroy lightboxes, layouts and pending retries before content is replaced (e.g. PJAX). */
+    destroy: function (root) {
+      root = root || document;
+      lightboxes.forEach((state, container) => {
+        if (root === document || root === container || root.contains(container)) destroyLightbox(container);
+      });
+      layouts.forEach((state, gallery) => {
+        if (root === document || root === gallery || root.contains(gallery)) destroyLayout(gallery);
+      });
+      requests.forEach((options, target) => {
+        if (root === document || root === target || root.contains(target)) requests.delete(target);
+      });
+    }
+  };
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', retry, {
+      once: true
+    });
+  }
+  if (document.readyState !== 'complete') window.addEventListener('load', retry, {
+    once: true
+  });
+  document.addEventListener('hexo:gallery:ready', retry);
+  // Deferred scripts may arrive after init, including on the first enabled page reached by PJAX.
+  // Retry the latest requests, rather than capturing a previous page's enabled configuration.
+  document.addEventListener('load', event => {
+    if (event.target.tagName === 'SCRIPT') retry();
+  }, true);
+}
+module.exports = '(' + installGallery.toString() + ')(window);';

package/lib/util/insight-search.js

@@ -0,0 +1,98 @@
+/**
+ * Create the DOM-independent Insight query engine.
+ * Keep the factory self-contained: the search view serializes it into an inline script, including
+ * when used without the Hexo asset generator or with a CDN-hosted insight.js.
+ * @module util/insight-search
+ * @returns {Function} Search (index, query), returning parsed keywords and ranked result sections.
+ */
+function createInsightSearch() {
+  const content = {
+    fields: ['title', 'text'],
+    weights: [3, 1]
+  };
+  const taxonomy = {
+    fields: ['name', 'slug'],
+    weights: [1, 1]
+  };
+  const sections = {
+    posts: content,
+    pages: content,
+    categories: taxonomy,
+    tags: taxonomy
+  };
+  function parseKeywords(query) {
+    return query.split(' ').filter(keyword => {
+      return !!keyword;
+    }).map(keyword => {
+      return keyword.toLowerCase();
+    });
+  }
+
+  // Every keyword must occur in at least one own field; keywords may span different fields.
+  function filter(keywords, obj, fields) {
+    const containKeywords = keywords.filter(keyword => {
+      const containFields = fields.filter(field => {
+        if (!Object.prototype.hasOwnProperty.call(obj, field)) {
+          return false;
+        }
+        if (obj[field].toLowerCase().indexOf(keyword) > -1) {
+          return true;
+        }
+        return false;
+      });
+      if (containFields.length > 0) {
+        return true;
+      }
+      return false;
+    });
+    return containKeywords.length === keywords.length;
+  }
+
+  // Count non-overlapping occurrences of a literal lowercase keyword, not a regular expression.
+  function countMatches(text, keyword) {
+    let count = 0;
+    for (let i = text.indexOf(keyword); i !== -1; i = text.indexOf(keyword, i + keyword.length)) {
+      count++;
+    }
+    return count;
+  }
+  function weight(keywords, obj, fields, weights) {
+    let value = 0;
+    keywords.forEach(keyword => {
+      fields.forEach((field, index) => {
+        if (Object.prototype.hasOwnProperty.call(obj, field)) {
+          value += countMatches(obj[field].toLowerCase(), keyword) * weights[index];
+        }
+      });
+    });
+    return value;
+  }
+
+  // Weigh each matching item once. Equal weights retain the input order, including an empty query.
+  function topItems(items, keywords, config) {
+    return items.filter(item => {
+      return filter(keywords, item, config.fields);
+    }).map(item => {
+      return {
+        item,
+        weight: weight(keywords, item, config.fields, config.weights)
+      };
+    }).sort((a, b) => {
+      return b.weight - a.weight;
+    }).slice(0, 5).map(result => {
+      return result.item;
+    });
+  }
+  return function search(json, query) {
+    const keywords = parseKeywords(query);
+    const results = {};
+    Object.keys(sections).forEach(section => {
+      results[section] = topItems(json[section], keywords, sections[section]);
+    });
+    return {
+      keywords,
+      results
+    };
+  };
+}
+module.exports = createInsightSearch;

package/lib/util/searchbox.js

@@ -0,0 +1,88 @@
+/**
+ * Inline installer shared by the search components. Keep it self-contained: components can be used
+ * without the Hexo asset generator, and PJAX may execute this script more than once.
+ * @module util/searchbox
+ */
+function installSearchbox(window) {
+  if (window.loadSearchbox) return;
+  const document = window.document;
+  let current;
+  window.loadSearchbox = function ($main, options) {
+    const $ = window.jQuery;
+    options = options || {};
+    // Preserve focus state only when replacing the controller for the same open DOM element.
+    let opener = current ? current.destroy($main[0]) : null;
+    let touch = false;
+    const $document = $(document);
+    const namespace = '.hexoSearchbox';
+    const controller = {
+      isCurrent: function () {
+        return current === controller && document.contains($main[0]);
+      },
+      destroy: function (nextMain) {
+        if (current !== controller) return null;
+        const nextOpener = nextMain === $main[0] && $main.hasClass('show') ? opener : null;
+        $document.off(namespace);
+        opener = null;
+        current = null;
+        if (options.onDestroy) options.onDestroy();
+        return nextOpener;
+      }
+    };
+    current = controller;
+    function open() {
+      if (!controller.isCurrent()) return;
+      if (!$main.hasClass('show')) {
+        opener = document.activeElement;
+        $main.addClass('show');
+      }
+      $main.find('.searchbox-input').focus();
+    }
+    function close(restoreFocus) {
+      $main.removeClass('show');
+      if (restoreFocus !== false && opener && document.contains(opener)) opener.focus();
+      opener = null;
+    }
+    function isSearchShortcut(e) {
+      if (e.altKey) return false;
+      if (e.ctrlKey || e.metaKey) {
+        return !e.shiftKey && typeof e.key === 'string' && e.key.toLowerCase() === 'k';
+      }
+      // e.key already accounts for the keyboard layout (including Shift).
+      const target = e.target;
+      const typing = target.isContentEditable || /^(input|textarea|select)$/i.test(target.tagName);
+      return e.key === '/' && !typing;
+    }
+    $document.on('click' + namespace, '.navbar-main .search', open).on('click' + namespace + (options.touch ? ' touchend' + namespace : ''), '.searchbox-close, .searchbox .searchbox-mask', e => {
+      if (!controller.isCurrent()) return;
+      if (e.type !== 'click' && !touch) return;
+      if (options.touch) {
+        $('.navbar-main').css('pointer-events', 'none');
+        setTimeout(() => {
+          $('.navbar-main').css('pointer-events', 'auto');
+        }, 400);
+      }
+      close();
+      touch = false;
+    }).on('focusin' + namespace, e => {
+      if (controller.isCurrent() && $main.hasClass('show') && !$main[0].contains(e.target)) {
+        close(false);
+      }
+    }).on('keydown' + namespace, e => {
+      if (!controller.isCurrent()) return;
+      if (isSearchShortcut(e)) {
+        e.preventDefault();
+        open();
+        return;
+      }
+      if (!$main.hasClass('show')) return;
+      if (e.keyCode === 27) close();else if (options.onKeyDown) options.onKeyDown(e);
+    }).on('touchstart' + namespace, () => {
+      touch = true;
+    }).on('touchmove' + namespace, () => {
+      touch = false;
+    });
+    return controller;
+  };
+}
+module.exports = '(' + installSearchbox.toString() + ')(window);';

package/lib/util/tab-options.js

@@ -0,0 +1,109 @@
+/**
+ * Pure option splitting for the Hexo tabs tag and its individual tab comments.
+ * @module util/tab-options
+ */
+
+/**
+ * Split a tabs option at its first colon, without trimming or interpreting the value.
+ * @param {string} option An option such as <code>title:Step 1: Install</code>.
+ * @returns {string[]} The key and value, or only the key when there is no colon.
+ */
+function splitOption(option) {
+  const index = option.indexOf(':');
+  return index === -1 ? [option] : [option.slice(0, index), option.slice(index + 1)];
+}
+
+/**
+ * Split individual tab comment options on ASCII spaces, respecting leading single or double quotes.
+ * Quotes within bare tokens are literal. Backslashes inside quotes protect the next character from
+ * closing the token, but remain in the result; they do not escape spaces in bare tokens.
+ * @param {string} source The option text inside a <code>&lt;!-- tab ... --&gt;</code> comment.
+ * @returns {string[]} Options with enclosing quotes removed and all other characters preserved.
+ * @throws {Error} For an unclosed quoted option or a non-space character after its closing quote.
+ */
+function splitTabOptions(source) {
+  const options = [];
+  const EOL = -1;
+  let i = 0;
+  let state = 1;
+  let begin = 0;
+  while (i <= source.length) {
+    const c = i < source.length ? source.charAt(i) : '';
+    switch (state) {
+      case 1:
+        // Start of an option
+        if (c === ' ') {
+          state = 1;
+          begin = i + 1;
+        } else if (c === '"') {
+          state = 2;
+          begin = i + 1;
+        } else if (c === "'") {
+          state = 4;
+          begin = i + 1;
+        } else if (c === '') {
+          state = EOL;
+        } else {
+          state = 7;
+        }
+        break;
+      case 2:
+        // Double-quoted option
+        if (c === '\\') {
+          state = 3;
+        } else if (c === '"') {
+          state = 6;
+        }
+        break;
+      case 3:
+        // Escaped character in a double-quoted option
+        state = 2;
+        break;
+      case 4:
+        // Single-quoted option
+        if (c === '\\') {
+          state = 5;
+        } else if (c === "'") {
+          state = 6;
+        }
+        break;
+      case 5:
+        // Escaped character in a single-quoted option
+        state = 4;
+        break;
+      case 6:
+        // The preceding character closed the quote
+        options.push(source.substring(begin, i - 1));
+        begin = i + 1;
+        if (c === ' ') {
+          state = 1;
+        } else if (c === '') {
+          state = EOL;
+        } else {
+          throw new Error(`malformatted tab options: ${source}`);
+        }
+        break;
+      case 7:
+        // Bare option
+        if (c === ' ') {
+          options.push(source.substring(begin, i));
+          begin = i + 1;
+          state = 1;
+        } else if (c === '') {
+          options.push(source.substring(begin, i));
+          begin = i + 1;
+          state = EOL;
+        }
+        break;
+    }
+    i++;
+  }
+  if (state !== EOL) {
+    throw new Error(`malformatted tab options: ${source}`);
+  }
+  return options;
+}
+module.exports = {
+  splitOption,
+  splitTabOptions
+};