@mjhls/mjh-framework 1.0.850-beta.0 → 1.0.850-beta.1

package/dist/esm/QueueDeckExpanded.js

@@ -8,7 +8,7 @@ import './core.get-iterator-method-e1de7503.js';
 import './_object-pie-33c40e79.js';
 import { _ as _extends } from './extends-6f2fcc99.js';
 import './web.dom.iterable-4439f05a.js';
-import React__default, { useEffect, useState, useRef } from 'react';
+import React__default, { useEffect, useLayoutEffect, createContext, useContext, useRef, useDebugValue, useState, useCallback, useMemo } from 'react';
 import './events-6c3a7a63.js';
 import { l as lib_3 } from './index-41a678ea.js';
 import 'prop-types';
@@ -46,6 +46,1055 @@ var reactPaginate = createCommonjsModule(function (module, exports) {
 var ReactPaginate = unwrapExports(reactPaginate);
 var reactPaginate_1 = reactPaginate.ReactPaginate;
 
+var has = Object.prototype.hasOwnProperty;
+
+function dequal(foo, bar) {
+	var ctor, len;
+	if (foo === bar) return true;
+
+	if (foo && bar && (ctor=foo.constructor) === bar.constructor) {
+		if (ctor === Date) return foo.getTime() === bar.getTime();
+		if (ctor === RegExp) return foo.toString() === bar.toString();
+
+		if (ctor === Array) {
+			if ((len=foo.length) === bar.length) {
+				while (len-- && dequal(foo[len], bar[len]));
+			}
+			return len === -1;
+		}
+
+		if (!ctor || typeof foo === 'object') {
+			len = 0;
+			for (ctor in foo) {
+				if (has.call(foo, ctor) && ++len && !has.call(bar, ctor)) return false;
+				if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+			}
+			return Object.keys(bar).length === len;
+		}
+	}
+
+	return foo !== foo && bar !== bar;
+}
+
+// use WeakMap to store the object->key mapping
+// so the objects can be garbage collected.
+// WeakMap uses a hashtable under the hood, so the lookup
+// complexity is almost O(1).
+var table = new WeakMap();
+// counter of the key
+var counter = 0;
+// hashes an array of objects and returns a string
+function hash(args) {
+    if (!args.length)
+        return '';
+    var key = 'arg';
+    for (var i = 0; i < args.length; ++i) {
+        if (args[i] === null) {
+            key += '@null';
+            continue;
+        }
+        var _hash = void 0;
+        if (typeof args[i] !== 'object' && typeof args[i] !== 'function') {
+            // need to consider the case that args[i] is a string:
+            // args[i]        _hash
+            // "undefined" -> '"undefined"'
+            // undefined   -> 'undefined'
+            // 123         -> '123'
+            // "null"      -> '"null"'
+            if (typeof args[i] === 'string') {
+                _hash = '"' + args[i] + '"';
+            }
+            else {
+                _hash = String(args[i]);
+            }
+        }
+        else {
+            if (!table.has(args[i])) {
+                _hash = counter;
+                table.set(args[i], counter++);
+            }
+            else {
+                _hash = table.get(args[i]);
+            }
+        }
+        key += '@' + _hash;
+    }
+    return key;
+}
+
+var Cache = /** @class */ (function () {
+    function Cache(initialData) {
+        if (initialData === void 0) { initialData = {}; }
+        this.cache = new Map(Object.entries(initialData));
+        this.subs = [];
+    }
+    Cache.prototype.get = function (key) {
+        var _key = this.serializeKey(key)[0];
+        return this.cache.get(_key);
+    };
+    Cache.prototype.set = function (key, value) {
+        var _key = this.serializeKey(key)[0];
+        this.cache.set(_key, value);
+        this.notify();
+    };
+    Cache.prototype.keys = function () {
+        return Array.from(this.cache.keys());
+    };
+    Cache.prototype.has = function (key) {
+        var _key = this.serializeKey(key)[0];
+        return this.cache.has(_key);
+    };
+    Cache.prototype.clear = function () {
+        this.cache.clear();
+        this.notify();
+    };
+    Cache.prototype.delete = function (key) {
+        var _key = this.serializeKey(key)[0];
+        this.cache.delete(_key);
+        this.notify();
+    };
+    // TODO: introduce namespace for the cache
+    Cache.prototype.serializeKey = function (key) {
+        var args = null;
+        if (typeof key === 'function') {
+            try {
+                key = key();
+            }
+            catch (err) {
+                // dependencies not ready
+                key = '';
+            }
+        }
+        if (Array.isArray(key)) {
+            // args array
+            args = key;
+            key = hash(key);
+        }
+        else {
+            // convert null to ''
+            key = String(key || '');
+        }
+        var errorKey = key ? 'err@' + key : '';
+        var isValidatingKey = key ? 'validating@' + key : '';
+        return [key, args, errorKey, isValidatingKey];
+    };
+    Cache.prototype.subscribe = function (listener) {
+        var _this = this;
+        if (typeof listener !== 'function') {
+            throw new Error('Expected the listener to be a function.');
+        }
+        var isSubscribed = true;
+        this.subs.push(listener);
+        return function () {
+            if (!isSubscribed)
+                return;
+            isSubscribed = false;
+            var index = _this.subs.indexOf(listener);
+            if (index > -1) {
+                _this.subs[index] = _this.subs[_this.subs.length - 1];
+                _this.subs.length--;
+            }
+        };
+    };
+    // Notify Cache subscribers about a change in the cache
+    Cache.prototype.notify = function () {
+        for (var _i = 0, _a = this.subs; _i < _a.length; _i++) {
+            var listener = _a[_i];
+            listener();
+        }
+    };
+    return Cache;
+}());
+
+/**
+ * Due to bug https://bugs.chromium.org/p/chromium/issues/detail?id=678075,
+ * it's not reliable to detect if the browser is currently online or offline
+ * based on `navigator.onLine`.
+ * As a work around, we always assume it's online on first load, and change
+ * the status upon `online` or `offline` events.
+ */
+var online = true;
+var isOnline = function () { return online; };
+var isDocumentVisible = function () {
+    if (typeof document !== 'undefined' &&
+        document.visibilityState !== undefined) {
+        return document.visibilityState !== 'hidden';
+    }
+    // always assume it's visible
+    return true;
+};
+var fetcher = function (url) { return fetch(url).then(function (res) { return res.json(); }); };
+var registerOnFocus = function (cb) {
+    if (typeof window !== 'undefined' &&
+        window.addEventListener !== undefined &&
+        typeof document !== 'undefined' &&
+        document.addEventListener !== undefined) {
+        // focus revalidate
+        document.addEventListener('visibilitychange', function () { return cb(); }, false);
+        window.addEventListener('focus', function () { return cb(); }, false);
+    }
+};
+var registerOnReconnect = function (cb) {
+    if (typeof window !== 'undefined' && window.addEventListener !== undefined) {
+        // reconnect revalidate
+        window.addEventListener('online', function () {
+            online = true;
+            cb();
+        }, false);
+        // nothing to revalidate, just update the status
+        window.addEventListener('offline', function () { return (online = false); }, false);
+    }
+};
+var webPreset = {
+    isOnline: isOnline,
+    isDocumentVisible: isDocumentVisible,
+    fetcher: fetcher,
+    registerOnFocus: registerOnFocus,
+    registerOnReconnect: registerOnReconnect
+};
+
+var __assign = (undefined && undefined.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+// cache
+var cache = new Cache();
+// error retry
+function onErrorRetry(_, __, config, revalidate, opts) {
+    if (!config.isDocumentVisible()) {
+        // if it's hidden, stop
+        // it will auto revalidate when focus
+        return;
+    }
+    if (typeof config.errorRetryCount === 'number' &&
+        opts.retryCount > config.errorRetryCount) {
+        return;
+    }
+    // exponential backoff
+    var count = Math.min(opts.retryCount, 8);
+    var timeout = ~~((Math.random() + 0.5) * (1 << count)) * config.errorRetryInterval;
+    setTimeout(revalidate, timeout, opts);
+}
+// client side: need to adjust the config
+// based on the browser status
+// slow connection (<= 70Kbps)
+var slowConnection = typeof window !== 'undefined' &&
+    // @ts-ignore
+    navigator['connection'] &&
+    // @ts-ignore
+    ['slow-2g', '2g'].indexOf(navigator['connection'].effectiveType) !== -1;
+// config
+var defaultConfig = __assign({ 
+    // events
+    onLoadingSlow: function () { }, onSuccess: function () { }, onError: function () { }, onErrorRetry: onErrorRetry, errorRetryInterval: (slowConnection ? 10 : 5) * 1000, focusThrottleInterval: 5 * 1000, dedupingInterval: 2 * 1000, loadingTimeout: (slowConnection ? 5 : 3) * 1000, refreshInterval: 0, revalidateOnFocus: true, revalidateOnReconnect: true, refreshWhenHidden: false, refreshWhenOffline: false, shouldRetryOnError: true, suspense: false, compare: dequal, isPaused: function () { return false; } }, webPreset);
+
+var IS_SERVER = typeof window === 'undefined' ||
+    // @ts-ignore
+    !!(typeof Deno !== 'undefined' && Deno && Deno.version && Deno.version.deno);
+// polyfill for requestAnimationFrame
+var rAF = IS_SERVER
+    ? null
+    : window['requestAnimationFrame']
+        ? function (f) { return window['requestAnimationFrame'](f); }
+        : function (f) { return setTimeout(f, 1); };
+// React currently throws a warning when using useLayoutEffect on the server.
+// To get around it, we can conditionally useEffect on the server (no-op) and
+// useLayoutEffect in the browser.
+var useIsomorphicLayoutEffect = IS_SERVER ? useEffect : useLayoutEffect;
+
+var SWRConfigContext = createContext({});
+SWRConfigContext.displayName = 'SWRConfigContext';
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+// global state managers
+var CONCURRENT_PROMISES = {};
+var CONCURRENT_PROMISES_TS = {};
+var FOCUS_REVALIDATORS = {};
+var RECONNECT_REVALIDATORS = {};
+var CACHE_REVALIDATORS = {};
+var MUTATION_TS = {};
+var MUTATION_END_TS = {};
+// generate strictly increasing timestamps
+var now = (function () {
+    var ts = 0;
+    return function () { return ++ts; };
+})();
+// setup DOM events listeners for `focus` and `reconnect` actions
+if (!IS_SERVER) {
+    var revalidate_1 = function (revalidators) {
+        if (!defaultConfig.isDocumentVisible() || !defaultConfig.isOnline())
+            return;
+        for (var key in revalidators) {
+            if (revalidators[key][0])
+                revalidators[key][0]();
+        }
+    };
+    if (typeof defaultConfig.registerOnFocus === 'function') {
+        defaultConfig.registerOnFocus(function () { return revalidate_1(FOCUS_REVALIDATORS); });
+    }
+    if (typeof defaultConfig.registerOnReconnect === 'function') {
+        defaultConfig.registerOnReconnect(function () { return revalidate_1(RECONNECT_REVALIDATORS); });
+    }
+}
+var trigger = function (_key, shouldRevalidate) {
+    if (shouldRevalidate === void 0) { shouldRevalidate = true; }
+    // we are ignoring the second argument which correspond to the arguments
+    // the fetcher will receive when key is an array
+    var _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2], keyValidating = _a[3];
+    if (!key)
+        return Promise.resolve();
+    var updaters = CACHE_REVALIDATORS[key];
+    if (key && updaters) {
+        var currentData = cache.get(key);
+        var currentError = cache.get(keyErr);
+        var currentIsValidating = cache.get(keyValidating);
+        var promises = [];
+        for (var i = 0; i < updaters.length; ++i) {
+            promises.push(updaters[i](shouldRevalidate, currentData, currentError, currentIsValidating, i > 0));
+        }
+        // return new updated value
+        return Promise.all(promises).then(function () { return cache.get(key); });
+    }
+    return Promise.resolve(cache.get(key));
+};
+var broadcastState = function (key, data, error, isValidating) {
+    var updaters = CACHE_REVALIDATORS[key];
+    if (key && updaters) {
+        for (var i = 0; i < updaters.length; ++i) {
+            updaters[i](false, data, error, isValidating);
+        }
+    }
+};
+var mutate = function (_key, _data, shouldRevalidate) {
+    if (shouldRevalidate === void 0) { shouldRevalidate = true; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var _a, key, keyErr, beforeMutationTs, beforeConcurrentPromisesTs, data, error, isAsyncMutation, err_1, shouldAbort, updaters, promises, i;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
+                case 0:
+                    _a = cache.serializeKey(_key), key = _a[0], keyErr = _a[2];
+                    if (!key)
+                        return [2 /*return*/];
+                    // if there is no new data to update, let's just revalidate the key
+                    if (typeof _data === 'undefined')
+                        return [2 /*return*/, trigger(_key, shouldRevalidate)
+                            // update global timestamps
+                        ];
+                    // update global timestamps
+                    MUTATION_TS[key] = now() - 1;
+                    MUTATION_END_TS[key] = 0;
+                    beforeMutationTs = MUTATION_TS[key];
+                    beforeConcurrentPromisesTs = CONCURRENT_PROMISES_TS[key];
+                    isAsyncMutation = false;
+                    if (_data && typeof _data === 'function') {
+                        // `_data` is a function, call it passing current cache value
+                        try {
+                            _data = _data(cache.get(key));
+                        }
+                        catch (err) {
+                            // if `_data` function throws an error synchronously, it shouldn't be cached
+                            _data = undefined;
+                            error = err;
+                        }
+                    }
+                    if (!(_data && typeof _data.then === 'function')) return [3 /*break*/, 5];
+                    // `_data` is a promise
+                    isAsyncMutation = true;
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 3, , 4]);
+                    return [4 /*yield*/, _data];
+                case 2:
+                    data = _b.sent();
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _b.sent();
+                    error = err_1;
+                    return [3 /*break*/, 4];
+                case 4: return [3 /*break*/, 6];
+                case 5:
+                    data = _data;
+                    _b.label = 6;
+                case 6:
+                    shouldAbort = function () {
+                        // check if other mutations have occurred since we've started this mutation
+                        if (beforeMutationTs !== MUTATION_TS[key] ||
+                            beforeConcurrentPromisesTs !== CONCURRENT_PROMISES_TS[key]) {
+                            if (error)
+                                throw error;
+                            return true;
+                        }
+                    };
+                    // if there's a race we don't update cache or broadcast change, just return the data
+                    if (shouldAbort())
+                        return [2 /*return*/, data];
+                    if (typeof data !== 'undefined') {
+                        // update cached data
+                        cache.set(key, data);
+                    }
+                    // always update or reset the error
+                    cache.set(keyErr, error);
+                    // reset the timestamp to mark the mutation has ended
+                    MUTATION_END_TS[key] = now() - 1;
+                    if (!isAsyncMutation) {
+                        // we skip broadcasting if there's another mutation happened synchronously
+                        if (shouldAbort())
+                            return [2 /*return*/, data];
+                    }
+                    updaters = CACHE_REVALIDATORS[key];
+                    if (updaters) {
+                        promises = [];
+                        for (i = 0; i < updaters.length; ++i) {
+                            promises.push(updaters[i](!!shouldRevalidate, data, error, undefined, i > 0));
+                        }
+                        // return new updated value
+                        return [2 /*return*/, Promise.all(promises).then(function () {
+                                if (error)
+                                    throw error;
+                                return cache.get(key);
+                            })];
+                    }
+                    // throw error or return data to be used by caller of mutate
+                    if (error)
+                        throw error;
+                    return [2 /*return*/, data];
+            }
+        });
+    });
+};
+function useSWR() {
+    var _this = this;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var _key = args[0];
+    var config = Object.assign({}, defaultConfig, useContext(SWRConfigContext), args.length > 2
+        ? args[2]
+        : args.length === 2 && typeof args[1] === 'object'
+            ? args[1]
+            : {});
+    // in typescript args.length > 2 is not same as args.lenth === 3
+    // we do a safe type assertion here
+    // args.length === 3
+    var fn = (args.length > 2
+        ? args[1]
+        : args.length === 2 && typeof args[1] === 'function'
+            ? args[1]
+            : /**
+                  pass fn as null will disable revalidate
+                  https://paco.sh/blog/shared-hook-state-with-swr
+                */
+                args[1] === null
+                    ? args[1]
+                    : config.fetcher);
+    // we assume `key` as the identifier of the request
+    // `key` can change but `fn` shouldn't
+    // (because `revalidate` only depends on `key`)
+    // `keyErr` is the cache key for error objects
+    var _a = cache.serializeKey(_key), key = _a[0], fnArgs = _a[1], keyErr = _a[2], keyValidating = _a[3];
+    var configRef = useRef(config);
+    useIsomorphicLayoutEffect(function () {
+        configRef.current = config;
+    });
+    var willRevalidateOnMount = function () {
+        return (config.revalidateOnMount ||
+            (!config.initialData && config.revalidateOnMount === undefined));
+    };
+    var resolveData = function () {
+        var cachedData = cache.get(key);
+        return typeof cachedData === 'undefined' ? config.initialData : cachedData;
+    };
+    var resolveIsValidating = function () {
+        return !!cache.get(keyValidating) || (key && willRevalidateOnMount());
+    };
+    var initialData = resolveData();
+    var initialError = cache.get(keyErr);
+    var initialIsValidating = resolveIsValidating();
+    // if a state is accessed (data, error or isValidating),
+    // we add the state to dependencies so if the state is
+    // updated in the future, we can trigger a rerender
+    var stateDependencies = useRef({
+        data: false,
+        error: false,
+        isValidating: false
+    });
+    var stateRef = useRef({
+        data: initialData,
+        error: initialError,
+        isValidating: initialIsValidating
+    });
+    // display the data label in the React DevTools next to SWR hooks
+    useDebugValue(stateRef.current.data);
+    var rerender = useState({})[1];
+    var dispatch = useCallback(function (payload) {
+        var shouldUpdateState = false;
+        for (var k in payload) {
+            // @ts-ignore
+            if (stateRef.current[k] === payload[k]) {
+                continue;
+            }
+            // @ts-ignore
+            stateRef.current[k] = payload[k];
+            // @ts-ignore
+            if (stateDependencies.current[k]) {
+                shouldUpdateState = true;
+            }
+        }
+        if (shouldUpdateState) {
+            // if component is unmounted, should skip rerender
+            // if component is not mounted, should skip rerender
+            if (unmountedRef.current || !initialMountedRef.current)
+                return;
+            rerender({});
+        }
+    }, 
+    // config.suspense isn't allowed to change during the lifecycle
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    []);
+    // error ref inside revalidate (is last request errored?)
+    var unmountedRef = useRef(false);
+    var keyRef = useRef(key);
+    // check if component is mounted in suspense mode
+    var initialMountedRef = useRef(false);
+    // do unmount check for callbacks
+    var eventsCallback = useCallback(function (event) {
+        var _a;
+        var params = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            params[_i - 1] = arguments[_i];
+        }
+        if (unmountedRef.current)
+            return;
+        if (!initialMountedRef.current)
+            return;
+        if (key !== keyRef.current)
+            return;
+        // @ts-ignore
+        (_a = configRef.current)[event].apply(_a, params);
+    }, [key]);
+    var boundMutate = useCallback(function (data, shouldRevalidate) {
+        return mutate(keyRef.current, data, shouldRevalidate);
+    }, []);
+    var addRevalidator = function (revalidators, callback) {
+        if (!revalidators[key]) {
+            revalidators[key] = [callback];
+        }
+        else {
+            revalidators[key].push(callback);
+        }
+        return function () {
+            var keyedRevalidators = revalidators[key];
+            var index = keyedRevalidators.indexOf(callback);
+            if (index >= 0) {
+                // O(1): faster than splice
+                keyedRevalidators[index] =
+                    keyedRevalidators[keyedRevalidators.length - 1];
+                keyedRevalidators.pop();
+            }
+        };
+    };
+    // start a revalidation
+    var revalidate = useCallback(function (revalidateOpts) {
+        if (revalidateOpts === void 0) { revalidateOpts = {}; }
+        return __awaiter(_this, void 0, void 0, function () {
+            var _a, retryCount, _b, dedupe, loading, shouldDeduping, newData, startAt, newState, err_2;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!key || !fn)
+                            return [2 /*return*/, false];
+                        if (unmountedRef.current)
+                            return [2 /*return*/, false];
+                        if (configRef.current.isPaused())
+                            return [2 /*return*/, false];
+                        _a = revalidateOpts.retryCount, retryCount = _a === void 0 ? 0 : _a, _b = revalidateOpts.dedupe, dedupe = _b === void 0 ? false : _b;
+                        loading = true;
+                        shouldDeduping = typeof CONCURRENT_PROMISES[key] !== 'undefined' && dedupe;
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 6, , 7]);
+                        dispatch({
+                            isValidating: true
+                        });
+                        cache.set(keyValidating, true);
+                        if (!shouldDeduping) {
+                            // also update other hooks
+                            broadcastState(key, stateRef.current.data, stateRef.current.error, true);
+                        }
+                        newData = void 0;
+                        startAt = void 0;
+                        if (!shouldDeduping) return [3 /*break*/, 3];
+                        // there's already an ongoing request,
+                        // this one needs to be deduplicated.
+                        startAt = CONCURRENT_PROMISES_TS[key];
+                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];
+                    case 2:
+                        newData = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 3:
+                        // if no cache being rendered currently (it shows a blank page),
+                        // we trigger the loading slow event.
+                        if (config.loadingTimeout && !cache.get(key)) {
+                            setTimeout(function () {
+                                if (loading)
+                                    eventsCallback('onLoadingSlow', key, config);
+                            }, config.loadingTimeout);
+                        }
+                        if (fnArgs !== null) {
+                            CONCURRENT_PROMISES[key] = fn.apply(void 0, fnArgs);
+                        }
+                        else {
+                            CONCURRENT_PROMISES[key] = fn(key);
+                        }
+                        CONCURRENT_PROMISES_TS[key] = startAt = now();
+                        return [4 /*yield*/, CONCURRENT_PROMISES[key]];
+                    case 4:
+                        newData = _c.sent();
+                        setTimeout(function () {
+                            delete CONCURRENT_PROMISES[key];
+                            delete CONCURRENT_PROMISES_TS[key];
+                        }, config.dedupingInterval);
+                        // trigger the success event,
+                        // only do this for the original request.
+                        eventsCallback('onSuccess', newData, key, config);
+                        _c.label = 5;
+                    case 5:
+                        // if there're other ongoing request(s), started after the current one,
+                        // we need to ignore the current one to avoid possible race conditions:
+                        //   req1------------------>res1        (current one)
+                        //        req2---------------->res2
+                        // the request that fired later will always be kept.
+                        if (CONCURRENT_PROMISES_TS[key] > startAt) {
+                            return [2 /*return*/, false];
+                        }
+                        // if there're other mutations(s), overlapped with the current revalidation:
+                        // case 1:
+                        //   req------------------>res
+                        //       mutate------>end
+                        // case 2:
+                        //         req------------>res
+                        //   mutate------>end
+                        // case 3:
+                        //   req------------------>res
+                        //       mutate-------...---------->
+                        // we have to ignore the revalidation result (res) because it's no longer fresh.
+                        // meanwhile, a new revalidation should be triggered when the mutation ends.
+                        if (MUTATION_TS[key] &&
+                            // case 1
+                            (startAt <= MUTATION_TS[key] ||
+                                // case 2
+                                startAt <= MUTATION_END_TS[key] ||
+                                // case 3
+                                MUTATION_END_TS[key] === 0)) {
+                            dispatch({ isValidating: false });
+                            return [2 /*return*/, false];
+                        }
+                        cache.set(keyErr, undefined);
+                        cache.set(keyValidating, false);
+                        newState = {
+                            isValidating: false
+                        };
+                        if (typeof stateRef.current.error !== 'undefined') {
+                            // we don't have an error
+                            newState.error = undefined;
+                        }
+                        if (!config.compare(stateRef.current.data, newData)) {
+                            // deep compare to avoid extra re-render
+                            // data changed
+                            newState.data = newData;
+                        }
+                        if (!config.compare(cache.get(key), newData)) {
+                            cache.set(key, newData);
+                        }
+                        // merge the new state
+                        dispatch(newState);
+                        if (!shouldDeduping) {
+                            // also update other hooks
+                            broadcastState(key, newData, newState.error, false);
+                        }
+                        return [3 /*break*/, 7];
+                    case 6:
+                        err_2 = _c.sent();
+                        delete CONCURRENT_PROMISES[key];
+                        delete CONCURRENT_PROMISES_TS[key];
+                        if (configRef.current.isPaused()) {
+                            dispatch({
+                                isValidating: false
+                            });
+                            return [2 /*return*/, false];
+                        }
+                        cache.set(keyErr, err_2);
+                        // get a new error
+                        // don't use deep equal for errors
+                        if (stateRef.current.error !== err_2) {
+                            // we keep the stale data
+                            dispatch({
+                                isValidating: false,
+                                error: err_2
+                            });
+                            if (!shouldDeduping) {
+                                // also broadcast to update other hooks
+                                broadcastState(key, undefined, err_2, false);
+                            }
+                        }
+                        // events and retry
+                        eventsCallback('onError', err_2, key, config);
+                        if (config.shouldRetryOnError) {
+                            // when retrying, we always enable deduping
+                            eventsCallback('onErrorRetry', err_2, key, config, revalidate, {
+                                retryCount: retryCount + 1,
+                                dedupe: true
+                            });
+                        }
+                        return [3 /*break*/, 7];
+                    case 7:
+                        loading = false;
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    }, 
+    // dispatch is immutable, and `eventsCallback`, `fnArgs`, `keyErr`, and `keyValidating` are based on `key`,
+    // so we can them from the deps array.
+    //
+    // FIXME:
+    // `fn` and `config` might be changed during the lifecycle,
+    // but they might be changed every render like this.
+    // useSWR('key', () => fetch('/api/'), { suspense: true })
+    // So we omit the values from the deps array
+    // even though it might cause unexpected behaviors.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [key]);
+    // mounted (client side rendering)
+    useIsomorphicLayoutEffect(function () {
+        if (!key)
+            return undefined;
+        // after `key` updates, we need to mark it as mounted
+        unmountedRef.current = false;
+        var isUpdating = initialMountedRef.current;
+        initialMountedRef.current = true;
+        // after the component is mounted (hydrated),
+        // we need to update the data from the cache
+        // and trigger a revalidation
+        var currentHookData = stateRef.current.data;
+        var latestKeyedData = resolveData();
+        // update the state if the key changed (not the inital render) or cache updated
+        keyRef.current = key;
+        if (!config.compare(currentHookData, latestKeyedData)) {
+            dispatch({ data: latestKeyedData });
+        }
+        // revalidate with deduping
+        var softRevalidate = function () { return revalidate({ dedupe: true }); };
+        // trigger a revalidation
+        if (isUpdating || willRevalidateOnMount()) {
+            if (typeof latestKeyedData !== 'undefined' && !IS_SERVER) {
+                // delay revalidate if there's cache
+                // to not block the rendering
+                // @ts-ignore it's safe to use requestAnimationFrame in browser
+                rAF(softRevalidate);
+            }
+            else {
+                softRevalidate();
+            }
+        }
+        var pending = false;
+        var onFocus = function () {
+            if (pending || !configRef.current.revalidateOnFocus)
+                return;
+            pending = true;
+            softRevalidate();
+            setTimeout(function () { return (pending = false); }, configRef.current.focusThrottleInterval);
+        };
+        var onReconnect = function () {
+            if (configRef.current.revalidateOnReconnect) {
+                softRevalidate();
+            }
+        };
+        // register global cache update listener
+        var onUpdate = function (shouldRevalidate, updatedData, updatedError, updatedIsValidating, dedupe) {
+            if (shouldRevalidate === void 0) { shouldRevalidate = true; }
+            if (dedupe === void 0) { dedupe = true; }
+            // update hook state
+            var newState = {};
+            var needUpdate = false;
+            if (typeof updatedData !== 'undefined' &&
+                !config.compare(stateRef.current.data, updatedData)) {
+                newState.data = updatedData;
+                needUpdate = true;
+            }
+            // always update error
+            // because it can be `undefined`
+            if (stateRef.current.error !== updatedError) {
+                newState.error = updatedError;
+                needUpdate = true;
+            }
+            if (typeof updatedIsValidating !== 'undefined' &&
+                stateRef.current.isValidating !== updatedIsValidating) {
+                newState.isValidating = updatedIsValidating;
+                needUpdate = true;
+            }
+            if (needUpdate) {
+                dispatch(newState);
+            }
+            if (shouldRevalidate) {
+                if (dedupe) {
+                    return softRevalidate();
+                }
+                else {
+                    return revalidate();
+                }
+            }
+            return false;
+        };
+        var unsubFocus = addRevalidator(FOCUS_REVALIDATORS, onFocus);
+        var unsubReconnect = addRevalidator(RECONNECT_REVALIDATORS, onReconnect);
+        var unsubUpdate = addRevalidator(CACHE_REVALIDATORS, onUpdate);
+        return function () {
+            // cleanup
+            dispatch = function () { return null; };
+            // mark it as unmounted
+            unmountedRef.current = true;
+            unsubFocus();
+            unsubReconnect();
+            unsubUpdate();
+        };
+    }, [key, revalidate]);
+    useIsomorphicLayoutEffect(function () {
+        var timer = null;
+        var tick = function () { return __awaiter(_this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(!stateRef.current.error &&
+                            (configRef.current.refreshWhenHidden ||
+                                configRef.current.isDocumentVisible()) &&
+                            (configRef.current.refreshWhenOffline || configRef.current.isOnline()))) return [3 /*break*/, 2];
+                        // only revalidate when the page is visible
+                        // if API request errored, we stop polling in this round
+                        // and let the error retry function handle it
+                        return [4 /*yield*/, revalidate({ dedupe: true })];
+                    case 1:
+                        // only revalidate when the page is visible
+                        // if API request errored, we stop polling in this round
+                        // and let the error retry function handle it
+                        _a.sent();
+                        _a.label = 2;
+                    case 2:
+                        // Read the latest refreshInterval
+                        if (configRef.current.refreshInterval && timer) {
+                            timer = setTimeout(tick, configRef.current.refreshInterval);
+                        }
+                        return [2 /*return*/];
+                }
+            });
+        }); };
+        if (configRef.current.refreshInterval) {
+            timer = setTimeout(tick, configRef.current.refreshInterval);
+        }
+        return function () {
+            if (timer) {
+                clearTimeout(timer);
+                timer = null;
+            }
+        };
+    }, [
+        config.refreshInterval,
+        config.refreshWhenHidden,
+        config.refreshWhenOffline,
+        revalidate
+    ]);
+    // suspense
+    var latestData;
+    var latestError;
+    if (config.suspense) {
+        // in suspense mode, we can't return empty state
+        // (it should be suspended)
+        // try to get data and error from cache
+        latestData = cache.get(key);
+        latestError = cache.get(keyErr);
+        if (typeof latestData === 'undefined') {
+            latestData = initialData;
+        }
+        if (typeof latestError === 'undefined') {
+            latestError = initialError;
+        }
+        if (typeof latestData === 'undefined' &&
+            typeof latestError === 'undefined') {
+            // need to start the request if it hasn't
+            if (!CONCURRENT_PROMISES[key]) {
+                // trigger revalidate immediately
+                // to get the promise
+                // in this revalidate, should not rerender
+                revalidate();
+            }
+            if (CONCURRENT_PROMISES[key] &&
+                typeof CONCURRENT_PROMISES[key].then === 'function') {
+                // if it is a promise
+                throw CONCURRENT_PROMISES[key];
+            }
+            // it's a value, return it directly (override)
+            latestData = CONCURRENT_PROMISES[key];
+        }
+        if (typeof latestData === 'undefined' && latestError) {
+            // in suspense mode, throw error if there's no content
+            throw latestError;
+        }
+    }
+    // define returned state
+    // can be memorized since the state is a ref
+    var memoizedState = useMemo(function () {
+        // revalidate will be deprecated in the 1.x release
+        // because mutate() covers the same use case of revalidate().
+        // This remains only for backward compatibility
+        var state = { revalidate: revalidate, mutate: boundMutate };
+        Object.defineProperties(state, {
+            error: {
+                // `key` might be changed in the upcoming hook re-render,
+                // but the previous state will stay
+                // so we need to match the latest key and data (fallback to `initialData`)
+                get: function () {
+                    stateDependencies.current.error = true;
+                    if (config.suspense) {
+                        return latestError;
+                    }
+                    return keyRef.current === key ? stateRef.current.error : initialError;
+                },
+                enumerable: true
+            },
+            data: {
+                get: function () {
+                    stateDependencies.current.data = true;
+                    if (config.suspense) {
+                        return latestData;
+                    }
+                    return keyRef.current === key ? stateRef.current.data : initialData;
+                },
+                enumerable: true
+            },
+            isValidating: {
+                get: function () {
+                    stateDependencies.current.isValidating = true;
+                    return key ? stateRef.current.isValidating : false;
+                },
+                enumerable: true
+            }
+        });
+        return state;
+        // `config.suspense` isn't allowed to change during the lifecycle.
+        // `boundMutate` is immutable, and the immutability of `revalidate` depends on `key`
+        // so we can omit them from the deps array,
+        // but we put it to enable react-hooks/exhaustive-deps rule.
+        // `initialData` and `initialError` are not initial values
+        // because they are changed during the lifecycle
+        // so we should add them in the deps array.
+    }, [
+        revalidate,
+        initialData,
+        initialError,
+        boundMutate,
+        key,
+        config.suspense,
+        latestError,
+        latestData
+    ]);
+    return memoizedState;
+}
+Object.defineProperty(SWRConfigContext.Provider, 'default', {
+    value: defaultConfig
+});
+var SWRConfig = SWRConfigContext.Provider;
+
+var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator$1 = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __rest = (undefined && undefined.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+
 var _this = undefined;
 
 var renderCardImage = function renderCardImage(row, client) {
@@ -1372,64 +2421,57 @@ var QueueDeckExpanded = function QueueDeckExpanded(props) {
       contentCategoryMapping = _props$contentCategor === undefined ? [] : _props$contentCategor,
       showPublished = props.showPublished;
 
-  var _useState3 = useState(initialData),
+  var _useState3 = useState(initialCurrentPage || 1),
       _useState4 = _slicedToArray(_useState3, 2),
-      data = _useState4[0],
-      setData = _useState4[1];
-
-  var _useState5 = useState(initialCurrentPage || 1),
-      _useState6 = _slicedToArray(_useState5, 2),
-      currentPage = _useState6[0],
-      setCurrentPage = _useState6[1];
-  // const [lastDataSize, setLastDataSize] = useState(initialData ? initialData.length : 0)
-  // const [values, setValues] = useState({
-  //   from: params ? params.from : 0,
-  //   to: params ? params.to : 0,
-  //   page: initialCurrentPage ? initialCurrentPage : 1
-  // })
+      currentPage = _useState4[0],
+      setCurrentPage = _useState4[1];
 
   var itemsPerPage = params && params.itemsPerPage ? params.itemsPerPage : params && params.from && params.to ? params.to - params.from : 10;
 
-  // let prevValues = usePrevious(values)
-
-  //  check for change in filter parameters from client side and refresh the page
-  // useEffect(() => {
-  //   if (initialData && data !== initialData && initialData.length >= 0) {
-  //     setData(initialData)
-  //     setCurrentPage(initialCurrentPage ? initialCurrentPage : 1)
-  //     setValues({
-  //       from: params ? params.from : 0,
-  //       to: params ? params.to : 0,
-  //       page: initialCurrentPage ? initialCurrentPage : 1
-  //     })
-  //     if (initialData.length > 0) {
-  //       setScrolling(true)
-  //     }
-  //   }
-  // }, [initialData])
+  var fetcher = function () {
+    var _ref4 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(currentPage) {
+      var start, params;
+      return regenerator.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              start = (currentPage - 1) * itemsPerPage;
+              params = _extends({}, params, {
+                from: start,
+                to: start + itemsPerPage
+              });
+              _context.next = 4;
+              return client.fetch(query, params);
 
-  // useEffect(() => {
-  //   if (prevValues) {
-  //     if (values.page !== prevValues.page && values.from !== prevValues.from && values.to !== prevValues.to) {
-  //       loadData(values, query, client, params, setData, setScrolling, setLastDataSize, pointer, pointerArray)
-  //     }
-  //   }
-  // }, [values, prevValues, query, client, params, setData, setScrolling, setLastDataSize, pointer, pointerArray])
+            case 4:
+              return _context.abrupt('return', _context.sent);
 
-  // useEffect(() => {
-  //   document.addEventListener('scroll', trackScrolling)
-  //   return () => {
-  //     document.removeEventListener('scroll', trackScrolling)
-  //   }
-  // }, [currentPage])
+            case 5:
+            case 'end':
+              return _context.stop();
+          }
+        }
+      }, _callee, _this);
+    }));
 
