1039 lines
35 KiB
JavaScript
Executable File
1039 lines
35 KiB
JavaScript
Executable File
import {
|
|
__commonJS
|
|
} from "./chunk-HKJ2B2AA.js";
|
|
|
|
// node_modules/ev-emitter/ev-emitter.js
|
|
var require_ev_emitter = __commonJS({
|
|
"node_modules/ev-emitter/ev-emitter.js"(exports, module) {
|
|
(function(global, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory();
|
|
} else {
|
|
global.EvEmitter = factory();
|
|
}
|
|
})(typeof window != "undefined" ? window : exports, function() {
|
|
function EvEmitter() {
|
|
}
|
|
let proto = EvEmitter.prototype;
|
|
proto.on = function(eventName, listener) {
|
|
if (!eventName || !listener) return this;
|
|
let events = this._events = this._events || {};
|
|
let listeners = events[eventName] = events[eventName] || [];
|
|
if (!listeners.includes(listener)) {
|
|
listeners.push(listener);
|
|
}
|
|
return this;
|
|
};
|
|
proto.once = function(eventName, listener) {
|
|
if (!eventName || !listener) return this;
|
|
this.on(eventName, listener);
|
|
let onceEvents = this._onceEvents = this._onceEvents || {};
|
|
let onceListeners = onceEvents[eventName] = onceEvents[eventName] || {};
|
|
onceListeners[listener] = true;
|
|
return this;
|
|
};
|
|
proto.off = function(eventName, listener) {
|
|
let listeners = this._events && this._events[eventName];
|
|
if (!listeners || !listeners.length) return this;
|
|
let index = listeners.indexOf(listener);
|
|
if (index != -1) {
|
|
listeners.splice(index, 1);
|
|
}
|
|
return this;
|
|
};
|
|
proto.emitEvent = function(eventName, args) {
|
|
let listeners = this._events && this._events[eventName];
|
|
if (!listeners || !listeners.length) return this;
|
|
listeners = listeners.slice(0);
|
|
args = args || [];
|
|
let onceListeners = this._onceEvents && this._onceEvents[eventName];
|
|
for (let listener of listeners) {
|
|
let isOnce = onceListeners && onceListeners[listener];
|
|
if (isOnce) {
|
|
this.off(eventName, listener);
|
|
delete onceListeners[listener];
|
|
}
|
|
listener.apply(this, args);
|
|
}
|
|
return this;
|
|
};
|
|
proto.allOff = function() {
|
|
delete this._events;
|
|
delete this._onceEvents;
|
|
return this;
|
|
};
|
|
return EvEmitter;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/fizzy-ui-utils/utils.js
|
|
var require_utils = __commonJS({
|
|
"node_modules/fizzy-ui-utils/utils.js"(exports, module) {
|
|
(function(global, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(global);
|
|
} else {
|
|
global.fizzyUIUtils = factory(global);
|
|
}
|
|
})(exports, function factory(global) {
|
|
let utils = {};
|
|
utils.extend = function(a, b) {
|
|
return Object.assign(a, b);
|
|
};
|
|
utils.modulo = function(num, div) {
|
|
return (num % div + div) % div;
|
|
};
|
|
utils.makeArray = function(obj) {
|
|
if (Array.isArray(obj)) return obj;
|
|
if (obj === null || obj === void 0) return [];
|
|
let isArrayLike = typeof obj == "object" && typeof obj.length == "number";
|
|
if (isArrayLike) return [...obj];
|
|
return [obj];
|
|
};
|
|
utils.removeFrom = function(ary, obj) {
|
|
let index = ary.indexOf(obj);
|
|
if (index != -1) {
|
|
ary.splice(index, 1);
|
|
}
|
|
};
|
|
utils.getParent = function(elem, selector) {
|
|
while (elem.parentNode && elem != document.body) {
|
|
elem = elem.parentNode;
|
|
if (elem.matches(selector)) return elem;
|
|
}
|
|
};
|
|
utils.getQueryElement = function(elem) {
|
|
if (typeof elem == "string") {
|
|
return document.querySelector(elem);
|
|
}
|
|
return elem;
|
|
};
|
|
utils.handleEvent = function(event) {
|
|
let method = "on" + event.type;
|
|
if (this[method]) {
|
|
this[method](event);
|
|
}
|
|
};
|
|
utils.filterFindElements = function(elems, selector) {
|
|
elems = utils.makeArray(elems);
|
|
return elems.filter((elem) => elem instanceof HTMLElement).reduce((ffElems, elem) => {
|
|
if (!selector) {
|
|
ffElems.push(elem);
|
|
return ffElems;
|
|
}
|
|
if (elem.matches(selector)) {
|
|
ffElems.push(elem);
|
|
}
|
|
let childElems = elem.querySelectorAll(selector);
|
|
ffElems = ffElems.concat(...childElems);
|
|
return ffElems;
|
|
}, []);
|
|
};
|
|
utils.debounceMethod = function(_class, methodName, threshold) {
|
|
threshold = threshold || 100;
|
|
let method = _class.prototype[methodName];
|
|
let timeoutName = methodName + "Timeout";
|
|
_class.prototype[methodName] = function() {
|
|
clearTimeout(this[timeoutName]);
|
|
let args = arguments;
|
|
this[timeoutName] = setTimeout(() => {
|
|
method.apply(this, args);
|
|
delete this[timeoutName];
|
|
}, threshold);
|
|
};
|
|
};
|
|
utils.docReady = function(onDocReady) {
|
|
let readyState = document.readyState;
|
|
if (readyState == "complete" || readyState == "interactive") {
|
|
setTimeout(onDocReady);
|
|
} else {
|
|
document.addEventListener("DOMContentLoaded", onDocReady);
|
|
}
|
|
};
|
|
utils.toDashed = function(str) {
|
|
return str.replace(/(.)([A-Z])/g, function(match, $1, $2) {
|
|
return $1 + "-" + $2;
|
|
}).toLowerCase();
|
|
};
|
|
let console2 = global.console;
|
|
utils.htmlInit = function(WidgetClass, namespace) {
|
|
utils.docReady(function() {
|
|
let dashedNamespace = utils.toDashed(namespace);
|
|
let dataAttr = "data-" + dashedNamespace;
|
|
let dataAttrElems = document.querySelectorAll(`[${dataAttr}]`);
|
|
let jQuery = global.jQuery;
|
|
[...dataAttrElems].forEach((elem) => {
|
|
let attr = elem.getAttribute(dataAttr);
|
|
let options;
|
|
try {
|
|
options = attr && JSON.parse(attr);
|
|
} catch (error) {
|
|
if (console2) {
|
|
console2.error(`Error parsing ${dataAttr} on ${elem.className}: ${error}`);
|
|
}
|
|
return;
|
|
}
|
|
let instance = new WidgetClass(elem, options);
|
|
if (jQuery) {
|
|
jQuery.data(elem, namespace, instance);
|
|
}
|
|
});
|
|
});
|
|
};
|
|
return utils;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/infinite-scroll/js/core.js
|
|
var require_core = __commonJS({
|
|
"node_modules/infinite-scroll/js/core.js"(exports, module) {
|
|
(function(window2, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(
|
|
window2,
|
|
require_ev_emitter(),
|
|
require_utils()
|
|
);
|
|
} else {
|
|
window2.InfiniteScroll = factory(
|
|
window2,
|
|
window2.EvEmitter,
|
|
window2.fizzyUIUtils
|
|
);
|
|
}
|
|
})(window, function factory(window2, EvEmitter, utils) {
|
|
let jQuery = window2.jQuery;
|
|
let instances = {};
|
|
function InfiniteScroll(element, options) {
|
|
let queryElem = utils.getQueryElement(element);
|
|
if (!queryElem) {
|
|
console.error("Bad element for InfiniteScroll: " + (queryElem || element));
|
|
return;
|
|
}
|
|
element = queryElem;
|
|
if (element.infiniteScrollGUID) {
|
|
let instance = instances[element.infiniteScrollGUID];
|
|
instance.option(options);
|
|
return instance;
|
|
}
|
|
this.element = element;
|
|
this.options = { ...InfiniteScroll.defaults };
|
|
this.option(options);
|
|
if (jQuery) {
|
|
this.$element = jQuery(this.element);
|
|
}
|
|
this.create();
|
|
}
|
|
InfiniteScroll.defaults = {
|
|
// path: null,
|
|
// hideNav: null,
|
|
// debug: false,
|
|
};
|
|
InfiniteScroll.create = {};
|
|
InfiniteScroll.destroy = {};
|
|
let proto = InfiniteScroll.prototype;
|
|
Object.assign(proto, EvEmitter.prototype);
|
|
let GUID = 0;
|
|
proto.create = function() {
|
|
let id = this.guid = ++GUID;
|
|
this.element.infiniteScrollGUID = id;
|
|
instances[id] = this;
|
|
this.pageIndex = 1;
|
|
this.loadCount = 0;
|
|
this.updateGetPath();
|
|
let hasPath = this.getPath && this.getPath();
|
|
if (!hasPath) {
|
|
console.error("Disabling InfiniteScroll");
|
|
return;
|
|
}
|
|
this.updateGetAbsolutePath();
|
|
this.log("initialized", [this.element.className]);
|
|
this.callOnInit();
|
|
for (let method in InfiniteScroll.create) {
|
|
InfiniteScroll.create[method].call(this);
|
|
}
|
|
};
|
|
proto.option = function(opts) {
|
|
Object.assign(this.options, opts);
|
|
};
|
|
proto.callOnInit = function() {
|
|
let onInit = this.options.onInit;
|
|
if (onInit) {
|
|
onInit.call(this, this);
|
|
}
|
|
};
|
|
proto.dispatchEvent = function(type, event, args) {
|
|
this.log(type, args);
|
|
let emitArgs = event ? [event].concat(args) : args;
|
|
this.emitEvent(type, emitArgs);
|
|
if (!jQuery || !this.$element) {
|
|
return;
|
|
}
|
|
type += ".infiniteScroll";
|
|
let $event = type;
|
|
if (event) {
|
|
let jQEvent = jQuery.Event(event);
|
|
jQEvent.type = type;
|
|
$event = jQEvent;
|
|
}
|
|
this.$element.trigger($event, args);
|
|
};
|
|
let loggers = {
|
|
initialized: (className) => `on ${className}`,
|
|
request: (path) => `URL: ${path}`,
|
|
load: (response, path) => `${response.title || ""}. URL: ${path}`,
|
|
error: (error, path) => `${error}. URL: ${path}`,
|
|
append: (response, path, items) => `${items.length} items. URL: ${path}`,
|
|
last: (response, path) => `URL: ${path}`,
|
|
history: (title, path) => `URL: ${path}`,
|
|
pageIndex: function(index, origin) {
|
|
return `current page determined to be: ${index} from ${origin}`;
|
|
}
|
|
};
|
|
proto.log = function(type, args) {
|
|
if (!this.options.debug) return;
|
|
let message = `[InfiniteScroll] ${type}`;
|
|
let logger = loggers[type];
|
|
if (logger) message += ". " + logger.apply(this, args);
|
|
console.log(message);
|
|
};
|
|
proto.updateMeasurements = function() {
|
|
this.windowHeight = window2.innerHeight;
|
|
let rect = this.element.getBoundingClientRect();
|
|
this.top = rect.top + window2.scrollY;
|
|
};
|
|
proto.updateScroller = function() {
|
|
let elementScroll = this.options.elementScroll;
|
|
if (!elementScroll) {
|
|
this.scroller = window2;
|
|
return;
|
|
}
|
|
this.scroller = elementScroll === true ? this.element : utils.getQueryElement(elementScroll);
|
|
if (!this.scroller) {
|
|
throw new Error(`Unable to find elementScroll: ${elementScroll}`);
|
|
}
|
|
};
|
|
proto.updateGetPath = function() {
|
|
let optPath = this.options.path;
|
|
if (!optPath) {
|
|
console.error(`InfiniteScroll path option required. Set as: ${optPath}`);
|
|
return;
|
|
}
|
|
let type = typeof optPath;
|
|
if (type == "function") {
|
|
this.getPath = optPath;
|
|
return;
|
|
}
|
|
let templateMatch = type == "string" && optPath.match("{{#}}");
|
|
if (templateMatch) {
|
|
this.updateGetPathTemplate(optPath);
|
|
return;
|
|
}
|
|
this.updateGetPathSelector(optPath);
|
|
};
|
|
proto.updateGetPathTemplate = function(optPath) {
|
|
this.getPath = () => {
|
|
let nextIndex = this.pageIndex + 1;
|
|
return optPath.replace("{{#}}", nextIndex);
|
|
};
|
|
let regexString = optPath.replace(/(\\\?|\?)/, "\\?").replace("{{#}}", "(\\d\\d?\\d?)");
|
|
let templateRe = new RegExp(regexString);
|
|
let match = location.href.match(templateRe);
|
|
if (match) {
|
|
this.pageIndex = parseInt(match[1], 10);
|
|
this.log("pageIndex", [this.pageIndex, "template string"]);
|
|
}
|
|
};
|
|
let pathRegexes = [
|
|
// WordPress & Tumblr - example.com/page/2
|
|
// Jekyll - example.com/page2
|
|
/^(.*?\/?page\/?)(\d\d?\d?)(.*?$)/,
|
|
// Drupal - example.com/?page=1
|
|
/^(.*?\/?\?page=)(\d\d?\d?)(.*?$)/,
|
|
// catch all, last occurence of a number
|
|
/(.*?)(\d\d?\d?)(?!.*\d)(.*?$)/
|
|
];
|
|
let getPathParts = InfiniteScroll.getPathParts = function(href) {
|
|
if (!href) return;
|
|
for (let regex of pathRegexes) {
|
|
let match = href.match(regex);
|
|
if (match) {
|
|
let [, begin, index, end] = match;
|
|
return { begin, index, end };
|
|
}
|
|
}
|
|
};
|
|
proto.updateGetPathSelector = function(optPath) {
|
|
let hrefElem = document.querySelector(optPath);
|
|
if (!hrefElem) {
|
|
console.error(`Bad InfiniteScroll path option. Next link not found: ${optPath}`);
|
|
return;
|
|
}
|
|
let href = hrefElem.getAttribute("href");
|
|
let pathParts = getPathParts(href);
|
|
if (!pathParts) {
|
|
console.error(`InfiniteScroll unable to parse next link href: ${href}`);
|
|
return;
|
|
}
|
|
let { begin, index, end } = pathParts;
|
|
this.isPathSelector = true;
|
|
this.getPath = () => begin + (this.pageIndex + 1) + end;
|
|
this.pageIndex = parseInt(index, 10) - 1;
|
|
this.log("pageIndex", [this.pageIndex, "next link"]);
|
|
};
|
|
proto.updateGetAbsolutePath = function() {
|
|
let path = this.getPath();
|
|
let isAbsolute = path.match(/^http/) || path.match(/^\//);
|
|
if (isAbsolute) {
|
|
this.getAbsolutePath = this.getPath;
|
|
return;
|
|
}
|
|
let { pathname } = location;
|
|
let isQuery = path.match(/^\?/);
|
|
let directory = pathname.substring(0, pathname.lastIndexOf("/"));
|
|
let pathStart = isQuery ? pathname : directory + "/";
|
|
this.getAbsolutePath = () => pathStart + this.getPath();
|
|
};
|
|
InfiniteScroll.create.hideNav = function() {
|
|
let nav = utils.getQueryElement(this.options.hideNav);
|
|
if (!nav) return;
|
|
nav.style.display = "none";
|
|
this.nav = nav;
|
|
};
|
|
InfiniteScroll.destroy.hideNav = function() {
|
|
if (this.nav) this.nav.style.display = "";
|
|
};
|
|
proto.destroy = function() {
|
|
this.allOff();
|
|
for (let method in InfiniteScroll.destroy) {
|
|
InfiniteScroll.destroy[method].call(this);
|
|
}
|
|
delete this.element.infiniteScrollGUID;
|
|
delete instances[this.guid];
|
|
if (jQuery && this.$element) {
|
|
jQuery.removeData(this.element, "infiniteScroll");
|
|
}
|
|
};
|
|
InfiniteScroll.throttle = function(fn, threshold) {
|
|
threshold = threshold || 200;
|
|
let last, timeout;
|
|
return function() {
|
|
let now = +/* @__PURE__ */ new Date();
|
|
let args = arguments;
|
|
let trigger = () => {
|
|
last = now;
|
|
fn.apply(this, args);
|
|
};
|
|
if (last && now < last + threshold) {
|
|
clearTimeout(timeout);
|
|
timeout = setTimeout(trigger, threshold);
|
|
} else {
|
|
trigger();
|
|
}
|
|
};
|
|
};
|
|
InfiniteScroll.data = function(elem) {
|
|
elem = utils.getQueryElement(elem);
|
|
let id = elem && elem.infiniteScrollGUID;
|
|
return id && instances[id];
|
|
};
|
|
InfiniteScroll.setJQuery = function(jqry) {
|
|
jQuery = jqry;
|
|
};
|
|
utils.htmlInit(InfiniteScroll, "infinite-scroll");
|
|
proto._init = function() {
|
|
};
|
|
let { jQueryBridget } = window2;
|
|
if (jQuery && jQueryBridget) {
|
|
jQueryBridget("infiniteScroll", InfiniteScroll, jQuery);
|
|
}
|
|
return InfiniteScroll;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/infinite-scroll/js/page-load.js
|
|
var require_page_load = __commonJS({
|
|
"node_modules/infinite-scroll/js/page-load.js"(exports, module) {
|
|
(function(window2, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(
|
|
window2,
|
|
require_core()
|
|
);
|
|
} else {
|
|
factory(
|
|
window2,
|
|
window2.InfiniteScroll
|
|
);
|
|
}
|
|
})(window, function factory(window2, InfiniteScroll) {
|
|
let proto = InfiniteScroll.prototype;
|
|
Object.assign(InfiniteScroll.defaults, {
|
|
// append: false,
|
|
loadOnScroll: true,
|
|
checkLastPage: true,
|
|
responseBody: "text",
|
|
domParseResponse: true
|
|
// prefill: false,
|
|
// outlayer: null,
|
|
});
|
|
InfiniteScroll.create.pageLoad = function() {
|
|
this.canLoad = true;
|
|
this.on("scrollThreshold", this.onScrollThresholdLoad);
|
|
this.on("load", this.checkLastPage);
|
|
if (this.options.outlayer) {
|
|
this.on("append", this.onAppendOutlayer);
|
|
}
|
|
};
|
|
proto.onScrollThresholdLoad = function() {
|
|
if (this.options.loadOnScroll) this.loadNextPage();
|
|
};
|
|
let domParser = new DOMParser();
|
|
proto.loadNextPage = function() {
|
|
if (this.isLoading || !this.canLoad) return;
|
|
let { responseBody, domParseResponse, fetchOptions } = this.options;
|
|
let path = this.getAbsolutePath();
|
|
this.isLoading = true;
|
|
if (typeof fetchOptions == "function") fetchOptions = fetchOptions();
|
|
let fetchPromise = fetch(path, fetchOptions).then((response) => {
|
|
if (!response.ok) {
|
|
let error = new Error(response.statusText);
|
|
this.onPageError(error, path, response);
|
|
return { response };
|
|
}
|
|
return response[responseBody]().then((body) => {
|
|
let canDomParse = responseBody == "text" && domParseResponse;
|
|
if (canDomParse) {
|
|
body = domParser.parseFromString(body, "text/html");
|
|
}
|
|
if (response.status == 204) {
|
|
this.lastPageReached(body, path);
|
|
return { body, response };
|
|
} else {
|
|
return this.onPageLoad(body, path, response);
|
|
}
|
|
});
|
|
}).catch((error) => {
|
|
this.onPageError(error, path);
|
|
});
|
|
this.dispatchEvent("request", null, [path, fetchPromise]);
|
|
return fetchPromise;
|
|
};
|
|
proto.onPageLoad = function(body, path, response) {
|
|
if (!this.options.append) {
|
|
this.isLoading = false;
|
|
}
|
|
this.pageIndex++;
|
|
this.loadCount++;
|
|
this.dispatchEvent("load", null, [body, path, response]);
|
|
return this.appendNextPage(body, path, response);
|
|
};
|
|
proto.appendNextPage = function(body, path, response) {
|
|
let { append, responseBody, domParseResponse } = this.options;
|
|
let isDocument = responseBody == "text" && domParseResponse;
|
|
if (!isDocument || !append) return { body, response };
|
|
let items = body.querySelectorAll(append);
|
|
let promiseValue = { body, response, items };
|
|
if (!items || !items.length) {
|
|
this.lastPageReached(body, path);
|
|
return promiseValue;
|
|
}
|
|
let fragment = getItemsFragment(items);
|
|
let appendReady = () => {
|
|
this.appendItems(items, fragment);
|
|
this.isLoading = false;
|
|
this.dispatchEvent("append", null, [body, path, items, response]);
|
|
return promiseValue;
|
|
};
|
|
if (this.options.outlayer) {
|
|
return this.appendOutlayerItems(fragment, appendReady);
|
|
} else {
|
|
return appendReady();
|
|
}
|
|
};
|
|
proto.appendItems = function(items, fragment) {
|
|
if (!items || !items.length) return;
|
|
fragment = fragment || getItemsFragment(items);
|
|
refreshScripts(fragment);
|
|
this.element.appendChild(fragment);
|
|
};
|
|
function getItemsFragment(items) {
|
|
let fragment = document.createDocumentFragment();
|
|
if (items) fragment.append(...items);
|
|
return fragment;
|
|
}
|
|
function refreshScripts(fragment) {
|
|
let scripts = fragment.querySelectorAll("script");
|
|
for (let script of scripts) {
|
|
let freshScript = document.createElement("script");
|
|
let attrs = script.attributes;
|
|
for (let attr of attrs) {
|
|
freshScript.setAttribute(attr.name, attr.value);
|
|
}
|
|
freshScript.innerHTML = script.innerHTML;
|
|
script.parentNode.replaceChild(freshScript, script);
|
|
}
|
|
}
|
|
proto.appendOutlayerItems = function(fragment, appendReady) {
|
|
let imagesLoaded = InfiniteScroll.imagesLoaded || window2.imagesLoaded;
|
|
if (!imagesLoaded) {
|
|
console.error("[InfiniteScroll] imagesLoaded required for outlayer option");
|
|
this.isLoading = false;
|
|
return;
|
|
}
|
|
return new Promise(function(resolve) {
|
|
imagesLoaded(fragment, function() {
|
|
let bodyResponse = appendReady();
|
|
resolve(bodyResponse);
|
|
});
|
|
});
|
|
};
|
|
proto.onAppendOutlayer = function(response, path, items) {
|
|
this.options.outlayer.appended(items);
|
|
};
|
|
proto.checkLastPage = function(body, path) {
|
|
let { checkLastPage, path: pathOpt } = this.options;
|
|
if (!checkLastPage) return;
|
|
if (typeof pathOpt == "function") {
|
|
let nextPath = this.getPath();
|
|
if (!nextPath) {
|
|
this.lastPageReached(body, path);
|
|
return;
|
|
}
|
|
}
|
|
let selector;
|
|
if (typeof checkLastPage == "string") {
|
|
selector = checkLastPage;
|
|
} else if (this.isPathSelector) {
|
|
selector = pathOpt;
|
|
}
|
|
if (!selector || !body.querySelector) return;
|
|
let nextElem = body.querySelector(selector);
|
|
if (!nextElem) this.lastPageReached(body, path);
|
|
};
|
|
proto.lastPageReached = function(body, path) {
|
|
this.canLoad = false;
|
|
this.dispatchEvent("last", null, [body, path]);
|
|
};
|
|
proto.onPageError = function(error, path, response) {
|
|
this.isLoading = false;
|
|
this.canLoad = false;
|
|
this.dispatchEvent("error", null, [error, path, response]);
|
|
return error;
|
|
};
|
|
InfiniteScroll.create.prefill = function() {
|
|
if (!this.options.prefill) return;
|
|
let append = this.options.append;
|
|
if (!append) {
|
|
console.error(`append option required for prefill. Set as :${append}`);
|
|
return;
|
|
}
|
|
this.updateMeasurements();
|
|
this.updateScroller();
|
|
this.isPrefilling = true;
|
|
this.on("append", this.prefill);
|
|
this.once("error", this.stopPrefill);
|
|
this.once("last", this.stopPrefill);
|
|
this.prefill();
|
|
};
|
|
proto.prefill = function() {
|
|
let distance = this.getPrefillDistance();
|
|
this.isPrefilling = distance >= 0;
|
|
if (this.isPrefilling) {
|
|
this.log("prefill");
|
|
this.loadNextPage();
|
|
} else {
|
|
this.stopPrefill();
|
|
}
|
|
};
|
|
proto.getPrefillDistance = function() {
|
|
if (this.options.elementScroll) {
|
|
return this.scroller.clientHeight - this.scroller.scrollHeight;
|
|
}
|
|
return this.windowHeight - this.element.clientHeight;
|
|
};
|
|
proto.stopPrefill = function() {
|
|
this.log("stopPrefill");
|
|
this.off("append", this.prefill);
|
|
};
|
|
return InfiniteScroll;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/infinite-scroll/js/scroll-watch.js
|
|
var require_scroll_watch = __commonJS({
|
|
"node_modules/infinite-scroll/js/scroll-watch.js"(exports, module) {
|
|
(function(window2, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(
|
|
window2,
|
|
require_core(),
|
|
require_utils()
|
|
);
|
|
} else {
|
|
factory(
|
|
window2,
|
|
window2.InfiniteScroll,
|
|
window2.fizzyUIUtils
|
|
);
|
|
}
|
|
})(window, function factory(window2, InfiniteScroll, utils) {
|
|
let proto = InfiniteScroll.prototype;
|
|
Object.assign(InfiniteScroll.defaults, {
|
|
scrollThreshold: 400
|
|
// elementScroll: null,
|
|
});
|
|
InfiniteScroll.create.scrollWatch = function() {
|
|
this.pageScrollHandler = this.onPageScroll.bind(this);
|
|
this.resizeHandler = this.onResize.bind(this);
|
|
let scrollThreshold = this.options.scrollThreshold;
|
|
let isEnable = scrollThreshold || scrollThreshold === 0;
|
|
if (isEnable) this.enableScrollWatch();
|
|
};
|
|
InfiniteScroll.destroy.scrollWatch = function() {
|
|
this.disableScrollWatch();
|
|
};
|
|
proto.enableScrollWatch = function() {
|
|
if (this.isScrollWatching) return;
|
|
this.isScrollWatching = true;
|
|
this.updateMeasurements();
|
|
this.updateScroller();
|
|
this.on("last", this.disableScrollWatch);
|
|
this.bindScrollWatchEvents(true);
|
|
};
|
|
proto.disableScrollWatch = function() {
|
|
if (!this.isScrollWatching) return;
|
|
this.bindScrollWatchEvents(false);
|
|
delete this.isScrollWatching;
|
|
};
|
|
proto.bindScrollWatchEvents = function(isBind) {
|
|
let addRemove = isBind ? "addEventListener" : "removeEventListener";
|
|
this.scroller[addRemove]("scroll", this.pageScrollHandler);
|
|
window2[addRemove]("resize", this.resizeHandler);
|
|
};
|
|
proto.onPageScroll = InfiniteScroll.throttle(function() {
|
|
let distance = this.getBottomDistance();
|
|
if (distance <= this.options.scrollThreshold) {
|
|
this.dispatchEvent("scrollThreshold");
|
|
}
|
|
});
|
|
proto.getBottomDistance = function() {
|
|
let bottom, scrollY;
|
|
if (this.options.elementScroll) {
|
|
bottom = this.scroller.scrollHeight;
|
|
scrollY = this.scroller.scrollTop + this.scroller.clientHeight;
|
|
} else {
|
|
bottom = this.top + this.element.clientHeight;
|
|
scrollY = window2.scrollY + this.windowHeight;
|
|
}
|
|
return bottom - scrollY;
|
|
};
|
|
proto.onResize = function() {
|
|
this.updateMeasurements();
|
|
};
|
|
utils.debounceMethod(InfiniteScroll, "onResize", 150);
|
|
return InfiniteScroll;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/infinite-scroll/js/history.js
|
|
var require_history = __commonJS({
|
|
"node_modules/infinite-scroll/js/history.js"(exports, module) {
|
|
(function(window2, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(
|
|
window2,
|
|
require_core(),
|
|
require_utils()
|
|
);
|
|
} else {
|
|
factory(
|
|
window2,
|
|
window2.InfiniteScroll,
|
|
window2.fizzyUIUtils
|
|
);
|
|
}
|
|
})(window, function factory(window2, InfiniteScroll, utils) {
|
|
let proto = InfiniteScroll.prototype;
|
|
Object.assign(InfiniteScroll.defaults, {
|
|
history: "replace"
|
|
// historyTitle: false,
|
|
});
|
|
let link = document.createElement("a");
|
|
InfiniteScroll.create.history = function() {
|
|
if (!this.options.history) return;
|
|
link.href = this.getAbsolutePath();
|
|
let linkOrigin = link.origin || link.protocol + "//" + link.host;
|
|
let isSameOrigin = linkOrigin == location.origin;
|
|
if (!isSameOrigin) {
|
|
console.error(`[InfiniteScroll] cannot set history with different origin: ${link.origin} on ${location.origin} . History behavior disabled.`);
|
|
return;
|
|
}
|
|
if (this.options.append) {
|
|
this.createHistoryAppend();
|
|
} else {
|
|
this.createHistoryPageLoad();
|
|
}
|
|
};
|
|
proto.createHistoryAppend = function() {
|
|
this.updateMeasurements();
|
|
this.updateScroller();
|
|
this.scrollPages = [
|
|
// first page
|
|
{
|
|
top: 0,
|
|
path: location.href,
|
|
title: document.title
|
|
}
|
|
];
|
|
this.scrollPage = this.scrollPages[0];
|
|
this.scrollHistoryHandler = this.onScrollHistory.bind(this);
|
|
this.unloadHandler = this.onUnload.bind(this);
|
|
this.scroller.addEventListener("scroll", this.scrollHistoryHandler);
|
|
this.on("append", this.onAppendHistory);
|
|
this.bindHistoryAppendEvents(true);
|
|
};
|
|
proto.bindHistoryAppendEvents = function(isBind) {
|
|
let addRemove = isBind ? "addEventListener" : "removeEventListener";
|
|
this.scroller[addRemove]("scroll", this.scrollHistoryHandler);
|
|
window2[addRemove]("unload", this.unloadHandler);
|
|
};
|
|
proto.createHistoryPageLoad = function() {
|
|
this.on("load", this.onPageLoadHistory);
|
|
};
|
|
InfiniteScroll.destroy.history = proto.destroyHistory = function() {
|
|
let isHistoryAppend = this.options.history && this.options.append;
|
|
if (isHistoryAppend) {
|
|
this.bindHistoryAppendEvents(false);
|
|
}
|
|
};
|
|
proto.onAppendHistory = function(response, path, items) {
|
|
if (!items || !items.length) return;
|
|
let firstItem = items[0];
|
|
let elemScrollY = this.getElementScrollY(firstItem);
|
|
link.href = path;
|
|
this.scrollPages.push({
|
|
top: elemScrollY,
|
|
path: link.href,
|
|
title: response.title
|
|
});
|
|
};
|
|
proto.getElementScrollY = function(elem) {
|
|
if (this.options.elementScroll) {
|
|
return elem.offsetTop - this.top;
|
|
} else {
|
|
let rect = elem.getBoundingClientRect();
|
|
return rect.top + window2.scrollY;
|
|
}
|
|
};
|
|
proto.onScrollHistory = function() {
|
|
let scrollPage = this.getClosestScrollPage();
|
|
if (scrollPage != this.scrollPage) {
|
|
this.scrollPage = scrollPage;
|
|
this.setHistory(scrollPage.title, scrollPage.path);
|
|
}
|
|
};
|
|
utils.debounceMethod(InfiniteScroll, "onScrollHistory", 150);
|
|
proto.getClosestScrollPage = function() {
|
|
let scrollViewY;
|
|
if (this.options.elementScroll) {
|
|
scrollViewY = this.scroller.scrollTop + this.scroller.clientHeight / 2;
|
|
} else {
|
|
scrollViewY = window2.scrollY + this.windowHeight / 2;
|
|
}
|
|
let scrollPage;
|
|
for (let page of this.scrollPages) {
|
|
if (page.top >= scrollViewY) break;
|
|
scrollPage = page;
|
|
}
|
|
return scrollPage;
|
|
};
|
|
proto.setHistory = function(title, path) {
|
|
let optHistory = this.options.history;
|
|
let historyMethod = optHistory && history[optHistory + "State"];
|
|
if (!historyMethod) return;
|
|
history[optHistory + "State"](null, title, path);
|
|
if (this.options.historyTitle) document.title = title;
|
|
this.dispatchEvent("history", null, [title, path]);
|
|
};
|
|
proto.onUnload = function() {
|
|
if (this.scrollPage.top === 0) return;
|
|
let scrollY = window2.scrollY - this.scrollPage.top + this.top;
|
|
this.destroyHistory();
|
|
scrollTo(0, scrollY);
|
|
};
|
|
proto.onPageLoadHistory = function(response, path) {
|
|
this.setHistory(response.title, path);
|
|
};
|
|
return InfiniteScroll;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/infinite-scroll/js/button.js
|
|
var require_button = __commonJS({
|
|
"node_modules/infinite-scroll/js/button.js"(exports, module) {
|
|
(function(window2, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(
|
|
window2,
|
|
require_core(),
|
|
require_utils()
|
|
);
|
|
} else {
|
|
factory(
|
|
window2,
|
|
window2.InfiniteScroll,
|
|
window2.fizzyUIUtils
|
|
);
|
|
}
|
|
})(window, function factory(window2, InfiniteScroll, utils) {
|
|
class InfiniteScrollButton {
|
|
constructor(element, infScroll) {
|
|
this.element = element;
|
|
this.infScroll = infScroll;
|
|
this.clickHandler = this.onClick.bind(this);
|
|
this.element.addEventListener("click", this.clickHandler);
|
|
infScroll.on("request", this.disable.bind(this));
|
|
infScroll.on("load", this.enable.bind(this));
|
|
infScroll.on("error", this.hide.bind(this));
|
|
infScroll.on("last", this.hide.bind(this));
|
|
}
|
|
onClick(event) {
|
|
event.preventDefault();
|
|
this.infScroll.loadNextPage();
|
|
}
|
|
enable() {
|
|
this.element.removeAttribute("disabled");
|
|
}
|
|
disable() {
|
|
this.element.disabled = "disabled";
|
|
}
|
|
hide() {
|
|
this.element.style.display = "none";
|
|
}
|
|
destroy() {
|
|
this.element.removeEventListener("click", this.clickHandler);
|
|
}
|
|
}
|
|
InfiniteScroll.create.button = function() {
|
|
let buttonElem = utils.getQueryElement(this.options.button);
|
|
if (buttonElem) {
|
|
this.button = new InfiniteScrollButton(buttonElem, this);
|
|
}
|
|
};
|
|
InfiniteScroll.destroy.button = function() {
|
|
if (this.button) this.button.destroy();
|
|
};
|
|
InfiniteScroll.Button = InfiniteScrollButton;
|
|
return InfiniteScroll;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/infinite-scroll/js/status.js
|
|
var require_status = __commonJS({
|
|
"node_modules/infinite-scroll/js/status.js"(exports, module) {
|
|
(function(window2, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(
|
|
window2,
|
|
require_core(),
|
|
require_utils()
|
|
);
|
|
} else {
|
|
factory(
|
|
window2,
|
|
window2.InfiniteScroll,
|
|
window2.fizzyUIUtils
|
|
);
|
|
}
|
|
})(window, function factory(window2, InfiniteScroll, utils) {
|
|
let proto = InfiniteScroll.prototype;
|
|
InfiniteScroll.create.status = function() {
|
|
let statusElem = utils.getQueryElement(this.options.status);
|
|
if (!statusElem) return;
|
|
this.statusElement = statusElem;
|
|
this.statusEventElements = {
|
|
request: statusElem.querySelector(".infinite-scroll-request"),
|
|
error: statusElem.querySelector(".infinite-scroll-error"),
|
|
last: statusElem.querySelector(".infinite-scroll-last")
|
|
};
|
|
this.on("request", this.showRequestStatus);
|
|
this.on("error", this.showErrorStatus);
|
|
this.on("last", this.showLastStatus);
|
|
this.bindHideStatus("on");
|
|
};
|
|
proto.bindHideStatus = function(bindMethod) {
|
|
let hideEvent = this.options.append ? "append" : "load";
|
|
this[bindMethod](hideEvent, this.hideAllStatus);
|
|
};
|
|
proto.showRequestStatus = function() {
|
|
this.showStatus("request");
|
|
};
|
|
proto.showErrorStatus = function() {
|
|
this.showStatus("error");
|
|
};
|
|
proto.showLastStatus = function() {
|
|
this.showStatus("last");
|
|
this.bindHideStatus("off");
|
|
};
|
|
proto.showStatus = function(eventName) {
|
|
show(this.statusElement);
|
|
this.hideStatusEventElements();
|
|
let eventElem = this.statusEventElements[eventName];
|
|
show(eventElem);
|
|
};
|
|
proto.hideAllStatus = function() {
|
|
hide(this.statusElement);
|
|
this.hideStatusEventElements();
|
|
};
|
|
proto.hideStatusEventElements = function() {
|
|
for (let type in this.statusEventElements) {
|
|
let eventElem = this.statusEventElements[type];
|
|
hide(eventElem);
|
|
}
|
|
};
|
|
function hide(elem) {
|
|
setDisplay(elem, "none");
|
|
}
|
|
function show(elem) {
|
|
setDisplay(elem, "block");
|
|
}
|
|
function setDisplay(elem, value) {
|
|
if (elem) {
|
|
elem.style.display = value;
|
|
}
|
|
}
|
|
return InfiniteScroll;
|
|
});
|
|
}
|
|
});
|
|
|
|
// node_modules/infinite-scroll/js/index.js
|
|
var require_js = __commonJS({
|
|
"node_modules/infinite-scroll/js/index.js"(exports, module) {
|
|
(function(window2, factory) {
|
|
if (typeof module == "object" && module.exports) {
|
|
module.exports = factory(
|
|
require_core(),
|
|
require_page_load(),
|
|
require_scroll_watch(),
|
|
require_history(),
|
|
require_button(),
|
|
require_status()
|
|
);
|
|
}
|
|
})(window, function factory(InfiniteScroll) {
|
|
return InfiniteScroll;
|
|
});
|
|
}
|
|
});
|
|
export default require_js();
|
|
//# sourceMappingURL=infinite-scroll.js.map
|