🚀 Big News: Socket Acquires Coana to Bring Reachability Analysis to Every Appsec Team.Learn more →
Socket
Book a DemoInstallSign in
Socket
Book a DemoInstallSign in

react-virtual-waterfall

Package Overview
Dependencies
Maintainers
0
Versions
9
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

react-virtual-waterfall - npm Package Compare versions

Comparing version

0.0.2
to
0.0.3

dist/README.md
README.md

5

dist/index.d.ts

@@ -1,1 +0,4 @@

export * from "./List";
import VirtualWaterfall, { VirtualWaterFallProps } from "./List";
export { VirtualWaterFallProps };
export default VirtualWaterfall;

1829

dist/index.js

@@ -1,5 +0,81 @@

import Ke, { forwardRef as hr, useState as se, useRef as Ye, useEffect as He, useMemo as Ve, useImperativeHandle as gr } from "react";
var je = { exports: {} }, oe = {};
/**
* @license React
import require$$1, { forwardRef, useState, useRef, useEffect, useMemo, useImperativeHandle } from "react";
var jsxRuntime = { exports: {} };
var reactJsxRuntime_production_min = {};
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/
var objectAssign;
var hasRequiredObjectAssign;
function requireObjectAssign() {
if (hasRequiredObjectAssign)
return objectAssign;
hasRequiredObjectAssign = 1;
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
function toObject(val) {
if (val === null || val === void 0) {
throw new TypeError("Object.assign cannot be called with null or undefined");
}
return Object(val);
}
function shouldUseNative() {
try {
if (!Object.assign) {
return false;
}
var test1 = new String("abc");
test1[5] = "de";
if (Object.getOwnPropertyNames(test1)[0] === "5") {
return false;
}
var test2 = {};
for (var i = 0; i < 10; i++) {
test2["_" + String.fromCharCode(i)] = i;
}
var order2 = Object.getOwnPropertyNames(test2).map(function(n) {
return test2[n];
});
if (order2.join("") !== "0123456789") {
return false;
}
var test3 = {};
"abcdefghijklmnopqrst".split("").forEach(function(letter) {
test3[letter] = letter;
});
if (Object.keys(Object.assign({}, test3)).join("") !== "abcdefghijklmnopqrst") {
return false;
}
return true;
} catch (err) {
return false;
}
}
objectAssign = shouldUseNative() ? Object.assign : function(target, source) {
var from;
var to = toObject(target);
var symbols;
for (var s = 1; s < arguments.length; s++) {
from = Object(arguments[s]);
for (var key in from) {
if (hasOwnProperty.call(from, key)) {
to[key] = from[key];
}
}
if (getOwnPropertySymbols) {
symbols = getOwnPropertySymbols(from);
for (var i = 0; i < symbols.length; i++) {
if (propIsEnumerable.call(from, symbols[i])) {
to[symbols[i]] = from[symbols[i]];
}
}
}
}
return to;
};
return objectAssign;
}
/** @license React v17.0.2
* react-jsx-runtime.production.min.js

@@ -12,23 +88,34 @@ *

*/
var Ue;
function mr() {
if (Ue)
return oe;
Ue = 1;
var M = Ke, D = Symbol.for("react.element"), B = Symbol.for("react.fragment"), m = Object.prototype.hasOwnProperty, T = M.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, k = { key: !0, ref: !0, __self: !0, __source: !0 };
function g(R, v, C) {
var y, O = {}, x = null, L = null;
C !== void 0 && (x = "" + C), v.key !== void 0 && (x = "" + v.key), v.ref !== void 0 && (L = v.ref);
for (y in v)
m.call(v, y) && !k.hasOwnProperty(y) && (O[y] = v[y]);
if (R && R.defaultProps)
for (y in v = R.defaultProps, v)
O[y] === void 0 && (O[y] = v[y]);
return { $$typeof: D, type: R, key: x, ref: L, props: O, _owner: T.current };
var hasRequiredReactJsxRuntime_production_min;
function requireReactJsxRuntime_production_min() {
if (hasRequiredReactJsxRuntime_production_min)
return reactJsxRuntime_production_min;
hasRequiredReactJsxRuntime_production_min = 1;
requireObjectAssign();
var f = require$$1, g = 60103;
reactJsxRuntime_production_min.Fragment = 60107;
if ("function" === typeof Symbol && Symbol.for) {
var h = Symbol.for;
g = h("react.element");
reactJsxRuntime_production_min.Fragment = h("react.fragment");
}
return oe.Fragment = B, oe.jsx = g, oe.jsxs = g, oe;
var m = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, n = Object.prototype.hasOwnProperty, p = { key: true, ref: true, __self: true, __source: true };
function q(c, a, k) {
var b, d = {}, e = null, l = null;
void 0 !== k && (e = "" + k);
void 0 !== a.key && (e = "" + a.key);
void 0 !== a.ref && (l = a.ref);
for (b in a)
n.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]);
if (c && c.defaultProps)
for (b in a = c.defaultProps, a)
void 0 === d[b] && (d[b] = a[b]);
return { $$typeof: g, type: c, key: e, ref: l, props: d, _owner: m.current };
}
reactJsxRuntime_production_min.jsx = q;
reactJsxRuntime_production_min.jsxs = q;
return reactJsxRuntime_production_min;
}
var ie = {};
/**
* @license React
var reactJsxRuntime_development = {};
/** @license React v17.0.2
* react-jsx-runtime.development.js

@@ -41,667 +128,971 @@ *

*/
var Je;
function yr() {
return Je || (Je = 1, process.env.NODE_ENV !== "production" && function() {
var M = Ke, D = Symbol.for("react.element"), B = Symbol.for("react.portal"), m = Symbol.for("react.fragment"), T = Symbol.for("react.strict_mode"), k = Symbol.for("react.profiler"), g = Symbol.for("react.provider"), R = Symbol.for("react.context"), v = Symbol.for("react.forward_ref"), C = Symbol.for("react.suspense"), y = Symbol.for("react.suspense_list"), O = Symbol.for("react.memo"), x = Symbol.for("react.lazy"), L = Symbol.for("react.offscreen"), q = Symbol.iterator, ge = "@@iterator";
function ue(e) {
if (e === null || typeof e != "object")
return null;
var r = q && e[q] || e[ge];
return typeof r == "function" ? r : null;
}
var F = M.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
function h(e) {
{
for (var r = arguments.length, t = new Array(r > 1 ? r - 1 : 0), n = 1; n < r; n++)
t[n - 1] = arguments[n];
G("error", e, t);
}
}
function G(e, r, t) {
{
var n = F.ReactDebugCurrentFrame, s = n.getStackAddendum();
s !== "" && (r += "%s", t = t.concat([s]));
var u = t.map(function(i) {
return String(i);
});
u.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, u);
}
}
var me = !1, z = !1, ye = !1, le = !1, be = !1, X;
X = Symbol.for("react.module.reference");
function Ee(e) {
return !!(typeof e == "string" || typeof e == "function" || e === m || e === k || be || e === T || e === C || e === y || le || e === L || me || z || ye || typeof e == "object" && e !== null && (e.$$typeof === x || e.$$typeof === O || e.$$typeof === g || e.$$typeof === R || e.$$typeof === v || // This needs to include all possible module reference object
// types supported by any Flight configuration anywhere since
// we don't know which Flight build this will end up being used
// with.
e.$$typeof === X || e.getModuleId !== void 0));
}
function Y(e, r, t) {
var n = e.displayName;
if (n)
return n;
var s = r.displayName || r.name || "";
return s !== "" ? t + "(" + s + ")" : t;
}
function Z(e) {
return e.displayName || "Context";
}
function _(e) {
if (e == null)
return null;
if (typeof e.tag == "number" && h("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
return e.displayName || e.name || null;
if (typeof e == "string")
return e;
switch (e) {
case m:
return "Fragment";
case B:
return "Portal";
case k:
return "Profiler";
case T:
return "StrictMode";
case C:
return "Suspense";
case y:
return "SuspenseList";
}
if (typeof e == "object")
switch (e.$$typeof) {
case R:
var r = e;
return Z(r) + ".Consumer";
case g:
var t = e;
return Z(t._context) + ".Provider";
case v:
return Y(e, e.render, "ForwardRef");
case O:
var n = e.displayName || null;
return n !== null ? n : _(e.type) || "Memo";
case x: {
var s = e, u = s._payload, i = s._init;
try {
return _(i(u));
} catch {
return null;
var hasRequiredReactJsxRuntime_development;
function requireReactJsxRuntime_development() {
if (hasRequiredReactJsxRuntime_development)
return reactJsxRuntime_development;
hasRequiredReactJsxRuntime_development = 1;
(function(exports) {
if (process.env.NODE_ENV !== "production") {
(function() {
var React = require$$1;
var _assign = requireObjectAssign();
var REACT_ELEMENT_TYPE = 60103;
var REACT_PORTAL_TYPE = 60106;
exports.Fragment = 60107;
var REACT_STRICT_MODE_TYPE = 60108;
var REACT_PROFILER_TYPE = 60114;
var REACT_PROVIDER_TYPE = 60109;
var REACT_CONTEXT_TYPE = 60110;
var REACT_FORWARD_REF_TYPE = 60112;
var REACT_SUSPENSE_TYPE = 60113;
var REACT_SUSPENSE_LIST_TYPE = 60120;
var REACT_MEMO_TYPE = 60115;
var REACT_LAZY_TYPE = 60116;
var REACT_BLOCK_TYPE = 60121;
var REACT_SERVER_BLOCK_TYPE = 60122;
var REACT_FUNDAMENTAL_TYPE = 60117;
var REACT_DEBUG_TRACING_MODE_TYPE = 60129;
var REACT_LEGACY_HIDDEN_TYPE = 60131;
if (typeof Symbol === "function" && Symbol.for) {
var symbolFor = Symbol.for;
REACT_ELEMENT_TYPE = symbolFor("react.element");
REACT_PORTAL_TYPE = symbolFor("react.portal");
exports.Fragment = symbolFor("react.fragment");
REACT_STRICT_MODE_TYPE = symbolFor("react.strict_mode");
REACT_PROFILER_TYPE = symbolFor("react.profiler");
REACT_PROVIDER_TYPE = symbolFor("react.provider");
REACT_CONTEXT_TYPE = symbolFor("react.context");
REACT_FORWARD_REF_TYPE = symbolFor("react.forward_ref");
REACT_SUSPENSE_TYPE = symbolFor("react.suspense");
REACT_SUSPENSE_LIST_TYPE = symbolFor("react.suspense_list");
REACT_MEMO_TYPE = symbolFor("react.memo");
REACT_LAZY_TYPE = symbolFor("react.lazy");
REACT_BLOCK_TYPE = symbolFor("react.block");
REACT_SERVER_BLOCK_TYPE = symbolFor("react.server.block");
REACT_FUNDAMENTAL_TYPE = symbolFor("react.fundamental");
symbolFor("react.scope");
symbolFor("react.opaque.id");
REACT_DEBUG_TRACING_MODE_TYPE = symbolFor("react.debug_trace_mode");
symbolFor("react.offscreen");
REACT_LEGACY_HIDDEN_TYPE = symbolFor("react.legacy_hidden");
}
var MAYBE_ITERATOR_SYMBOL = typeof Symbol === "function" && Symbol.iterator;
var FAUX_ITERATOR_SYMBOL = "@@iterator";
function getIteratorFn(maybeIterable) {
if (maybeIterable === null || typeof maybeIterable !== "object") {
return null;
}
var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL];
if (typeof maybeIterator === "function") {
return maybeIterator;
}
return null;
}
var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
function error(format) {
{
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
printWarning("error", format, args);
}
}
return null;
}
var S = Object.assign, W = 0, Q, j, ee, $, re, fe, ce;
function de() {
}
de.__reactDisabledLog = !0;
function _e() {
{
if (W === 0) {
Q = console.log, j = console.info, ee = console.warn, $ = console.error, re = console.group, fe = console.groupCollapsed, ce = console.groupEnd;
var e = {
configurable: !0,
enumerable: !0,
value: de,
writable: !0
};
Object.defineProperties(console, {
info: e,
log: e,
warn: e,
error: e,
group: e,
groupCollapsed: e,
groupEnd: e
});
function printWarning(level, format, args) {
{
var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
var stack = ReactDebugCurrentFrame2.getStackAddendum();
if (stack !== "") {
format += "%s";
args = args.concat([stack]);
}
var argsWithFormat = args.map(function(item) {
return "" + item;
});
argsWithFormat.unshift("Warning: " + format);
Function.prototype.apply.call(console[level], console, argsWithFormat);
}
}
W++;
}
}
function Re() {
{
if (W--, W === 0) {
var e = {
configurable: !0,
enumerable: !0,
writable: !0
};
Object.defineProperties(console, {
log: S({}, e, {
value: Q
}),
info: S({}, e, {
value: j
}),
warn: S({}, e, {
value: ee
}),
error: S({}, e, {
value: $
}),
group: S({}, e, {
value: re
}),
groupCollapsed: S({}, e, {
value: fe
}),
groupEnd: S({}, e, {
value: ce
})
});
var enableScopeAPI = false;
function isValidElementType(type) {
if (typeof type === "string" || typeof type === "function") {
return true;
}
if (type === exports.Fragment || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI) {
return true;
}
if (typeof type === "object" && type !== null) {
if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
return true;
}
}
return false;
}
W < 0 && h("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
}
}
var te = F.ReactCurrentDispatcher, f;
function a(e, r, t) {
{
if (f === void 0)
try {
throw Error();
} catch (s) {
var n = s.stack.trim().match(/\n( *(at )?)/);
f = n && n[1] || "";
function getWrappedName(outerType, innerType, wrapperName) {
var functionName = innerType.displayName || innerType.name || "";
return outerType.displayName || (functionName !== "" ? wrapperName + "(" + functionName + ")" : wrapperName);
}
function getContextName(type) {
return type.displayName || "Context";
}
function getComponentName(type) {
if (type == null) {
return null;
}
return `
` + f + e;
}
}
var l = !1, c;
{
var ve = typeof WeakMap == "function" ? WeakMap : Map;
c = new ve();
}
function H(e, r) {
if (!e || l)
return "";
{
var t = c.get(e);
if (t !== void 0)
return t;
}
var n;
l = !0;
var s = Error.prepareStackTrace;
Error.prepareStackTrace = void 0;
var u;
u = te.current, te.current = null, _e();
try {
if (r) {
var i = function() {
throw Error();
};
if (Object.defineProperty(i.prototype, "props", {
set: function() {
throw Error();
{
if (typeof type.tag === "number") {
error("Received an unexpected object in getComponentName(). This is likely a bug in React. Please file an issue.");
}
}), typeof Reflect == "object" && Reflect.construct) {
try {
Reflect.construct(i, []);
} catch (E) {
n = E;
}
if (typeof type === "function") {
return type.displayName || type.name || null;
}
if (typeof type === "string") {
return type;
}
switch (type) {
case exports.Fragment:
return "Fragment";
case REACT_PORTAL_TYPE:
return "Portal";
case REACT_PROFILER_TYPE:
return "Profiler";
case REACT_STRICT_MODE_TYPE:
return "StrictMode";
case REACT_SUSPENSE_TYPE:
return "Suspense";
case REACT_SUSPENSE_LIST_TYPE:
return "SuspenseList";
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_CONTEXT_TYPE:
var context = type;
return getContextName(context) + ".Consumer";
case REACT_PROVIDER_TYPE:
var provider = type;
return getContextName(provider._context) + ".Provider";
case REACT_FORWARD_REF_TYPE:
return getWrappedName(type, type.render, "ForwardRef");
case REACT_MEMO_TYPE:
return getComponentName(type.type);
case REACT_BLOCK_TYPE:
return getComponentName(type._render);
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
try {
return getComponentName(init(payload));
} catch (x) {
return null;
}
}
}
Reflect.construct(e, [], i);
} else {
try {
i.call();
} catch (E) {
n = E;
}
return null;
}
var disabledDepth = 0;
var prevLog;
var prevInfo;
var prevWarn;
var prevError;
var prevGroup;
var prevGroupCollapsed;
var prevGroupEnd;
function disabledLog() {
}
disabledLog.__reactDisabledLog = true;
function disableLogs() {
{
if (disabledDepth === 0) {
prevLog = console.log;
prevInfo = console.info;
prevWarn = console.warn;
prevError = console.error;
prevGroup = console.group;
prevGroupCollapsed = console.groupCollapsed;
prevGroupEnd = console.groupEnd;
var props = {
configurable: true,
enumerable: true,
value: disabledLog,
writable: true
};
Object.defineProperties(console, {
info: props,
log: props,
warn: props,
error: props,
group: props,
groupCollapsed: props,
groupEnd: props
});
}
e.call(i.prototype);
disabledDepth++;
}
} else {
}
function reenableLogs() {
{
disabledDepth--;
if (disabledDepth === 0) {
var props = {
configurable: true,
enumerable: true,
writable: true
};
Object.defineProperties(console, {
log: _assign({}, props, {
value: prevLog
}),
info: _assign({}, props, {
value: prevInfo
}),
warn: _assign({}, props, {
value: prevWarn
}),
error: _assign({}, props, {
value: prevError
}),
group: _assign({}, props, {
value: prevGroup
}),
groupCollapsed: _assign({}, props, {
value: prevGroupCollapsed
}),
groupEnd: _assign({}, props, {
value: prevGroupEnd
})
});
}
if (disabledDepth < 0) {
error("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
}
}
}
var ReactCurrentDispatcher = ReactSharedInternals.ReactCurrentDispatcher;
var prefix;
function describeBuiltInComponentFrame(name, source, ownerFn) {
{
if (prefix === void 0) {
try {
throw Error();
} catch (x) {
var match = x.stack.trim().match(/\n( *(at )?)/);
prefix = match && match[1] || "";
}
}
return "\n" + prefix + name;
}
}
var reentry = false;
var componentFrameCache;
{
var PossiblyWeakMap = typeof WeakMap === "function" ? WeakMap : Map;
componentFrameCache = new PossiblyWeakMap();
}
function describeNativeComponentFrame(fn, construct) {
if (!fn || reentry) {
return "";
}
{
var frame = componentFrameCache.get(fn);
if (frame !== void 0) {
return frame;
}
}
var control;
reentry = true;
var previousPrepareStackTrace = Error.prepareStackTrace;
Error.prepareStackTrace = void 0;
var previousDispatcher;
{
previousDispatcher = ReactCurrentDispatcher.current;
ReactCurrentDispatcher.current = null;
disableLogs();
}
try {
throw Error();
} catch (E) {
n = E;
if (construct) {
var Fake = function() {
throw Error();
};
Object.defineProperty(Fake.prototype, "props", {
set: function() {
throw Error();
}
});
if (typeof Reflect === "object" && Reflect.construct) {
try {
Reflect.construct(Fake, []);
} catch (x) {
control = x;
}
Reflect.construct(fn, [], Fake);
} else {
try {
Fake.call();
} catch (x) {
control = x;
}
fn.call(Fake.prototype);
}
} else {
try {
throw Error();
} catch (x) {
control = x;
}
fn();
}
} catch (sample) {
if (sample && control && typeof sample.stack === "string") {
var sampleLines = sample.stack.split("\n");
var controlLines = control.stack.split("\n");
var s = sampleLines.length - 1;
var c = controlLines.length - 1;
while (s >= 1 && c >= 0 && sampleLines[s] !== controlLines[c]) {
c--;
}
for (; s >= 1 && c >= 0; s--, c--) {
if (sampleLines[s] !== controlLines[c]) {
if (s !== 1 || c !== 1) {
do {
s--;
c--;
if (c < 0 || sampleLines[s] !== controlLines[c]) {
var _frame = "\n" + sampleLines[s].replace(" at new ", " at ");
{
if (typeof fn === "function") {
componentFrameCache.set(fn, _frame);
}
}
return _frame;
}
} while (s >= 1 && c >= 0);
}
break;
}
}
}
} finally {
reentry = false;
{
ReactCurrentDispatcher.current = previousDispatcher;
reenableLogs();
}
Error.prepareStackTrace = previousPrepareStackTrace;
}
e();
var name = fn ? fn.displayName || fn.name : "";
var syntheticFrame = name ? describeBuiltInComponentFrame(name) : "";
{
if (typeof fn === "function") {
componentFrameCache.set(fn, syntheticFrame);
}
}
return syntheticFrame;
}
} catch (E) {
if (E && n && typeof E.stack == "string") {
for (var o = E.stack.split(`
`), b = n.stack.split(`
`), d = o.length - 1, p = b.length - 1; d >= 1 && p >= 0 && o[d] !== b[p]; )
p--;
for (; d >= 1 && p >= 0; d--, p--)
if (o[d] !== b[p]) {
if (d !== 1 || p !== 1)
do
if (d--, p--, p < 0 || o[d] !== b[p]) {
var w = `
` + o[d].replace(" at new ", " at ");
return e.displayName && w.includes("<anonymous>") && (w = w.replace("<anonymous>", e.displayName)), typeof e == "function" && c.set(e, w), w;
function describeFunctionComponentFrame(fn, source, ownerFn) {
{
return describeNativeComponentFrame(fn, false);
}
}
function shouldConstruct(Component) {
var prototype = Component.prototype;
return !!(prototype && prototype.isReactComponent);
}
function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) {
if (type == null) {
return "";
}
if (typeof type === "function") {
{
return describeNativeComponentFrame(type, shouldConstruct(type));
}
}
if (typeof type === "string") {
return describeBuiltInComponentFrame(type);
}
switch (type) {
case REACT_SUSPENSE_TYPE:
return describeBuiltInComponentFrame("Suspense");
case REACT_SUSPENSE_LIST_TYPE:
return describeBuiltInComponentFrame("SuspenseList");
}
if (typeof type === "object") {
switch (type.$$typeof) {
case REACT_FORWARD_REF_TYPE:
return describeFunctionComponentFrame(type.render);
case REACT_MEMO_TYPE:
return describeUnknownElementTypeFrameInDEV(type.type, source, ownerFn);
case REACT_BLOCK_TYPE:
return describeFunctionComponentFrame(type._render);
case REACT_LAZY_TYPE: {
var lazyComponent = type;
var payload = lazyComponent._payload;
var init = lazyComponent._init;
try {
return describeUnknownElementTypeFrameInDEV(init(payload), source, ownerFn);
} catch (x) {
}
}
}
}
return "";
}
var loggedTypeFailures = {};
var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement(element) {
{
if (element) {
var owner = element._owner;
var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
ReactDebugCurrentFrame.setExtraStackFrame(stack);
} else {
ReactDebugCurrentFrame.setExtraStackFrame(null);
}
}
}
function checkPropTypes(typeSpecs, values, location, componentName, element) {
{
var has = Function.call.bind(Object.prototype.hasOwnProperty);
for (var typeSpecName in typeSpecs) {
if (has(typeSpecs, typeSpecName)) {
var error$1 = void 0;
try {
if (typeof typeSpecs[typeSpecName] !== "function") {
var err = Error((componentName || "React class") + ": " + location + " type `" + typeSpecName + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof typeSpecs[typeSpecName] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
err.name = "Invariant Violation";
throw err;
}
while (d >= 1 && p >= 0);
break;
error$1 = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
} catch (ex) {
error$1 = ex;
}
if (error$1 && !(error$1 instanceof Error)) {
setCurrentlyValidatingElement(element);
error("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", componentName || "React class", location, typeSpecName, typeof error$1);
setCurrentlyValidatingElement(null);
}
if (error$1 instanceof Error && !(error$1.message in loggedTypeFailures)) {
loggedTypeFailures[error$1.message] = true;
setCurrentlyValidatingElement(element);
error("Failed %s type: %s", location, error$1.message);
setCurrentlyValidatingElement(null);
}
}
}
}
}
} finally {
l = !1, te.current = u, Re(), Error.prepareStackTrace = s;
}
var K = e ? e.displayName || e.name : "", N = K ? a(K) : "";
return typeof e == "function" && c.set(e, N), N;
}
function V(e, r, t) {
return H(e, !1);
}
function pe(e) {
var r = e.prototype;
return !!(r && r.isReactComponent);
}
function A(e, r, t) {
if (e == null)
return "";
if (typeof e == "function")
return H(e, pe(e));
if (typeof e == "string")
return a(e);
switch (e) {
case C:
return a("Suspense");
case y:
return a("SuspenseList");
}
if (typeof e == "object")
switch (e.$$typeof) {
case v:
return V(e.render);
case O:
return A(e.type, r, t);
case x: {
var n = e, s = n._payload, u = n._init;
try {
return A(u(s), r, t);
} catch {
var ReactCurrentOwner = ReactSharedInternals.ReactCurrentOwner;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var RESERVED_PROPS = {
key: true,
ref: true,
__self: true,
__source: true
};
var specialPropKeyWarningShown;
var specialPropRefWarningShown;
var didWarnAboutStringRefs;
{
didWarnAboutStringRefs = {};
}
function hasValidRef(config) {
{
if (hasOwnProperty.call(config, "ref")) {
var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
if (getter && getter.isReactWarning) {
return false;
}
}
}
return config.ref !== void 0;
}
return "";
}
var I = Object.prototype.hasOwnProperty, ne = {}, he = F.ReactDebugCurrentFrame;
function U(e) {
if (e) {
var r = e._owner, t = A(e.type, e._source, r ? r.type : null);
he.setExtraStackFrame(t);
} else
he.setExtraStackFrame(null);
}
function Be(e, r, t, n, s) {
{
var u = Function.call.bind(I);
for (var i in e)
if (u(e, i)) {
var o = void 0;
try {
if (typeof e[i] != "function") {
var b = Error((n || "React class") + ": " + t + " type `" + i + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[i] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
throw b.name = "Invariant Violation", b;
function hasValidKey(config) {
{
if (hasOwnProperty.call(config, "key")) {
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
if (getter && getter.isReactWarning) {
return false;
}
o = e[i](r, i, n, t, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
} catch (d) {
o = d;
}
o && !(o instanceof Error) && (U(s), h("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", n || "React class", t, i, typeof o), U(null)), o instanceof Error && !(o.message in ne) && (ne[o.message] = !0, U(s), h("Failed %s type: %s", t, o.message), U(null));
}
}
}
var qe = Array.isArray;
function we(e) {
return qe(e);
}
function Ge(e) {
{
var r = typeof Symbol == "function" && Symbol.toStringTag, t = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
return t;
}
}
function ze(e) {
try {
return Pe(e), !1;
} catch {
return !0;
}
}
function Pe(e) {
return "" + e;
}
function ke(e) {
if (ze(e))
return h("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Ge(e)), Pe(e);
}
var ae = F.ReactCurrentOwner, Xe = {
key: !0,
ref: !0,
__self: !0,
__source: !0
}, Ae, Ie, Te;
Te = {};
function Ze(e) {
if (I.call(e, "ref")) {
var r = Object.getOwnPropertyDescriptor(e, "ref").get;
if (r && r.isReactWarning)
return !1;
}
return e.ref !== void 0;
}
function Qe(e) {
if (I.call(e, "key")) {
var r = Object.getOwnPropertyDescriptor(e, "key").get;
if (r && r.isReactWarning)
return !1;
}
return e.key !== void 0;
}
function er(e, r) {
if (typeof e.ref == "string" && ae.current && r && ae.current.stateNode !== r) {
var t = _(ae.current.type);
Te[t] || (h('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', _(ae.current.type), e.ref), Te[t] = !0);
}
}
function rr(e, r) {
{
var t = function() {
Ae || (Ae = !0, h("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
return config.key !== void 0;
}
function warnIfStringRefCannotBeAutoConverted(config, self) {
{
if (typeof config.ref === "string" && ReactCurrentOwner.current && self && ReactCurrentOwner.current.stateNode !== self) {
var componentName = getComponentName(ReactCurrentOwner.current.type);
if (!didWarnAboutStringRefs[componentName]) {
error('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', getComponentName(ReactCurrentOwner.current.type), config.ref);
didWarnAboutStringRefs[componentName] = true;
}
}
}
}
function defineKeyPropWarningGetter(props, displayName) {
{
var warnAboutAccessingKey = function() {
if (!specialPropKeyWarningShown) {
specialPropKeyWarningShown = true;
error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
}
};
warnAboutAccessingKey.isReactWarning = true;
Object.defineProperty(props, "key", {
get: warnAboutAccessingKey,
configurable: true
});
}
}
function defineRefPropWarningGetter(props, displayName) {
{
var warnAboutAccessingRef = function() {
if (!specialPropRefWarningShown) {
specialPropRefWarningShown = true;
error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", displayName);
}
};
warnAboutAccessingRef.isReactWarning = true;
Object.defineProperty(props, "ref", {
get: warnAboutAccessingRef,
configurable: true
});
}
}
var ReactElement = function(type, key, ref, self, source, owner, props) {
var element = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
type,
key,
ref,
props,
// Record the component responsible for creating this element.
_owner: owner
};
{
element._store = {};
Object.defineProperty(element._store, "validated", {
configurable: false,
enumerable: false,
writable: true,
value: false
});
Object.defineProperty(element, "_self", {
configurable: false,
enumerable: false,
writable: false,
value: self
});
Object.defineProperty(element, "_source", {
configurable: false,
enumerable: false,
writable: false,
value: source
});
if (Object.freeze) {
Object.freeze(element.props);
Object.freeze(element);
}
}
return element;
};
t.isReactWarning = !0, Object.defineProperty(e, "key", {
get: t,
configurable: !0
});
}
}
function tr(e, r) {
{
var t = function() {
Ie || (Ie = !0, h("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
};
t.isReactWarning = !0, Object.defineProperty(e, "ref", {
get: t,
configurable: !0
});
}
}
var nr = function(e, r, t, n, s, u, i) {
var o = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: D,
// Built-in properties that belong on the element
type: e,
key: r,
ref: t,
props: i,
// Record the component responsible for creating this element.
_owner: u
};
return o._store = {}, Object.defineProperty(o._store, "validated", {
configurable: !1,
enumerable: !1,
writable: !0,
value: !1
}), Object.defineProperty(o, "_self", {
configurable: !1,
enumerable: !1,
writable: !1,
value: n
}), Object.defineProperty(o, "_source", {
configurable: !1,
enumerable: !1,
writable: !1,
value: s
}), Object.freeze && (Object.freeze(o.props), Object.freeze(o)), o;
};
function ar(e, r, t, n, s) {
{
var u, i = {}, o = null, b = null;
t !== void 0 && (ke(t), o = "" + t), Qe(r) && (ke(r.key), o = "" + r.key), Ze(r) && (b = r.ref, er(r, s));
for (u in r)
I.call(r, u) && !Xe.hasOwnProperty(u) && (i[u] = r[u]);
if (e && e.defaultProps) {
var d = e.defaultProps;
for (u in d)
i[u] === void 0 && (i[u] = d[u]);
function jsxDEV(type, config, maybeKey, source, self) {
{
var propName;
var props = {};
var key = null;
var ref = null;
if (maybeKey !== void 0) {
key = "" + maybeKey;
}
if (hasValidKey(config)) {
key = "" + config.key;
}
if (hasValidRef(config)) {
ref = config.ref;
warnIfStringRefCannotBeAutoConverted(config, self);
}
for (propName in config) {
if (hasOwnProperty.call(config, propName) && !RESERVED_PROPS.hasOwnProperty(propName)) {
props[propName] = config[propName];
}
}
if (type && type.defaultProps) {
var defaultProps = type.defaultProps;
for (propName in defaultProps) {
if (props[propName] === void 0) {
props[propName] = defaultProps[propName];
}
}
}
if (key || ref) {
var displayName = typeof type === "function" ? type.displayName || type.name || "Unknown" : type;
if (key) {
defineKeyPropWarningGetter(props, displayName);
}
if (ref) {
defineRefPropWarningGetter(props, displayName);
}
}
return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props);
}
}
if (o || b) {
var p = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
o && rr(i, p), b && tr(i, p);
var ReactCurrentOwner$1 = ReactSharedInternals.ReactCurrentOwner;
var ReactDebugCurrentFrame$1 = ReactSharedInternals.ReactDebugCurrentFrame;
function setCurrentlyValidatingElement$1(element) {
{
if (element) {
var owner = element._owner;
var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
ReactDebugCurrentFrame$1.setExtraStackFrame(stack);
} else {
ReactDebugCurrentFrame$1.setExtraStackFrame(null);
}
}
}
return nr(e, o, b, s, n, ae.current, i);
}
}
var Oe = F.ReactCurrentOwner, De = F.ReactDebugCurrentFrame;
function J(e) {
if (e) {
var r = e._owner, t = A(e.type, e._source, r ? r.type : null);
De.setExtraStackFrame(t);
} else
De.setExtraStackFrame(null);
}
var Se;
Se = !1;
function Ce(e) {
return typeof e == "object" && e !== null && e.$$typeof === D;
}
function Fe() {
{
if (Oe.current) {
var e = _(Oe.current.type);
if (e)
return `
Check the render method of \`` + e + "`.";
var propTypesMisspellWarningShown;
{
propTypesMisspellWarningShown = false;
}
return "";
}
}
function or(e) {
{
if (e !== void 0) {
var r = e.fileName.replace(/^.*[\\\/]/, ""), t = e.lineNumber;
return `
Check your code at ` + r + ":" + t + ".";
function isValidElement(object) {
{
return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
}
return "";
}
}
var We = {};
function ir(e) {
{
var r = Fe();
if (!r) {
var t = typeof e == "string" ? e : e.displayName || e.name;
t && (r = `
Check the top-level render call using <` + t + ">.");
function getDeclarationErrorAddendum() {
{
if (ReactCurrentOwner$1.current) {
var name = getComponentName(ReactCurrentOwner$1.current.type);
if (name) {
return "\n\nCheck the render method of `" + name + "`.";
}
}
return "";
}
}
return r;
}
}
function $e(e, r) {
{
if (!e._store || e._store.validated || e.key != null)
return;
e._store.validated = !0;
var t = ir(r);
if (We[t])
return;
We[t] = !0;
var n = "";
e && e._owner && e._owner !== Oe.current && (n = " It was passed a child from " + _(e._owner.type) + "."), J(e), h('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', t, n), J(null);
}
}
function Me(e, r) {
{
if (typeof e != "object")
return;
if (we(e))
for (var t = 0; t < e.length; t++) {
var n = e[t];
Ce(n) && $e(n, r);
function getSourceInfoErrorAddendum(source) {
{
if (source !== void 0) {
var fileName = source.fileName.replace(/^.*[\\\/]/, "");
var lineNumber = source.lineNumber;
return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
}
return "";
}
else if (Ce(e))
e._store && (e._store.validated = !0);
else if (e) {
var s = ue(e);
if (typeof s == "function" && s !== e.entries)
for (var u = s.call(e), i; !(i = u.next()).done; )
Ce(i.value) && $e(i.value, r);
}
}
}
function sr(e) {
{
var r = e.type;
if (r == null || typeof r == "string")
return;
var t;
if (typeof r == "function")
t = r.propTypes;
else if (typeof r == "object" && (r.$$typeof === v || // Note: Memo only checks outer props here.
// Inner props are checked in the reconciler.
r.$$typeof === O))
t = r.propTypes;
else
return;
if (t) {
var n = _(r);
Be(t, e.props, "prop", n, e);
} else if (r.PropTypes !== void 0 && !Se) {
Se = !0;
var s = _(r);
h("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", s || "Unknown");
var ownerHasKeyUseWarning = {};
function getCurrentComponentErrorInfo(parentType) {
{
var info = getDeclarationErrorAddendum();
if (!info) {
var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
if (parentName) {
info = "\n\nCheck the top-level render call using <" + parentName + ">.";
}
}
return info;
}
}
typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && h("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
}
}
function ur(e) {
{
for (var r = Object.keys(e.props), t = 0; t < r.length; t++) {
var n = r[t];
if (n !== "children" && n !== "key") {
J(e), h("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", n), J(null);
break;
function validateExplicitKey(element, parentType) {
{
if (!element._store || element._store.validated || element.key != null) {
return;
}
element._store.validated = true;
var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
if (ownerHasKeyUseWarning[currentComponentErrorInfo]) {
return;
}
ownerHasKeyUseWarning[currentComponentErrorInfo] = true;
var childOwner = "";
if (element && element._owner && element._owner !== ReactCurrentOwner$1.current) {
childOwner = " It was passed a child from " + getComponentName(element._owner.type) + ".";
}
setCurrentlyValidatingElement$1(element);
error('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', currentComponentErrorInfo, childOwner);
setCurrentlyValidatingElement$1(null);
}
}
e.ref !== null && (J(e), h("Invalid attribute `ref` supplied to `React.Fragment`."), J(null));
}
}
var Ne = {};
function Le(e, r, t, n, s, u) {
{
var i = Ee(e);
if (!i) {
var o = "";
(e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (o += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
var b = or(s);
b ? o += b : o += Fe();
var d;
e === null ? d = "null" : we(e) ? d = "array" : e !== void 0 && e.$$typeof === D ? (d = "<" + (_(e.type) || "Unknown") + " />", o = " Did you accidentally export a JSX literal instead of a component?") : d = typeof e, h("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", d, o);
function validateChildKeys(node, parentType) {
{
if (typeof node !== "object") {
return;
}
if (Array.isArray(node)) {
for (var i = 0; i < node.length; i++) {
var child = node[i];
if (isValidElement(child)) {
validateExplicitKey(child, parentType);
}
}
} else if (isValidElement(node)) {
if (node._store) {
node._store.validated = true;
}
} else if (node) {
var iteratorFn = getIteratorFn(node);
if (typeof iteratorFn === "function") {
if (iteratorFn !== node.entries) {
var iterator = iteratorFn.call(node);
var step;
while (!(step = iterator.next()).done) {
if (isValidElement(step.value)) {
validateExplicitKey(step.value, parentType);
}
}
}
}
}
}
}
var p = ar(e, r, t, s, u);
if (p == null)
return p;
if (i) {
var w = r.children;
if (w !== void 0)
if (n)
if (we(w)) {
for (var K = 0; K < w.length; K++)
Me(w[K], e);
Object.freeze && Object.freeze(w);
} else
h("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
else
Me(w, e);
function validatePropTypes(element) {
{
var type = element.type;
if (type === null || type === void 0 || typeof type === "string") {
return;
}
var propTypes;
if (typeof type === "function") {
propTypes = type.propTypes;
} else if (typeof type === "object" && (type.$$typeof === REACT_FORWARD_REF_TYPE || // Note: Memo only checks outer props here.
// Inner props are checked in the reconciler.
type.$$typeof === REACT_MEMO_TYPE)) {
propTypes = type.propTypes;
} else {
return;
}
if (propTypes) {
var name = getComponentName(type);
checkPropTypes(propTypes, element.props, "prop", name, element);
} else if (type.PropTypes !== void 0 && !propTypesMisspellWarningShown) {
propTypesMisspellWarningShown = true;
var _name = getComponentName(type);
error("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", _name || "Unknown");
}
if (typeof type.getDefaultProps === "function" && !type.getDefaultProps.isReactClassApproved) {
error("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
}
}
}
if (I.call(r, "key")) {
var N = _(e), E = Object.keys(r).filter(function(pr) {
return pr !== "key";
}), xe = E.length > 0 ? "{key: someKey, " + E.join(": ..., ") + ": ...}" : "{key: someKey}";
if (!Ne[N + xe]) {
var vr = E.length > 0 ? "{" + E.join(": ..., ") + ": ...}" : "{}";
h(`A props object containing a "key" prop is being spread into JSX:
let props = %s;
<%s {...props} />
React keys must be passed directly to JSX without using spread:
let props = %s;
<%s key={someKey} {...props} />`, xe, N, vr, N), Ne[N + xe] = !0;
function validateFragmentProps(fragment) {
{
var keys = Object.keys(fragment.props);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (key !== "children" && key !== "key") {
setCurrentlyValidatingElement$1(fragment);
error("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", key);
setCurrentlyValidatingElement$1(null);
break;
}
}
if (fragment.ref !== null) {
setCurrentlyValidatingElement$1(fragment);
error("Invalid attribute `ref` supplied to `React.Fragment`.");
setCurrentlyValidatingElement$1(null);
}
}
}
return e === m ? ur(p) : sr(p), p;
}
function jsxWithValidation(type, props, key, isStaticChildren, source, self) {
{
var validType = isValidElementType(type);
if (!validType) {
var info = "";
if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
info += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.";
}
var sourceInfo = getSourceInfoErrorAddendum(source);
if (sourceInfo) {
info += sourceInfo;
} else {
info += getDeclarationErrorAddendum();
}
var typeString;
if (type === null) {
typeString = "null";
} else if (Array.isArray(type)) {
typeString = "array";
} else if (type !== void 0 && type.$$typeof === REACT_ELEMENT_TYPE) {
typeString = "<" + (getComponentName(type.type) || "Unknown") + " />";
info = " Did you accidentally export a JSX literal instead of a component?";
} else {
typeString = typeof type;
}
error("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", typeString, info);
}
var element = jsxDEV(type, props, key, source, self);
if (element == null) {
return element;
}
if (validType) {
var children = props.children;
if (children !== void 0) {
if (isStaticChildren) {
if (Array.isArray(children)) {
for (var i = 0; i < children.length; i++) {
validateChildKeys(children[i], type);
}
if (Object.freeze) {
Object.freeze(children);
}
} else {
error("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
}
} else {
validateChildKeys(children, type);
}
}
}
if (type === exports.Fragment) {
validateFragmentProps(element);
} else {
validatePropTypes(element);
}
return element;
}
}
function jsxWithValidationStatic(type, props, key) {
{
return jsxWithValidation(type, props, key, true);
}
}
function jsxWithValidationDynamic(type, props, key) {
{
return jsxWithValidation(type, props, key, false);
}
}
var jsx = jsxWithValidationDynamic;
var jsxs = jsxWithValidationStatic;
exports.jsx = jsx;
exports.jsxs = jsxs;
})();
}
function lr(e, r, t) {
return Le(e, r, t, !0);
}
function fr(e, r, t) {
return Le(e, r, t, !1);
}
var cr = fr, dr = lr;
ie.Fragment = m, ie.jsx = cr, ie.jsxs = dr;
}()), ie;
})(reactJsxRuntime_development);
return reactJsxRuntime_development;
}
process.env.NODE_ENV === "production" ? je.exports = mr() : je.exports = yr();
var P = je.exports;
hr((M, D) => {
if (process.env.NODE_ENV === "production") {
jsxRuntime.exports = requireReactJsxRuntime_production_min();
} else {
jsxRuntime.exports = requireReactJsxRuntime_development();
}
var jsxRuntimeExports = jsxRuntime.exports;
const VariableSizeList = forwardRef((props, ref) => {
const {
renderItem: B,
dataSource: m,
containerHeight: T = window.innerHeight,
getItemHeight: k,
columnCount: g,
columnGap: R = 0,
rowGap: v = 0,
next: C,
scrollThreshold: y = 1,
loader: O,
end: x,
endMessage: L,
skeleton: q,
skeletonCount: ge = 8,
averageItemHeight: ue = 40,
showLoader: F,
paddingCount: h = 0,
onItemRendered: G,
appearOnce: me = !0
} = M, [z, ye] = se(0), [le, be] = se(0), [X, Ee] = se(m.length), Y = new Array(g).fill(0), Z = window.innerWidth, _ = Ye(!1), S = Ye(), W = Array(g).fill(0).map((f, a) => ({
offsetsColumnNum: a,
listTotalHeight: 0,
list: []
})), Q = () => {
const f = Array(g).fill(0).map((a, l) => ({
offsetsColumnNum: l,
renderItem: Item,
dataSource,
containerHeight = window.innerHeight,
getItemHeight,
columnCount,
columnGap = 0,
rowGap = 0,
next,
scrollThreshold = 1,
loader,
end,
endMessage,
skeleton,
skeletonCount = 8,
averageItemHeight = 40,
showLoader,
paddingCount = 0,
onItemRendered,
appearOnce = true
} = props;
const [scrollTop, setScrollTop] = useState(0);
const [scrollStartIdx, setScrollStartIdx] = useState(0);
const [scrollEndIdx, setScrollEndIdx] = useState(dataSource.length);
const columnHeightList = new Array(columnCount).fill(0);
const clientWidhth = window.innerWidth;
const updateFlag = useRef(false);
const listItemRef = useRef();
const defaultOffsets = Array(columnCount).fill(0).map((_, index) => {
return {
offsetsColumnNum: index,
listTotalHeight: 0,
list: []
}));
for (let a = 0; a < m.length; a++) {
const l = Math.min(...Y), c = Y.indexOf(l);
a < g ? (f[a].list = { [a]: 0 }, f[a].listTotalHeight = 0, Y[a] = k(a)) : (f[c].list = {
...f[c].list,
[a]: l + v
}, f[c].listTotalHeight = k(a) + l + v, Y[c] = k(a) + l + v);
};
});
const genOffsets = () => {
const offsetsList = Array(columnCount).fill(0).map((_, index) => {
return {
offsetsColumnNum: index,
listTotalHeight: 0,
list: []
};
});
for (let i = 0; i < dataSource.length; i++) {
const minHeight = Math.min(...columnHeightList);
const minHeightColumn = columnHeightList.indexOf(minHeight);
if (i < columnCount) {
offsetsList[i].list = { [i]: 0 };
offsetsList[i].listTotalHeight = 0;
columnHeightList[i] = getItemHeight(i);
} else {
offsetsList[minHeightColumn].list = {
...offsetsList[minHeightColumn].list,
[i]: minHeight + rowGap
};
offsetsList[minHeightColumn].listTotalHeight = getItemHeight(i) + minHeight + rowGap;
columnHeightList[minHeightColumn] = getItemHeight(i) + minHeight + rowGap;
}
}
return f;
}, [j, ee] = se(W);
He(() => {
ee(Q());
}, [m]);
const $ = Math.max(
...Array(g).fill(0).map((f, a) => j[a].listTotalHeight - T)
return offsetsList;
};
const [offsets, setOffsets] = useState(defaultOffsets);
useEffect(() => {
setOffsets(genOffsets());
}, [dataSource]);
const contentHeight = Math.max(
...Array(columnCount).fill(0).map((_, index) => {
return offsets[index].listTotalHeight - containerHeight;
})
);
He(() => {
const f = [], a = [];
j.forEach((l) => {
Object.keys(l.list).some((c) => {
if (l.list[Number(c)] > z)
return f.push(Number(c)), !0;
useEffect(() => {
const tempStartKey = [];
const tempEndKey = [];
offsets.forEach((offsets2) => {
Object.keys(offsets2.list).some((key) => {
if (offsets2.list[Number(key)] > scrollTop) {
tempStartKey.push(Number(key));
return true;
}
});
}), be(Math.min(...f) - g), j.forEach((l) => {
Object.keys(l.list).some((c) => {
if (l.list[Number(c)] > z + T)
return a.push(Number(c)), !0;
});
setScrollStartIdx(Math.min(...tempStartKey) - columnCount);
offsets.forEach((offsets2) => {
Object.keys(offsets2.list).some((key) => {
if (offsets2.list[Number(key)] > scrollTop + containerHeight) {
tempEndKey.push(Number(key));
return true;
}
});
}), Ee(Math.min(...a));
}, [z, j]);
const re = Ve(() => Math.max(le - h, 0), [le, m]), fe = Ve(() => Math.min(X + h, m.length - 1), [X, m]), ce = () => x ? null : /* @__PURE__ */ P.jsx(
});
setScrollEndIdx(Math.min(...tempEndKey));
}, [scrollTop, offsets]);
const showStartIdx = useMemo(() => {
return Math.max(scrollStartIdx - paddingCount, 0);
}, [scrollStartIdx, dataSource]);
const showEndIdx = useMemo(() => {
return Math.min(scrollEndIdx + paddingCount, dataSource.length - 1);
}, [scrollEndIdx, dataSource]);
const loaderDom = () => {
if (end)
return null;
return /* @__PURE__ */ jsxRuntimeExports.jsx(
"div",
{
style: {
position: "absolute",
top: contentHeight + containerHeight,
justifyContent: "center",
display: "flex",
width: "100%"
},
children: loader
}
);
};
const endMessageDom = () => /* @__PURE__ */ jsxRuntimeExports.jsx(
"div",

@@ -711,3 +1102,3 @@ {

position: "absolute",
top: $ + T,
top: contentHeight + containerHeight,
justifyContent: "center",

@@ -717,107 +1108,127 @@ display: "flex",

},
children: O
children: endMessage
}
), de = () => /* @__PURE__ */ P.jsx(
"div",
{
style: {
position: "absolute",
top: $ + T,
justifyContent: "center",
display: "flex",
width: "100%"
},
children: L
}
);
gr(D, () => ({
useImperativeHandle(ref, () => ({
resetHeight: () => {
ee(Q());
setOffsets(genOffsets());
}
}));
const _e = Array(ge).fill(0).map((f, a) => {
const l = (Z - R * (g - 1)) / g, c = a % g, H = Math.floor(a / g) * (ue + v) + "px", V = c * l + c * R + "px";
return /* @__PURE__ */ P.jsx(
useEffect(() => {
updateFlag.current = false;
}, [dataSource.length]);
const sekeletonDom = Array(skeletonCount).fill(0).map((_, index) => {
const cardWidth = (clientWidhth - columnGap * (columnCount - 1)) / columnCount;
const columnIndex = index % columnCount;
const row = Math.floor(index / columnCount);
const nextTop = row * (averageItemHeight + rowGap) + "px";
const nextLeft = columnIndex * cardWidth + columnIndex * columnGap + "px";
return /* @__PURE__ */ jsxRuntimeExports.jsx(
"div",
{
className: "waterfall-item",
"data-list-index": a,
id: `waterfall-item-skeleton-${a}`,
"data-list-index": index,
id: `waterfall-item-skeleton-${index}`,
style: {
width: l + "px",
height: ue,
width: cardWidth + "px",
height: averageItemHeight,
position: "absolute",
top: H,
left: V
top: nextTop,
left: nextLeft
},
children: q
children: skeleton
},
a
index
);
});
if (m.length === 0)
return q ? /* @__PURE__ */ P.jsx(
if (dataSource.length === 0) {
if (!skeleton)
return null;
return /* @__PURE__ */ jsxRuntimeExports.jsx(
"div",
{
style: {
height: T,
height: containerHeight,
overflow: "auto",
position: "relative"
},
children: /* @__PURE__ */ P.jsx("div", { style: { height: $ }, children: _e })
children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { style: { height: contentHeight }, children: sekeletonDom })
}
) : null;
const Re = JSON.stringify(j) !== JSON.stringify(W), te = m.map((f, a) => {
var V, pe;
const l = (pe = (V = j.filter((A) => A.list[a] !== void 0)) == null ? void 0 : V[0]) == null ? void 0 : pe.offsetsColumnNum;
if (l === void 0)
);
}
const showList = JSON.stringify(offsets) !== JSON.stringify(defaultOffsets);
const virtualList = dataSource.map((itemData, index) => {
var _a, _b;
const minHeightColumn = (_b = (_a = offsets.filter((offset) => {
if (offset.list[index] !== void 0) {
return true;
} else {
return false;
}
})) == null ? void 0 : _a[0]) == null ? void 0 : _b.offsetsColumnNum;
if (minHeightColumn === void 0)
return null;
const c = (Z - R * (g - 1)) / g, ve = j[l].list[a] + "px", H = l * c + l * R + "px";
return /* @__PURE__ */ P.jsx(
const cardWidth = (clientWidhth - columnGap * (columnCount - 1)) / columnCount;
const nextTop = offsets[minHeightColumn].list[index] + "px";
const nextLeft = minHeightColumn * cardWidth + minHeightColumn * columnGap + "px";
return /* @__PURE__ */ jsxRuntimeExports.jsx(
"div",
{
className: "waterfall-item",
"data-list-index": a,
id: `waterfall-item-${a}`,
"data-list-index": index,
id: `waterfall-item-${index}`,
style: {
width: c + "px",
height: k(a),
width: cardWidth + "px",
height: getItemHeight(index),
position: "absolute",
top: ve,
left: H
top: nextTop,
left: nextLeft
},
ref: (A) => {
var ne;
if (!A || (ne = S.current) != null && ne[a])
ref: (ref2) => {
var _a2;
if (!ref2)
return;
const I = new IntersectionObserver((he) => {
he.forEach((U) => {
U.isIntersecting && (G == null || G(a), me && I.disconnect());
if ((_a2 = listItemRef.current) == null ? void 0 : _a2[index]) {
return;
}
const ob = new IntersectionObserver((entries) => {
entries.forEach((entry) => {
if (entry.isIntersecting) {
onItemRendered == null ? void 0 : onItemRendered(index);
appearOnce && ob.disconnect();
}
});
});
I.observe(A), S.current = {
...S.current,
[a]: I
ob.observe(ref2);
listItemRef.current = {
...listItemRef.current,
[index]: ob
};
},
children: /* @__PURE__ */ P.jsx(B, { index: a, data: f })
children: /* @__PURE__ */ jsxRuntimeExports.jsx(Item, { index, data: itemData })
},
a
index
);
}).splice(re, fe - re + 1);
return /* @__PURE__ */ P.jsx(
}).splice(showStartIdx, showEndIdx - showStartIdx + 1);
return /* @__PURE__ */ jsxRuntimeExports.jsx(
"div",
{
style: {
height: T,
height: containerHeight,
overflow: "auto",
position: "relative"
},
onScroll: (f) => {
ye(f.target.scrollTop), _.current || f.target.scrollTop / $ >= y && (C == null || C(), _.current = !0);
onScroll: (e) => {
setScrollTop(e.target.scrollTop);
if (!updateFlag.current) {
if (e.target.scrollTop / contentHeight >= scrollThreshold) {
next == null ? void 0 : next();
updateFlag.current = true;
}
}
},
children: /* @__PURE__ */ P.jsxs("div", { style: { height: $ }, children: [
Re && te,
F && ce(),
x && de()
children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: { height: contentHeight }, children: [
showList && virtualList,
showLoader && loaderDom(),
end && endMessageDom()
] })

@@ -827,8 +1238,4 @@ }

});
const Er = () => {
const [M, D] = se("asdf");
return /* @__PURE__ */ P.jsx("div", { children: M });
};
export {
Er as default
VariableSizeList as default
};

7

dist/List.d.ts

@@ -0,6 +1,8 @@

import React, { ReactNode } from "react";
type ListProps<T = any> = {
onScroll?: ((props: ListOnScrollProps) => any) | undefined;
onScroll?: ((e: any) => any) | undefined;
/** 需要渲染的Item数据 */
renderItem: ReactNode<{ index: number; data: any }>;
renderItem: (props: { index: number; data: any }) => ReactNode;

@@ -19,2 +21,3 @@ /** 总数据列表 */

/** 触发next勾子滚动比例 */
scrollThreshold?: number;

@@ -21,0 +24,0 @@

16

package.json
{
"name": "react-virtual-waterfall",
"version": "0.0.2",
"version": "0.0.3",
"type": "module",
"files": ["dist"],
"files": [
"dist"
],
"main": "./dist/index.umd.cjs",
"module": "./dist/index.js",
"typings": "./dist/index.d.ts",
"author": "aplanckfish",
"email":"327987913@qq.com",
"license": "MIT",
"scripts": {

@@ -15,6 +20,2 @@ "dev": "vite",

},
"dependencies": {
"@faker-js/faker": "^8.4.1",
"lodash": "^4.17.21"
},
"peerDependencies": {

@@ -25,2 +26,3 @@ "react": "^17.0.2",

"devDependencies": {
"@faker-js/faker": "^8.4.1",
"@types/lodash": "^4.17.7",

@@ -37,2 +39,4 @@ "@types/node": "^22.5.4",

"rollup-plugin-copy": "^3.5.0",
"rollup-plugin-terser": "^7.0.2",
"terser": "^5.32.0",
"typescript": "^5.0.2",

@@ -39,0 +43,0 @@ "vite": "^4.3.9",

dist/index.umd.cjs

Sorry, the diff of this file is not supported yet