-  // const trackScrolling = (current) => {
-  //   if (window.pageYOffset === 0) {
-  //     if (currentPage > 1) {
-  //       changePageNumber(1, seoPaginate, pageview, router, currentPage, setCurrentPage, itemsPerPage, 1)
-  //     }
-  //   }
-  // }
+    return function fetcher(_x5) {
+      return _ref4.apply(this, arguments);
+    };
+  }();
+
+  var onLoadDataSuccess = function onLoadDataSuccess() {
+    document.body.scrollTop = 0;
+    document.documentElement.scrollTop = 0;
+    seoPaginate && seoPagination(currentPage);
+    lib_3.refresh();
+  };
+
+  var _useSWR = useSWR([currentPage], fetcher, { initialData: initialData, onSuccess: onLoadDataSuccess }),
+      data = _useSWR.data;
+
+  var handlePageChange = function handlePageChange(selectedPage) {
+    setCurrentPage(selectedPage);
+  };
 
   var seoPagination = function seoPagination(pageNumber) {
     var path = router.asPath;
@@ -1450,69 +2492,13 @@ var QueueDeckExpanded = function QueueDeckExpanded(props) {
     }
     if (queryString.length > 0) path += '?' + queryString;
     pageNumber = parseInt(pageNumber);
-    if (currentPage !== pageNumber) {
-      if (path[0] !== '/') path = '/' + path;
-      var newPath = pageNumber === 1 ? '' + path : '' + path + (queryString.length > 0 ? '&' : '?') + 'page=' + pageNumber;
-      router.push(pathname, newPath, {
-        shallow: true
-      });
-    }
+    if (path[0] !== '/') path = '/' + path;
+    var newPath = pageNumber === 1 ? '' + path : '' + path + (queryString.length > 0 ? '&' : '?') + 'page=' + pageNumber;
+    router.push(pathname, newPath, {
+      shallow: true
+    });
   };
 
