You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3670 lines
128 KiB
3670 lines
128 KiB
"use strict";
|
|
(self["webpackChunk"] = self["webpackChunk"] || []).push([[62709],{
|
|
|
|
/***/ 62709:
|
|
/*!*********************************************************************!*\
|
|
!*** ./node_modules/@rc-component/trigger/es/index.js + 42 modules ***!
|
|
\*********************************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ trigger_es; }
|
|
});
|
|
|
|
// UNUSED EXPORTS: generateTrigger
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(45987);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
var react_namespaceObject = /*#__PURE__*/__webpack_require__.t(react, 2);
|
|
// EXTERNAL MODULE: ./node_modules/react-dom/index.js
|
|
var react_dom = __webpack_require__(73935);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/Dom/canUseDom.js
|
|
function canUseDom() {
|
|
return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/warning.js
|
|
/* eslint-disable no-console */
|
|
var warned = {};
|
|
function warning(valid, message) {
|
|
// Support uglify
|
|
if (false) {}
|
|
}
|
|
function note(valid, message) {
|
|
// Support uglify
|
|
if (false) {}
|
|
}
|
|
function resetWarned() {
|
|
warned = {};
|
|
}
|
|
function call(method, valid, message) {
|
|
if (!valid && !warned[message]) {
|
|
method(false, message);
|
|
warned[message] = true;
|
|
}
|
|
}
|
|
function warningOnce(valid, message) {
|
|
call(warning, valid, message);
|
|
}
|
|
function noteOnce(valid, message) {
|
|
call(note, valid, message);
|
|
}
|
|
/* harmony default export */ var es_warning = ((/* unused pure expression or super */ null && (warningOnce)));
|
|
/* eslint-enable */
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
// EXTERNAL MODULE: ./node_modules/react-is/index.js
|
|
var react_is = __webpack_require__(59864);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/hooks/useMemo.js
|
|
|
|
function useMemo(getValue, condition, shouldUpdate) {
|
|
var cacheRef = react.useRef({});
|
|
if (!('value' in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
|
|
cacheRef.current.value = getValue();
|
|
cacheRef.current.condition = condition;
|
|
}
|
|
return cacheRef.current.value;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/ref.js
|
|
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
|
|
|
|
function fillRef(ref, node) {
|
|
if (typeof ref === 'function') {
|
|
ref(node);
|
|
} else if ((0,esm_typeof/* default */.Z)(ref) === 'object' && ref && 'current' in ref) {
|
|
ref.current = node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge refs into one ref function to support ref passing.
|
|
*/
|
|
function composeRef() {
|
|
for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
refs[_key] = arguments[_key];
|
|
}
|
|
var refList = refs.filter(function (ref) {
|
|
return ref;
|
|
});
|
|
if (refList.length <= 1) {
|
|
return refList[0];
|
|
}
|
|
return function (node) {
|
|
refs.forEach(function (ref) {
|
|
fillRef(ref, node);
|
|
});
|
|
};
|
|
}
|
|
function useComposeRef() {
|
|
for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
refs[_key2] = arguments[_key2];
|
|
}
|
|
return useMemo(function () {
|
|
return composeRef.apply(void 0, refs);
|
|
}, refs, function (prev, next) {
|
|
return prev.length === next.length && prev.every(function (ref, i) {
|
|
return ref === next[i];
|
|
});
|
|
});
|
|
}
|
|
function supportRef(nodeOrComponent) {
|
|
var _type$prototype, _nodeOrComponent$prot;
|
|
var type = (0,react_is.isMemo)(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
|
|
|
|
// Function component node
|
|
if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
|
|
return false;
|
|
}
|
|
|
|
// Class component
|
|
if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/* eslint-enable */
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/es/Context.js
|
|
|
|
var OrderContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var Context = (OrderContext);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/toConsumableArray.js + 2 modules
|
|
var toConsumableArray = __webpack_require__(74902);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
|
|
|
|
|
|
/**
|
|
* Wrap `React.useLayoutEffect` which will not throw warning message in test env
|
|
*/
|
|
var useLayoutEffect = true && canUseDom() ? react.useLayoutEffect : react.useEffect;
|
|
/* harmony default export */ var hooks_useLayoutEffect = (useLayoutEffect);
|
|
var useLayoutEffect_useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {
|
|
var firstMountRef = React.useRef(true);
|
|
useLayoutEffect(function () {
|
|
if (!firstMountRef.current) {
|
|
return callback();
|
|
}
|
|
}, deps);
|
|
|
|
// We tell react that first mount has passed
|
|
useLayoutEffect(function () {
|
|
firstMountRef.current = false;
|
|
return function () {
|
|
firstMountRef.current = true;
|
|
};
|
|
}, []);
|
|
};
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/es/useDom.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var EMPTY_LIST = [];
|
|
|
|
/**
|
|
* Will add `div` to document. Nest call will keep order
|
|
* @param render Render DOM in document
|
|
*/
|
|
function useDom(render, debug) {
|
|
var _React$useState = react.useState(function () {
|
|
if (!canUseDom()) {
|
|
return null;
|
|
}
|
|
var defaultEle = document.createElement('div');
|
|
if (false) {}
|
|
return defaultEle;
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 1),
|
|
ele = _React$useState2[0];
|
|
|
|
// ========================== Order ==========================
|
|
var appendedRef = react.useRef(false);
|
|
var queueCreate = react.useContext(Context);
|
|
var _React$useState3 = react.useState(EMPTY_LIST),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
queue = _React$useState4[0],
|
|
setQueue = _React$useState4[1];
|
|
var mergedQueueCreate = queueCreate || (appendedRef.current ? undefined : function (appendFn) {
|
|
setQueue(function (origin) {
|
|
var newQueue = [appendFn].concat((0,toConsumableArray/* default */.Z)(origin));
|
|
return newQueue;
|
|
});
|
|
});
|
|
|
|
// =========================== DOM ===========================
|
|
function append() {
|
|
if (!ele.parentElement) {
|
|
document.body.appendChild(ele);
|
|
}
|
|
appendedRef.current = true;
|
|
}
|
|
function cleanup() {
|
|
var _ele$parentElement;
|
|
(_ele$parentElement = ele.parentElement) === null || _ele$parentElement === void 0 ? void 0 : _ele$parentElement.removeChild(ele);
|
|
appendedRef.current = false;
|
|
}
|
|
hooks_useLayoutEffect(function () {
|
|
if (render) {
|
|
if (queueCreate) {
|
|
queueCreate(append);
|
|
} else {
|
|
append();
|
|
}
|
|
} else {
|
|
cleanup();
|
|
}
|
|
return cleanup;
|
|
}, [render]);
|
|
hooks_useLayoutEffect(function () {
|
|
if (queue.length) {
|
|
queue.forEach(function (appendFn) {
|
|
return appendFn();
|
|
});
|
|
setQueue(EMPTY_LIST);
|
|
}
|
|
}, [queue]);
|
|
return [ele, mergedQueueCreate];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/Dom/contains.js
|
|
function contains(root, n) {
|
|
if (!root) {
|
|
return false;
|
|
}
|
|
|
|
// Use native if support
|
|
if (root.contains) {
|
|
return root.contains(n);
|
|
}
|
|
|
|
// `document.contains` not support with IE11
|
|
var node = n;
|
|
while (node) {
|
|
if (node === root) {
|
|
return true;
|
|
}
|
|
node = node.parentNode;
|
|
}
|
|
return false;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/Dom/dynamicCSS.js
|
|
|
|
|
|
var APPEND_ORDER = 'data-rc-order';
|
|
var MARK_KEY = "rc-util-key";
|
|
var containerCache = new Map();
|
|
function getMark() {
|
|
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
|
|
mark = _ref.mark;
|
|
if (mark) {
|
|
return mark.startsWith('data-') ? mark : "data-".concat(mark);
|
|
}
|
|
return MARK_KEY;
|
|
}
|
|
function getContainer(option) {
|
|
if (option.attachTo) {
|
|
return option.attachTo;
|
|
}
|
|
var head = document.querySelector('head');
|
|
return head || document.body;
|
|
}
|
|
function getOrder(prepend) {
|
|
if (prepend === 'queue') {
|
|
return 'prependQueue';
|
|
}
|
|
return prepend ? 'prepend' : 'append';
|
|
}
|
|
|
|
/**
|
|
* Find style which inject by rc-util
|
|
*/
|
|
function findStyles(container) {
|
|
return Array.from((containerCache.get(container) || container).children).filter(function (node) {
|
|
return node.tagName === 'STYLE';
|
|
});
|
|
}
|
|
function injectCSS(css) {
|
|
var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
if (!canUseDom()) {
|
|
return null;
|
|
}
|
|
var csp = option.csp,
|
|
prepend = option.prepend;
|
|
var styleNode = document.createElement('style');
|
|
styleNode.setAttribute(APPEND_ORDER, getOrder(prepend));
|
|
if (csp !== null && csp !== void 0 && csp.nonce) {
|
|
styleNode.nonce = csp === null || csp === void 0 ? void 0 : csp.nonce;
|
|
}
|
|
styleNode.innerHTML = css;
|
|
var container = getContainer(option);
|
|
var firstChild = container.firstChild;
|
|
if (prepend) {
|
|
// If is queue `prepend`, it will prepend first style and then append rest style
|
|
if (prepend === 'queue') {
|
|
var existStyle = findStyles(container).filter(function (node) {
|
|
return ['prepend', 'prependQueue'].includes(node.getAttribute(APPEND_ORDER));
|
|
});
|
|
if (existStyle.length) {
|
|
container.insertBefore(styleNode, existStyle[existStyle.length - 1].nextSibling);
|
|
return styleNode;
|
|
}
|
|
}
|
|
|
|
// Use `insertBefore` as `prepend`
|
|
container.insertBefore(styleNode, firstChild);
|
|
} else {
|
|
container.appendChild(styleNode);
|
|
}
|
|
return styleNode;
|
|
}
|
|
function findExistNode(key) {
|
|
var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var container = getContainer(option);
|
|
return findStyles(container).find(function (node) {
|
|
return node.getAttribute(getMark(option)) === key;
|
|
});
|
|
}
|
|
function removeCSS(key) {
|
|
var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
var existNode = findExistNode(key, option);
|
|
if (existNode) {
|
|
var container = getContainer(option);
|
|
container.removeChild(existNode);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* qiankun will inject `appendChild` to insert into other
|
|
*/
|
|
function syncRealContainer(container, option) {
|
|
var cachedRealContainer = containerCache.get(container);
|
|
|
|
// Find real container when not cached or cached container removed
|
|
if (!cachedRealContainer || !contains(document, cachedRealContainer)) {
|
|
var placeholderStyle = injectCSS('', option);
|
|
var parentNode = placeholderStyle.parentNode;
|
|
containerCache.set(container, parentNode);
|
|
container.removeChild(placeholderStyle);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* manually clear container cache to avoid global cache in unit testes
|
|
*/
|
|
function clearContainerCache() {
|
|
containerCache.clear();
|
|
}
|
|
function updateCSS(css, key) {
|
|
var option = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
|
|
var container = getContainer(option);
|
|
|
|
// Sync real parent
|
|
syncRealContainer(container, option);
|
|
var existNode = findExistNode(key, option);
|
|
if (existNode) {
|
|
var _option$csp, _option$csp2;
|
|
if ((_option$csp = option.csp) !== null && _option$csp !== void 0 && _option$csp.nonce && existNode.nonce !== ((_option$csp2 = option.csp) === null || _option$csp2 === void 0 ? void 0 : _option$csp2.nonce)) {
|
|
var _option$csp3;
|
|
existNode.nonce = (_option$csp3 = option.csp) === null || _option$csp3 === void 0 ? void 0 : _option$csp3.nonce;
|
|
}
|
|
if (existNode.innerHTML !== css) {
|
|
existNode.innerHTML = css;
|
|
}
|
|
return existNode;
|
|
}
|
|
var newNode = injectCSS(css, option);
|
|
newNode.setAttribute(getMark(option), key);
|
|
return newNode;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/node_modules/rc-util/es/getScrollBarSize.js
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
var cached;
|
|
function getScrollBarSize(fresh) {
|
|
if (typeof document === 'undefined') {
|
|
return 0;
|
|
}
|
|
if (fresh || cached === undefined) {
|
|
var inner = document.createElement('div');
|
|
inner.style.width = '100%';
|
|
inner.style.height = '200px';
|
|
var outer = document.createElement('div');
|
|
var outerStyle = outer.style;
|
|
outerStyle.position = 'absolute';
|
|
outerStyle.top = '0';
|
|
outerStyle.left = '0';
|
|
outerStyle.pointerEvents = 'none';
|
|
outerStyle.visibility = 'hidden';
|
|
outerStyle.width = '200px';
|
|
outerStyle.height = '150px';
|
|
outerStyle.overflow = 'hidden';
|
|
outer.appendChild(inner);
|
|
document.body.appendChild(outer);
|
|
var widthContained = inner.offsetWidth;
|
|
outer.style.overflow = 'scroll';
|
|
var widthScroll = inner.offsetWidth;
|
|
if (widthContained === widthScroll) {
|
|
widthScroll = outer.clientWidth;
|
|
}
|
|
document.body.removeChild(outer);
|
|
cached = widthContained - widthScroll;
|
|
}
|
|
return cached;
|
|
}
|
|
function ensureSize(str) {
|
|
var match = str.match(/^(.*)px$/);
|
|
var value = Number(match === null || match === void 0 ? void 0 : match[1]);
|
|
return Number.isNaN(value) ? getScrollBarSize() : value;
|
|
}
|
|
function getTargetScrollBarSize(target) {
|
|
if (typeof document === 'undefined' || !target || !(target instanceof Element)) {
|
|
return {
|
|
width: 0,
|
|
height: 0
|
|
};
|
|
}
|
|
var _getComputedStyle = getComputedStyle(target, '::-webkit-scrollbar'),
|
|
width = _getComputedStyle.width,
|
|
height = _getComputedStyle.height;
|
|
return {
|
|
width: ensureSize(width),
|
|
height: ensureSize(height)
|
|
};
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/es/util.js
|
|
/**
|
|
* Test usage export. Do not use in your production
|
|
*/
|
|
function isBodyOverflowing() {
|
|
return document.body.scrollHeight > (window.innerHeight || document.documentElement.clientHeight) && window.innerWidth > document.body.offsetWidth;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/es/useScrollLocker.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var UNIQUE_ID = "rc-util-locker-".concat(Date.now());
|
|
var uuid = 0;
|
|
function useScrollLocker(lock) {
|
|
var mergedLock = !!lock;
|
|
var _React$useState = react.useState(function () {
|
|
uuid += 1;
|
|
return "".concat(UNIQUE_ID, "_").concat(uuid);
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 1),
|
|
id = _React$useState2[0];
|
|
hooks_useLayoutEffect(function () {
|
|
if (mergedLock) {
|
|
var scrollbarSize = getTargetScrollBarSize(document.body).width;
|
|
var isOverflow = isBodyOverflowing();
|
|
updateCSS("\nhtml body {\n overflow-y: hidden;\n ".concat(isOverflow ? "width: calc(100% - ".concat(scrollbarSize, "px);") : '', "\n}"), id);
|
|
} else {
|
|
removeCSS(id);
|
|
}
|
|
return function () {
|
|
removeCSS(id);
|
|
};
|
|
}, [mergedLock, id]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/es/mock.js
|
|
var inline = false;
|
|
function inlineMock(nextInline) {
|
|
if (typeof nextInline === 'boolean') {
|
|
inline = nextInline;
|
|
}
|
|
return inline;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/es/Portal.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var getPortalContainer = function getPortalContainer(getContainer) {
|
|
if (getContainer === false) {
|
|
return false;
|
|
}
|
|
if (!canUseDom() || !getContainer) {
|
|
return null;
|
|
}
|
|
if (typeof getContainer === 'string') {
|
|
return document.querySelector(getContainer);
|
|
}
|
|
if (typeof getContainer === 'function') {
|
|
return getContainer();
|
|
}
|
|
return getContainer;
|
|
};
|
|
var Portal = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var open = props.open,
|
|
autoLock = props.autoLock,
|
|
getContainer = props.getContainer,
|
|
debug = props.debug,
|
|
_props$autoDestroy = props.autoDestroy,
|
|
autoDestroy = _props$autoDestroy === void 0 ? true : _props$autoDestroy,
|
|
children = props.children;
|
|
var _React$useState = react.useState(open),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
shouldRender = _React$useState2[0],
|
|
setShouldRender = _React$useState2[1];
|
|
var mergedRender = shouldRender || open;
|
|
|
|
// ========================= Warning =========================
|
|
if (false) {}
|
|
|
|
// ====================== Should Render ======================
|
|
react.useEffect(function () {
|
|
if (autoDestroy || open) {
|
|
setShouldRender(open);
|
|
}
|
|
}, [open, autoDestroy]);
|
|
|
|
// ======================== Container ========================
|
|
var _React$useState3 = react.useState(function () {
|
|
return getPortalContainer(getContainer);
|
|
}),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
innerContainer = _React$useState4[0],
|
|
setInnerContainer = _React$useState4[1];
|
|
react.useEffect(function () {
|
|
var customizeContainer = getPortalContainer(getContainer);
|
|
|
|
// Tell component that we check this in effect which is safe to be `null`
|
|
setInnerContainer(customizeContainer !== null && customizeContainer !== void 0 ? customizeContainer : null);
|
|
});
|
|
var _useDom = useDom(mergedRender && !innerContainer, debug),
|
|
_useDom2 = (0,slicedToArray/* default */.Z)(_useDom, 2),
|
|
defaultContainer = _useDom2[0],
|
|
queueCreate = _useDom2[1];
|
|
var mergedContainer = innerContainer !== null && innerContainer !== void 0 ? innerContainer : defaultContainer;
|
|
|
|
// ========================= Locker ==========================
|
|
useScrollLocker(autoLock && open && canUseDom() && (mergedContainer === defaultContainer || mergedContainer === document.body));
|
|
|
|
// =========================== Ref ===========================
|
|
var childRef = null;
|
|
if (children && supportRef(children) && ref) {
|
|
var _ref = children;
|
|
childRef = _ref.ref;
|
|
}
|
|
var mergedRef = useComposeRef(childRef, ref);
|
|
|
|
// ========================= Render ==========================
|
|
// Do not render when nothing need render
|
|
// When innerContainer is `undefined`, it may not ready since user use ref in the same render
|
|
if (!mergedRender || !canUseDom() || innerContainer === undefined) {
|
|
return null;
|
|
}
|
|
|
|
// Render inline
|
|
var renderInline = mergedContainer === false || inlineMock();
|
|
var reffedChildren = children;
|
|
if (ref) {
|
|
reffedChildren = /*#__PURE__*/react.cloneElement(children, {
|
|
ref: mergedRef
|
|
});
|
|
}
|
|
return /*#__PURE__*/react.createElement(Context.Provider, {
|
|
value: queueCreate
|
|
}, renderInline ? reffedChildren : /*#__PURE__*/(0,react_dom.createPortal)(reffedChildren, mergedContainer));
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var es_Portal = (Portal);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/@rc-component/portal/es/index.js
|
|
|
|
|
|
|
|
/* harmony default export */ var es = (es_Portal);
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
var classnames = __webpack_require__(94184);
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
// EXTERNAL MODULE: ./node_modules/rc-resize-observer/es/index.js + 4 modules
|
|
var rc_resize_observer_es = __webpack_require__(48555);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/Dom/findDOMNode.js
|
|
|
|
|
|
function isDOM(node) {
|
|
// https://developer.mozilla.org/en-US/docs/Web/API/Element
|
|
// Since XULElement is also subclass of Element, we only need HTMLElement and SVGElement
|
|
return node instanceof HTMLElement || node instanceof SVGElement;
|
|
}
|
|
|
|
/**
|
|
* Return if a node is a DOM node. Else will return by `findDOMNode`
|
|
*/
|
|
function findDOMNode(node) {
|
|
if (isDOM(node)) {
|
|
return node;
|
|
}
|
|
if (node instanceof React.Component) {
|
|
return ReactDOM.findDOMNode(node);
|
|
}
|
|
return null;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/Dom/shadow.js
|
|
function getRoot(ele) {
|
|
var _ele$getRootNode;
|
|
return ele === null || ele === void 0 ? void 0 : (_ele$getRootNode = ele.getRootNode) === null || _ele$getRootNode === void 0 ? void 0 : _ele$getRootNode.call(ele);
|
|
}
|
|
|
|
/**
|
|
* Check if is in shadowRoot
|
|
*/
|
|
function inShadow(ele) {
|
|
return getRoot(ele) !== (ele === null || ele === void 0 ? void 0 : ele.ownerDocument);
|
|
}
|
|
|
|
/**
|
|
* Return shadowRoot if possible
|
|
*/
|
|
function getShadowRoot(ele) {
|
|
return inShadow(ele) ? getRoot(ele) : null;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/hooks/useEvent.js
|
|
|
|
function useEvent_useEvent(callback) {
|
|
var fnRef = react.useRef();
|
|
fnRef.current = callback;
|
|
var memoFn = react.useCallback(function () {
|
|
var _fnRef$current;
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
return (_fnRef$current = fnRef.current) === null || _fnRef$current === void 0 ? void 0 : _fnRef$current.call.apply(_fnRef$current, [fnRef].concat(args));
|
|
}, []);
|
|
return memoFn;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/hooks/useId.js
|
|
|
|
|
|
|
|
function getUseId() {
|
|
// We need fully clone React function here to avoid webpack warning React 17 do not export `useId`
|
|
var fullClone = (0,objectSpread2/* default */.Z)({}, react_namespaceObject);
|
|
return fullClone.useId;
|
|
}
|
|
var useId_uuid = 0;
|
|
|
|
/** @private Note only worked in develop env. Not work in production. */
|
|
function resetUuid() {
|
|
if (false) {}
|
|
}
|
|
function useId(id) {
|
|
// Inner id for accessibility usage. Only work in client side
|
|
var _React$useState = react.useState('ssr-id'),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
innerId = _React$useState2[0],
|
|
setInnerId = _React$useState2[1];
|
|
var useOriginId = getUseId();
|
|
var reactNativeId = useOriginId === null || useOriginId === void 0 ? void 0 : useOriginId();
|
|
react.useEffect(function () {
|
|
if (!useOriginId) {
|
|
var nextId = useId_uuid;
|
|
useId_uuid += 1;
|
|
setInnerId("rc_unique_".concat(nextId));
|
|
}
|
|
}, []);
|
|
|
|
// Developer passed id is single source of truth
|
|
if (id) {
|
|
return id;
|
|
}
|
|
|
|
// Test env always return mock id
|
|
if (false) {}
|
|
|
|
// Return react native id or inner id
|
|
return reactNativeId || innerId;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/Dom/canUseDom.js
|
|
function canUseDom_canUseDom() {
|
|
return !!(typeof window !== 'undefined' && window.document && window.document.createElement);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/hooks/useLayoutEffect.js
|
|
|
|
|
|
|
|
/**
|
|
* Wrap `React.useLayoutEffect` which will not throw warning message in test env
|
|
*/
|
|
var useInternalLayoutEffect = true && canUseDom_canUseDom() ? react.useLayoutEffect : react.useEffect;
|
|
var useLayoutEffect_useLayoutEffect = function useLayoutEffect(callback, deps) {
|
|
var firstMountRef = react.useRef(true);
|
|
useInternalLayoutEffect(function () {
|
|
return callback(firstMountRef.current);
|
|
}, deps);
|
|
|
|
// We tell react that first mount has passed
|
|
useInternalLayoutEffect(function () {
|
|
firstMountRef.current = false;
|
|
return function () {
|
|
firstMountRef.current = true;
|
|
};
|
|
}, []);
|
|
};
|
|
var hooks_useLayoutEffect_useLayoutUpdateEffect = function useLayoutUpdateEffect(callback, deps) {
|
|
useLayoutEffect_useLayoutEffect(function (firstMount) {
|
|
if (!firstMount) {
|
|
return callback();
|
|
}
|
|
}, deps);
|
|
};
|
|
/* harmony default export */ var es_hooks_useLayoutEffect = (useLayoutEffect_useLayoutEffect);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/isMobile.js
|
|
/* harmony default export */ var isMobile = (function () {
|
|
if (typeof navigator === 'undefined' || typeof window === 'undefined') {
|
|
return false;
|
|
}
|
|
var agent = navigator.userAgent || navigator.vendor || window.opera;
|
|
return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(agent) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw-(n|u)|c55\/|capi|ccwa|cdm-|cell|chtm|cldc|cmd-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc-s|devi|dica|dmob|do(c|p)o|ds(12|-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(-|_)|g1 u|g560|gene|gf-5|g-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd-(m|p|t)|hei-|hi(pt|ta)|hp( i|ip)|hs-c|ht(c(-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i-(20|go|ma)|i230|iac( |-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|-[a-w])|libw|lynx|m1-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|-([1-8]|c))|phil|pire|pl(ay|uc)|pn-2|po(ck|rt|se)|prox|psio|pt-g|qa-a|qc(07|12|21|32|60|-[2-7]|i-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h-|oo|p-)|sdk\/|se(c(-|0|1)|47|mc|nd|ri)|sgh-|shar|sie(-|m)|sk-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h-|v-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl-|tdg-|tel(i|m)|tim-|t-mo|to(pl|sh)|ts(70|m-|m3|m5)|tx-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas-|your|zeto|zte-/i.test(agent === null || agent === void 0 ? void 0 : agent.substr(0, 4));
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/context.js
|
|
|
|
var TriggerContext = /*#__PURE__*/react.createContext(null);
|
|
/* harmony default export */ var es_context = (TriggerContext);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/hooks/useAction.js
|
|
|
|
function toArray(val) {
|
|
return val ? Array.isArray(val) ? val : [val] : [];
|
|
}
|
|
function useAction(mobile, action, showAction, hideAction) {
|
|
return react.useMemo(function () {
|
|
var mergedShowAction = toArray(showAction !== null && showAction !== void 0 ? showAction : action);
|
|
var mergedHideAction = toArray(hideAction !== null && hideAction !== void 0 ? hideAction : action);
|
|
var showActionSet = new Set(mergedShowAction);
|
|
var hideActionSet = new Set(mergedHideAction);
|
|
if (mobile) {
|
|
if (showActionSet.has('hover')) {
|
|
showActionSet.delete('hover');
|
|
showActionSet.add('click');
|
|
}
|
|
if (hideActionSet.has('hover')) {
|
|
hideActionSet.delete('hover');
|
|
hideActionSet.add('click');
|
|
}
|
|
}
|
|
return [showActionSet, hideActionSet];
|
|
}, [mobile, action, showAction, hideAction]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/Dom/isVisible.js
|
|
/* harmony default export */ var isVisible = (function (element) {
|
|
if (!element) {
|
|
return false;
|
|
}
|
|
if (element instanceof Element) {
|
|
if (element.offsetParent) {
|
|
return true;
|
|
}
|
|
if (element.getBBox) {
|
|
var _getBBox = element.getBBox(),
|
|
width = _getBBox.width,
|
|
height = _getBBox.height;
|
|
if (width || height) {
|
|
return true;
|
|
}
|
|
}
|
|
if (element.getBoundingClientRect) {
|
|
var _element$getBoundingC = element.getBoundingClientRect(),
|
|
_width = _element$getBoundingC.width,
|
|
_height = _element$getBoundingC.height;
|
|
if (_width || _height) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/util.js
|
|
|
|
function isPointsEq() {
|
|
var a1 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
var a2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
var isAlignPoint = arguments.length > 2 ? arguments[2] : undefined;
|
|
if (isAlignPoint) {
|
|
return a1[0] === a2[0];
|
|
}
|
|
return a1[0] === a2[0] && a1[1] === a2[1];
|
|
}
|
|
function getAlignPopupClassName(builtinPlacements, prefixCls, align, isAlignPoint) {
|
|
var points = align.points;
|
|
var placements = Object.keys(builtinPlacements);
|
|
for (var i = 0; i < placements.length; i += 1) {
|
|
var _builtinPlacements$pl;
|
|
var placement = placements[i];
|
|
if (isPointsEq((_builtinPlacements$pl = builtinPlacements[placement]) === null || _builtinPlacements$pl === void 0 ? void 0 : _builtinPlacements$pl.points, points, isAlignPoint)) {
|
|
return "".concat(prefixCls, "-placement-").concat(placement);
|
|
}
|
|
}
|
|
return '';
|
|
}
|
|
|
|
/** @deprecated We should not use this if we can refactor all deps */
|
|
function getMotion(prefixCls, motion, animation, transitionName) {
|
|
if (motion) {
|
|
return motion;
|
|
}
|
|
if (animation) {
|
|
return {
|
|
motionName: "".concat(prefixCls, "-").concat(animation)
|
|
};
|
|
}
|
|
if (transitionName) {
|
|
return {
|
|
motionName: transitionName
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
function getWin(ele) {
|
|
return ele.ownerDocument.defaultView;
|
|
}
|
|
|
|
/**
|
|
* Get all the scrollable parent elements of the element
|
|
* @param ele The element to be detected
|
|
* @param areaOnly Only return the parent which will cut visible area
|
|
*/
|
|
function collectScroller(ele) {
|
|
var scrollerList = [];
|
|
var current = ele === null || ele === void 0 ? void 0 : ele.parentElement;
|
|
var scrollStyle = ['hidden', 'scroll', 'clip', 'auto'];
|
|
while (current) {
|
|
var _getWin$getComputedSt = getWin(current).getComputedStyle(current),
|
|
overflowX = _getWin$getComputedSt.overflowX,
|
|
overflowY = _getWin$getComputedSt.overflowY,
|
|
overflow = _getWin$getComputedSt.overflow;
|
|
if ([overflowX, overflowY, overflow].some(function (o) {
|
|
return scrollStyle.includes(o);
|
|
})) {
|
|
scrollerList.push(current);
|
|
}
|
|
current = current.parentElement;
|
|
}
|
|
return scrollerList;
|
|
}
|
|
function toNum(num) {
|
|
var defaultValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
return Number.isNaN(num) ? defaultValue : num;
|
|
}
|
|
function getPxValue(val) {
|
|
return toNum(parseFloat(val), 0);
|
|
}
|
|
/**
|
|
*
|
|
*
|
|
* **************************************
|
|
* * Border *
|
|
* * ************************** *
|
|
* * * * * *
|
|
* * B * * S * B *
|
|
* * o * * c * o *
|
|
* * r * Content * r * r *
|
|
* * d * * o * d *
|
|
* * e * * l * e *
|
|
* * r ******************** l * r *
|
|
* * * Scroll * *
|
|
* * ************************** *
|
|
* * Border *
|
|
* **************************************
|
|
*
|
|
*/
|
|
/**
|
|
* Get visible area of element
|
|
*/
|
|
function getVisibleArea(initArea, scrollerList) {
|
|
var visibleArea = (0,objectSpread2/* default */.Z)({}, initArea);
|
|
(scrollerList || []).forEach(function (ele) {
|
|
if (ele instanceof HTMLBodyElement) {
|
|
return;
|
|
}
|
|
|
|
// Skip if static position which will not affect visible area
|
|
var _getWin$getComputedSt2 = getWin(ele).getComputedStyle(ele),
|
|
overflow = _getWin$getComputedSt2.overflow,
|
|
overflowClipMargin = _getWin$getComputedSt2.overflowClipMargin,
|
|
borderTopWidth = _getWin$getComputedSt2.borderTopWidth,
|
|
borderBottomWidth = _getWin$getComputedSt2.borderBottomWidth,
|
|
borderLeftWidth = _getWin$getComputedSt2.borderLeftWidth,
|
|
borderRightWidth = _getWin$getComputedSt2.borderRightWidth;
|
|
var eleRect = ele.getBoundingClientRect();
|
|
var eleOutHeight = ele.offsetHeight,
|
|
eleInnerHeight = ele.clientHeight,
|
|
eleOutWidth = ele.offsetWidth,
|
|
eleInnerWidth = ele.clientWidth;
|
|
var borderTopNum = getPxValue(borderTopWidth);
|
|
var borderBottomNum = getPxValue(borderBottomWidth);
|
|
var borderLeftNum = getPxValue(borderLeftWidth);
|
|
var borderRightNum = getPxValue(borderRightWidth);
|
|
var scaleX = toNum(Math.round(eleRect.width / eleOutWidth * 1000) / 1000);
|
|
var scaleY = toNum(Math.round(eleRect.height / eleOutHeight * 1000) / 1000);
|
|
|
|
// Original visible area
|
|
var eleScrollWidth = (eleOutWidth - eleInnerWidth - borderLeftNum - borderRightNum) * scaleX;
|
|
var eleScrollHeight = (eleOutHeight - eleInnerHeight - borderTopNum - borderBottomNum) * scaleY;
|
|
|
|
// Cut border size
|
|
var scaledBorderTopWidth = borderTopNum * scaleY;
|
|
var scaledBorderBottomWidth = borderBottomNum * scaleY;
|
|
var scaledBorderLeftWidth = borderLeftNum * scaleX;
|
|
var scaledBorderRightWidth = borderRightNum * scaleX;
|
|
|
|
// Clip margin
|
|
var clipMarginWidth = 0;
|
|
var clipMarginHeight = 0;
|
|
if (overflow === 'clip') {
|
|
var clipNum = getPxValue(overflowClipMargin);
|
|
clipMarginWidth = clipNum * scaleX;
|
|
clipMarginHeight = clipNum * scaleY;
|
|
}
|
|
|
|
// Region
|
|
var eleLeft = eleRect.x + scaledBorderLeftWidth - clipMarginWidth;
|
|
var eleTop = eleRect.y + scaledBorderTopWidth - clipMarginHeight;
|
|
var eleRight = eleLeft + eleRect.width + 2 * clipMarginWidth - scaledBorderLeftWidth - scaledBorderRightWidth - eleScrollWidth;
|
|
var eleBottom = eleTop + eleRect.height + 2 * clipMarginHeight - scaledBorderTopWidth - scaledBorderBottomWidth - eleScrollHeight;
|
|
visibleArea.left = Math.max(visibleArea.left, eleLeft);
|
|
visibleArea.top = Math.max(visibleArea.top, eleTop);
|
|
visibleArea.right = Math.min(visibleArea.right, eleRight);
|
|
visibleArea.bottom = Math.min(visibleArea.bottom, eleBottom);
|
|
});
|
|
return visibleArea;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/hooks/useAlign.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function getUnitOffset(size) {
|
|
var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
var offsetStr = "".concat(offset);
|
|
var cells = offsetStr.match(/^(.*)\%$/);
|
|
if (cells) {
|
|
return size * (parseFloat(cells[1]) / 100);
|
|
}
|
|
return parseFloat(offsetStr);
|
|
}
|
|
function getNumberOffset(rect, offset) {
|
|
var _ref = offset || [],
|
|
_ref2 = (0,slicedToArray/* default */.Z)(_ref, 2),
|
|
offsetX = _ref2[0],
|
|
offsetY = _ref2[1];
|
|
return [getUnitOffset(rect.width, offsetX), getUnitOffset(rect.height, offsetY)];
|
|
}
|
|
function splitPoints() {
|
|
var points = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : '';
|
|
return [points[0], points[1]];
|
|
}
|
|
function getAlignPoint(rect, points) {
|
|
var topBottom = points[0];
|
|
var leftRight = points[1];
|
|
var x;
|
|
var y;
|
|
|
|
// Top & Bottom
|
|
if (topBottom === 't') {
|
|
y = rect.y;
|
|
} else if (topBottom === 'b') {
|
|
y = rect.y + rect.height;
|
|
} else {
|
|
y = rect.y + rect.height / 2;
|
|
}
|
|
|
|
// Left & Right
|
|
if (leftRight === 'l') {
|
|
x = rect.x;
|
|
} else if (leftRight === 'r') {
|
|
x = rect.x + rect.width;
|
|
} else {
|
|
x = rect.x + rect.width / 2;
|
|
}
|
|
return {
|
|
x: x,
|
|
y: y
|
|
};
|
|
}
|
|
function reversePoints(points, index) {
|
|
var reverseMap = {
|
|
t: 'b',
|
|
b: 't',
|
|
l: 'r',
|
|
r: 'l'
|
|
};
|
|
return points.map(function (point, i) {
|
|
if (i === index) {
|
|
return reverseMap[point] || 'c';
|
|
}
|
|
return point;
|
|
}).join('');
|
|
}
|
|
function useAlign(open, popupEle, target, placement, builtinPlacements, popupAlign, onPopupAlign) {
|
|
var _React$useState = react.useState({
|
|
ready: false,
|
|
offsetX: 0,
|
|
offsetY: 0,
|
|
offsetR: 0,
|
|
offsetB: 0,
|
|
arrowX: 0,
|
|
arrowY: 0,
|
|
scaleX: 1,
|
|
scaleY: 1,
|
|
align: builtinPlacements[placement] || {}
|
|
}),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
offsetInfo = _React$useState2[0],
|
|
setOffsetInfo = _React$useState2[1];
|
|
var alignCountRef = react.useRef(0);
|
|
var scrollerList = react.useMemo(function () {
|
|
if (!popupEle) {
|
|
return [];
|
|
}
|
|
return collectScroller(popupEle);
|
|
}, [popupEle]);
|
|
|
|
// ========================= Flip ==========================
|
|
// We will memo flip info.
|
|
// If size change to make flip, it will memo the flip info and use it in next align.
|
|
var prevFlipRef = react.useRef({});
|
|
var resetFlipCache = function resetFlipCache() {
|
|
prevFlipRef.current = {};
|
|
};
|
|
if (!open) {
|
|
resetFlipCache();
|
|
}
|
|
|
|
// ========================= Align =========================
|
|
var onAlign = useEvent_useEvent(function () {
|
|
if (popupEle && target && open) {
|
|
var popupElement = popupEle;
|
|
var originLeft = popupElement.style.left;
|
|
var originTop = popupElement.style.top;
|
|
var originRight = popupElement.style.right;
|
|
var originBottom = popupElement.style.bottom;
|
|
var doc = popupElement.ownerDocument;
|
|
var win = getWin(popupElement);
|
|
|
|
// Placement
|
|
var placementInfo = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, builtinPlacements[placement]), popupAlign);
|
|
|
|
// Reset first
|
|
popupElement.style.left = '0';
|
|
popupElement.style.top = '0';
|
|
popupElement.style.right = 'auto';
|
|
popupElement.style.bottom = 'auto';
|
|
|
|
// Calculate align style, we should consider `transform` case
|
|
var targetRect;
|
|
if (Array.isArray(target)) {
|
|
targetRect = {
|
|
x: target[0],
|
|
y: target[1],
|
|
width: 0,
|
|
height: 0
|
|
};
|
|
} else {
|
|
var rect = target.getBoundingClientRect();
|
|
targetRect = {
|
|
x: rect.x,
|
|
y: rect.y,
|
|
width: rect.width,
|
|
height: rect.height
|
|
};
|
|
}
|
|
var popupRect = popupElement.getBoundingClientRect();
|
|
var _win$getComputedStyle = win.getComputedStyle(popupElement),
|
|
width = _win$getComputedStyle.width,
|
|
height = _win$getComputedStyle.height;
|
|
var _doc$documentElement = doc.documentElement,
|
|
clientWidth = _doc$documentElement.clientWidth,
|
|
clientHeight = _doc$documentElement.clientHeight,
|
|
scrollWidth = _doc$documentElement.scrollWidth,
|
|
scrollHeight = _doc$documentElement.scrollHeight,
|
|
scrollTop = _doc$documentElement.scrollTop,
|
|
scrollLeft = _doc$documentElement.scrollLeft;
|
|
var popupHeight = popupRect.height;
|
|
var popupWidth = popupRect.width;
|
|
var targetHeight = targetRect.height;
|
|
var targetWidth = targetRect.width;
|
|
|
|
// Get bounding of visible area
|
|
var visibleRegion = {
|
|
left: 0,
|
|
top: 0,
|
|
right: clientWidth,
|
|
bottom: clientHeight
|
|
};
|
|
var scrollRegion = {
|
|
left: -scrollLeft,
|
|
top: -scrollTop,
|
|
right: scrollWidth - scrollLeft,
|
|
bottom: scrollHeight - scrollTop
|
|
};
|
|
var htmlRegion = placementInfo.htmlRegion;
|
|
var VISIBLE = 'visible';
|
|
var VISIBLE_FIRST = 'visibleFirst';
|
|
if (htmlRegion !== 'scroll' && htmlRegion !== VISIBLE_FIRST) {
|
|
htmlRegion = VISIBLE;
|
|
}
|
|
var isVisibleFirst = htmlRegion === VISIBLE_FIRST;
|
|
var scrollRegionArea = getVisibleArea(scrollRegion, scrollerList);
|
|
var visibleRegionArea = getVisibleArea(visibleRegion, scrollerList);
|
|
var visibleArea = htmlRegion === VISIBLE ? visibleRegionArea : scrollRegionArea;
|
|
|
|
// When set to `visibleFirst`,
|
|
// the check `adjust` logic will use `visibleRegion` for check first.
|
|
var adjustCheckVisibleArea = isVisibleFirst ? visibleRegionArea : visibleArea;
|
|
|
|
// Record right & bottom align data
|
|
popupElement.style.left = 'auto';
|
|
popupElement.style.top = 'auto';
|
|
popupElement.style.right = '0';
|
|
popupElement.style.bottom = '0';
|
|
var popupMirrorRect = popupElement.getBoundingClientRect();
|
|
|
|
// Reset back
|
|
popupElement.style.left = originLeft;
|
|
popupElement.style.top = originTop;
|
|
popupElement.style.right = originRight;
|
|
popupElement.style.bottom = originBottom;
|
|
|
|
// Calculate scale
|
|
var _scaleX = toNum(Math.round(popupWidth / parseFloat(width) * 1000) / 1000);
|
|
var _scaleY = toNum(Math.round(popupHeight / parseFloat(height) * 1000) / 1000);
|
|
|
|
// No need to align since it's not visible in view
|
|
if (_scaleX === 0 || _scaleY === 0 || isDOM(target) && !isVisible(target)) {
|
|
return;
|
|
}
|
|
|
|
// Offset
|
|
var offset = placementInfo.offset,
|
|
targetOffset = placementInfo.targetOffset;
|
|
var _getNumberOffset = getNumberOffset(popupRect, offset),
|
|
_getNumberOffset2 = (0,slicedToArray/* default */.Z)(_getNumberOffset, 2),
|
|
popupOffsetX = _getNumberOffset2[0],
|
|
popupOffsetY = _getNumberOffset2[1];
|
|
var _getNumberOffset3 = getNumberOffset(targetRect, targetOffset),
|
|
_getNumberOffset4 = (0,slicedToArray/* default */.Z)(_getNumberOffset3, 2),
|
|
targetOffsetX = _getNumberOffset4[0],
|
|
targetOffsetY = _getNumberOffset4[1];
|
|
targetRect.x -= targetOffsetX;
|
|
targetRect.y -= targetOffsetY;
|
|
|
|
// Points
|
|
var _ref3 = placementInfo.points || [],
|
|
_ref4 = (0,slicedToArray/* default */.Z)(_ref3, 2),
|
|
popupPoint = _ref4[0],
|
|
targetPoint = _ref4[1];
|
|
var targetPoints = splitPoints(targetPoint);
|
|
var popupPoints = splitPoints(popupPoint);
|
|
var targetAlignPoint = getAlignPoint(targetRect, targetPoints);
|
|
var popupAlignPoint = getAlignPoint(popupRect, popupPoints);
|
|
|
|
// Real align info may not same as origin one
|
|
var nextAlignInfo = (0,objectSpread2/* default */.Z)({}, placementInfo);
|
|
|
|
// Next Offset
|
|
var nextOffsetX = targetAlignPoint.x - popupAlignPoint.x + popupOffsetX;
|
|
var nextOffsetY = targetAlignPoint.y - popupAlignPoint.y + popupOffsetY;
|
|
|
|
// ============== Intersection ===============
|
|
// Get area by position. Used for check if flip area is better
|
|
function getIntersectionVisibleArea(offsetX, offsetY) {
|
|
var area = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : visibleArea;
|
|
var l = popupRect.x + offsetX;
|
|
var t = popupRect.y + offsetY;
|
|
var r = l + popupWidth;
|
|
var b = t + popupHeight;
|
|
var visibleL = Math.max(l, area.left);
|
|
var visibleT = Math.max(t, area.top);
|
|
var visibleR = Math.min(r, area.right);
|
|
var visibleB = Math.min(b, area.bottom);
|
|
return Math.max(0, (visibleR - visibleL) * (visibleB - visibleT));
|
|
}
|
|
var originIntersectionVisibleArea = getIntersectionVisibleArea(nextOffsetX, nextOffsetY);
|
|
|
|
// As `visibleFirst`, we prepare this for check
|
|
var originIntersectionRecommendArea = getIntersectionVisibleArea(nextOffsetX, nextOffsetY, visibleRegionArea);
|
|
|
|
// ========================== Overflow ===========================
|
|
var targetAlignPointTL = getAlignPoint(targetRect, ['t', 'l']);
|
|
var popupAlignPointTL = getAlignPoint(popupRect, ['t', 'l']);
|
|
var targetAlignPointBR = getAlignPoint(targetRect, ['b', 'r']);
|
|
var popupAlignPointBR = getAlignPoint(popupRect, ['b', 'r']);
|
|
var overflow = placementInfo.overflow || {};
|
|
var adjustX = overflow.adjustX,
|
|
adjustY = overflow.adjustY,
|
|
shiftX = overflow.shiftX,
|
|
shiftY = overflow.shiftY;
|
|
var supportAdjust = function supportAdjust(val) {
|
|
if (typeof val === 'boolean') {
|
|
return val;
|
|
}
|
|
return val >= 0;
|
|
};
|
|
|
|
// Prepare position
|
|
var nextPopupY;
|
|
var nextPopupBottom;
|
|
var nextPopupX;
|
|
var nextPopupRight;
|
|
function syncNextPopupPosition() {
|
|
nextPopupY = popupRect.y + nextOffsetY;
|
|
nextPopupBottom = nextPopupY + popupHeight;
|
|
nextPopupX = popupRect.x + nextOffsetX;
|
|
nextPopupRight = nextPopupX + popupWidth;
|
|
}
|
|
syncNextPopupPosition();
|
|
|
|
// >>>>>>>>>> Top & Bottom
|
|
var needAdjustY = supportAdjust(adjustY);
|
|
var sameTB = popupPoints[0] === targetPoints[0];
|
|
|
|
// Bottom to Top
|
|
if (needAdjustY && popupPoints[0] === 't' && (nextPopupBottom > adjustCheckVisibleArea.bottom || prevFlipRef.current.bt)) {
|
|
var tmpNextOffsetY = nextOffsetY;
|
|
if (sameTB) {
|
|
tmpNextOffsetY -= popupHeight - targetHeight;
|
|
} else {
|
|
tmpNextOffsetY = targetAlignPointTL.y - popupAlignPointBR.y - popupOffsetY;
|
|
}
|
|
var newVisibleArea = getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY);
|
|
var newVisibleRecommendArea = getIntersectionVisibleArea(nextOffsetX, tmpNextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
newVisibleArea > originIntersectionVisibleArea || newVisibleArea === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
newVisibleRecommendArea >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.bt = true;
|
|
nextOffsetY = tmpNextOffsetY;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 0), reversePoints(targetPoints, 0)];
|
|
} else {
|
|
prevFlipRef.current.bt = false;
|
|
}
|
|
}
|
|
|
|
// Top to Bottom
|
|
if (needAdjustY && popupPoints[0] === 'b' && (nextPopupY < adjustCheckVisibleArea.top || prevFlipRef.current.tb)) {
|
|
var _tmpNextOffsetY = nextOffsetY;
|
|
if (sameTB) {
|
|
_tmpNextOffsetY += popupHeight - targetHeight;
|
|
} else {
|
|
_tmpNextOffsetY = targetAlignPointBR.y - popupAlignPointTL.y - popupOffsetY;
|
|
}
|
|
var _newVisibleArea = getIntersectionVisibleArea(nextOffsetX, _tmpNextOffsetY);
|
|
var _newVisibleRecommendArea = getIntersectionVisibleArea(nextOffsetX, _tmpNextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
_newVisibleArea > originIntersectionVisibleArea || _newVisibleArea === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
_newVisibleRecommendArea >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.tb = true;
|
|
nextOffsetY = _tmpNextOffsetY;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 0), reversePoints(targetPoints, 0)];
|
|
} else {
|
|
prevFlipRef.current.tb = false;
|
|
}
|
|
}
|
|
|
|
// >>>>>>>>>> Left & Right
|
|
var needAdjustX = supportAdjust(adjustX);
|
|
|
|
// >>>>> Flip
|
|
var sameLR = popupPoints[1] === targetPoints[1];
|
|
|
|
// Right to Left
|
|
if (needAdjustX && popupPoints[1] === 'l' && (nextPopupRight > adjustCheckVisibleArea.right || prevFlipRef.current.rl)) {
|
|
var tmpNextOffsetX = nextOffsetX;
|
|
if (sameLR) {
|
|
tmpNextOffsetX -= popupWidth - targetWidth;
|
|
} else {
|
|
tmpNextOffsetX = targetAlignPointTL.x - popupAlignPointBR.x - popupOffsetX;
|
|
}
|
|
var _newVisibleArea2 = getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY);
|
|
var _newVisibleRecommendArea2 = getIntersectionVisibleArea(tmpNextOffsetX, nextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
_newVisibleArea2 > originIntersectionVisibleArea || _newVisibleArea2 === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
_newVisibleRecommendArea2 >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.rl = true;
|
|
nextOffsetX = tmpNextOffsetX;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 1), reversePoints(targetPoints, 1)];
|
|
} else {
|
|
prevFlipRef.current.rl = false;
|
|
}
|
|
}
|
|
|
|
// Left to Right
|
|
if (needAdjustX && popupPoints[1] === 'r' && (nextPopupX < adjustCheckVisibleArea.left || prevFlipRef.current.lr)) {
|
|
var _tmpNextOffsetX = nextOffsetX;
|
|
if (sameLR) {
|
|
_tmpNextOffsetX += popupWidth - targetWidth;
|
|
} else {
|
|
_tmpNextOffsetX = targetAlignPointBR.x - popupAlignPointTL.x - popupOffsetX;
|
|
}
|
|
var _newVisibleArea3 = getIntersectionVisibleArea(_tmpNextOffsetX, nextOffsetY);
|
|
var _newVisibleRecommendArea3 = getIntersectionVisibleArea(_tmpNextOffsetX, nextOffsetY, visibleRegionArea);
|
|
if (
|
|
// Of course use larger one
|
|
_newVisibleArea3 > originIntersectionVisibleArea || _newVisibleArea3 === originIntersectionVisibleArea && (!isVisibleFirst ||
|
|
// Choose recommend one
|
|
_newVisibleRecommendArea3 >= originIntersectionRecommendArea)) {
|
|
prevFlipRef.current.lr = true;
|
|
nextOffsetX = _tmpNextOffsetX;
|
|
nextAlignInfo.points = [reversePoints(popupPoints, 1), reversePoints(targetPoints, 1)];
|
|
} else {
|
|
prevFlipRef.current.lr = false;
|
|
}
|
|
}
|
|
|
|
// ============================ Shift ============================
|
|
syncNextPopupPosition();
|
|
var numShiftX = shiftX === true ? 0 : shiftX;
|
|
if (typeof numShiftX === 'number') {
|
|
// Left
|
|
if (nextPopupX < visibleRegionArea.left) {
|
|
nextOffsetX -= nextPopupX - visibleRegionArea.left;
|
|
if (targetRect.x + targetWidth < visibleRegionArea.left + numShiftX) {
|
|
nextOffsetX += targetRect.x - visibleRegionArea.left + targetWidth - numShiftX;
|
|
}
|
|
}
|
|
|
|
// Right
|
|
if (nextPopupRight > visibleRegionArea.right) {
|
|
nextOffsetX -= nextPopupRight - visibleRegionArea.right;
|
|
if (targetRect.x > visibleRegionArea.right - numShiftX) {
|
|
nextOffsetX += targetRect.x - visibleRegionArea.right + numShiftX;
|
|
}
|
|
}
|
|
}
|
|
var numShiftY = shiftY === true ? 0 : shiftY;
|
|
if (typeof numShiftY === 'number') {
|
|
// Top
|
|
if (nextPopupY < visibleRegionArea.top) {
|
|
nextOffsetY -= nextPopupY - visibleRegionArea.top;
|
|
if (targetRect.y + targetHeight < visibleRegionArea.top + numShiftY) {
|
|
nextOffsetY += targetRect.y - visibleRegionArea.top + targetHeight - numShiftY;
|
|
}
|
|
}
|
|
|
|
// Bottom
|
|
if (nextPopupBottom > visibleRegionArea.bottom) {
|
|
nextOffsetY -= nextPopupBottom - visibleRegionArea.bottom;
|
|
if (targetRect.y > visibleRegionArea.bottom - numShiftY) {
|
|
nextOffsetY += targetRect.y - visibleRegionArea.bottom + numShiftY;
|
|
}
|
|
}
|
|
}
|
|
|
|
// ============================ Arrow ============================
|
|
// Arrow center align
|
|
var popupLeft = popupRect.x + nextOffsetX;
|
|
var popupRight = popupLeft + popupWidth;
|
|
var popupTop = popupRect.y + nextOffsetY;
|
|
var popupBottom = popupTop + popupHeight;
|
|
var targetLeft = targetRect.x;
|
|
var targetRight = targetLeft + targetWidth;
|
|
var targetTop = targetRect.y;
|
|
var targetBottom = targetTop + targetHeight;
|
|
var maxLeft = Math.max(popupLeft, targetLeft);
|
|
var minRight = Math.min(popupRight, targetRight);
|
|
var xCenter = (maxLeft + minRight) / 2;
|
|
var nextArrowX = xCenter - popupLeft;
|
|
var maxTop = Math.max(popupTop, targetTop);
|
|
var minBottom = Math.min(popupBottom, targetBottom);
|
|
var yCenter = (maxTop + minBottom) / 2;
|
|
var nextArrowY = yCenter - popupTop;
|
|
onPopupAlign === null || onPopupAlign === void 0 ? void 0 : onPopupAlign(popupEle, nextAlignInfo);
|
|
|
|
// Additional calculate right & bottom position
|
|
var offsetX4Right = popupMirrorRect.right - popupRect.x - (nextOffsetX + popupRect.width);
|
|
var offsetY4Bottom = popupMirrorRect.bottom - popupRect.y - (nextOffsetY + popupRect.height);
|
|
setOffsetInfo({
|
|
ready: true,
|
|
offsetX: nextOffsetX / _scaleX,
|
|
offsetY: nextOffsetY / _scaleY,
|
|
offsetR: offsetX4Right / _scaleX,
|
|
offsetB: offsetY4Bottom / _scaleY,
|
|
arrowX: nextArrowX / _scaleX,
|
|
arrowY: nextArrowY / _scaleY,
|
|
scaleX: _scaleX,
|
|
scaleY: _scaleY,
|
|
align: nextAlignInfo
|
|
});
|
|
}
|
|
});
|
|
var triggerAlign = function triggerAlign() {
|
|
alignCountRef.current += 1;
|
|
var id = alignCountRef.current;
|
|
|
|
// Merge all align requirement into one frame
|
|
Promise.resolve().then(function () {
|
|
if (alignCountRef.current === id) {
|
|
onAlign();
|
|
}
|
|
});
|
|
};
|
|
|
|
// Reset ready status when placement & open changed
|
|
var resetReady = function resetReady() {
|
|
setOffsetInfo(function (ori) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, ori), {}, {
|
|
ready: false
|
|
});
|
|
});
|
|
};
|
|
es_hooks_useLayoutEffect(resetReady, [placement]);
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (!open) {
|
|
resetReady();
|
|
}
|
|
}, [open]);
|
|
return [offsetInfo.ready, offsetInfo.offsetX, offsetInfo.offsetY, offsetInfo.offsetR, offsetInfo.offsetB, offsetInfo.arrowX, offsetInfo.arrowY, offsetInfo.scaleX, offsetInfo.scaleY, offsetInfo.align, triggerAlign];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/hooks/useWatch.js
|
|
|
|
|
|
|
|
function useWatch(open, target, popup, onAlign) {
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (open && target && popup) {
|
|
var targetElement = target;
|
|
var popupElement = popup;
|
|
var targetScrollList = collectScroller(targetElement);
|
|
var popupScrollList = collectScroller(popupElement);
|
|
var win = getWin(popupElement);
|
|
var mergedList = new Set([win].concat((0,toConsumableArray/* default */.Z)(targetScrollList), (0,toConsumableArray/* default */.Z)(popupScrollList)));
|
|
function notifyScroll() {
|
|
onAlign();
|
|
}
|
|
mergedList.forEach(function (scroller) {
|
|
scroller.addEventListener('scroll', notifyScroll, {
|
|
passive: true
|
|
});
|
|
});
|
|
win.addEventListener('resize', notifyScroll, {
|
|
passive: true
|
|
});
|
|
|
|
// First time always do align
|
|
onAlign();
|
|
return function () {
|
|
mergedList.forEach(function (scroller) {
|
|
scroller.removeEventListener('scroll', notifyScroll);
|
|
win.removeEventListener('resize', notifyScroll);
|
|
});
|
|
};
|
|
}
|
|
}, [open, target, popup]);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/hooks/useState.js
|
|
|
|
|
|
/**
|
|
* Same as React.useState but `setState` accept `ignoreDestroy` param to not to setState after destroyed.
|
|
* We do not make this auto is to avoid real memory leak.
|
|
* Developer should confirm it's safe to ignore themselves.
|
|
*/
|
|
function useSafeState(defaultValue) {
|
|
var destroyRef = React.useRef(false);
|
|
var _React$useState = React.useState(defaultValue),
|
|
_React$useState2 = _slicedToArray(_React$useState, 2),
|
|
value = _React$useState2[0],
|
|
setValue = _React$useState2[1];
|
|
React.useEffect(function () {
|
|
destroyRef.current = false;
|
|
return function () {
|
|
destroyRef.current = true;
|
|
};
|
|
}, []);
|
|
function safeSetState(updater, ignoreDestroy) {
|
|
if (ignoreDestroy && destroyRef.current) {
|
|
return;
|
|
}
|
|
setValue(updater);
|
|
}
|
|
return [value, safeSetState];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/hooks/useMergedState.js
|
|
|
|
|
|
|
|
|
|
/** We only think `undefined` is empty */
|
|
function hasValue(value) {
|
|
return value !== undefined;
|
|
}
|
|
|
|
/**
|
|
* Similar to `useState` but will use props value if provided.
|
|
* Note that internal use rc-util `useState` hook.
|
|
*/
|
|
function useMergedState(defaultStateValue, option) {
|
|
var _ref = option || {},
|
|
defaultValue = _ref.defaultValue,
|
|
value = _ref.value,
|
|
onChange = _ref.onChange,
|
|
postState = _ref.postState;
|
|
|
|
// ======================= Init =======================
|
|
var _useState = useState(function () {
|
|
if (hasValue(value)) {
|
|
return value;
|
|
} else if (hasValue(defaultValue)) {
|
|
return typeof defaultValue === 'function' ? defaultValue() : defaultValue;
|
|
} else {
|
|
return typeof defaultStateValue === 'function' ? defaultStateValue() : defaultStateValue;
|
|
}
|
|
}),
|
|
_useState2 = _slicedToArray(_useState, 2),
|
|
innerValue = _useState2[0],
|
|
setInnerValue = _useState2[1];
|
|
var mergedValue = value !== undefined ? value : innerValue;
|
|
var postMergedValue = postState ? postState(mergedValue) : mergedValue;
|
|
|
|
// ====================== Change ======================
|
|
var onChangeFn = useEvent(onChange);
|
|
var _useState3 = useState([mergedValue]),
|
|
_useState4 = _slicedToArray(_useState3, 2),
|
|
prevValue = _useState4[0],
|
|
setPrevValue = _useState4[1];
|
|
useLayoutUpdateEffect(function () {
|
|
var prev = prevValue[0];
|
|
if (innerValue !== prev) {
|
|
onChangeFn(innerValue, prev);
|
|
}
|
|
}, [prevValue]);
|
|
|
|
// Sync value back to `undefined` when it from control to un-control
|
|
useLayoutUpdateEffect(function () {
|
|
if (!hasValue(value)) {
|
|
setInnerValue(value);
|
|
}
|
|
}, [value]);
|
|
|
|
// ====================== Update ======================
|
|
var triggerChange = useEvent(function (updater, ignoreDestroy) {
|
|
setInnerValue(updater, ignoreDestroy);
|
|
setPrevValue([mergedValue], ignoreDestroy);
|
|
});
|
|
return [postMergedValue, triggerChange];
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/utils/set.js
|
|
|
|
|
|
|
|
|
|
|
|
function internalSet(entity, paths, value, removeIfUndefined) {
|
|
if (!paths.length) {
|
|
return value;
|
|
}
|
|
var _paths = _toArray(paths),
|
|
path = _paths[0],
|
|
restPath = _paths.slice(1);
|
|
var clone;
|
|
if (!entity && typeof path === 'number') {
|
|
clone = [];
|
|
} else if (Array.isArray(entity)) {
|
|
clone = _toConsumableArray(entity);
|
|
} else {
|
|
clone = _objectSpread({}, entity);
|
|
}
|
|
|
|
// Delete prop if `removeIfUndefined` and value is undefined
|
|
if (removeIfUndefined && value === undefined && restPath.length === 1) {
|
|
delete clone[path][restPath[0]];
|
|
} else {
|
|
clone[path] = internalSet(clone[path], restPath, value, removeIfUndefined);
|
|
}
|
|
return clone;
|
|
}
|
|
function set(entity, paths, value) {
|
|
var removeIfUndefined = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
|
|
// Do nothing if `removeIfUndefined` and parent object not exist
|
|
if (paths.length && removeIfUndefined && value === undefined && !get(entity, paths.slice(0, -1))) {
|
|
return entity;
|
|
}
|
|
return internalSet(entity, paths, value, removeIfUndefined);
|
|
}
|
|
function isObject(obj) {
|
|
return _typeof(obj) === 'object' && obj !== null && Object.getPrototypeOf(obj) === Object.prototype;
|
|
}
|
|
function createEmpty(source) {
|
|
return Array.isArray(source) ? [] : {};
|
|
}
|
|
var keys = typeof Reflect === 'undefined' ? Object.keys : Reflect.ownKeys;
|
|
|
|
/**
|
|
* Merge objects which will create
|
|
*/
|
|
function merge() {
|
|
for (var _len = arguments.length, sources = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
sources[_key] = arguments[_key];
|
|
}
|
|
var clone = createEmpty(sources[0]);
|
|
sources.forEach(function (src) {
|
|
function internalMerge(path, parentLoopSet) {
|
|
var loopSet = new Set(parentLoopSet);
|
|
var value = get(src, path);
|
|
var isArr = Array.isArray(value);
|
|
if (isArr || isObject(value)) {
|
|
// Only add not loop obj
|
|
if (!loopSet.has(value)) {
|
|
loopSet.add(value);
|
|
var originValue = get(clone, path);
|
|
if (isArr) {
|
|
// Array will always be override
|
|
clone = set(clone, path, []);
|
|
} else if (!originValue || _typeof(originValue) !== 'object') {
|
|
// Init container if not exist
|
|
clone = set(clone, path, createEmpty(value));
|
|
}
|
|
keys(value).forEach(function (key) {
|
|
internalMerge([].concat(_toConsumableArray(path), [key]), loopSet);
|
|
});
|
|
}
|
|
} else {
|
|
clone = set(clone, path, value);
|
|
}
|
|
}
|
|
internalMerge([]);
|
|
});
|
|
return clone;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/warning.js
|
|
/* eslint-disable no-console */
|
|
var warning_warned = {};
|
|
var preWarningFns = [];
|
|
|
|
/**
|
|
* Pre warning enable you to parse content before console.error.
|
|
* Modify to null will prevent warning.
|
|
*/
|
|
var preMessage = function preMessage(fn) {
|
|
preWarningFns.push(fn);
|
|
};
|
|
function warning_warning(valid, message) {
|
|
// Support uglify
|
|
if (false) { var finalMessage; }
|
|
}
|
|
function warning_note(valid, message) {
|
|
// Support uglify
|
|
if (false) { var finalMessage; }
|
|
}
|
|
function warning_resetWarned() {
|
|
warning_warned = {};
|
|
}
|
|
function warning_call(method, valid, message) {
|
|
if (!valid && !warning_warned[message]) {
|
|
method(false, message);
|
|
warning_warned[message] = true;
|
|
}
|
|
}
|
|
function warning_warningOnce(valid, message) {
|
|
warning_call(warning_warning, valid, message);
|
|
}
|
|
function warning_noteOnce(valid, message) {
|
|
warning_call(warning_note, valid, message);
|
|
}
|
|
warning_warningOnce.preMessage = preMessage;
|
|
warning_warningOnce.resetWarned = warning_resetWarned;
|
|
warning_warningOnce.noteOnce = warning_noteOnce;
|
|
/* harmony default export */ var rc_util_es_warning = ((/* unused pure expression or super */ null && (warning_warningOnce)));
|
|
/* eslint-enable */
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/index.js
|
|
|
|
|
|
|
|
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/raf.js
|
|
var raf = function raf(callback) {
|
|
return +setTimeout(callback, 16);
|
|
};
|
|
var caf = function caf(num) {
|
|
return clearTimeout(num);
|
|
};
|
|
if (typeof window !== 'undefined' && 'requestAnimationFrame' in window) {
|
|
raf = function raf(callback) {
|
|
return window.requestAnimationFrame(callback);
|
|
};
|
|
caf = function caf(handle) {
|
|
return window.cancelAnimationFrame(handle);
|
|
};
|
|
}
|
|
var rafUUID = 0;
|
|
var rafIds = new Map();
|
|
function cleanup(id) {
|
|
rafIds.delete(id);
|
|
}
|
|
var wrapperRaf = function wrapperRaf(callback) {
|
|
var times = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
|
|
rafUUID += 1;
|
|
var id = rafUUID;
|
|
function callRef(leftTimes) {
|
|
if (leftTimes === 0) {
|
|
// Clean up
|
|
cleanup(id);
|
|
|
|
// Trigger
|
|
callback();
|
|
} else {
|
|
// Next raf
|
|
var realId = raf(function () {
|
|
callRef(leftTimes - 1);
|
|
});
|
|
|
|
// Bind real raf id
|
|
rafIds.set(id, realId);
|
|
}
|
|
}
|
|
callRef(times);
|
|
return id;
|
|
};
|
|
wrapperRaf.cancel = function (id) {
|
|
var realId = rafIds.get(id);
|
|
cleanup(realId);
|
|
return caf(realId);
|
|
};
|
|
/* harmony default export */ var es_raf = (wrapperRaf);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/hooks/useWinClick.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function useWinClick(open, clickToHide, targetEle, popupEle, mask, maskClosable, inPopupOrChild, triggerOpen) {
|
|
var openRef = react.useRef(open);
|
|
|
|
// Window click to hide should be lock to avoid trigger lock immediately
|
|
var lockRef = react.useRef(false);
|
|
if (openRef.current !== open) {
|
|
lockRef.current = true;
|
|
openRef.current = open;
|
|
}
|
|
react.useEffect(function () {
|
|
var id = es_raf(function () {
|
|
lockRef.current = false;
|
|
});
|
|
return function () {
|
|
es_raf.cancel(id);
|
|
};
|
|
}, [open]);
|
|
|
|
// Click to hide is special action since click popup element should not hide
|
|
react.useEffect(function () {
|
|
if (clickToHide && popupEle && (!mask || maskClosable)) {
|
|
var genClickEvents = function genClickEvents() {
|
|
var clickInside = false;
|
|
|
|
// User may mouseDown inside and drag out of popup and mouse up
|
|
// Record here to prevent close
|
|
var onWindowMouseDown = function onWindowMouseDown(_ref) {
|
|
var target = _ref.target;
|
|
clickInside = inPopupOrChild(target);
|
|
};
|
|
var onWindowClick = function onWindowClick(_ref2) {
|
|
var target = _ref2.target;
|
|
if (!lockRef.current && openRef.current && !clickInside && !inPopupOrChild(target)) {
|
|
triggerOpen(false);
|
|
}
|
|
};
|
|
return [onWindowMouseDown, onWindowClick];
|
|
};
|
|
|
|
// Events
|
|
var _genClickEvents = genClickEvents(),
|
|
_genClickEvents2 = (0,slicedToArray/* default */.Z)(_genClickEvents, 2),
|
|
onWinMouseDown = _genClickEvents2[0],
|
|
onWinClick = _genClickEvents2[1];
|
|
var _genClickEvents3 = genClickEvents(),
|
|
_genClickEvents4 = (0,slicedToArray/* default */.Z)(_genClickEvents3, 2),
|
|
onShadowMouseDown = _genClickEvents4[0],
|
|
onShadowClick = _genClickEvents4[1];
|
|
var win = getWin(popupEle);
|
|
win.addEventListener('mousedown', onWinMouseDown);
|
|
win.addEventListener('click', onWinClick);
|
|
win.addEventListener('contextmenu', onWinClick);
|
|
|
|
// shadow root
|
|
var targetShadowRoot = getShadowRoot(targetEle);
|
|
if (targetShadowRoot) {
|
|
targetShadowRoot.addEventListener('mousedown', onShadowMouseDown);
|
|
targetShadowRoot.addEventListener('click', onShadowClick);
|
|
targetShadowRoot.addEventListener('contextmenu', onShadowClick);
|
|
}
|
|
|
|
// Warning if target and popup not in same root
|
|
if (false) { var popupRoot, targetRoot, _targetEle$getRootNod, _popupEle$getRootNode; }
|
|
return function () {
|
|
win.removeEventListener('mousedown', onWinMouseDown);
|
|
win.removeEventListener('click', onWinClick);
|
|
win.removeEventListener('contextmenu', onWinClick);
|
|
if (targetShadowRoot) {
|
|
targetShadowRoot.removeEventListener('mousedown', onShadowMouseDown);
|
|
targetShadowRoot.removeEventListener('click', onShadowClick);
|
|
targetShadowRoot.removeEventListener('contextmenu', onShadowClick);
|
|
}
|
|
};
|
|
}
|
|
}, [clickToHide, targetEle, popupEle, mask, maskClosable]);
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/rc-motion/es/index.js + 11 modules
|
|
var rc_motion_es = __webpack_require__(62874);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/hooks/useMemo.js
|
|
|
|
function useMemo_useMemo(getValue, condition, shouldUpdate) {
|
|
var cacheRef = react.useRef({});
|
|
if (!('value' in cacheRef.current) || shouldUpdate(cacheRef.current.condition, condition)) {
|
|
cacheRef.current.value = getValue();
|
|
cacheRef.current.condition = condition;
|
|
}
|
|
return cacheRef.current.value;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/node_modules/rc-util/es/ref.js
|
|
|
|
/* eslint-disable no-param-reassign */
|
|
|
|
|
|
|
|
function ref_fillRef(ref, node) {
|
|
if (typeof ref === 'function') {
|
|
ref(node);
|
|
} else if ((0,esm_typeof/* default */.Z)(ref) === 'object' && ref && 'current' in ref) {
|
|
ref.current = node;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Merge refs into one ref function to support ref passing.
|
|
*/
|
|
function ref_composeRef() {
|
|
for (var _len = arguments.length, refs = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
refs[_key] = arguments[_key];
|
|
}
|
|
var refList = refs.filter(function (ref) {
|
|
return ref;
|
|
});
|
|
if (refList.length <= 1) {
|
|
return refList[0];
|
|
}
|
|
return function (node) {
|
|
refs.forEach(function (ref) {
|
|
ref_fillRef(ref, node);
|
|
});
|
|
};
|
|
}
|
|
function ref_useComposeRef() {
|
|
for (var _len2 = arguments.length, refs = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
|
refs[_key2] = arguments[_key2];
|
|
}
|
|
return useMemo_useMemo(function () {
|
|
return ref_composeRef.apply(void 0, refs);
|
|
}, refs, function (prev, next) {
|
|
return prev.length === next.length && prev.every(function (ref, i) {
|
|
return ref === next[i];
|
|
});
|
|
});
|
|
}
|
|
function ref_supportRef(nodeOrComponent) {
|
|
var _type$prototype, _nodeOrComponent$prot;
|
|
var type = (0,react_is.isMemo)(nodeOrComponent) ? nodeOrComponent.type.type : nodeOrComponent.type;
|
|
|
|
// Function component node
|
|
if (typeof type === 'function' && !((_type$prototype = type.prototype) !== null && _type$prototype !== void 0 && _type$prototype.render)) {
|
|
return false;
|
|
}
|
|
|
|
// Class component
|
|
if (typeof nodeOrComponent === 'function' && !((_nodeOrComponent$prot = nodeOrComponent.prototype) !== null && _nodeOrComponent$prot !== void 0 && _nodeOrComponent$prot.render)) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
/* eslint-enable */
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/Popup/Arrow.js
|
|
|
|
|
|
function Arrow(props) {
|
|
var prefixCls = props.prefixCls,
|
|
align = props.align,
|
|
arrow = props.arrow,
|
|
arrowPos = props.arrowPos;
|
|
var _ref = arrow || {},
|
|
className = _ref.className,
|
|
content = _ref.content;
|
|
var _arrowPos$x = arrowPos.x,
|
|
x = _arrowPos$x === void 0 ? 0 : _arrowPos$x,
|
|
_arrowPos$y = arrowPos.y,
|
|
y = _arrowPos$y === void 0 ? 0 : _arrowPos$y;
|
|
var arrowRef = react.useRef();
|
|
|
|
// Skip if no align
|
|
if (!align || !align.points) {
|
|
return null;
|
|
}
|
|
var alignStyle = {
|
|
position: 'absolute'
|
|
};
|
|
|
|
// Skip if no need to align
|
|
if (align.autoArrow !== false) {
|
|
var popupPoints = align.points[0];
|
|
var targetPoints = align.points[1];
|
|
var popupTB = popupPoints[0];
|
|
var popupLR = popupPoints[1];
|
|
var targetTB = targetPoints[0];
|
|
var targetLR = targetPoints[1];
|
|
|
|
// Top & Bottom
|
|
if (popupTB === targetTB || !['t', 'b'].includes(popupTB)) {
|
|
alignStyle.top = y;
|
|
} else if (popupTB === 't') {
|
|
alignStyle.top = 0;
|
|
} else {
|
|
alignStyle.bottom = 0;
|
|
}
|
|
|
|
// Left & Right
|
|
if (popupLR === targetLR || !['l', 'r'].includes(popupLR)) {
|
|
alignStyle.left = x;
|
|
} else if (popupLR === 'l') {
|
|
alignStyle.left = 0;
|
|
} else {
|
|
alignStyle.right = 0;
|
|
}
|
|
}
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
ref: arrowRef,
|
|
className: classnames_default()("".concat(prefixCls, "-arrow"), className),
|
|
style: alignStyle
|
|
}, content);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/Popup/Mask.js
|
|
|
|
|
|
|
|
|
|
function Mask(props) {
|
|
var prefixCls = props.prefixCls,
|
|
open = props.open,
|
|
zIndex = props.zIndex,
|
|
mask = props.mask,
|
|
motion = props.motion;
|
|
if (!mask) {
|
|
return null;
|
|
}
|
|
return /*#__PURE__*/react.createElement(rc_motion_es/* default */.Z, (0,esm_extends/* default */.Z)({}, motion, {
|
|
motionAppear: true,
|
|
visible: open,
|
|
removeOnLeave: true
|
|
}), function (_ref) {
|
|
var className = _ref.className;
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
style: {
|
|
zIndex: zIndex
|
|
},
|
|
className: classnames_default()("".concat(prefixCls, "-mask"), className)
|
|
});
|
|
});
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/Popup/PopupContent.js
|
|
|
|
var PopupContent = /*#__PURE__*/react.memo(function (_ref) {
|
|
var children = _ref.children;
|
|
return children;
|
|
}, function (_, next) {
|
|
return next.cache;
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var Popup_PopupContent = (PopupContent);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/Popup/index.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var Popup = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var popup = props.popup,
|
|
className = props.className,
|
|
prefixCls = props.prefixCls,
|
|
style = props.style,
|
|
target = props.target,
|
|
_onVisibleChanged = props.onVisibleChanged,
|
|
open = props.open,
|
|
keepDom = props.keepDom,
|
|
onClick = props.onClick,
|
|
mask = props.mask,
|
|
arrow = props.arrow,
|
|
arrowPos = props.arrowPos,
|
|
align = props.align,
|
|
motion = props.motion,
|
|
maskMotion = props.maskMotion,
|
|
forceRender = props.forceRender,
|
|
getPopupContainer = props.getPopupContainer,
|
|
autoDestroy = props.autoDestroy,
|
|
Portal = props.portal,
|
|
zIndex = props.zIndex,
|
|
onMouseEnter = props.onMouseEnter,
|
|
onMouseLeave = props.onMouseLeave,
|
|
ready = props.ready,
|
|
offsetX = props.offsetX,
|
|
offsetY = props.offsetY,
|
|
offsetR = props.offsetR,
|
|
offsetB = props.offsetB,
|
|
onAlign = props.onAlign,
|
|
onPrepare = props.onPrepare,
|
|
stretch = props.stretch,
|
|
targetWidth = props.targetWidth,
|
|
targetHeight = props.targetHeight;
|
|
var childNode = typeof popup === 'function' ? popup() : popup;
|
|
|
|
// We can not remove holder only when motion finished.
|
|
var isNodeVisible = open || keepDom;
|
|
|
|
// ======================= Container ========================
|
|
var getPopupContainerNeedParams = (getPopupContainer === null || getPopupContainer === void 0 ? void 0 : getPopupContainer.length) > 0;
|
|
var _React$useState = react.useState(!getPopupContainer || !getPopupContainerNeedParams),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
show = _React$useState2[0],
|
|
setShow = _React$useState2[1];
|
|
|
|
// Delay to show since `getPopupContainer` need target element
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (!show && getPopupContainerNeedParams && target) {
|
|
setShow(true);
|
|
}
|
|
}, [show, getPopupContainerNeedParams, target]);
|
|
|
|
// ========================= Render =========================
|
|
if (!show) {
|
|
return null;
|
|
}
|
|
|
|
// >>>>> Offset
|
|
var AUTO = 'auto';
|
|
var offsetStyle = {
|
|
left: '-1000vw',
|
|
top: '-1000vh',
|
|
right: AUTO,
|
|
bottom: AUTO
|
|
};
|
|
|
|
// Set align style
|
|
if (ready || !open) {
|
|
var points = align.points,
|
|
_experimental = align._experimental;
|
|
var dynamicInset = _experimental === null || _experimental === void 0 ? void 0 : _experimental.dynamicInset;
|
|
var alignRight = dynamicInset && points[0][1] === 'r';
|
|
var alignBottom = dynamicInset && points[0][0] === 'b';
|
|
if (alignRight) {
|
|
offsetStyle.right = offsetR;
|
|
offsetStyle.left = AUTO;
|
|
} else {
|
|
offsetStyle.left = offsetX;
|
|
offsetStyle.right = AUTO;
|
|
}
|
|
if (alignBottom) {
|
|
offsetStyle.bottom = offsetB;
|
|
offsetStyle.top = AUTO;
|
|
} else {
|
|
offsetStyle.top = offsetY;
|
|
offsetStyle.bottom = AUTO;
|
|
}
|
|
}
|
|
|
|
// >>>>> Misc
|
|
var miscStyle = {};
|
|
if (stretch) {
|
|
if (stretch.includes('height') && targetHeight) {
|
|
miscStyle.height = targetHeight;
|
|
} else if (stretch.includes('minHeight') && targetHeight) {
|
|
miscStyle.minHeight = targetHeight;
|
|
}
|
|
if (stretch.includes('width') && targetWidth) {
|
|
miscStyle.width = targetWidth;
|
|
} else if (stretch.includes('minWidth') && targetWidth) {
|
|
miscStyle.minWidth = targetWidth;
|
|
}
|
|
}
|
|
if (!open) {
|
|
miscStyle.pointerEvents = 'none';
|
|
}
|
|
return /*#__PURE__*/react.createElement(Portal, {
|
|
open: forceRender || isNodeVisible,
|
|
getContainer: getPopupContainer && function () {
|
|
return getPopupContainer(target);
|
|
},
|
|
autoDestroy: autoDestroy
|
|
}, /*#__PURE__*/react.createElement(Mask, {
|
|
prefixCls: prefixCls,
|
|
open: open,
|
|
zIndex: zIndex,
|
|
mask: mask,
|
|
motion: maskMotion
|
|
}), /*#__PURE__*/react.createElement(rc_resize_observer_es/* default */.Z, {
|
|
onResize: onAlign,
|
|
disabled: !open
|
|
}, function (resizeObserverRef) {
|
|
return /*#__PURE__*/react.createElement(rc_motion_es/* default */.Z, (0,esm_extends/* default */.Z)({
|
|
motionAppear: true,
|
|
motionEnter: true,
|
|
motionLeave: true,
|
|
removeOnLeave: false,
|
|
forceRender: forceRender,
|
|
leavedClassName: "".concat(prefixCls, "-hidden")
|
|
}, motion, {
|
|
onAppearPrepare: onPrepare,
|
|
onEnterPrepare: onPrepare,
|
|
visible: open,
|
|
onVisibleChanged: function onVisibleChanged(nextVisible) {
|
|
var _motion$onVisibleChan;
|
|
motion === null || motion === void 0 ? void 0 : (_motion$onVisibleChan = motion.onVisibleChanged) === null || _motion$onVisibleChan === void 0 ? void 0 : _motion$onVisibleChan.call(motion, nextVisible);
|
|
_onVisibleChanged(nextVisible);
|
|
}
|
|
}), function (_ref, motionRef) {
|
|
var motionClassName = _ref.className,
|
|
motionStyle = _ref.style;
|
|
var cls = classnames_default()(prefixCls, motionClassName, className);
|
|
return /*#__PURE__*/react.createElement("div", {
|
|
ref: ref_composeRef(resizeObserverRef, ref, motionRef),
|
|
className: cls,
|
|
style: (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({
|
|
'--arrow-x': "".concat(arrowPos.x || 0, "px"),
|
|
'--arrow-y': "".concat(arrowPos.y || 0, "px")
|
|
}, offsetStyle), miscStyle), motionStyle), {}, {
|
|
boxSizing: 'border-box',
|
|
zIndex: zIndex
|
|
}, style),
|
|
onMouseEnter: onMouseEnter,
|
|
onMouseLeave: onMouseLeave,
|
|
onClick: onClick
|
|
}, arrow && /*#__PURE__*/react.createElement(Arrow, {
|
|
prefixCls: prefixCls,
|
|
arrow: arrow,
|
|
arrowPos: arrowPos,
|
|
align: align
|
|
}), /*#__PURE__*/react.createElement(Popup_PopupContent, {
|
|
cache: !open
|
|
}, childNode));
|
|
});
|
|
}));
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var es_Popup = (Popup);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/TriggerWrapper.js
|
|
|
|
|
|
var TriggerWrapper = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var children = props.children,
|
|
getTriggerDOMNode = props.getTriggerDOMNode;
|
|
var canUseRef = ref_supportRef(children);
|
|
|
|
// When use `getTriggerDOMNode`, we should do additional work to get the real dom
|
|
var setRef = react.useCallback(function (node) {
|
|
ref_fillRef(ref, getTriggerDOMNode ? getTriggerDOMNode(node) : node);
|
|
}, [getTriggerDOMNode]);
|
|
var mergedRef = ref_useComposeRef(setRef, children.ref);
|
|
return canUseRef ? /*#__PURE__*/react.cloneElement(children, {
|
|
ref: mergedRef
|
|
}) : children;
|
|
});
|
|
if (false) {}
|
|
/* harmony default export */ var es_TriggerWrapper = (TriggerWrapper);
|
|
;// CONCATENATED MODULE: ./node_modules/@rc-component/trigger/es/index.js
|
|
|
|
|
|
|
|
var _excluded = ["prefixCls", "children", "action", "showAction", "hideAction", "popupVisible", "defaultPopupVisible", "onPopupVisibleChange", "afterPopupVisibleChange", "mouseEnterDelay", "mouseLeaveDelay", "focusDelay", "blurDelay", "mask", "maskClosable", "getPopupContainer", "forceRender", "autoDestroy", "destroyPopupOnHide", "popup", "popupClassName", "popupStyle", "popupPlacement", "builtinPlacements", "popupAlign", "zIndex", "stretch", "getPopupClassNameFromAlign", "alignPoint", "onPopupClick", "onPopupAlign", "arrow", "popupMotion", "maskMotion", "popupTransitionName", "popupAnimation", "maskTransitionName", "maskAnimation", "className", "getTriggerDOMNode"];
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// Removed Props List
|
|
// Seems this can be auto
|
|
// getDocument?: (element?: HTMLElement) => Document;
|
|
// New version will not wrap popup with `rc-trigger-popup-content` when multiple children
|
|
function generateTrigger() {
|
|
var PortalComponent = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : es;
|
|
var Trigger = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _props$prefixCls = props.prefixCls,
|
|
prefixCls = _props$prefixCls === void 0 ? 'rc-trigger-popup' : _props$prefixCls,
|
|
children = props.children,
|
|
_props$action = props.action,
|
|
action = _props$action === void 0 ? 'hover' : _props$action,
|
|
showAction = props.showAction,
|
|
hideAction = props.hideAction,
|
|
popupVisible = props.popupVisible,
|
|
defaultPopupVisible = props.defaultPopupVisible,
|
|
onPopupVisibleChange = props.onPopupVisibleChange,
|
|
afterPopupVisibleChange = props.afterPopupVisibleChange,
|
|
mouseEnterDelay = props.mouseEnterDelay,
|
|
_props$mouseLeaveDela = props.mouseLeaveDelay,
|
|
mouseLeaveDelay = _props$mouseLeaveDela === void 0 ? 0.1 : _props$mouseLeaveDela,
|
|
focusDelay = props.focusDelay,
|
|
blurDelay = props.blurDelay,
|
|
mask = props.mask,
|
|
_props$maskClosable = props.maskClosable,
|
|
maskClosable = _props$maskClosable === void 0 ? true : _props$maskClosable,
|
|
getPopupContainer = props.getPopupContainer,
|
|
forceRender = props.forceRender,
|
|
autoDestroy = props.autoDestroy,
|
|
destroyPopupOnHide = props.destroyPopupOnHide,
|
|
popup = props.popup,
|
|
popupClassName = props.popupClassName,
|
|
popupStyle = props.popupStyle,
|
|
popupPlacement = props.popupPlacement,
|
|
_props$builtinPlaceme = props.builtinPlacements,
|
|
builtinPlacements = _props$builtinPlaceme === void 0 ? {} : _props$builtinPlaceme,
|
|
popupAlign = props.popupAlign,
|
|
zIndex = props.zIndex,
|
|
stretch = props.stretch,
|
|
getPopupClassNameFromAlign = props.getPopupClassNameFromAlign,
|
|
alignPoint = props.alignPoint,
|
|
onPopupClick = props.onPopupClick,
|
|
onPopupAlign = props.onPopupAlign,
|
|
arrow = props.arrow,
|
|
popupMotion = props.popupMotion,
|
|
maskMotion = props.maskMotion,
|
|
popupTransitionName = props.popupTransitionName,
|
|
popupAnimation = props.popupAnimation,
|
|
maskTransitionName = props.maskTransitionName,
|
|
maskAnimation = props.maskAnimation,
|
|
className = props.className,
|
|
getTriggerDOMNode = props.getTriggerDOMNode,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(props, _excluded);
|
|
var mergedAutoDestroy = autoDestroy || destroyPopupOnHide || false;
|
|
|
|
// =========================== Mobile ===========================
|
|
var _React$useState = react.useState(false),
|
|
_React$useState2 = (0,slicedToArray/* default */.Z)(_React$useState, 2),
|
|
mobile = _React$useState2[0],
|
|
setMobile = _React$useState2[1];
|
|
es_hooks_useLayoutEffect(function () {
|
|
setMobile(isMobile());
|
|
}, []);
|
|
|
|
// ========================== Context ===========================
|
|
var subPopupElements = react.useRef({});
|
|
var parentContext = react.useContext(es_context);
|
|
var context = react.useMemo(function () {
|
|
return {
|
|
registerSubPopup: function registerSubPopup(id, subPopupEle) {
|
|
subPopupElements.current[id] = subPopupEle;
|
|
parentContext === null || parentContext === void 0 ? void 0 : parentContext.registerSubPopup(id, subPopupEle);
|
|
}
|
|
};
|
|
}, [parentContext]);
|
|
|
|
// =========================== Popup ============================
|
|
var id = useId();
|
|
var _React$useState3 = react.useState(null),
|
|
_React$useState4 = (0,slicedToArray/* default */.Z)(_React$useState3, 2),
|
|
popupEle = _React$useState4[0],
|
|
setPopupEle = _React$useState4[1];
|
|
var setPopupRef = useEvent_useEvent(function (node) {
|
|
if (isDOM(node) && popupEle !== node) {
|
|
setPopupEle(node);
|
|
}
|
|
parentContext === null || parentContext === void 0 ? void 0 : parentContext.registerSubPopup(id, node);
|
|
});
|
|
|
|
// =========================== Target ===========================
|
|
// Use state to control here since `useRef` update not trigger render
|
|
var _React$useState5 = react.useState(null),
|
|
_React$useState6 = (0,slicedToArray/* default */.Z)(_React$useState5, 2),
|
|
targetEle = _React$useState6[0],
|
|
setTargetEle = _React$useState6[1];
|
|
var setTargetRef = useEvent_useEvent(function (node) {
|
|
if (isDOM(node) && targetEle !== node) {
|
|
setTargetEle(node);
|
|
}
|
|
});
|
|
|
|
// ========================== Children ==========================
|
|
var child = react.Children.only(children);
|
|
var originChildProps = (child === null || child === void 0 ? void 0 : child.props) || {};
|
|
var cloneProps = {};
|
|
var inPopupOrChild = useEvent_useEvent(function (ele) {
|
|
var _getShadowRoot, _getShadowRoot2;
|
|
var childDOM = targetEle;
|
|
return (childDOM === null || childDOM === void 0 ? void 0 : childDOM.contains(ele)) || ((_getShadowRoot = getShadowRoot(childDOM)) === null || _getShadowRoot === void 0 ? void 0 : _getShadowRoot.host) === ele || ele === childDOM || (popupEle === null || popupEle === void 0 ? void 0 : popupEle.contains(ele)) || ((_getShadowRoot2 = getShadowRoot(popupEle)) === null || _getShadowRoot2 === void 0 ? void 0 : _getShadowRoot2.host) === ele || ele === popupEle || Object.values(subPopupElements.current).some(function (subPopupEle) {
|
|
return (subPopupEle === null || subPopupEle === void 0 ? void 0 : subPopupEle.contains(ele)) || ele === subPopupEle;
|
|
});
|
|
});
|
|
|
|
// =========================== Motion ===========================
|
|
var mergePopupMotion = getMotion(prefixCls, popupMotion, popupAnimation, popupTransitionName);
|
|
var mergeMaskMotion = getMotion(prefixCls, maskMotion, maskAnimation, maskTransitionName);
|
|
|
|
// ============================ Open ============================
|
|
var _React$useState7 = react.useState(defaultPopupVisible || false),
|
|
_React$useState8 = (0,slicedToArray/* default */.Z)(_React$useState7, 2),
|
|
internalOpen = _React$useState8[0],
|
|
setInternalOpen = _React$useState8[1];
|
|
|
|
// Render still use props as first priority
|
|
var mergedOpen = popupVisible !== null && popupVisible !== void 0 ? popupVisible : internalOpen;
|
|
|
|
// We use effect sync here in case `popupVisible` back to `undefined`
|
|
var setMergedOpen = useEvent_useEvent(function (nextOpen) {
|
|
if (popupVisible === undefined) {
|
|
setInternalOpen(nextOpen);
|
|
}
|
|
});
|
|
es_hooks_useLayoutEffect(function () {
|
|
setInternalOpen(popupVisible || false);
|
|
}, [popupVisible]);
|
|
var openRef = react.useRef(mergedOpen);
|
|
openRef.current = mergedOpen;
|
|
var internalTriggerOpen = useEvent_useEvent(function (nextOpen) {
|
|
if (mergedOpen !== nextOpen) {
|
|
setMergedOpen(nextOpen);
|
|
onPopupVisibleChange === null || onPopupVisibleChange === void 0 ? void 0 : onPopupVisibleChange(nextOpen);
|
|
}
|
|
});
|
|
|
|
// Trigger for delay
|
|
var delayRef = react.useRef();
|
|
var clearDelay = function clearDelay() {
|
|
clearTimeout(delayRef.current);
|
|
};
|
|
var triggerOpen = function triggerOpen(nextOpen) {
|
|
var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
|
|
clearDelay();
|
|
if (delay === 0) {
|
|
internalTriggerOpen(nextOpen);
|
|
} else {
|
|
delayRef.current = setTimeout(function () {
|
|
internalTriggerOpen(nextOpen);
|
|
}, delay * 1000);
|
|
}
|
|
};
|
|
react.useEffect(function () {
|
|
return clearDelay;
|
|
}, []);
|
|
|
|
// ========================== Motion ============================
|
|
var _React$useState9 = react.useState(false),
|
|
_React$useState10 = (0,slicedToArray/* default */.Z)(_React$useState9, 2),
|
|
inMotion = _React$useState10[0],
|
|
setInMotion = _React$useState10[1];
|
|
es_hooks_useLayoutEffect(function (firstMount) {
|
|
if (!firstMount || mergedOpen) {
|
|
setInMotion(true);
|
|
}
|
|
}, [mergedOpen]);
|
|
var _React$useState11 = react.useState(null),
|
|
_React$useState12 = (0,slicedToArray/* default */.Z)(_React$useState11, 2),
|
|
motionPrepareResolve = _React$useState12[0],
|
|
setMotionPrepareResolve = _React$useState12[1];
|
|
|
|
// =========================== Align ============================
|
|
var _React$useState13 = react.useState([0, 0]),
|
|
_React$useState14 = (0,slicedToArray/* default */.Z)(_React$useState13, 2),
|
|
mousePos = _React$useState14[0],
|
|
setMousePos = _React$useState14[1];
|
|
var setMousePosByEvent = function setMousePosByEvent(event) {
|
|
setMousePos([event.clientX, event.clientY]);
|
|
};
|
|
var _useAlign = useAlign(mergedOpen, popupEle, alignPoint ? mousePos : targetEle, popupPlacement, builtinPlacements, popupAlign, onPopupAlign),
|
|
_useAlign2 = (0,slicedToArray/* default */.Z)(_useAlign, 11),
|
|
ready = _useAlign2[0],
|
|
offsetX = _useAlign2[1],
|
|
offsetY = _useAlign2[2],
|
|
offsetR = _useAlign2[3],
|
|
offsetB = _useAlign2[4],
|
|
arrowX = _useAlign2[5],
|
|
arrowY = _useAlign2[6],
|
|
scaleX = _useAlign2[7],
|
|
scaleY = _useAlign2[8],
|
|
alignInfo = _useAlign2[9],
|
|
onAlign = _useAlign2[10];
|
|
var triggerAlign = useEvent_useEvent(function () {
|
|
if (!inMotion) {
|
|
onAlign();
|
|
}
|
|
});
|
|
useWatch(mergedOpen, targetEle, popupEle, triggerAlign);
|
|
es_hooks_useLayoutEffect(function () {
|
|
triggerAlign();
|
|
}, [mousePos, popupPlacement]);
|
|
|
|
// When no builtinPlacements and popupAlign changed
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (mergedOpen && !(builtinPlacements !== null && builtinPlacements !== void 0 && builtinPlacements[popupPlacement])) {
|
|
triggerAlign();
|
|
}
|
|
}, [JSON.stringify(popupAlign)]);
|
|
var alignedClassName = react.useMemo(function () {
|
|
var baseClassName = getAlignPopupClassName(builtinPlacements, prefixCls, alignInfo, alignPoint);
|
|
return classnames_default()(baseClassName, getPopupClassNameFromAlign === null || getPopupClassNameFromAlign === void 0 ? void 0 : getPopupClassNameFromAlign(alignInfo));
|
|
}, [alignInfo, getPopupClassNameFromAlign, builtinPlacements, prefixCls, alignPoint]);
|
|
react.useImperativeHandle(ref, function () {
|
|
return {
|
|
forceAlign: triggerAlign
|
|
};
|
|
});
|
|
|
|
// ========================== Motion ============================
|
|
var onVisibleChanged = function onVisibleChanged(visible) {
|
|
setInMotion(false);
|
|
onAlign();
|
|
afterPopupVisibleChange === null || afterPopupVisibleChange === void 0 ? void 0 : afterPopupVisibleChange(visible);
|
|
};
|
|
|
|
// We will trigger align when motion is in prepare
|
|
var onPrepare = function onPrepare() {
|
|
return new Promise(function (resolve) {
|
|
setMotionPrepareResolve(function () {
|
|
return resolve;
|
|
});
|
|
});
|
|
};
|
|
es_hooks_useLayoutEffect(function () {
|
|
if (motionPrepareResolve) {
|
|
onAlign();
|
|
motionPrepareResolve();
|
|
setMotionPrepareResolve(null);
|
|
}
|
|
}, [motionPrepareResolve]);
|
|
|
|
// ========================== Stretch ===========================
|
|
var _React$useState15 = react.useState(0),
|
|
_React$useState16 = (0,slicedToArray/* default */.Z)(_React$useState15, 2),
|
|
targetWidth = _React$useState16[0],
|
|
setTargetWidth = _React$useState16[1];
|
|
var _React$useState17 = react.useState(0),
|
|
_React$useState18 = (0,slicedToArray/* default */.Z)(_React$useState17, 2),
|
|
targetHeight = _React$useState18[0],
|
|
setTargetHeight = _React$useState18[1];
|
|
var onTargetResize = function onTargetResize(_, ele) {
|
|
triggerAlign();
|
|
if (stretch) {
|
|
var rect = ele.getBoundingClientRect();
|
|
setTargetWidth(rect.width);
|
|
setTargetHeight(rect.height);
|
|
}
|
|
};
|
|
|
|
// =========================== Action ===========================
|
|
var _useAction = useAction(mobile, action, showAction, hideAction),
|
|
_useAction2 = (0,slicedToArray/* default */.Z)(_useAction, 2),
|
|
showActions = _useAction2[0],
|
|
hideActions = _useAction2[1];
|
|
|
|
// Util wrapper for trigger action
|
|
var wrapperAction = function wrapperAction(eventName, nextOpen, delay, preEvent) {
|
|
cloneProps[eventName] = function (event) {
|
|
var _originChildProps$eve;
|
|
preEvent === null || preEvent === void 0 ? void 0 : preEvent(event);
|
|
triggerOpen(nextOpen, delay);
|
|
|
|
// Pass to origin
|
|
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
|
|
args[_key - 1] = arguments[_key];
|
|
}
|
|
(_originChildProps$eve = originChildProps[eventName]) === null || _originChildProps$eve === void 0 ? void 0 : _originChildProps$eve.call.apply(_originChildProps$eve, [originChildProps, event].concat(args));
|
|
};
|
|
};
|
|
|
|
// ======================= Action: Click ========================
|
|
var clickToShow = showActions.has('click');
|
|
var clickToHide = hideActions.has('click') || hideActions.has('contextMenu');
|
|
if (clickToShow || clickToHide) {
|
|
cloneProps.onClick = function (event) {
|
|
var _originChildProps$onC;
|
|
if (openRef.current && clickToHide) {
|
|
triggerOpen(false);
|
|
} else if (!openRef.current && clickToShow) {
|
|
setMousePosByEvent(event);
|
|
triggerOpen(true);
|
|
}
|
|
|
|
// Pass to origin
|
|
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
|
|
args[_key2 - 1] = arguments[_key2];
|
|
}
|
|
(_originChildProps$onC = originChildProps.onClick) === null || _originChildProps$onC === void 0 ? void 0 : _originChildProps$onC.call.apply(_originChildProps$onC, [originChildProps, event].concat(args));
|
|
};
|
|
}
|
|
|
|
// Click to hide is special action since click popup element should not hide
|
|
useWinClick(mergedOpen, clickToHide, targetEle, popupEle, mask, maskClosable, inPopupOrChild, triggerOpen);
|
|
|
|
// ======================= Action: Hover ========================
|
|
var hoverToShow = showActions.has('hover');
|
|
var hoverToHide = hideActions.has('hover');
|
|
var onPopupMouseEnter;
|
|
var onPopupMouseLeave;
|
|
if (hoverToShow) {
|
|
wrapperAction('onMouseEnter', true, mouseEnterDelay, function (event) {
|
|
setMousePosByEvent(event);
|
|
});
|
|
onPopupMouseEnter = function onPopupMouseEnter() {
|
|
// Only trigger re-open when popup is visible
|
|
if (mergedOpen || inMotion) {
|
|
triggerOpen(true, mouseEnterDelay);
|
|
}
|
|
};
|
|
|
|
// Align Point
|
|
if (alignPoint) {
|
|
cloneProps.onMouseMove = function (event) {
|
|
var _originChildProps$onM;
|
|
// setMousePosByEvent(event);
|
|
(_originChildProps$onM = originChildProps.onMouseMove) === null || _originChildProps$onM === void 0 ? void 0 : _originChildProps$onM.call(originChildProps, event);
|
|
};
|
|
}
|
|
}
|
|
if (hoverToHide) {
|
|
wrapperAction('onMouseLeave', false, mouseLeaveDelay);
|
|
onPopupMouseLeave = function onPopupMouseLeave() {
|
|
triggerOpen(false, mouseLeaveDelay);
|
|
};
|
|
}
|
|
|
|
// ======================= Action: Focus ========================
|
|
if (showActions.has('focus')) {
|
|
wrapperAction('onFocus', true, focusDelay);
|
|
}
|
|
if (hideActions.has('focus')) {
|
|
wrapperAction('onBlur', false, blurDelay);
|
|
}
|
|
|
|
// ==================== Action: ContextMenu =====================
|
|
if (showActions.has('contextMenu')) {
|
|
cloneProps.onContextMenu = function (event) {
|
|
var _originChildProps$onC2;
|
|
if (openRef.current && hideActions.has('contextMenu')) {
|
|
triggerOpen(false);
|
|
} else {
|
|
setMousePosByEvent(event);
|
|
triggerOpen(true);
|
|
}
|
|
event.preventDefault();
|
|
|
|
// Pass to origin
|
|
for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
|
|
args[_key3 - 1] = arguments[_key3];
|
|
}
|
|
(_originChildProps$onC2 = originChildProps.onContextMenu) === null || _originChildProps$onC2 === void 0 ? void 0 : _originChildProps$onC2.call.apply(_originChildProps$onC2, [originChildProps, event].concat(args));
|
|
};
|
|
}
|
|
|
|
// ========================= ClassName ==========================
|
|
if (className) {
|
|
cloneProps.className = classnames_default()(originChildProps.className, className);
|
|
}
|
|
|
|
// =========================== Render ===========================
|
|
var mergedChildrenProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, originChildProps), cloneProps);
|
|
|
|
// Pass props into cloneProps for nest usage
|
|
var passedProps = {};
|
|
var passedEventList = ['onContextMenu', 'onClick', 'onMouseDown', 'onTouchStart', 'onMouseEnter', 'onMouseLeave', 'onFocus', 'onBlur'];
|
|
passedEventList.forEach(function (eventName) {
|
|
if (restProps[eventName]) {
|
|
passedProps[eventName] = function () {
|
|
var _mergedChildrenProps$;
|
|
for (var _len4 = arguments.length, args = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
|
|
args[_key4] = arguments[_key4];
|
|
}
|
|
(_mergedChildrenProps$ = mergedChildrenProps[eventName]) === null || _mergedChildrenProps$ === void 0 ? void 0 : _mergedChildrenProps$.call.apply(_mergedChildrenProps$, [mergedChildrenProps].concat(args));
|
|
restProps[eventName].apply(restProps, args);
|
|
};
|
|
}
|
|
});
|
|
|
|
// Child Node
|
|
var triggerNode = /*#__PURE__*/react.cloneElement(child, (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedChildrenProps), passedProps));
|
|
var arrowPos = {
|
|
x: arrowX,
|
|
y: arrowY
|
|
};
|
|
var innerArrow = arrow ? (0,objectSpread2/* default */.Z)({}, arrow !== true ? arrow : {}) : null;
|
|
|
|
// Render
|
|
return /*#__PURE__*/react.createElement(react.Fragment, null, /*#__PURE__*/react.createElement(rc_resize_observer_es/* default */.Z, {
|
|
disabled: !mergedOpen,
|
|
ref: setTargetRef,
|
|
onResize: onTargetResize
|
|
}, /*#__PURE__*/react.createElement(es_TriggerWrapper, {
|
|
getTriggerDOMNode: getTriggerDOMNode
|
|
}, triggerNode)), /*#__PURE__*/react.createElement(es_context.Provider, {
|
|
value: context
|
|
}, /*#__PURE__*/react.createElement(es_Popup, {
|
|
portal: PortalComponent,
|
|
ref: setPopupRef,
|
|
prefixCls: prefixCls,
|
|
popup: popup,
|
|
className: classnames_default()(popupClassName, alignedClassName),
|
|
style: popupStyle,
|
|
target: targetEle,
|
|
onMouseEnter: onPopupMouseEnter,
|
|
onMouseLeave: onPopupMouseLeave,
|
|
zIndex: zIndex
|
|
// Open
|
|
,
|
|
open: mergedOpen,
|
|
keepDom: inMotion
|
|
// Click
|
|
,
|
|
onClick: onPopupClick
|
|
// Mask
|
|
,
|
|
mask: mask
|
|
// Motion
|
|
,
|
|
motion: mergePopupMotion,
|
|
maskMotion: mergeMaskMotion,
|
|
onVisibleChanged: onVisibleChanged,
|
|
onPrepare: onPrepare
|
|
// Portal
|
|
,
|
|
forceRender: forceRender,
|
|
autoDestroy: mergedAutoDestroy,
|
|
getPopupContainer: getPopupContainer
|
|
// Arrow
|
|
,
|
|
align: alignInfo,
|
|
arrow: innerArrow,
|
|
arrowPos: arrowPos
|
|
// Align
|
|
,
|
|
ready: ready,
|
|
offsetX: offsetX,
|
|
offsetY: offsetY,
|
|
offsetR: offsetR,
|
|
offsetB: offsetB,
|
|
onAlign: triggerAlign
|
|
// Stretch
|
|
,
|
|
stretch: stretch,
|
|
targetWidth: targetWidth / scaleX,
|
|
targetHeight: targetHeight / scaleY
|
|
})));
|
|
});
|
|
if (false) {}
|
|
return Trigger;
|
|
}
|
|
/* harmony default export */ var trigger_es = (generateTrigger(es));
|
|
|
|
/***/ }),
|
|
|
|
/***/ 62874:
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/rc-motion/es/index.js + 11 modules ***!
|
|
\*********************************************************/
|
|
/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
|
|
|
|
|
|
// EXPORTS
|
|
__webpack_require__.d(__webpack_exports__, {
|
|
"Z": function() { return /* binding */ es; }
|
|
});
|
|
|
|
// UNUSED EXPORTS: CSSMotionList
|
|
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/defineProperty.js
|
|
var defineProperty = __webpack_require__(4942);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectSpread2.js
|
|
var objectSpread2 = __webpack_require__(1413);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/slicedToArray.js + 1 modules
|
|
var slicedToArray = __webpack_require__(97685);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/typeof.js
|
|
var esm_typeof = __webpack_require__(71002);
|
|
// EXTERNAL MODULE: ./node_modules/react/index.js
|
|
var react = __webpack_require__(67294);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/Dom/findDOMNode.js
|
|
var findDOMNode = __webpack_require__(34203);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/ref.js
|
|
var es_ref = __webpack_require__(42550);
|
|
// EXTERNAL MODULE: ./node_modules/classnames/index.js
|
|
var classnames = __webpack_require__(94184);
|
|
var classnames_default = /*#__PURE__*/__webpack_require__.n(classnames);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/Dom/canUseDom.js
|
|
var canUseDom = __webpack_require__(98924);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/util/motion.js
|
|
|
|
|
|
|
|
// ================= Transition =================
|
|
// Event wrapper. Copy from react source code
|
|
function makePrefixMap(styleProp, eventName) {
|
|
var prefixes = {};
|
|
prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
|
|
prefixes["Webkit".concat(styleProp)] = "webkit".concat(eventName);
|
|
prefixes["Moz".concat(styleProp)] = "moz".concat(eventName);
|
|
prefixes["ms".concat(styleProp)] = "MS".concat(eventName);
|
|
prefixes["O".concat(styleProp)] = "o".concat(eventName.toLowerCase());
|
|
return prefixes;
|
|
}
|
|
|
|
function getVendorPrefixes(domSupport, win) {
|
|
var prefixes = {
|
|
animationend: makePrefixMap('Animation', 'AnimationEnd'),
|
|
transitionend: makePrefixMap('Transition', 'TransitionEnd')
|
|
};
|
|
|
|
if (domSupport) {
|
|
if (!('AnimationEvent' in win)) {
|
|
delete prefixes.animationend.animation;
|
|
}
|
|
|
|
if (!('TransitionEvent' in win)) {
|
|
delete prefixes.transitionend.transition;
|
|
}
|
|
}
|
|
|
|
return prefixes;
|
|
}
|
|
var vendorPrefixes = getVendorPrefixes((0,canUseDom/* default */.Z)(), typeof window !== 'undefined' ? window : {});
|
|
var style = {};
|
|
|
|
if ((0,canUseDom/* default */.Z)()) {
|
|
var _document$createEleme = document.createElement('div');
|
|
|
|
style = _document$createEleme.style;
|
|
}
|
|
|
|
var prefixedEventNames = {};
|
|
function getVendorPrefixedEventName(eventName) {
|
|
if (prefixedEventNames[eventName]) {
|
|
return prefixedEventNames[eventName];
|
|
}
|
|
|
|
var prefixMap = vendorPrefixes[eventName];
|
|
|
|
if (prefixMap) {
|
|
var stylePropList = Object.keys(prefixMap);
|
|
var len = stylePropList.length;
|
|
|
|
for (var i = 0; i < len; i += 1) {
|
|
var styleProp = stylePropList[i];
|
|
|
|
if (Object.prototype.hasOwnProperty.call(prefixMap, styleProp) && styleProp in style) {
|
|
prefixedEventNames[eventName] = prefixMap[styleProp];
|
|
return prefixedEventNames[eventName];
|
|
}
|
|
}
|
|
}
|
|
|
|
return '';
|
|
}
|
|
var internalAnimationEndName = getVendorPrefixedEventName('animationend');
|
|
var internalTransitionEndName = getVendorPrefixedEventName('transitionend');
|
|
var supportTransition = !!(internalAnimationEndName && internalTransitionEndName);
|
|
var animationEndName = internalAnimationEndName || 'animationend';
|
|
var transitionEndName = internalTransitionEndName || 'transitionend';
|
|
function getTransitionName(transitionName, transitionType) {
|
|
if (!transitionName) return null;
|
|
|
|
if ((0,esm_typeof/* default */.Z)(transitionName) === 'object') {
|
|
var type = transitionType.replace(/-\w/g, function (match) {
|
|
return match[1].toUpperCase();
|
|
});
|
|
return transitionName[type];
|
|
}
|
|
|
|
return "".concat(transitionName, "-").concat(transitionType);
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/interface.js
|
|
var STATUS_NONE = 'none';
|
|
var STATUS_APPEAR = 'appear';
|
|
var STATUS_ENTER = 'enter';
|
|
var STATUS_LEAVE = 'leave';
|
|
var STEP_NONE = 'none';
|
|
var STEP_PREPARE = 'prepare';
|
|
var STEP_START = 'start';
|
|
var STEP_ACTIVE = 'active';
|
|
var STEP_ACTIVATED = 'end';
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/hooks/useState.js
|
|
var useState = __webpack_require__(30470);
|
|
// EXTERNAL MODULE: ./node_modules/rc-util/es/raf.js
|
|
var raf = __webpack_require__(75164);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/hooks/useNextFrame.js
|
|
|
|
|
|
/* harmony default export */ var useNextFrame = (function () {
|
|
var nextFrameRef = react.useRef(null);
|
|
|
|
function cancelNextFrame() {
|
|
raf/* default.cancel */.Z.cancel(nextFrameRef.current);
|
|
}
|
|
|
|
function nextFrame(callback) {
|
|
var delay = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
|
|
cancelNextFrame();
|
|
var nextFrameId = (0,raf/* default */.Z)(function () {
|
|
if (delay <= 1) {
|
|
callback({
|
|
isCanceled: function isCanceled() {
|
|
return nextFrameId !== nextFrameRef.current;
|
|
}
|
|
});
|
|
} else {
|
|
nextFrame(callback, delay - 1);
|
|
}
|
|
});
|
|
nextFrameRef.current = nextFrameId;
|
|
}
|
|
|
|
react.useEffect(function () {
|
|
return function () {
|
|
cancelNextFrame();
|
|
};
|
|
}, []);
|
|
return [nextFrame, cancelNextFrame];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/hooks/useIsomorphicLayoutEffect.js
|
|
|
|
// It's safe to use `useLayoutEffect` but the warning is annoying
|
|
|
|
var useIsomorphicLayoutEffect = (0,canUseDom/* default */.Z)() ? react.useLayoutEffect : react.useEffect;
|
|
/* harmony default export */ var hooks_useIsomorphicLayoutEffect = (useIsomorphicLayoutEffect);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/hooks/useStepQueue.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var STEP_QUEUE = [STEP_PREPARE, STEP_START, STEP_ACTIVE, STEP_ACTIVATED];
|
|
/** Skip current step */
|
|
|
|
var SkipStep = false;
|
|
/** Current step should be update in */
|
|
|
|
var DoStep = true;
|
|
function isActive(step) {
|
|
return step === STEP_ACTIVE || step === STEP_ACTIVATED;
|
|
}
|
|
/* harmony default export */ var useStepQueue = (function (status, callback) {
|
|
var _useState = (0,useState/* default */.Z)(STEP_NONE),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
step = _useState2[0],
|
|
setStep = _useState2[1];
|
|
|
|
var _useNextFrame = useNextFrame(),
|
|
_useNextFrame2 = (0,slicedToArray/* default */.Z)(_useNextFrame, 2),
|
|
nextFrame = _useNextFrame2[0],
|
|
cancelNextFrame = _useNextFrame2[1];
|
|
|
|
function startQueue() {
|
|
setStep(STEP_PREPARE, true);
|
|
}
|
|
|
|
hooks_useIsomorphicLayoutEffect(function () {
|
|
if (step !== STEP_NONE && step !== STEP_ACTIVATED) {
|
|
var index = STEP_QUEUE.indexOf(step);
|
|
var nextStep = STEP_QUEUE[index + 1];
|
|
var result = callback(step);
|
|
|
|
if (result === SkipStep) {
|
|
// Skip when no needed
|
|
setStep(nextStep, true);
|
|
} else {
|
|
// Do as frame for step update
|
|
nextFrame(function (info) {
|
|
function doNext() {
|
|
// Skip since current queue is ood
|
|
if (info.isCanceled()) return;
|
|
setStep(nextStep, true);
|
|
}
|
|
|
|
if (result === true) {
|
|
doNext();
|
|
} else {
|
|
// Only promise should be async
|
|
Promise.resolve(result).then(doNext);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}, [status, step]);
|
|
react.useEffect(function () {
|
|
return function () {
|
|
cancelNextFrame();
|
|
};
|
|
}, []);
|
|
return [startQueue, step];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/hooks/useDomMotionEvents.js
|
|
|
|
|
|
|
|
/* harmony default export */ var useDomMotionEvents = (function (callback) {
|
|
var cacheElementRef = (0,react.useRef)(); // Cache callback
|
|
|
|
var callbackRef = (0,react.useRef)(callback);
|
|
callbackRef.current = callback; // Internal motion event handler
|
|
|
|
var onInternalMotionEnd = react.useCallback(function (event) {
|
|
callbackRef.current(event);
|
|
}, []); // Remove events
|
|
|
|
function removeMotionEvents(element) {
|
|
if (element) {
|
|
element.removeEventListener(transitionEndName, onInternalMotionEnd);
|
|
element.removeEventListener(animationEndName, onInternalMotionEnd);
|
|
}
|
|
} // Patch events
|
|
|
|
|
|
function patchMotionEvents(element) {
|
|
if (cacheElementRef.current && cacheElementRef.current !== element) {
|
|
removeMotionEvents(cacheElementRef.current);
|
|
}
|
|
|
|
if (element && element !== cacheElementRef.current) {
|
|
element.addEventListener(transitionEndName, onInternalMotionEnd);
|
|
element.addEventListener(animationEndName, onInternalMotionEnd); // Save as cache in case dom removed trigger by `motionDeadline`
|
|
|
|
cacheElementRef.current = element;
|
|
}
|
|
} // Clean up when removed
|
|
|
|
|
|
react.useEffect(function () {
|
|
return function () {
|
|
removeMotionEvents(cacheElementRef.current);
|
|
};
|
|
}, []);
|
|
return [patchMotionEvents, removeMotionEvents];
|
|
});
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/hooks/useStatus.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function useStatus(supportMotion, visible, getElement, _ref) {
|
|
var _ref$motionEnter = _ref.motionEnter,
|
|
motionEnter = _ref$motionEnter === void 0 ? true : _ref$motionEnter,
|
|
_ref$motionAppear = _ref.motionAppear,
|
|
motionAppear = _ref$motionAppear === void 0 ? true : _ref$motionAppear,
|
|
_ref$motionLeave = _ref.motionLeave,
|
|
motionLeave = _ref$motionLeave === void 0 ? true : _ref$motionLeave,
|
|
motionDeadline = _ref.motionDeadline,
|
|
motionLeaveImmediately = _ref.motionLeaveImmediately,
|
|
onAppearPrepare = _ref.onAppearPrepare,
|
|
onEnterPrepare = _ref.onEnterPrepare,
|
|
onLeavePrepare = _ref.onLeavePrepare,
|
|
onAppearStart = _ref.onAppearStart,
|
|
onEnterStart = _ref.onEnterStart,
|
|
onLeaveStart = _ref.onLeaveStart,
|
|
onAppearActive = _ref.onAppearActive,
|
|
onEnterActive = _ref.onEnterActive,
|
|
onLeaveActive = _ref.onLeaveActive,
|
|
onAppearEnd = _ref.onAppearEnd,
|
|
onEnterEnd = _ref.onEnterEnd,
|
|
onLeaveEnd = _ref.onLeaveEnd,
|
|
onVisibleChanged = _ref.onVisibleChanged;
|
|
|
|
// Used for outer render usage to avoid `visible: false & status: none` to render nothing
|
|
var _useState = (0,useState/* default */.Z)(),
|
|
_useState2 = (0,slicedToArray/* default */.Z)(_useState, 2),
|
|
asyncVisible = _useState2[0],
|
|
setAsyncVisible = _useState2[1];
|
|
|
|
var _useState3 = (0,useState/* default */.Z)(STATUS_NONE),
|
|
_useState4 = (0,slicedToArray/* default */.Z)(_useState3, 2),
|
|
status = _useState4[0],
|
|
setStatus = _useState4[1];
|
|
|
|
var _useState5 = (0,useState/* default */.Z)(null),
|
|
_useState6 = (0,slicedToArray/* default */.Z)(_useState5, 2),
|
|
style = _useState6[0],
|
|
setStyle = _useState6[1];
|
|
|
|
var mountedRef = (0,react.useRef)(false);
|
|
var deadlineRef = (0,react.useRef)(null); // =========================== Dom Node ===========================
|
|
|
|
function getDomElement() {
|
|
return getElement();
|
|
} // ========================== Motion End ==========================
|
|
|
|
|
|
var activeRef = (0,react.useRef)(false);
|
|
|
|
function onInternalMotionEnd(event) {
|
|
var element = getDomElement();
|
|
|
|
if (event && !event.deadline && event.target !== element) {
|
|
// event exists
|
|
// not initiated by deadline
|
|
// transitionEnd not fired by inner elements
|
|
return;
|
|
}
|
|
|
|
var currentActive = activeRef.current;
|
|
var canEnd;
|
|
|
|
if (status === STATUS_APPEAR && currentActive) {
|
|
canEnd = onAppearEnd === null || onAppearEnd === void 0 ? void 0 : onAppearEnd(element, event);
|
|
} else if (status === STATUS_ENTER && currentActive) {
|
|
canEnd = onEnterEnd === null || onEnterEnd === void 0 ? void 0 : onEnterEnd(element, event);
|
|
} else if (status === STATUS_LEAVE && currentActive) {
|
|
canEnd = onLeaveEnd === null || onLeaveEnd === void 0 ? void 0 : onLeaveEnd(element, event);
|
|
} // Only update status when `canEnd` and not destroyed
|
|
|
|
|
|
if (status !== STATUS_NONE && currentActive && canEnd !== false) {
|
|
setStatus(STATUS_NONE, true);
|
|
setStyle(null, true);
|
|
}
|
|
}
|
|
|
|
var _useDomMotionEvents = useDomMotionEvents(onInternalMotionEnd),
|
|
_useDomMotionEvents2 = (0,slicedToArray/* default */.Z)(_useDomMotionEvents, 1),
|
|
patchMotionEvents = _useDomMotionEvents2[0]; // ============================= Step =============================
|
|
|
|
|
|
var eventHandlers = react.useMemo(function () {
|
|
var _ref2, _ref3, _ref4;
|
|
|
|
switch (status) {
|
|
case STATUS_APPEAR:
|
|
return _ref2 = {}, (0,defineProperty/* default */.Z)(_ref2, STEP_PREPARE, onAppearPrepare), (0,defineProperty/* default */.Z)(_ref2, STEP_START, onAppearStart), (0,defineProperty/* default */.Z)(_ref2, STEP_ACTIVE, onAppearActive), _ref2;
|
|
|
|
case STATUS_ENTER:
|
|
return _ref3 = {}, (0,defineProperty/* default */.Z)(_ref3, STEP_PREPARE, onEnterPrepare), (0,defineProperty/* default */.Z)(_ref3, STEP_START, onEnterStart), (0,defineProperty/* default */.Z)(_ref3, STEP_ACTIVE, onEnterActive), _ref3;
|
|
|
|
case STATUS_LEAVE:
|
|
return _ref4 = {}, (0,defineProperty/* default */.Z)(_ref4, STEP_PREPARE, onLeavePrepare), (0,defineProperty/* default */.Z)(_ref4, STEP_START, onLeaveStart), (0,defineProperty/* default */.Z)(_ref4, STEP_ACTIVE, onLeaveActive), _ref4;
|
|
|
|
default:
|
|
return {};
|
|
}
|
|
}, [status]);
|
|
|
|
var _useStepQueue = useStepQueue(status, function (newStep) {
|
|
// Only prepare step can be skip
|
|
if (newStep === STEP_PREPARE) {
|
|
var onPrepare = eventHandlers[STEP_PREPARE];
|
|
|
|
if (!onPrepare) {
|
|
return SkipStep;
|
|
}
|
|
|
|
return onPrepare(getDomElement());
|
|
} // Rest step is sync update
|
|
|
|
|
|
if (step in eventHandlers) {
|
|
var _eventHandlers$step;
|
|
|
|
setStyle(((_eventHandlers$step = eventHandlers[step]) === null || _eventHandlers$step === void 0 ? void 0 : _eventHandlers$step.call(eventHandlers, getDomElement(), null)) || null);
|
|
}
|
|
|
|
if (step === STEP_ACTIVE) {
|
|
// Patch events when motion needed
|
|
patchMotionEvents(getDomElement());
|
|
|
|
if (motionDeadline > 0) {
|
|
clearTimeout(deadlineRef.current);
|
|
deadlineRef.current = setTimeout(function () {
|
|
onInternalMotionEnd({
|
|
deadline: true
|
|
});
|
|
}, motionDeadline);
|
|
}
|
|
}
|
|
|
|
return DoStep;
|
|
}),
|
|
_useStepQueue2 = (0,slicedToArray/* default */.Z)(_useStepQueue, 2),
|
|
startStep = _useStepQueue2[0],
|
|
step = _useStepQueue2[1];
|
|
|
|
var active = isActive(step);
|
|
activeRef.current = active; // ============================ Status ============================
|
|
// Update with new status
|
|
|
|
hooks_useIsomorphicLayoutEffect(function () {
|
|
setAsyncVisible(visible);
|
|
var isMounted = mountedRef.current;
|
|
mountedRef.current = true;
|
|
|
|
if (!supportMotion) {
|
|
return;
|
|
}
|
|
|
|
var nextStatus; // Appear
|
|
|
|
if (!isMounted && visible && motionAppear) {
|
|
nextStatus = STATUS_APPEAR;
|
|
} // Enter
|
|
|
|
|
|
if (isMounted && visible && motionEnter) {
|
|
nextStatus = STATUS_ENTER;
|
|
} // Leave
|
|
|
|
|
|
if (isMounted && !visible && motionLeave || !isMounted && motionLeaveImmediately && !visible && motionLeave) {
|
|
nextStatus = STATUS_LEAVE;
|
|
} // Update to next status
|
|
|
|
|
|
if (nextStatus) {
|
|
setStatus(nextStatus);
|
|
startStep();
|
|
}
|
|
}, [visible]); // ============================ Effect ============================
|
|
// Reset when motion changed
|
|
|
|
(0,react.useEffect)(function () {
|
|
if ( // Cancel appear
|
|
status === STATUS_APPEAR && !motionAppear || // Cancel enter
|
|
status === STATUS_ENTER && !motionEnter || // Cancel leave
|
|
status === STATUS_LEAVE && !motionLeave) {
|
|
setStatus(STATUS_NONE);
|
|
}
|
|
}, [motionAppear, motionEnter, motionLeave]);
|
|
(0,react.useEffect)(function () {
|
|
return function () {
|
|
mountedRef.current = false;
|
|
clearTimeout(deadlineRef.current);
|
|
};
|
|
}, []); // Trigger `onVisibleChanged`
|
|
|
|
var firstMountChangeRef = react.useRef(false);
|
|
(0,react.useEffect)(function () {
|
|
// [visible & motion not end] => [!visible & motion end] still need trigger onVisibleChanged
|
|
if (asyncVisible) {
|
|
firstMountChangeRef.current = true;
|
|
}
|
|
|
|
if (asyncVisible !== undefined && status === STATUS_NONE) {
|
|
// Skip first render is invisible since it's nothing changed
|
|
if (firstMountChangeRef.current || asyncVisible) {
|
|
onVisibleChanged === null || onVisibleChanged === void 0 ? void 0 : onVisibleChanged(asyncVisible);
|
|
}
|
|
|
|
firstMountChangeRef.current = true;
|
|
}
|
|
}, [asyncVisible, status]); // ============================ Styles ============================
|
|
|
|
var mergedStyle = style;
|
|
|
|
if (eventHandlers[STEP_PREPARE] && step === STEP_START) {
|
|
mergedStyle = (0,objectSpread2/* default */.Z)({
|
|
transition: 'none'
|
|
}, mergedStyle);
|
|
}
|
|
|
|
return [status, step, mergedStyle, asyncVisible !== null && asyncVisible !== void 0 ? asyncVisible : visible];
|
|
}
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/classCallCheck.js
|
|
var classCallCheck = __webpack_require__(15671);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createClass.js
|
|
var createClass = __webpack_require__(43144);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/inherits.js
|
|
var inherits = __webpack_require__(60136);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/createSuper.js + 1 modules
|
|
var createSuper = __webpack_require__(51630);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/DomWrapper.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var DomWrapper = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(DomWrapper, _React$Component);
|
|
|
|
var _super = (0,createSuper/* default */.Z)(DomWrapper);
|
|
|
|
function DomWrapper() {
|
|
(0,classCallCheck/* default */.Z)(this, DomWrapper);
|
|
|
|
return _super.apply(this, arguments);
|
|
}
|
|
|
|
(0,createClass/* default */.Z)(DomWrapper, [{
|
|
key: "render",
|
|
value: function render() {
|
|
return this.props.children;
|
|
}
|
|
}]);
|
|
|
|
return DomWrapper;
|
|
}(react.Component);
|
|
|
|
/* harmony default export */ var es_DomWrapper = (DomWrapper);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/CSSMotion.js
|
|
|
|
|
|
|
|
|
|
|
|
/* eslint-disable react/default-props-match-prop-types, react/no-multi-comp, react/prop-types */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
* `transitionSupport` is used for none transition test case.
|
|
* Default we use browser transition event support check.
|
|
*/
|
|
function genCSSMotion(config) {
|
|
var transitionSupport = config;
|
|
|
|
if ((0,esm_typeof/* default */.Z)(config) === 'object') {
|
|
transitionSupport = config.transitionSupport;
|
|
}
|
|
|
|
function isSupportTransition(props) {
|
|
return !!(props.motionName && transitionSupport);
|
|
}
|
|
|
|
var CSSMotion = /*#__PURE__*/react.forwardRef(function (props, ref) {
|
|
var _props$visible = props.visible,
|
|
visible = _props$visible === void 0 ? true : _props$visible,
|
|
_props$removeOnLeave = props.removeOnLeave,
|
|
removeOnLeave = _props$removeOnLeave === void 0 ? true : _props$removeOnLeave,
|
|
forceRender = props.forceRender,
|
|
children = props.children,
|
|
motionName = props.motionName,
|
|
leavedClassName = props.leavedClassName,
|
|
eventProps = props.eventProps;
|
|
var supportMotion = isSupportTransition(props); // Ref to the react node, it may be a HTMLElement
|
|
|
|
var nodeRef = (0,react.useRef)(); // Ref to the dom wrapper in case ref can not pass to HTMLElement
|
|
|
|
var wrapperNodeRef = (0,react.useRef)();
|
|
|
|
function getDomElement() {
|
|
try {
|
|
// Here we're avoiding call for findDOMNode since it's deprecated
|
|
// in strict mode. We're calling it only when node ref is not
|
|
// an instance of DOM HTMLElement. Otherwise use
|
|
// findDOMNode as a final resort
|
|
return nodeRef.current instanceof HTMLElement ? nodeRef.current : (0,findDOMNode/* default */.Z)(wrapperNodeRef.current);
|
|
} catch (e) {
|
|
// Only happen when `motionDeadline` trigger but element removed.
|
|
return null;
|
|
}
|
|
}
|
|
|
|
var _useStatus = useStatus(supportMotion, visible, getDomElement, props),
|
|
_useStatus2 = (0,slicedToArray/* default */.Z)(_useStatus, 4),
|
|
status = _useStatus2[0],
|
|
statusStep = _useStatus2[1],
|
|
statusStyle = _useStatus2[2],
|
|
mergedVisible = _useStatus2[3]; // Record whether content has rendered
|
|
// Will return null for un-rendered even when `removeOnLeave={false}`
|
|
|
|
|
|
var renderedRef = react.useRef(mergedVisible);
|
|
|
|
if (mergedVisible) {
|
|
renderedRef.current = true;
|
|
} // ====================== Refs ======================
|
|
|
|
|
|
var setNodeRef = react.useCallback(function (node) {
|
|
nodeRef.current = node;
|
|
(0,es_ref/* fillRef */.mH)(ref, node);
|
|
}, [ref]); // ===================== Render =====================
|
|
|
|
var motionChildren;
|
|
|
|
var mergedProps = (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, eventProps), {}, {
|
|
visible: visible
|
|
});
|
|
|
|
if (!children) {
|
|
// No children
|
|
motionChildren = null;
|
|
} else if (status === STATUS_NONE || !isSupportTransition(props)) {
|
|
// Stable children
|
|
if (mergedVisible) {
|
|
motionChildren = children((0,objectSpread2/* default */.Z)({}, mergedProps), setNodeRef);
|
|
} else if (!removeOnLeave && renderedRef.current && leavedClassName) {
|
|
motionChildren = children((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedProps), {}, {
|
|
className: leavedClassName
|
|
}), setNodeRef);
|
|
} else if (forceRender || !removeOnLeave && !leavedClassName) {
|
|
motionChildren = children((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedProps), {}, {
|
|
style: {
|
|
display: 'none'
|
|
}
|
|
}), setNodeRef);
|
|
} else {
|
|
motionChildren = null;
|
|
}
|
|
} else {
|
|
var _classNames;
|
|
|
|
// In motion
|
|
var statusSuffix;
|
|
|
|
if (statusStep === STEP_PREPARE) {
|
|
statusSuffix = 'prepare';
|
|
} else if (isActive(statusStep)) {
|
|
statusSuffix = 'active';
|
|
} else if (statusStep === STEP_START) {
|
|
statusSuffix = 'start';
|
|
}
|
|
|
|
motionChildren = children((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, mergedProps), {}, {
|
|
className: classnames_default()(getTransitionName(motionName, status), (_classNames = {}, (0,defineProperty/* default */.Z)(_classNames, getTransitionName(motionName, "".concat(status, "-").concat(statusSuffix)), statusSuffix), (0,defineProperty/* default */.Z)(_classNames, motionName, typeof motionName === 'string'), _classNames)),
|
|
style: statusStyle
|
|
}), setNodeRef);
|
|
} // Auto inject ref if child node not have `ref` props
|
|
|
|
|
|
if ( /*#__PURE__*/react.isValidElement(motionChildren) && (0,es_ref/* supportRef */.Yr)(motionChildren)) {
|
|
var _ref = motionChildren,
|
|
originNodeRef = _ref.ref;
|
|
|
|
if (!originNodeRef) {
|
|
motionChildren = /*#__PURE__*/react.cloneElement(motionChildren, {
|
|
ref: setNodeRef
|
|
});
|
|
}
|
|
}
|
|
|
|
return /*#__PURE__*/react.createElement(es_DomWrapper, {
|
|
ref: wrapperNodeRef
|
|
}, motionChildren);
|
|
});
|
|
CSSMotion.displayName = 'CSSMotion';
|
|
return CSSMotion;
|
|
}
|
|
/* harmony default export */ var es_CSSMotion = (genCSSMotion(supportTransition));
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/extends.js
|
|
var esm_extends = __webpack_require__(87462);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/objectWithoutProperties.js
|
|
var objectWithoutProperties = __webpack_require__(45987);
|
|
// EXTERNAL MODULE: ./node_modules/@babel/runtime/helpers/esm/assertThisInitialized.js
|
|
var assertThisInitialized = __webpack_require__(97326);
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/util/diff.js
|
|
|
|
|
|
var STATUS_ADD = 'add';
|
|
var STATUS_KEEP = 'keep';
|
|
var STATUS_REMOVE = 'remove';
|
|
var STATUS_REMOVED = 'removed';
|
|
function wrapKeyToObject(key) {
|
|
var keyObj;
|
|
|
|
if (key && (0,esm_typeof/* default */.Z)(key) === 'object' && 'key' in key) {
|
|
keyObj = key;
|
|
} else {
|
|
keyObj = {
|
|
key: key
|
|
};
|
|
}
|
|
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, keyObj), {}, {
|
|
key: String(keyObj.key)
|
|
});
|
|
}
|
|
function parseKeys() {
|
|
var keys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
return keys.map(wrapKeyToObject);
|
|
}
|
|
function diffKeys() {
|
|
var prevKeys = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
|
|
var currentKeys = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
|
|
var list = [];
|
|
var currentIndex = 0;
|
|
var currentLen = currentKeys.length;
|
|
var prevKeyObjects = parseKeys(prevKeys);
|
|
var currentKeyObjects = parseKeys(currentKeys); // Check prev keys to insert or keep
|
|
|
|
prevKeyObjects.forEach(function (keyObj) {
|
|
var hit = false;
|
|
|
|
for (var i = currentIndex; i < currentLen; i += 1) {
|
|
var currentKeyObj = currentKeyObjects[i];
|
|
|
|
if (currentKeyObj.key === keyObj.key) {
|
|
// New added keys should add before current key
|
|
if (currentIndex < i) {
|
|
list = list.concat(currentKeyObjects.slice(currentIndex, i).map(function (obj) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, obj), {}, {
|
|
status: STATUS_ADD
|
|
});
|
|
}));
|
|
currentIndex = i;
|
|
}
|
|
|
|
list.push((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, currentKeyObj), {}, {
|
|
status: STATUS_KEEP
|
|
}));
|
|
currentIndex += 1;
|
|
hit = true;
|
|
break;
|
|
}
|
|
} // If not hit, it means key is removed
|
|
|
|
|
|
if (!hit) {
|
|
list.push((0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, keyObj), {}, {
|
|
status: STATUS_REMOVE
|
|
}));
|
|
}
|
|
}); // Add rest to the list
|
|
|
|
if (currentIndex < currentLen) {
|
|
list = list.concat(currentKeyObjects.slice(currentIndex).map(function (obj) {
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, obj), {}, {
|
|
status: STATUS_ADD
|
|
});
|
|
}));
|
|
}
|
|
/**
|
|
* Merge same key when it remove and add again:
|
|
* [1 - add, 2 - keep, 1 - remove] -> [1 - keep, 2 - keep]
|
|
*/
|
|
|
|
|
|
var keys = {};
|
|
list.forEach(function (_ref) {
|
|
var key = _ref.key;
|
|
keys[key] = (keys[key] || 0) + 1;
|
|
});
|
|
var duplicatedKeys = Object.keys(keys).filter(function (key) {
|
|
return keys[key] > 1;
|
|
});
|
|
duplicatedKeys.forEach(function (matchKey) {
|
|
// Remove `STATUS_REMOVE` node.
|
|
list = list.filter(function (_ref2) {
|
|
var key = _ref2.key,
|
|
status = _ref2.status;
|
|
return key !== matchKey || status !== STATUS_REMOVE;
|
|
}); // Update `STATUS_ADD` to `STATUS_KEEP`
|
|
|
|
list.forEach(function (node) {
|
|
if (node.key === matchKey) {
|
|
// eslint-disable-next-line no-param-reassign
|
|
node.status = STATUS_KEEP;
|
|
}
|
|
});
|
|
});
|
|
return list;
|
|
}
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/CSSMotionList.js
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
var _excluded = ["component", "children", "onVisibleChanged", "onAllRemoved"],
|
|
_excluded2 = ["status"];
|
|
|
|
/* eslint react/prop-types: 0 */
|
|
|
|
|
|
|
|
|
|
var MOTION_PROP_NAMES = ['eventProps', 'visible', 'children', 'motionName', 'motionAppear', 'motionEnter', 'motionLeave', 'motionLeaveImmediately', 'motionDeadline', 'removeOnLeave', 'leavedClassName', 'onAppearStart', 'onAppearActive', 'onAppearEnd', 'onEnterStart', 'onEnterActive', 'onEnterEnd', 'onLeaveStart', 'onLeaveActive', 'onLeaveEnd'];
|
|
|
|
/**
|
|
* Generate a CSSMotionList component with config
|
|
* @param transitionSupport No need since CSSMotionList no longer depends on transition support
|
|
* @param CSSMotion CSSMotion component
|
|
*/
|
|
function genCSSMotionList(transitionSupport) {
|
|
var CSSMotion = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : es_CSSMotion;
|
|
|
|
var CSSMotionList = /*#__PURE__*/function (_React$Component) {
|
|
(0,inherits/* default */.Z)(CSSMotionList, _React$Component);
|
|
|
|
var _super = (0,createSuper/* default */.Z)(CSSMotionList);
|
|
|
|
function CSSMotionList() {
|
|
var _this;
|
|
|
|
(0,classCallCheck/* default */.Z)(this, CSSMotionList);
|
|
|
|
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
|
|
args[_key] = arguments[_key];
|
|
}
|
|
|
|
_this = _super.call.apply(_super, [this].concat(args));
|
|
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "state", {
|
|
keyEntities: []
|
|
});
|
|
|
|
(0,defineProperty/* default */.Z)((0,assertThisInitialized/* default */.Z)(_this), "removeKey", function (removeKey) {
|
|
var keyEntities = _this.state.keyEntities;
|
|
var nextKeyEntities = keyEntities.map(function (entity) {
|
|
if (entity.key !== removeKey) return entity;
|
|
return (0,objectSpread2/* default */.Z)((0,objectSpread2/* default */.Z)({}, entity), {}, {
|
|
status: STATUS_REMOVED
|
|
});
|
|
});
|
|
|
|
_this.setState({
|
|
keyEntities: nextKeyEntities
|
|
});
|
|
|
|
return nextKeyEntities.filter(function (_ref) {
|
|
var status = _ref.status;
|
|
return status !== STATUS_REMOVED;
|
|
}).length;
|
|
});
|
|
|
|
return _this;
|
|
}
|
|
|
|
(0,createClass/* default */.Z)(CSSMotionList, [{
|
|
key: "render",
|
|
value: function render() {
|
|
var _this2 = this;
|
|
|
|
var keyEntities = this.state.keyEntities;
|
|
|
|
var _this$props = this.props,
|
|
component = _this$props.component,
|
|
children = _this$props.children,
|
|
_onVisibleChanged = _this$props.onVisibleChanged,
|
|
onAllRemoved = _this$props.onAllRemoved,
|
|
restProps = (0,objectWithoutProperties/* default */.Z)(_this$props, _excluded);
|
|
|
|
var Component = component || react.Fragment;
|
|
var motionProps = {};
|
|
MOTION_PROP_NAMES.forEach(function (prop) {
|
|
motionProps[prop] = restProps[prop];
|
|
delete restProps[prop];
|
|
});
|
|
delete restProps.keys;
|
|
return /*#__PURE__*/react.createElement(Component, restProps, keyEntities.map(function (_ref2) {
|
|
var status = _ref2.status,
|
|
eventProps = (0,objectWithoutProperties/* default */.Z)(_ref2, _excluded2);
|
|
|
|
var visible = status === STATUS_ADD || status === STATUS_KEEP;
|
|
return /*#__PURE__*/react.createElement(CSSMotion, (0,esm_extends/* default */.Z)({}, motionProps, {
|
|
key: eventProps.key,
|
|
visible: visible,
|
|
eventProps: eventProps,
|
|
onVisibleChanged: function onVisibleChanged(changedVisible) {
|
|
_onVisibleChanged === null || _onVisibleChanged === void 0 ? void 0 : _onVisibleChanged(changedVisible, {
|
|
key: eventProps.key
|
|
});
|
|
|
|
if (!changedVisible) {
|
|
var restKeysCount = _this2.removeKey(eventProps.key);
|
|
|
|
if (restKeysCount === 0 && onAllRemoved) {
|
|
onAllRemoved();
|
|
}
|
|
}
|
|
}
|
|
}), children);
|
|
}));
|
|
}
|
|
}], [{
|
|
key: "getDerivedStateFromProps",
|
|
value: function getDerivedStateFromProps(_ref3, _ref4) {
|
|
var keys = _ref3.keys;
|
|
var keyEntities = _ref4.keyEntities;
|
|
var parsedKeyObjects = parseKeys(keys);
|
|
var mixedKeyEntities = diffKeys(keyEntities, parsedKeyObjects);
|
|
return {
|
|
keyEntities: mixedKeyEntities.filter(function (entity) {
|
|
var prevEntity = keyEntities.find(function (_ref5) {
|
|
var key = _ref5.key;
|
|
return entity.key === key;
|
|
}); // Remove if already mark as removed
|
|
|
|
if (prevEntity && prevEntity.status === STATUS_REMOVED && entity.status === STATUS_REMOVE) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
})
|
|
};
|
|
} // ZombieJ: Return the count of rest keys. It's safe to refactor if need more info.
|
|
|
|
}]);
|
|
|
|
return CSSMotionList;
|
|
}(react.Component);
|
|
|
|
(0,defineProperty/* default */.Z)(CSSMotionList, "defaultProps", {
|
|
component: 'div'
|
|
});
|
|
|
|
return CSSMotionList;
|
|
}
|
|
/* harmony default export */ var CSSMotionList = (genCSSMotionList(supportTransition));
|
|
;// CONCATENATED MODULE: ./node_modules/rc-motion/es/index.js
|
|
|
|
|
|
|
|
/* harmony default export */ var es = (es_CSSMotion);
|
|
|
|
/***/ })
|
|
|
|
}]); |