-  var handlePageChange = function () {
-    var _ref4 = _asyncToGenerator( /*#__PURE__*/regenerator.mark(function _callee(selectedPage) {
-      var start, newParams, newData;
-      return regenerator.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              if (!(selectedPage && selectedPage != currentPage)) {
-                _context.next = 13;
-                break;
-              }
-
-              start = (selectedPage - 1) * itemsPerPage;
-              newParams = _extends({}, params, {
-                from: start,
-                to: start + itemsPerPage
-              });
-              _context.prev = 3;
-              _context.next = 6;
-              return client.fetch(query, newParams);
-
-            case 6:
-              newData = _context.sent;
-
-              if (newData && newData.length > 0) {
-                setData(newData);
-                document.body.scrollTop = 0;
-                document.documentElement.scrollTop = 0;
-                seoPaginate && seoPagination(selectedPage);
-                setCurrentPage(selectedPage);
-                lib_3.refresh();
-              }
-              _context.next = 13;
-              break;
-
-            case 10:
-              _context.prev = 10;
-              _context.t0 = _context['catch'](3);
-
-              console.error(_context.t0);
-
-            case 13:
-            case 'end':
-              return _context.stop();
-          }
-        }
-      }, _callee, _this, [[3, 10]]);
-    }));
-
-    return function handlePageChange(_x5) {
-      return _ref4.apply(this, arguments);
-    };
-  }();
-
   return React__default.createElement(
     'div',
     null,