From 2e84def71ff1e6981b6918aa5c371bea8ff0ac22 Mon Sep 17 00:00:00 2001 From: git Date: Thu, 22 Jul 2021 01:30:33 +0800 Subject: [PATCH 1/6] popper.js --- src/core/popper.js | 1908 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1908 insertions(+) create mode 100644 src/core/popper.js diff --git a/src/core/popper.js b/src/core/popper.js new file mode 100644 index 000000000..a3708dbd5 --- /dev/null +++ b/src/core/popper.js @@ -0,0 +1,1908 @@ +/** + * @popperjs/core v2.9.2 - MIT License + */ + +(function (global, factory) { + factory(BI.Popper = {}); +}(this, (function (exports) { 'use strict'; + + function getBoundingClientRect(element) { + var rect = element.getBoundingClientRect(); + return { + width: rect.width, + height: rect.height, + top: rect.top, + right: rect.right, + bottom: rect.bottom, + left: rect.left, + x: rect.left, + y: rect.top + }; + } + + function getWindow(node) { + if (node == null) { + return window; + } + + if (node.toString() !== '[object Window]') { + var ownerDocument = node.ownerDocument; + return ownerDocument ? ownerDocument.defaultView || window : window; + } + + return node; + } + + function getWindowScroll(node) { + var win = getWindow(node); + var scrollLeft = win.pageXOffset; + var scrollTop = win.pageYOffset; + return { + scrollLeft: scrollLeft, + scrollTop: scrollTop + }; + } + + function isElement(node) { + var OwnElement = getWindow(node).Element; + return node instanceof OwnElement || node instanceof Element; + } + + function isHTMLElement(node) { + var OwnElement = getWindow(node).HTMLElement; + return node instanceof OwnElement || node instanceof HTMLElement; + } + + function isShadowRoot(node) { + // IE 11 has no ShadowRoot + if (typeof ShadowRoot === 'undefined') { + return false; + } + + var OwnElement = getWindow(node).ShadowRoot; + return node instanceof OwnElement || node instanceof ShadowRoot; + } + + function getHTMLElementScroll(element) { + return { + scrollLeft: element.scrollLeft, + scrollTop: element.scrollTop + }; + } + + function getNodeScroll(node) { + if (node === getWindow(node) || !isHTMLElement(node)) { + return getWindowScroll(node); + } else { + return getHTMLElementScroll(node); + } + } + + function getNodeName(element) { + return element ? (element.nodeName || '').toLowerCase() : null; + } + + function getDocumentElement(element) { + // $FlowFixMe[incompatible-return]: assume body is always available + return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] + element.document) || window.document).documentElement; + } + + function getWindowScrollBarX(element) { + // If has a CSS width greater than the viewport, then this will be + // incorrect for RTL. + // Popper 1 is broken in this case and never had a bug report so let's assume + // it's not an issue. I don't think anyone ever specifies width on + // anyway. + // Browsers where the left scrollbar doesn't cause an issue report `0` for + // this (e.g. Edge 2019, IE11, Safari) + return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; + } + + function getComputedStyle(element) { + return getWindow(element).getComputedStyle(element); + } + + function isScrollParent(element) { + // Firefox wants us to check `-x` and `-y` variations as well + var _getComputedStyle = getComputedStyle(element), + overflow = _getComputedStyle.overflow, + overflowX = _getComputedStyle.overflowX, + overflowY = _getComputedStyle.overflowY; + + return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); + } + + // Composite means it takes into account transforms as well as layout. + + function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { + if (isFixed === void 0) { + isFixed = false; + } + + var documentElement = getDocumentElement(offsetParent); + var rect = getBoundingClientRect(elementOrVirtualElement); + var isOffsetParentAnElement = isHTMLElement(offsetParent); + var scroll = { + scrollLeft: 0, + scrollTop: 0 + }; + var offsets = { + x: 0, + y: 0 + }; + + if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { + if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078 + isScrollParent(documentElement)) { + scroll = getNodeScroll(offsetParent); + } + + if (isHTMLElement(offsetParent)) { + offsets = getBoundingClientRect(offsetParent); + offsets.x += offsetParent.clientLeft; + offsets.y += offsetParent.clientTop; + } else if (documentElement) { + offsets.x = getWindowScrollBarX(documentElement); + } + } + + return { + x: rect.left + scroll.scrollLeft - offsets.x, + y: rect.top + scroll.scrollTop - offsets.y, + width: rect.width, + height: rect.height + }; + } + + // means it doesn't take into account transforms. + + function getLayoutRect(element) { + var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. + // Fixes https://github.com/popperjs/popper-core/issues/1223 + + var width = element.offsetWidth; + var height = element.offsetHeight; + + if (Math.abs(clientRect.width - width) <= 1) { + width = clientRect.width; + } + + if (Math.abs(clientRect.height - height) <= 1) { + height = clientRect.height; + } + + return { + x: element.offsetLeft, + y: element.offsetTop, + width: width, + height: height + }; + } + + function getParentNode(element) { + if (getNodeName(element) === 'html') { + return element; + } + + return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle + // $FlowFixMe[incompatible-return] + // $FlowFixMe[prop-missing] + element.assignedSlot || // step into the shadow DOM of the parent of a slotted node + element.parentNode || ( // DOM Element detected + isShadowRoot(element) ? element.host : null) || // ShadowRoot detected + // $FlowFixMe[incompatible-call]: HTMLElement is a Node + getDocumentElement(element) // fallback + + ); + } + + function getScrollParent(node) { + if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { + // $FlowFixMe[incompatible-return]: assume body is always available + return node.ownerDocument.body; + } + + if (isHTMLElement(node) && isScrollParent(node)) { + return node; + } + + return getScrollParent(getParentNode(node)); + } + + /* + given a DOM element, return the list of all scroll parents, up the list of ancesors + until we get to the top window object. This list is what we attach scroll listeners + to, because if any of these parent elements scroll, we'll need to re-calculate the + reference element's position. + */ + + function listScrollParents(element, list) { + var _element$ownerDocumen; + + if (list === void 0) { + list = []; + } + + var scrollParent = getScrollParent(element); + var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); + var win = getWindow(scrollParent); + var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; + var updatedList = list.concat(target); + return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here + updatedList.concat(listScrollParents(getParentNode(target))); + } + + function isTableElement(element) { + return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; + } + + function getTrueOffsetParent(element) { + if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837 + getComputedStyle(element).position === 'fixed') { + return null; + } + + return element.offsetParent; + } // `.offsetParent` reports `null` for fixed elements, while absolute elements + // return the containing block + + + function getContainingBlock(element) { + var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1; + var isIE = navigator.userAgent.indexOf('Trident') !== -1; + + if (isIE && isHTMLElement(element)) { + // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport + var elementCss = getComputedStyle(element); + + if (elementCss.position === 'fixed') { + return null; + } + } + + var currentNode = getParentNode(element); + + while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) { + var css = getComputedStyle(currentNode); // This is non-exhaustive but covers the most common CSS properties that + // create a containing block. + // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block + + if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') { + return currentNode; + } else { + currentNode = currentNode.parentNode; + } + } + + return null; + } // Gets the closest ancestor positioned element. Handles some edge cases, + // such as table ancestors and cross browser bugs. + + + function getOffsetParent(element) { + var window = getWindow(element); + var offsetParent = getTrueOffsetParent(element); + + while (offsetParent && isTableElement(offsetParent) && getComputedStyle(offsetParent).position === 'static') { + offsetParent = getTrueOffsetParent(offsetParent); + } + + if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle(offsetParent).position === 'static')) { + return window; + } + + return offsetParent || getContainingBlock(element) || window; + } + + var top = 'top'; + var bottom = 'bottom'; + var right = 'right'; + var left = 'left'; + var auto = 'auto'; + var basePlacements = [top, bottom, right, left]; + var start = 'start'; + var end = 'end'; + var clippingParents = 'clippingParents'; + var viewport = 'viewport'; + var popper = 'popper'; + var reference = 'reference'; + var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { + return acc.concat([placement + "-" + start, placement + "-" + end]); + }, []); + var placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { + return acc.concat([placement, placement + "-" + start, placement + "-" + end]); + }, []); // modifiers that need to read the DOM + + var beforeRead = 'beforeRead'; + var read = 'read'; + var afterRead = 'afterRead'; // pure-logic modifiers + + var beforeMain = 'beforeMain'; + var main = 'main'; + var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) + + var beforeWrite = 'beforeWrite'; + var write = 'write'; + var afterWrite = 'afterWrite'; + var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; + + function order(modifiers) { + var map = new Map(); + var visited = new Set(); + var result = []; + modifiers.forEach(function (modifier) { + map.set(modifier.name, modifier); + }); // On visiting object, check for its dependencies and visit them recursively + + function sort(modifier) { + visited.add(modifier.name); + var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); + requires.forEach(function (dep) { + if (!visited.has(dep)) { + var depModifier = map.get(dep); + + if (depModifier) { + sort(depModifier); + } + } + }); + result.push(modifier); + } + + modifiers.forEach(function (modifier) { + if (!visited.has(modifier.name)) { + // check for visited object + sort(modifier); + } + }); + return result; + } + + function orderModifiers(modifiers) { + // order based on dependencies + var orderedModifiers = order(modifiers); // order based on phase + + return modifierPhases.reduce(function (acc, phase) { + return acc.concat(orderedModifiers.filter(function (modifier) { + return modifier.phase === phase; + })); + }, []); + } + + function debounce(fn) { + var pending; + return function () { + if (!pending) { + pending = new Promise(function (resolve) { + Promise.resolve().then(function () { + pending = undefined; + resolve(fn()); + }); + }); + } + + return pending; + }; + } + + function format(str) { + for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + args[_key - 1] = arguments[_key]; + } + + return [].concat(args).reduce(function (p, c) { + return p.replace(/%s/, c); + }, str); + } + + var INVALID_MODIFIER_ERROR = 'Popper: modifier "%s" provided an invalid %s property, expected %s but got %s'; + var MISSING_DEPENDENCY_ERROR = 'Popper: modifier "%s" requires "%s", but "%s" modifier is not available'; + var VALID_PROPERTIES = ['name', 'enabled', 'phase', 'fn', 'effect', 'requires', 'options']; + function validateModifiers(modifiers) { + modifiers.forEach(function (modifier) { + Object.keys(modifier).forEach(function (key) { + switch (key) { + case 'name': + if (typeof modifier.name !== 'string') { + console.error(format(INVALID_MODIFIER_ERROR, String(modifier.name), '"name"', '"string"', "\"" + String(modifier.name) + "\"")); + } + + break; + + case 'enabled': + if (typeof modifier.enabled !== 'boolean') { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"enabled"', '"boolean"', "\"" + String(modifier.enabled) + "\"")); + } + + case 'phase': + if (modifierPhases.indexOf(modifier.phase) < 0) { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"phase"', "either " + modifierPhases.join(', '), "\"" + String(modifier.phase) + "\"")); + } + + break; + + case 'fn': + if (typeof modifier.fn !== 'function') { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"fn"', '"function"', "\"" + String(modifier.fn) + "\"")); + } + + break; + + case 'effect': + if (typeof modifier.effect !== 'function') { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"effect"', '"function"', "\"" + String(modifier.fn) + "\"")); + } + + break; + + case 'requires': + if (!Array.isArray(modifier.requires)) { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requires"', '"array"', "\"" + String(modifier.requires) + "\"")); + } + + break; + + case 'requiresIfExists': + if (!Array.isArray(modifier.requiresIfExists)) { + console.error(format(INVALID_MODIFIER_ERROR, modifier.name, '"requiresIfExists"', '"array"', "\"" + String(modifier.requiresIfExists) + "\"")); + } + + break; + + case 'options': + case 'data': + break; + + default: + console.error("PopperJS: an invalid property has been provided to the \"" + modifier.name + "\" modifier, valid properties are " + VALID_PROPERTIES.map(function (s) { + return "\"" + s + "\""; + }).join(', ') + "; but \"" + key + "\" was provided."); + } + + modifier.requires && modifier.requires.forEach(function (requirement) { + if (modifiers.find(function (mod) { + return mod.name === requirement; + }) == null) { + console.error(format(MISSING_DEPENDENCY_ERROR, String(modifier.name), requirement, requirement)); + } + }); + }); + }); + } + + function uniqueBy(arr, fn) { + var identifiers = new Set(); + return arr.filter(function (item) { + var identifier = fn(item); + + if (!identifiers.has(identifier)) { + identifiers.add(identifier); + return true; + } + }); + } + + function getBasePlacement(placement) { + return placement.split('-')[0]; + } + + function mergeByName(modifiers) { + var merged = modifiers.reduce(function (merged, current) { + var existing = merged[current.name]; + merged[current.name] = existing ? Object.assign({}, existing, current, { + options: Object.assign({}, existing.options, current.options), + data: Object.assign({}, existing.data, current.data) + }) : current; + return merged; + }, {}); // IE11 does not support Object.values + + return Object.keys(merged).map(function (key) { + return merged[key]; + }); + } + + function getViewportRect(element) { + var win = getWindow(element); + var html = getDocumentElement(element); + var visualViewport = win.visualViewport; + var width = html.clientWidth; + var height = html.clientHeight; + var x = 0; + var y = 0; // NB: This isn't supported on iOS <= 12. If the keyboard is open, the popper + // can be obscured underneath it. + // Also, `html.clientHeight` adds the bottom bar height in Safari iOS, even + // if it isn't open, so if this isn't available, the popper will be detected + // to overflow the bottom of the screen too early. + + if (visualViewport) { + width = visualViewport.width; + height = visualViewport.height; // Uses Layout Viewport (like Chrome; Safari does not currently) + // In Chrome, it returns a value very close to 0 (+/-) but contains rounding + // errors due to floating point numbers, so we need to check precision. + // Safari returns a number <= 0, usually < -1 when pinch-zoomed + // Feature detection fails in mobile emulation mode in Chrome. + // Math.abs(win.innerWidth / visualViewport.scale - visualViewport.width) < + // 0.001 + // Fallback here: "Not Safari" userAgent + + if (!/^((?!chrome|android).)*safari/i.test(navigator.userAgent)) { + x = visualViewport.offsetLeft; + y = visualViewport.offsetTop; + } + } + + return { + width: width, + height: height, + x: x + getWindowScrollBarX(element), + y: y + }; + } + + var max = Math.max; + var min = Math.min; + var round = Math.round; + + // of the `` and `` rect bounds if horizontally scrollable + + function getDocumentRect(element) { + var _element$ownerDocumen; + + var html = getDocumentElement(element); + var winScroll = getWindowScroll(element); + var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; + var width = max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); + var height = max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); + var x = -winScroll.scrollLeft + getWindowScrollBarX(element); + var y = -winScroll.scrollTop; + + if (getComputedStyle(body || html).direction === 'rtl') { + x += max(html.clientWidth, body ? body.clientWidth : 0) - width; + } + + return { + width: width, + height: height, + x: x, + y: y + }; + } + + function contains(parent, child) { + var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method + + if (parent.contains(child)) { + return true; + } // then fallback to custom implementation with Shadow DOM support + else if (rootNode && isShadowRoot(rootNode)) { + var next = child; + + do { + if (next && parent.isSameNode(next)) { + return true; + } // $FlowFixMe[prop-missing]: need a better way to handle this... + + + next = next.parentNode || next.host; + } while (next); + } // Give up, the result is false + + + return false; + } + + function rectToClientRect(rect) { + return Object.assign({}, rect, { + left: rect.x, + top: rect.y, + right: rect.x + rect.width, + bottom: rect.y + rect.height + }); + } + + function getInnerBoundingClientRect(element) { + var rect = getBoundingClientRect(element); + rect.top = rect.top + element.clientTop; + rect.left = rect.left + element.clientLeft; + rect.bottom = rect.top + element.clientHeight; + rect.right = rect.left + element.clientWidth; + rect.width = element.clientWidth; + rect.height = element.clientHeight; + rect.x = rect.left; + rect.y = rect.top; + return rect; + } + + function getClientRectFromMixedType(element, clippingParent) { + return clippingParent === viewport ? rectToClientRect(getViewportRect(element)) : isHTMLElement(clippingParent) ? getInnerBoundingClientRect(clippingParent) : rectToClientRect(getDocumentRect(getDocumentElement(element))); + } // A "clipping parent" is an overflowable container with the characteristic of + // clipping (or hiding) overflowing elements with a position different from + // `initial` + + + function getClippingParents(element) { + var clippingParents = listScrollParents(getParentNode(element)); + var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle(element).position) >= 0; + var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; + + if (!isElement(clipperElement)) { + return []; + } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414 + + + return clippingParents.filter(function (clippingParent) { + return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'; + }); + } // Gets the maximum area that the element is visible in due to any number of + // clipping parents + + + function getClippingRect(element, boundary, rootBoundary) { + var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary); + var clippingParents = [].concat(mainClippingParents, [rootBoundary]); + var firstClippingParent = clippingParents[0]; + var clippingRect = clippingParents.reduce(function (accRect, clippingParent) { + var rect = getClientRectFromMixedType(element, clippingParent); + accRect.top = max(rect.top, accRect.top); + accRect.right = min(rect.right, accRect.right); + accRect.bottom = min(rect.bottom, accRect.bottom); + accRect.left = max(rect.left, accRect.left); + return accRect; + }, getClientRectFromMixedType(element, firstClippingParent)); + clippingRect.width = clippingRect.right - clippingRect.left; + clippingRect.height = clippingRect.bottom - clippingRect.top; + clippingRect.x = clippingRect.left; + clippingRect.y = clippingRect.top; + return clippingRect; + } + + function getVariation(placement) { + return placement.split('-')[1]; + } + + function getMainAxisFromPlacement(placement) { + return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; + } + + function computeOffsets(_ref) { + var reference = _ref.reference, + element = _ref.element, + placement = _ref.placement; + var basePlacement = placement ? getBasePlacement(placement) : null; + var variation = placement ? getVariation(placement) : null; + var commonX = reference.x + reference.width / 2 - element.width / 2; + var commonY = reference.y + reference.height / 2 - element.height / 2; + var offsets; + + switch (basePlacement) { + case top: + offsets = { + x: commonX, + y: reference.y - element.height + }; + break; + + case bottom: + offsets = { + x: commonX, + y: reference.y + reference.height + }; + break; + + case right: + offsets = { + x: reference.x + reference.width, + y: commonY + }; + break; + + case left: + offsets = { + x: reference.x - element.width, + y: commonY + }; + break; + + default: + offsets = { + x: reference.x, + y: reference.y + }; + } + + var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; + + if (mainAxis != null) { + var len = mainAxis === 'y' ? 'height' : 'width'; + + switch (variation) { + case start: + offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); + break; + + case end: + offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); + break; + } + } + + return offsets; + } + + function getFreshSideObject() { + return { + top: 0, + right: 0, + bottom: 0, + left: 0 + }; + } + + function mergePaddingObject(paddingObject) { + return Object.assign({}, getFreshSideObject(), paddingObject); + } + + function expandToHashMap(value, keys) { + return keys.reduce(function (hashMap, key) { + hashMap[key] = value; + return hashMap; + }, {}); + } + + function detectOverflow(state, options) { + if (options === void 0) { + options = {}; + } + + var _options = options, + _options$placement = _options.placement, + placement = _options$placement === void 0 ? state.placement : _options$placement, + _options$boundary = _options.boundary, + boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, + _options$rootBoundary = _options.rootBoundary, + rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, + _options$elementConte = _options.elementContext, + elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, + _options$altBoundary = _options.altBoundary, + altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, + _options$padding = _options.padding, + padding = _options$padding === void 0 ? 0 : _options$padding; + var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); + var altContext = elementContext === popper ? reference : popper; + var referenceElement = state.elements.reference; + var popperRect = state.rects.popper; + var element = state.elements[altBoundary ? altContext : elementContext]; + var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary); + var referenceClientRect = getBoundingClientRect(referenceElement); + var popperOffsets = computeOffsets({ + reference: referenceClientRect, + element: popperRect, + strategy: 'absolute', + placement: placement + }); + var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets)); + var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect + // 0 or negative = within the clipping rect + + var overflowOffsets = { + top: clippingClientRect.top - elementClientRect.top + paddingObject.top, + bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, + left: clippingClientRect.left - elementClientRect.left + paddingObject.left, + right: elementClientRect.right - clippingClientRect.right + paddingObject.right + }; + var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element + + if (elementContext === popper && offsetData) { + var offset = offsetData[placement]; + Object.keys(overflowOffsets).forEach(function (key) { + var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1; + var axis = [top, bottom].indexOf(key) >= 0 ? 'y' : 'x'; + overflowOffsets[key] += offset[axis] * multiply; + }); + } + + return overflowOffsets; + } + + var INVALID_ELEMENT_ERROR = 'Popper: Invalid reference or popper argument provided. They must be either a DOM element or virtual element.'; + var INFINITE_LOOP_ERROR = 'Popper: An infinite loop in the modifiers cycle has been detected! The cycle has been interrupted to prevent a browser crash.'; + var DEFAULT_OPTIONS = { + placement: 'bottom', + modifiers: [], + strategy: 'absolute' + }; + + function areValidElements() { + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return !args.some(function (element) { + return !(element && typeof element.getBoundingClientRect === 'function'); + }); + } + + function popperGenerator(generatorOptions) { + if (generatorOptions === void 0) { + generatorOptions = {}; + } + + var _generatorOptions = generatorOptions, + _generatorOptions$def = _generatorOptions.defaultModifiers, + defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, + _generatorOptions$def2 = _generatorOptions.defaultOptions, + defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2; + return function createPopper(reference, popper, options) { + if (options === void 0) { + options = defaultOptions; + } + + var state = { + placement: 'bottom', + orderedModifiers: [], + options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), + modifiersData: {}, + elements: { + reference: reference, + popper: popper + }, + attributes: {}, + styles: {} + }; + var effectCleanupFns = []; + var isDestroyed = false; + var instance = { + state: state, + setOptions: function setOptions(options) { + cleanupModifierEffects(); + state.options = Object.assign({}, defaultOptions, state.options, options); + state.scrollParents = { + reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [], + popper: listScrollParents(popper) + }; // Orders the modifiers based on their dependencies and `phase` + // properties + + var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers + + state.orderedModifiers = orderedModifiers.filter(function (m) { + return m.enabled; + }); // Validate the provided modifiers so that the consumer will get warned + // if one of the modifiers is invalid for any reason + + { + var modifiers = uniqueBy([].concat(orderedModifiers, state.options.modifiers), function (_ref) { + var name = _ref.name; + return name; + }); + validateModifiers(modifiers); + + if (getBasePlacement(state.options.placement) === auto) { + var flipModifier = state.orderedModifiers.find(function (_ref2) { + var name = _ref2.name; + return name === 'flip'; + }); + + if (!flipModifier) { + console.error(['Popper: "auto" placements require the "flip" modifier be', 'present and enabled to work.'].join(' ')); + } + } + + var _getComputedStyle = getComputedStyle(popper), + marginTop = _getComputedStyle.marginTop, + marginRight = _getComputedStyle.marginRight, + marginBottom = _getComputedStyle.marginBottom, + marginLeft = _getComputedStyle.marginLeft; // We no longer take into account `margins` on the popper, and it can + // cause bugs with positioning, so we'll warn the consumer + + + if ([marginTop, marginRight, marginBottom, marginLeft].some(function (margin) { + return parseFloat(margin); + })) { + console.warn(['Popper: CSS "margin" styles cannot be used to apply padding', 'between the popper and its reference element or boundary.', 'To replicate margin, use the `offset` modifier, as well as', 'the `padding` option in the `preventOverflow` and `flip`', 'modifiers.'].join(' ')); + } + } + + runModifierEffects(); + return instance.update(); + }, + // Sync update – it will always be executed, even if not necessary. This + // is useful for low frequency updates where sync behavior simplifies the + // logic. + // For high frequency updates (e.g. `resize` and `scroll` events), always + // prefer the async Popper#update method + forceUpdate: function forceUpdate() { + if (isDestroyed) { + return; + } + + var _state$elements = state.elements, + reference = _state$elements.reference, + popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements + // anymore + + if (!areValidElements(reference, popper)) { + { + console.error(INVALID_ELEMENT_ERROR); + } + + return; + } // Store the reference and popper rects to be read by modifiers + + + state.rects = { + reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'), + popper: getLayoutRect(popper) + }; // Modifiers have the ability to reset the current update cycle. The + // most common use case for this is the `flip` modifier changing the + // placement, which then needs to re-run all the modifiers, because the + // logic was previously ran for the previous placement and is therefore + // stale/incorrect + + state.reset = false; + state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier + // is filled with the initial data specified by the modifier. This means + // it doesn't persist and is fresh on each update. + // To ensure persistent data, use `${name}#persistent` + + state.orderedModifiers.forEach(function (modifier) { + return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); + }); + var __debug_loops__ = 0; + + for (var index = 0; index < state.orderedModifiers.length; index++) { + { + __debug_loops__ += 1; + + if (__debug_loops__ > 100) { + console.error(INFINITE_LOOP_ERROR); + break; + } + } + + if (state.reset === true) { + state.reset = false; + index = -1; + continue; + } + + var _state$orderedModifie = state.orderedModifiers[index], + fn = _state$orderedModifie.fn, + _state$orderedModifie2 = _state$orderedModifie.options, + _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, + name = _state$orderedModifie.name; + + if (typeof fn === 'function') { + state = fn({ + state: state, + options: _options, + name: name, + instance: instance + }) || state; + } + } + }, + // Async and optimistically optimized update – it will not be executed if + // not necessary (debounced to run at most once-per-tick) + update: debounce(function () { + return new Promise(function (resolve) { + instance.forceUpdate(); + resolve(state); + }); + }), + destroy: function destroy() { + cleanupModifierEffects(); + isDestroyed = true; + } + }; + + if (!areValidElements(reference, popper)) { + { + console.error(INVALID_ELEMENT_ERROR); + } + + return instance; + } + + instance.setOptions(options).then(function (state) { + if (!isDestroyed && options.onFirstUpdate) { + options.onFirstUpdate(state); + } + }); // Modifiers have the ability to execute arbitrary code before the first + // update cycle runs. They will be executed in the same order as the update + // cycle. This is useful when a modifier adds some persistent data that + // other modifiers need to use, but the modifier is run after the dependent + // one. + + function runModifierEffects() { + state.orderedModifiers.forEach(function (_ref3) { + var name = _ref3.name, + _ref3$options = _ref3.options, + options = _ref3$options === void 0 ? {} : _ref3$options, + effect = _ref3.effect; + + if (typeof effect === 'function') { + var cleanupFn = effect({ + state: state, + name: name, + instance: instance, + options: options + }); + + var noopFn = function noopFn() {}; + + effectCleanupFns.push(cleanupFn || noopFn); + } + }); + } + + function cleanupModifierEffects() { + effectCleanupFns.forEach(function (fn) { + return fn(); + }); + effectCleanupFns = []; + } + + return instance; + }; + } + + var passive = { + passive: true + }; + + function effect$2(_ref) { + var state = _ref.state, + instance = _ref.instance, + options = _ref.options; + var _options$scroll = options.scroll, + scroll = _options$scroll === void 0 ? true : _options$scroll, + _options$resize = options.resize, + resize = _options$resize === void 0 ? true : _options$resize; + var window = getWindow(state.elements.popper); + var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); + + if (scroll) { + scrollParents.forEach(function (scrollParent) { + scrollParent.addEventListener('scroll', instance.update, passive); + }); + } + + if (resize) { + window.addEventListener('resize', instance.update, passive); + } + + return function () { + if (scroll) { + scrollParents.forEach(function (scrollParent) { + scrollParent.removeEventListener('scroll', instance.update, passive); + }); + } + + if (resize) { + window.removeEventListener('resize', instance.update, passive); + } + }; + } // eslint-disable-next-line import/no-unused-modules + + + var eventListeners = { + name: 'eventListeners', + enabled: true, + phase: 'write', + fn: function fn() {}, + effect: effect$2, + data: {} + }; + + function popperOffsets(_ref) { + var state = _ref.state, + name = _ref.name; + // Offsets are the actual position the popper needs to have to be + // properly positioned near its reference element + // This is the most basic placement, and will be adjusted by + // the modifiers in the next step + state.modifiersData[name] = computeOffsets({ + reference: state.rects.reference, + element: state.rects.popper, + strategy: 'absolute', + placement: state.placement + }); + } // eslint-disable-next-line import/no-unused-modules + + + var popperOffsets$1 = { + name: 'popperOffsets', + enabled: true, + phase: 'read', + fn: popperOffsets, + data: {} + }; + + var unsetSides = { + top: 'auto', + right: 'auto', + bottom: 'auto', + left: 'auto' + }; // Round the offsets to the nearest suitable subpixel based on the DPR. + // Zooming can change the DPR, but it seems to report a value that will + // cleanly divide the values into the appropriate subpixels. + + function roundOffsetsByDPR(_ref) { + var x = _ref.x, + y = _ref.y; + var win = window; + var dpr = win.devicePixelRatio || 1; + return { + x: round(round(x * dpr) / dpr) || 0, + y: round(round(y * dpr) / dpr) || 0 + }; + } + + function mapToStyles(_ref2) { + var _Object$assign2; + + var popper = _ref2.popper, + popperRect = _ref2.popperRect, + placement = _ref2.placement, + offsets = _ref2.offsets, + position = _ref2.position, + gpuAcceleration = _ref2.gpuAcceleration, + adaptive = _ref2.adaptive, + roundOffsets = _ref2.roundOffsets; + + var _ref3 = roundOffsets === true ? roundOffsetsByDPR(offsets) : typeof roundOffsets === 'function' ? roundOffsets(offsets) : offsets, + _ref3$x = _ref3.x, + x = _ref3$x === void 0 ? 0 : _ref3$x, + _ref3$y = _ref3.y, + y = _ref3$y === void 0 ? 0 : _ref3$y; + + var hasX = offsets.hasOwnProperty('x'); + var hasY = offsets.hasOwnProperty('y'); + var sideX = left; + var sideY = top; + var win = window; + + if (adaptive) { + var offsetParent = getOffsetParent(popper); + var heightProp = 'clientHeight'; + var widthProp = 'clientWidth'; + + if (offsetParent === getWindow(popper)) { + offsetParent = getDocumentElement(popper); + + if (getComputedStyle(offsetParent).position !== 'static') { + heightProp = 'scrollHeight'; + widthProp = 'scrollWidth'; + } + } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it + + + offsetParent = offsetParent; + + if (placement === top) { + sideY = bottom; // $FlowFixMe[prop-missing] + + y -= offsetParent[heightProp] - popperRect.height; + y *= gpuAcceleration ? 1 : -1; + } + + if (placement === left) { + sideX = right; // $FlowFixMe[prop-missing] + + x -= offsetParent[widthProp] - popperRect.width; + x *= gpuAcceleration ? 1 : -1; + } + } + + var commonStyles = Object.assign({ + position: position + }, adaptive && unsetSides); + + if (gpuAcceleration) { + var _Object$assign; + + return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) < 2 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign)); + } + + return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2)); + } + + function computeStyles(_ref4) { + var state = _ref4.state, + options = _ref4.options; + var _options$gpuAccelerat = options.gpuAcceleration, + gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, + _options$adaptive = options.adaptive, + adaptive = _options$adaptive === void 0 ? true : _options$adaptive, + _options$roundOffsets = options.roundOffsets, + roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets; + + { + var transitionProperty = getComputedStyle(state.elements.popper).transitionProperty || ''; + + if (adaptive && ['transform', 'top', 'right', 'bottom', 'left'].some(function (property) { + return transitionProperty.indexOf(property) >= 0; + })) { + console.warn(['Popper: Detected CSS transitions on at least one of the following', 'CSS properties: "transform", "top", "right", "bottom", "left".', '\n\n', 'Disable the "computeStyles" modifier\'s `adaptive` option to allow', 'for smooth transitions, or remove these properties from the CSS', 'transition declaration on the popper element if only transitioning', 'opacity or background-color for example.', '\n\n', 'We recommend using the popper element as a wrapper around an inner', 'element that can have any CSS property transitioned for animations.'].join(' ')); + } + } + + var commonStyles = { + placement: getBasePlacement(state.placement), + popper: state.elements.popper, + popperRect: state.rects.popper, + gpuAcceleration: gpuAcceleration + }; + + if (state.modifiersData.popperOffsets != null) { + state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { + offsets: state.modifiersData.popperOffsets, + position: state.options.strategy, + adaptive: adaptive, + roundOffsets: roundOffsets + }))); + } + + if (state.modifiersData.arrow != null) { + state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { + offsets: state.modifiersData.arrow, + position: 'absolute', + adaptive: false, + roundOffsets: roundOffsets + }))); + } + + state.attributes.popper = Object.assign({}, state.attributes.popper, { + 'data-popper-placement': state.placement + }); + } // eslint-disable-next-line import/no-unused-modules + + + var computeStyles$1 = { + name: 'computeStyles', + enabled: true, + phase: 'beforeWrite', + fn: computeStyles, + data: {} + }; + + // and applies them to the HTMLElements such as popper and arrow + + function applyStyles(_ref) { + var state = _ref.state; + Object.keys(state.elements).forEach(function (name) { + var style = state.styles[name] || {}; + var attributes = state.attributes[name] || {}; + var element = state.elements[name]; // arrow is optional + virtual elements + + if (!isHTMLElement(element) || !getNodeName(element)) { + return; + } // Flow doesn't support to extend this property, but it's the most + // effective way to apply styles to an HTMLElement + // $FlowFixMe[cannot-write] + + + Object.assign(element.style, style); + Object.keys(attributes).forEach(function (name) { + var value = attributes[name]; + + if (value === false) { + element.removeAttribute(name); + } else { + element.setAttribute(name, value === true ? '' : value); + } + }); + }); + } + + function effect$1(_ref2) { + var state = _ref2.state; + var initialStyles = { + popper: { + position: state.options.strategy, + left: '0', + top: '0', + margin: '0' + }, + arrow: { + position: 'absolute' + }, + reference: {} + }; + Object.assign(state.elements.popper.style, initialStyles.popper); + state.styles = initialStyles; + + if (state.elements.arrow) { + Object.assign(state.elements.arrow.style, initialStyles.arrow); + } + + return function () { + Object.keys(state.elements).forEach(function (name) { + var element = state.elements[name]; + var attributes = state.attributes[name] || {}; + var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them + + var style = styleProperties.reduce(function (style, property) { + style[property] = ''; + return style; + }, {}); // arrow is optional + virtual elements + + if (!isHTMLElement(element) || !getNodeName(element)) { + return; + } + + Object.assign(element.style, style); + Object.keys(attributes).forEach(function (attribute) { + element.removeAttribute(attribute); + }); + }); + }; + } // eslint-disable-next-line import/no-unused-modules + + + var applyStyles$1 = { + name: 'applyStyles', + enabled: true, + phase: 'write', + fn: applyStyles, + effect: effect$1, + requires: ['computeStyles'] + }; + + function distanceAndSkiddingToXY(placement, rects, offset) { + var basePlacement = getBasePlacement(placement); + var invertDistance = [left, top].indexOf(basePlacement) >= 0 ? -1 : 1; + + var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { + placement: placement + })) : offset, + skidding = _ref[0], + distance = _ref[1]; + + skidding = skidding || 0; + distance = (distance || 0) * invertDistance; + return [left, right].indexOf(basePlacement) >= 0 ? { + x: distance, + y: skidding + } : { + x: skidding, + y: distance + }; + } + + function offset(_ref2) { + var state = _ref2.state, + options = _ref2.options, + name = _ref2.name; + var _options$offset = options.offset, + offset = _options$offset === void 0 ? [0, 0] : _options$offset; + var data = placements.reduce(function (acc, placement) { + acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); + return acc; + }, {}); + var _data$state$placement = data[state.placement], + x = _data$state$placement.x, + y = _data$state$placement.y; + + if (state.modifiersData.popperOffsets != null) { + state.modifiersData.popperOffsets.x += x; + state.modifiersData.popperOffsets.y += y; + } + + state.modifiersData[name] = data; + } // eslint-disable-next-line import/no-unused-modules + + + var offset$1 = { + name: 'offset', + enabled: true, + phase: 'main', + requires: ['popperOffsets'], + fn: offset + }; + + var hash$1 = { + left: 'right', + right: 'left', + bottom: 'top', + top: 'bottom' + }; + function getOppositePlacement(placement) { + return placement.replace(/left|right|bottom|top/g, function (matched) { + return hash$1[matched]; + }); + } + + var hash = { + start: 'end', + end: 'start' + }; + function getOppositeVariationPlacement(placement) { + return placement.replace(/start|end/g, function (matched) { + return hash[matched]; + }); + } + + function computeAutoPlacement(state, options) { + if (options === void 0) { + options = {}; + } + + var _options = options, + placement = _options.placement, + boundary = _options.boundary, + rootBoundary = _options.rootBoundary, + padding = _options.padding, + flipVariations = _options.flipVariations, + _options$allowedAutoP = _options.allowedAutoPlacements, + allowedAutoPlacements = _options$allowedAutoP === void 0 ? placements : _options$allowedAutoP; + var variation = getVariation(placement); + var placements$1 = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { + return getVariation(placement) === variation; + }) : basePlacements; + var allowedPlacements = placements$1.filter(function (placement) { + return allowedAutoPlacements.indexOf(placement) >= 0; + }); + + if (allowedPlacements.length === 0) { + allowedPlacements = placements$1; + + { + console.error(['Popper: The `allowedAutoPlacements` option did not allow any', 'placements. Ensure the `placement` option matches the variation', 'of the allowed placements.', 'For example, "auto" cannot be used to allow "bottom-start".', 'Use "auto-start" instead.'].join(' ')); + } + } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... + + + var overflows = allowedPlacements.reduce(function (acc, placement) { + acc[placement] = detectOverflow(state, { + placement: placement, + boundary: boundary, + rootBoundary: rootBoundary, + padding: padding + })[getBasePlacement(placement)]; + return acc; + }, {}); + return Object.keys(overflows).sort(function (a, b) { + return overflows[a] - overflows[b]; + }); + } + + function getExpandedFallbackPlacements(placement) { + if (getBasePlacement(placement) === auto) { + return []; + } + + var oppositePlacement = getOppositePlacement(placement); + return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; + } + + function flip(_ref) { + var state = _ref.state, + options = _ref.options, + name = _ref.name; + + if (state.modifiersData[name]._skip) { + return; + } + + var _options$mainAxis = options.mainAxis, + checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, + _options$altAxis = options.altAxis, + checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, + specifiedFallbackPlacements = options.fallbackPlacements, + padding = options.padding, + boundary = options.boundary, + rootBoundary = options.rootBoundary, + altBoundary = options.altBoundary, + _options$flipVariatio = options.flipVariations, + flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, + allowedAutoPlacements = options.allowedAutoPlacements; + var preferredPlacement = state.options.placement; + var basePlacement = getBasePlacement(preferredPlacement); + var isBasePlacement = basePlacement === preferredPlacement; + var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement)); + var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) { + return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, { + placement: placement, + boundary: boundary, + rootBoundary: rootBoundary, + padding: padding, + flipVariations: flipVariations, + allowedAutoPlacements: allowedAutoPlacements + }) : placement); + }, []); + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var checksMap = new Map(); + var makeFallbackChecks = true; + var firstFittingPlacement = placements[0]; + + for (var i = 0; i < placements.length; i++) { + var placement = placements[i]; + + var _basePlacement = getBasePlacement(placement); + + var isStartVariation = getVariation(placement) === start; + var isVertical = [top, bottom].indexOf(_basePlacement) >= 0; + var len = isVertical ? 'width' : 'height'; + var overflow = detectOverflow(state, { + placement: placement, + boundary: boundary, + rootBoundary: rootBoundary, + altBoundary: altBoundary, + padding: padding + }); + var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : top; + + if (referenceRect[len] > popperRect[len]) { + mainVariationSide = getOppositePlacement(mainVariationSide); + } + + var altVariationSide = getOppositePlacement(mainVariationSide); + var checks = []; + + if (checkMainAxis) { + checks.push(overflow[_basePlacement] <= 0); + } + + if (checkAltAxis) { + checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0); + } + + if (checks.every(function (check) { + return check; + })) { + firstFittingPlacement = placement; + makeFallbackChecks = false; + break; + } + + checksMap.set(placement, checks); + } + + if (makeFallbackChecks) { + // `2` may be desired in some cases – research later + var numberOfChecks = flipVariations ? 3 : 1; + + var _loop = function _loop(_i) { + var fittingPlacement = placements.find(function (placement) { + var checks = checksMap.get(placement); + + if (checks) { + return checks.slice(0, _i).every(function (check) { + return check; + }); + } + }); + + if (fittingPlacement) { + firstFittingPlacement = fittingPlacement; + return "break"; + } + }; + + for (var _i = numberOfChecks; _i > 0; _i--) { + var _ret = _loop(_i); + + if (_ret === "break") break; + } + } + + if (state.placement !== firstFittingPlacement) { + state.modifiersData[name]._skip = true; + state.placement = firstFittingPlacement; + state.reset = true; + } + } // eslint-disable-next-line import/no-unused-modules + + + var flip$1 = { + name: 'flip', + enabled: true, + phase: 'main', + fn: flip, + requiresIfExists: ['offset'], + data: { + _skip: false + } + }; + + function getAltAxis(axis) { + return axis === 'x' ? 'y' : 'x'; + } + + function within(min$1, value, max$1) { + return max(min$1, min(value, max$1)); + } + + function preventOverflow(_ref) { + var state = _ref.state, + options = _ref.options, + name = _ref.name; + var _options$mainAxis = options.mainAxis, + checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, + _options$altAxis = options.altAxis, + checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, + boundary = options.boundary, + rootBoundary = options.rootBoundary, + altBoundary = options.altBoundary, + padding = options.padding, + _options$tether = options.tether, + tether = _options$tether === void 0 ? true : _options$tether, + _options$tetherOffset = options.tetherOffset, + tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset; + var overflow = detectOverflow(state, { + boundary: boundary, + rootBoundary: rootBoundary, + padding: padding, + altBoundary: altBoundary + }); + var basePlacement = getBasePlacement(state.placement); + var variation = getVariation(state.placement); + var isBasePlacement = !variation; + var mainAxis = getMainAxisFromPlacement(basePlacement); + var altAxis = getAltAxis(mainAxis); + var popperOffsets = state.modifiersData.popperOffsets; + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, { + placement: state.placement + })) : tetherOffset; + var data = { + x: 0, + y: 0 + }; + + if (!popperOffsets) { + return; + } + + if (checkMainAxis || checkAltAxis) { + var mainSide = mainAxis === 'y' ? top : left; + var altSide = mainAxis === 'y' ? bottom : right; + var len = mainAxis === 'y' ? 'height' : 'width'; + var offset = popperOffsets[mainAxis]; + var min$1 = popperOffsets[mainAxis] + overflow[mainSide]; + var max$1 = popperOffsets[mainAxis] - overflow[altSide]; + var additive = tether ? -popperRect[len] / 2 : 0; + var minLen = variation === start ? referenceRect[len] : popperRect[len]; + var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go + // outside the reference bounds + + var arrowElement = state.elements.arrow; + var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { + width: 0, + height: 0 + }; + var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject(); + var arrowPaddingMin = arrowPaddingObject[mainSide]; + var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want + // to include its full size in the calculation. If the reference is small + // and near the edge of a boundary, the popper can overflow even if the + // reference is not overflowing as well (e.g. virtual elements with no + // width or height) + + var arrowLen = within(0, referenceRect[len], arrowRect[len]); + var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - tetherOffsetValue : minLen - arrowLen - arrowPaddingMin - tetherOffsetValue; + var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + tetherOffsetValue : maxLen + arrowLen + arrowPaddingMax + tetherOffsetValue; + var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow); + var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0; + var offsetModifierValue = state.modifiersData.offset ? state.modifiersData.offset[state.placement][mainAxis] : 0; + var tetherMin = popperOffsets[mainAxis] + minOffset - offsetModifierValue - clientOffset; + var tetherMax = popperOffsets[mainAxis] + maxOffset - offsetModifierValue; + + if (checkMainAxis) { + var preventedOffset = within(tether ? min(min$1, tetherMin) : min$1, offset, tether ? max(max$1, tetherMax) : max$1); + popperOffsets[mainAxis] = preventedOffset; + data[mainAxis] = preventedOffset - offset; + } + + if (checkAltAxis) { + var _mainSide = mainAxis === 'x' ? top : left; + + var _altSide = mainAxis === 'x' ? bottom : right; + + var _offset = popperOffsets[altAxis]; + + var _min = _offset + overflow[_mainSide]; + + var _max = _offset - overflow[_altSide]; + + var _preventedOffset = within(tether ? min(_min, tetherMin) : _min, _offset, tether ? max(_max, tetherMax) : _max); + + popperOffsets[altAxis] = _preventedOffset; + data[altAxis] = _preventedOffset - _offset; + } + } + + state.modifiersData[name] = data; + } // eslint-disable-next-line import/no-unused-modules + + + var preventOverflow$1 = { + name: 'preventOverflow', + enabled: true, + phase: 'main', + fn: preventOverflow, + requiresIfExists: ['offset'] + }; + + var toPaddingObject = function toPaddingObject(padding, state) { + padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, { + placement: state.placement + })) : padding; + return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); + }; + + function arrow(_ref) { + var _state$modifiersData$; + + var state = _ref.state, + name = _ref.name, + options = _ref.options; + var arrowElement = state.elements.arrow; + var popperOffsets = state.modifiersData.popperOffsets; + var basePlacement = getBasePlacement(state.placement); + var axis = getMainAxisFromPlacement(basePlacement); + var isVertical = [left, right].indexOf(basePlacement) >= 0; + var len = isVertical ? 'height' : 'width'; + + if (!arrowElement || !popperOffsets) { + return; + } + + var paddingObject = toPaddingObject(options.padding, state); + var arrowRect = getLayoutRect(arrowElement); + var minProp = axis === 'y' ? top : left; + var maxProp = axis === 'y' ? bottom : right; + var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len]; + var startDiff = popperOffsets[axis] - state.rects.reference[axis]; + var arrowOffsetParent = getOffsetParent(arrowElement); + var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0; + var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is + // outside of the popper bounds + + var min = paddingObject[minProp]; + var max = clientSize - arrowRect[len] - paddingObject[maxProp]; + var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference; + var offset = within(min, center, max); // Prevents breaking syntax highlighting... + + var axisProp = axis; + state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$); + } + + function effect(_ref2) { + var state = _ref2.state, + options = _ref2.options; + var _options$element = options.element, + arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element; + + if (arrowElement == null) { + return; + } // CSS selector + + + if (typeof arrowElement === 'string') { + arrowElement = state.elements.popper.querySelector(arrowElement); + + if (!arrowElement) { + return; + } + } + + { + if (!isHTMLElement(arrowElement)) { + console.error(['Popper: "arrow" element must be an HTMLElement (not an SVGElement).', 'To use an SVG arrow, wrap it in an HTMLElement that will be used as', 'the arrow.'].join(' ')); + } + } + + if (!contains(state.elements.popper, arrowElement)) { + { + console.error(['Popper: "arrow" modifier\'s `element` must be a child of the popper', 'element.'].join(' ')); + } + + return; + } + + state.elements.arrow = arrowElement; + } // eslint-disable-next-line import/no-unused-modules + + + var arrow$1 = { + name: 'arrow', + enabled: true, + phase: 'main', + fn: arrow, + effect: effect, + requires: ['popperOffsets'], + requiresIfExists: ['preventOverflow'] + }; + + function getSideOffsets(overflow, rect, preventedOffsets) { + if (preventedOffsets === void 0) { + preventedOffsets = { + x: 0, + y: 0 + }; + } + + return { + top: overflow.top - rect.height - preventedOffsets.y, + right: overflow.right - rect.width + preventedOffsets.x, + bottom: overflow.bottom - rect.height + preventedOffsets.y, + left: overflow.left - rect.width - preventedOffsets.x + }; + } + + function isAnySideFullyClipped(overflow) { + return [top, right, bottom, left].some(function (side) { + return overflow[side] >= 0; + }); + } + + function hide(_ref) { + var state = _ref.state, + name = _ref.name; + var referenceRect = state.rects.reference; + var popperRect = state.rects.popper; + var preventedOffsets = state.modifiersData.preventOverflow; + var referenceOverflow = detectOverflow(state, { + elementContext: 'reference' + }); + var popperAltOverflow = detectOverflow(state, { + altBoundary: true + }); + var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); + var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); + var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); + var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); + state.modifiersData[name] = { + referenceClippingOffsets: referenceClippingOffsets, + popperEscapeOffsets: popperEscapeOffsets, + isReferenceHidden: isReferenceHidden, + hasPopperEscaped: hasPopperEscaped + }; + state.attributes.popper = Object.assign({}, state.attributes.popper, { + 'data-popper-reference-hidden': isReferenceHidden, + 'data-popper-escaped': hasPopperEscaped + }); + } // eslint-disable-next-line import/no-unused-modules + + + var hide$1 = { + name: 'hide', + enabled: true, + phase: 'main', + requiresIfExists: ['preventOverflow'], + fn: hide + }; + + var defaultModifiers$1 = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1]; + var createPopper$1 = /*#__PURE__*/popperGenerator({ + defaultModifiers: defaultModifiers$1 + }); // eslint-disable-next-line import/no-unused-modules + + var defaultModifiers = [eventListeners, popperOffsets$1, computeStyles$1, applyStyles$1, offset$1, flip$1, preventOverflow$1, arrow$1, hide$1]; + var createPopper = /*#__PURE__*/popperGenerator({ + defaultModifiers: defaultModifiers + }); // eslint-disable-next-line import/no-unused-modules + + exports.applyStyles = applyStyles$1; + exports.arrow = arrow$1; + exports.computeStyles = computeStyles$1; + exports.createPopper = createPopper; + exports.createPopperLite = createPopper$1; + exports.defaultModifiers = defaultModifiers; + exports.detectOverflow = detectOverflow; + exports.eventListeners = eventListeners; + exports.flip = flip$1; + exports.hide = hide$1; + exports.offset = offset$1; + exports.popperGenerator = popperGenerator; + exports.popperOffsets = popperOffsets$1; + exports.preventOverflow = preventOverflow$1; + + Object.defineProperty(exports, '__esModule', { value: true }); + +}))); From 973d4c250af45d26b2c10318c496f2e45aadb1d9 Mon Sep 17 00:00:00 2001 From: guy Date: Thu, 22 Jul 2021 17:44:57 +0800 Subject: [PATCH 2/6] =?UTF-8?q?bubble=E4=BD=BF=E7=94=A8popper.js=E5=AE=9E?= =?UTF-8?q?=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- changelog.md | 1 + src/core/{worker.js => 10.worker.js} | 0 src/core/{popper.js => 9.popper.js} | 0 src/core/action/action.js | 12 +- src/core/action/action.show.js | 4 - src/core/behavior/0.behavior.js | 7 +- src/core/behavior/behavior.highlight.js | 11 +- src/core/behavior/behavior.redmark.js | 13 +- src/core/controller/0.controller.js | 5 - src/core/controller/controller.broadcast.js | 9 +- src/core/controller/controller.bubbles.js | 295 +++----------------- src/core/controller/controller.layer.js | 11 +- src/core/controller/controller.masker.js | 10 +- src/core/controller/controller.popover.js | 9 +- src/core/controller/controller.resizer.js | 9 +- src/core/controller/controller.tooltips.js | 11 +- src/core/listener/listener.show.js | 11 +- src/core/logic/logic.layout.js | 24 +- src/less/base/single/tip/tip.bubble.less | 17 +- 19 files changed, 88 insertions(+), 371 deletions(-) rename src/core/{worker.js => 10.worker.js} (100%) rename src/core/{popper.js => 9.popper.js} (100%) diff --git a/changelog.md b/changelog.md index 4506df680..f28681515 100644 --- a/changelog.md +++ b/changelog.md @@ -1,5 +1,6 @@ # 更新日志 2.0(2021-07) +- bubble使用popper.js实现 - 优化了日期类型控件标红时的报错提示 - 支持虚拟dom - 修复了树控件节点未初始化时调用树的getValue始终为空的问题 diff --git a/src/core/worker.js b/src/core/10.worker.js similarity index 100% rename from src/core/worker.js rename to src/core/10.worker.js diff --git a/src/core/popper.js b/src/core/9.popper.js similarity index 100% rename from src/core/popper.js rename to src/core/9.popper.js diff --git a/src/core/action/action.js b/src/core/action/action.js index 5ddf480d8..3639c00e5 100644 --- a/src/core/action/action.js +++ b/src/core/action/action.js @@ -6,15 +6,11 @@ * @abstract */ BI.Action = BI.inherit(BI.OB, { - _defaultConfig: function () { - return BI.extend(BI.Action.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { src: null, tar: null - }); - }, - - _init: function () { - BI.Action.superclass._init.apply(this, arguments); + }; }, actionPerformed: function (src, tar, callback) { @@ -36,4 +32,4 @@ BI.ActionFactory = { } return new action(options); } -}; \ No newline at end of file +}; diff --git a/src/core/action/action.show.js b/src/core/action/action.show.js index 4fd6c3fae..68296ae19 100644 --- a/src/core/action/action.show.js +++ b/src/core/action/action.show.js @@ -5,10 +5,6 @@ * @extends BI.Action */ BI.ShowAction = BI.inherit(BI.Action, { - _defaultConfig: function () { - return BI.extend(BI.ShowAction.superclass._defaultConfig.apply(this, arguments), {}); - }, - actionPerformed: function (src, tar, callback) { tar = tar || this.options.tar; tar.setVisible(true); diff --git a/src/core/behavior/0.behavior.js b/src/core/behavior/0.behavior.js index 849a6a075..3645f87b7 100644 --- a/src/core/behavior/0.behavior.js +++ b/src/core/behavior/0.behavior.js @@ -26,12 +26,7 @@ BI.Behavior = BI.inherit(BI.OB, { }); }, - _init: function () { - BI.Behavior.superclass._init.apply(this, arguments); - - }, - doBehavior: function () { } -}); \ No newline at end of file +}); diff --git a/src/core/behavior/behavior.highlight.js b/src/core/behavior/behavior.highlight.js index 9ea3da0b9..683bc061e 100644 --- a/src/core/behavior/behavior.highlight.js +++ b/src/core/behavior/behavior.highlight.js @@ -5,15 +5,6 @@ * @extends BI.Behavior */ BI.HighlightBehavior = BI.inherit(BI.Behavior, { - _defaultConfig: function () { - return BI.extend(BI.HighlightBehavior.superclass._defaultConfig.apply(this, arguments), {}); - }, - - _init: function () { - BI.HighlightBehavior.superclass._init.apply(this, arguments); - - }, - doBehavior: function (items) { var args = Array.prototype.slice.call(arguments, 1), o = this.options; @@ -39,4 +30,4 @@ BI.HighlightBehavior = BI.inherit(BI.Behavior, { } }); } -}); \ No newline at end of file +}); diff --git a/src/core/behavior/behavior.redmark.js b/src/core/behavior/behavior.redmark.js index 80850140a..b9c6572e9 100644 --- a/src/core/behavior/behavior.redmark.js +++ b/src/core/behavior/behavior.redmark.js @@ -5,17 +5,6 @@ * @extends BI.Behavior */ BI.RedMarkBehavior = BI.inherit(BI.Behavior, { - _defaultConfig: function () { - return BI.extend(BI.RedMarkBehavior.superclass._defaultConfig.apply(this, arguments), { - - }); - }, - - _init: function () { - BI.RedMarkBehavior.superclass._init.apply(this, arguments); - - }, - doBehavior: function (items) { var args = Array.prototype.slice.call(arguments, 1), o = this.options; @@ -31,4 +20,4 @@ BI.RedMarkBehavior = BI.inherit(BI.Behavior, { } }); } -}); \ No newline at end of file +}); diff --git a/src/core/controller/0.controller.js b/src/core/controller/0.controller.js index ac55e834b..4eba2c0ad 100644 --- a/src/core/controller/0.controller.js +++ b/src/core/controller/0.controller.js @@ -7,10 +7,5 @@ * @abstract */ BI.Controller = BI.inherit(BI.OB, { - _defaultConfig: function () { - return BI.extend(BI.Controller.superclass._defaultConfig.apply(this, arguments), { - - }); - } }); BI.Controller.EVENT_CHANGE = "__EVENT_CHANGE__"; diff --git a/src/core/controller/controller.broadcast.js b/src/core/controller/controller.broadcast.js index 200f98f0b..89b2f0c35 100644 --- a/src/core/controller/controller.broadcast.js +++ b/src/core/controller/controller.broadcast.js @@ -5,12 +5,7 @@ * @class */ BI.BroadcastController = BI.inherit(BI.Controller, { - _defaultConfig: function () { - return BI.extend(BI.BroadcastController.superclass._defaultConfig.apply(this, arguments), {}); - }, - - _init: function () { - BI.BroadcastController.superclass._init.apply(this, arguments); + init: function () { this._broadcasts = {}; }, @@ -47,4 +42,4 @@ BI.BroadcastController = BI.inherit(BI.Controller, { } return this; } -}); \ No newline at end of file +}); diff --git a/src/core/controller/controller.bubbles.js b/src/core/controller/controller.bubbles.js index 93b9eaa5a..048053b44 100644 --- a/src/core/controller/controller.bubbles.js +++ b/src/core/controller/controller.bubbles.js @@ -6,99 +6,8 @@ * @class */ BI.BubblesController = BI.inherit(BI.Controller, { - _defaultConfig: function () { - return BI.extend(BI.BubblesController.superclass._defaultConfig.apply(this, arguments), {}); - }, - - _const: { - bubbleHeight: 18 - }, - - _init: function () { - BI.BubblesController.superclass._init.apply(this, arguments); - var self = this; - this.fixedBubblesManager = {}; - this.fixedStoreBubbles = {}; - this.bubblesManager = {}; + init: function () { this.storeBubbles = {}; - BI.Resizers.add("bubbleController" + BI.uniqueId(), function () { - BI.each(self.fixedBubblesManager, function (name) { - self.remove(name); - }); - self.fixedBubblesManager = {}; - self.fixedStoreBubbles = {}; - }); - }, - - _createBubble: function (direct, text, level, height, fixed) { - return BI.createWidget({ - type: fixed === false ? "bi.bubble_view" : "bi.bubble", - text: text, - level: level, - height: height || 18, - direction: direct - }); - }, - - _getOffsetLeft: function (name, context, offsetStyle) { - var left = 0; - if ("center" === offsetStyle) { - left = context.element.offset().left + (context.element.bounds().width - this.get(name).element.bounds().width) / 2; - if (left < 0) { - left = 0; - } - return left; - } - if ("right" === offsetStyle) { - left = context.element.offset().left + context.element.bounds().width - this.get(name).element.bounds().width; - if (left < 0) { - left = 0; - } - return left; - } - return context.element.offset().left; - }, - - _getOffsetTop: function (name, context, offsetStyle) { - var top = 0; - if ("center" === offsetStyle) { - top = context.element.offset().top + (context.element.bounds().height - this.get(name).element.bounds().height) / 2; - if (top < 0) { - top = 0; - } - return top; - } else if ("right" === offsetStyle) { - top = context.element.offset().top + context.element.bounds().height - this.get(name).element.bounds().height; - if (top < 0) { - top = 0; - } - return top; - } - return context.element.offset().top; - }, - - _getLeftPosition: function (name, context, offsetStyle) { - var position = BI.DOM.getLeftPosition(context, this.get(name)); - position.top = this._getOffsetTop(name, context, offsetStyle); - return position; - }, - - _getBottomPosition: function (name, context, offsetStyle) { - var position = BI.DOM.getBottomPosition(context, this.get(name)); - position.left = this._getOffsetLeft(name, context, offsetStyle); - return position; - }, - - _getTopPosition: function (name, context, offsetStyle) { - var position = BI.DOM.getTopPosition(context, this.get(name)); - position.left = this._getOffsetLeft(name, context, offsetStyle); - return position; - }, - - _getRightPosition: function (name, context, offsetStyle) { - var position = BI.DOM.getRightPosition(context, this.get(name)); - position.top = this._getOffsetTop(name, context, offsetStyle); - return position; }, /** @@ -111,194 +20,66 @@ BI.BubblesController = BI.inherit(BI.Controller, { */ show: function (name, text, context, opt) { opt || (opt = {}); - var container = opt.container || context; + var container = opt.container || "body"; var offsetStyle = opt.offsetStyle || "left"; var level = opt.level || "error"; var adjustYOffset = opt.adjustYOffset || 0; var adjustXOffset = opt.adjustXOffset || 0; - var fixed = opt.fixed !== false; - // 如果是非固定位置（fixed）的bubble - if (fixed === false) { - if (!this.storeBubbles[name]) { - this.storeBubbles[name] = {}; - } - if (!this.storeBubbles[name]["top"]) { - this.storeBubbles[name]["top"] = this._createBubble("top", text, level, null, fixed); - } - BI.createWidget({ - type: "bi.absolute", - element: container, - items: [{ - el: this.storeBubbles[name]["top"] - }] + // var fixed = opt.fixed !== false; + + if (!this.storeBubbles[name]) { + this.storeBubbles[name] = BI.createWidget({ + type: "bi.label", + root: true, + cls: "bi-bubble" + " bubble-" + level, + text: text, + hgap: 5, + height: 18 }); - this.set(name, this.storeBubbles[name]["top"]); - var bubble = this.storeBubbles[name]["top"]; - var bounds = bubble.element.bounds(); - if (BI.DOM.isTopSpaceEnough(context, this.get(name), adjustYOffset)) { - var top = -(bounds.height + adjustYOffset); - switch (offsetStyle) { - case "center": - bubble.element.css({ - left: (context.element.bounds().width - bounds.width) / 2 + adjustXOffset, - top: top - }); - break; - case "right": - bubble.element.css({ - right: adjustXOffset, - top: top - }); - break; - default: - bubble.element.css({ - left: adjustXOffset, - top: top - }); - break; - } - } else { - var bottom = -(bounds.height + adjustYOffset); - switch (offsetStyle) { - case "center": - bubble.element.css({ - left: (context.element.bounds().width - bounds.width) / 2 + adjustXOffset, - bottom: bottom - }); - break; - case "right": - bubble.element.css({ - right: adjustXOffset, - bottom: bottom - }); - break; - default: - bubble.element.css({ - left: adjustXOffset, - bottom: bottom - }); - break; - } - } - } else { - if (!this.fixedStoreBubbles[name]) { - this.fixedStoreBubbles[name] = {}; - } - if (!this.fixedStoreBubbles[name]["top"]) { - this.fixedStoreBubbles[name]["top"] = this._createBubble("top", text, level, null, fixed); - } - BI.createWidget({ - type: "bi.absolute", - element: container, - items: [{ - el: this.fixedStoreBubbles[name]["top"] - }] - }); - this.set(name, this.fixedStoreBubbles[name]["top"]); - var position = this._getTopPosition(name, context, offsetStyle); - this.get(name).element.css({left: position.left + adjustXOffset, top: position.top - adjustYOffset}); - if (!BI.DOM.isTopSpaceEnough(context, this.get(name), adjustYOffset)) { - this.get(name).invisible(); - if (!this.fixedStoreBubbles[name]["bottom"]) { - this.fixedStoreBubbles[name]["bottom"] = this._createBubble("bottom", text, level); - } - BI.createWidget({ - type: "bi.absolute", - element: container, - items: [{ - el: this.fixedStoreBubbles[name]["bottom"] - }] - }); - this.set(name, this.fixedStoreBubbles[name]["bottom"]); - var position = this._getBottomPosition(name, context, offsetStyle); - this.get(name).element.css({left: position.left + adjustXOffset, top: position.top + adjustYOffset}); - if (!BI.DOM.isBottomSpaceEnough(context, this.get(name), adjustYOffset)) { - this.get(name).invisible(); - if (!this.fixedStoreBubbles[name]["right"]) { - this.fixedStoreBubbles[name]["right"] = this._createBubble("right", text, level); - } - BI.createWidget({ - type: "bi.absolute", - element: container, - items: [{ - el: this.fixedStoreBubbles[name]["right"] - }] - }); - this.set(name, this.fixedStoreBubbles[name]["right"]); - var position = this._getRightPosition(name, context, offsetStyle); - this.get(name).element.css({ - left: position.left + adjustXOffset, - top: position.top - adjustYOffset - }); - if (!BI.DOM.isRightSpaceEnough(context, this.get(name), adjustXOffset)) { - this.get(name).invisible(); - if (!this.fixedStoreBubbles[name]["left"]) { - this.fixedStoreBubbles[name]["left"] = this._createBubble("left", text, level, 30); - } - BI.createWidget({ - type: "bi.absolute", - element: container, - items: [{ - el: this.fixedStoreBubbles[name]["left"] - }] - }); - this.set(name, this.fixedStoreBubbles[name]["left"]); - var position = this._getLeftPosition(name, context, offsetStyle); - this.get(name).element.css({ - left: position.left - adjustXOffset, - top: position.top - adjustYOffset - }); + } + var bubble = this.storeBubbles[name]; + + BI.createWidget({ + type: "bi.default", + element: container, + items: [{ + el: bubble + }] + }); + BI.Popper.createPopper(context.element[0], bubble.element[0], { + placement: ({ + left: "top-start", + center: "top", + right: "top-end" + })[offsetStyle], + modifiers: [ + { + name: "offset", + options: { + offset: [adjustXOffset, adjustYOffset] } } - } - } - this.get(name).setText(text); - this.get(name).visible(); + ] + }); return this; }, hide: function (name) { - if (!this.has(name)) { - return this; - } - this.get(name).invisible(); - return this; - }, - - add: function (name, bubble) { - if (this.has(name)) { - return this; - } - this.set(name, bubble); - return this; - }, - - get: function (name) { - return this.fixedBubblesManager[name] || this.bubblesManager[name]; - }, - - set: function (name, bubble, fixed) { - fixed === false ? (this.bubblesManager[name] = bubble) : (this.fixedBubblesManager[name] = bubble); + this.remove(name); }, has: function (name) { - return this.fixedBubblesManager[name] != null || this.bubblesManager[name] != null; + return this.storeBubbles[name] != null; }, remove: function (name) { if (!this.has(name)) { return this; } - BI.each(this.fixedStoreBubbles[name], function (dir, bubble) { - bubble.destroy(); - }); - delete this.fixedStoreBubbles[name]; - delete this.fixedBubblesManager[name]; - BI.each(this.storeBubbles[name], function (dir, bubble) { + BI.each(this.storeBubbles, function (dir, bubble) { bubble.destroy(); }); delete this.storeBubbles[name]; - delete this.bubblesManager[name]; return this; } }); diff --git a/src/core/controller/controller.layer.js b/src/core/controller/controller.layer.js index 3fbc03c22..af245b133 100644 --- a/src/core/controller/controller.layer.js +++ b/src/core/controller/controller.layer.js @@ -5,14 +5,13 @@ * @class */ BI.LayerController = BI.inherit(BI.Controller, { - _defaultConfig: function () { - return BI.extend(BI.LayerController.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { render: "body" - }); + }; }, - _init: function () { - BI.LayerController.superclass._init.apply(this, arguments); + init: function () { this.layerManager = {}; this.layouts = {}; this.zindex = BI.zIndex_layer; @@ -167,4 +166,4 @@ BI.LayerController = BI.inherit(BI.Controller, { this.layouts = {}; return this; } -}); \ No newline at end of file +}); diff --git a/src/core/controller/controller.masker.js b/src/core/controller/controller.masker.js index 5c34fc8d5..0b55b0781 100644 --- a/src/core/controller/controller.masker.js +++ b/src/core/controller/controller.masker.js @@ -5,12 +5,8 @@ * @class */ BI.MaskersController = BI.inherit(BI.LayerController, { - _defaultConfig: function () { - return BI.extend(BI.MaskersController.superclass._defaultConfig.apply(this, arguments), {}); - }, - - _init: function () { - BI.MaskersController.superclass._init.apply(this, arguments); + init: function () { + BI.MaskersController.superclass.init.apply(this, arguments); this.zindex = BI.zIndex_masker; } -}); \ No newline at end of file +}); diff --git a/src/core/controller/controller.popover.js b/src/core/controller/controller.popover.js index c9de3a29a..8f53bd5ff 100644 --- a/src/core/controller/controller.popover.js +++ b/src/core/controller/controller.popover.js @@ -5,15 +5,14 @@ * @extends BI.Controller */ BI.PopoverController = BI.inherit(BI.Controller, { - _defaultConfig: function () { - return BI.extend(BI.PopoverController.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { modal: true, // 模态窗口 render: "body" - }); + }; }, - _init: function () { - BI.PopoverController.superclass._init.apply(this, arguments); + init: function () { this.modal = this.options.modal; this.floatManager = {}; this.floatLayer = {}; diff --git a/src/core/controller/controller.resizer.js b/src/core/controller/controller.resizer.js index ad1ac2c42..a471cebdf 100644 --- a/src/core/controller/controller.resizer.js +++ b/src/core/controller/controller.resizer.js @@ -5,12 +5,7 @@ * @class */ BI.ResizeController = BI.inherit(BI.Controller, { - _defaultConfig: function () { - return BI.extend(BI.ResizeController.superclass._defaultConfig.apply(this, arguments), {}); - }, - - _init: function () { - BI.ResizeController.superclass._init.apply(this, arguments); + init: function () { var self = this; this.resizerManger = {}; var fn = BI.debounce(function (ev) { @@ -70,4 +65,4 @@ BI.ResizeController = BI.inherit(BI.Controller, { delete this.resizerManger[name]; return this; } -}); \ No newline at end of file +}); diff --git a/src/core/controller/controller.tooltips.js b/src/core/controller/controller.tooltips.js index 8dd3e494a..a6722b560 100644 --- a/src/core/controller/controller.tooltips.js +++ b/src/core/controller/controller.tooltips.js @@ -7,16 +7,7 @@ * @extends BI.Controller */ BI.TooltipsController = BI.inherit(BI.Controller, { - _defaultConfig: function () { - return BI.extend(BI.TooltipsController.superclass._defaultConfig.apply(this, arguments), {}); - }, - - _const: { - height: 18 - }, - - _init: function () { - BI.TooltipsController.superclass._init.apply(this, arguments); + init: function () { this.tooltipsManager = {}; this.showingTips = {};// 存储正在显示的tooltip }, diff --git a/src/core/listener/listener.show.js b/src/core/listener/listener.show.js index c27eb4e13..85c7309c3 100644 --- a/src/core/listener/listener.show.js +++ b/src/core/listener/listener.show.js @@ -6,8 +6,8 @@ * @extends BI.OB */ BI.ShowListener = BI.inherit(BI.OB, { - _defaultConfig: function () { - return BI.extend(BI.ShowListener.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { eventObj: BI.createWidget(), cardLayout: null, cardNameCreator: function (v) { @@ -16,11 +16,10 @@ BI.ShowListener = BI.inherit(BI.OB, { cardCreator: BI.emptyFn, afterCardCreated: BI.emptyFn, afterCardShow: BI.emptyFn - }); + }; }, - _init: function () { - BI.ShowListener.superclass._init.apply(this, arguments); + init: function () { var self = this, o = this.options; if (o.eventObj) { o.eventObj.on(BI.Controller.EVENT_CHANGE, function (type, v, ob) { @@ -46,4 +45,4 @@ BI.ShowListener = BI.inherit(BI.OB, { } } }); -BI.ShowListener.EVENT_CHANGE = "EVENT_CHANGE"; \ No newline at end of file +BI.ShowListener.EVENT_CHANGE = "EVENT_CHANGE"; diff --git a/src/core/logic/logic.layout.js b/src/core/logic/logic.layout.js index a3a630b3a..93fb60a86 100644 --- a/src/core/logic/logic.layout.js +++ b/src/core/logic/logic.layout.js @@ -7,8 +7,8 @@ * @extends BI.Logic */ BI.VerticalLayoutLogic = BI.inherit(BI.Logic, { - _defaultConfig: function () { - return BI.extend(BI.VerticalLayoutLogic.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { dynamic: false, scrollable: null, scrolly: false, @@ -20,7 +20,7 @@ BI.VerticalLayoutLogic = BI.inherit(BI.Logic, { rgap: 0, tgap: 0, bgap: 0 - }); + }; }, createLogic: function () { @@ -56,8 +56,8 @@ BI.VerticalLayoutLogic = BI.inherit(BI.Logic, { * @extends BI.Logic */ BI.HorizontalLayoutLogic = BI.inherit(BI.Logic, { - _defaultConfig: function () { - return BI.extend(BI.HorizontalLayoutLogic.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { dynamic: false, scrollable: null, scrolly: false, @@ -69,7 +69,7 @@ BI.HorizontalLayoutLogic = BI.inherit(BI.Logic, { rgap: 0, tgap: 0, bgap: 0 - }); + }; }, createLogic: function () { @@ -104,8 +104,8 @@ BI.HorizontalLayoutLogic = BI.inherit(BI.Logic, { * @extends BI.OB */ BI.TableLayoutLogic = BI.inherit(BI.Logic, { - _defaultConfig: function () { - return BI.extend(BI.TableLayoutLogic.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { dynamic: false, scrollable: null, scrolly: false, @@ -117,7 +117,7 @@ BI.TableLayoutLogic = BI.inherit(BI.Logic, { hgap: 0, vgap: 0, items: [] - }); + }; }, createLogic: function () { @@ -151,8 +151,8 @@ BI.TableLayoutLogic = BI.inherit(BI.Logic, { * @extends BI.Logic */ BI.HorizontalFillLayoutLogic = BI.inherit(BI.Logic, { - _defaultConfig: function () { - return BI.extend(BI.HorizontalFillLayoutLogic.superclass._defaultConfig.apply(this, arguments), { + props: function () { + return { dynamic: false, scrollable: null, scrolly: false, @@ -164,7 +164,7 @@ BI.HorizontalFillLayoutLogic = BI.inherit(BI.Logic, { rgap: 0, tgap: 0, bgap: 0 - }); + }; }, createLogic: function () { diff --git a/src/less/base/single/tip/tip.bubble.less b/src/less/base/single/tip/tip.bubble.less index b47874ea0..ec3704fab 100644 --- a/src/less/base/single/tip/tip.bubble.less +++ b/src/less/base/single/tip/tip.bubble.less @@ -1,30 +1,29 @@ @import "../../../index"; -.bi-bubble{ - & .bubble-text{ - .border-radius(2px); - } +.bi-bubble { + z-index: @zIndex-tip; + .border-radius(2px); - & .bubble-error{ + &.bubble-error{ background: @color-bi-background-light-failure; color: @color-bi-text-failure; } - .bi-theme-dark & .bubble-error { + .bi-theme-dark &.bubble-error { background: @color-bi-background-dark-failure; } - & .bubble-common{ + &.bubble-common{ background: @color-bi-background-light-highlight; color: @color-bi-text-highlight; } - & .bubble-success{ + &.bubble-success{ background: @color-bi-background-light-success; color: @color-bi-text-success; } - & .bubble-warning{ + &.bubble-warning{ background: @color-bi-background-light-warning; color: @color-bi-text-redmark; } From aa6cbc4d802bf1196c26fe4d178366cebae1eb12 Mon Sep 17 00:00:00 2001 From: guy Date: Thu, 22 Jul 2021 17:48:04 +0800 Subject: [PATCH 3/6] =?UTF-8?q?bubble=E4=BD=BF=E7=94=A8popper.js=E5=AE=9E?= =?UTF-8?q?=E7=8E=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/base/single/tip/tip.bubble.js | 212 ------------------------------ 1 file changed, 212 deletions(-) delete mode 100644 src/base/single/tip/tip.bubble.js diff --git a/src/base/single/tip/tip.bubble.js b/src/base/single/tip/tip.bubble.js deleted file mode 100644 index 2ba43ef4c..000000000 --- a/src/base/single/tip/tip.bubble.js +++ /dev/null @@ -1,212 +0,0 @@ -/** - * guy - * 气泡提示 - * @class BI.Bubble - * @extends BI.Tip - * @type {*|void|Object} - */ -BI.Bubble = BI.inherit(BI.Tip, { - _defaultConfig: function () { - return BI.extend(BI.Bubble.superclass._defaultConfig.apply(this, arguments), { - extraCls: "bi-bubble", - direction: "top", - text: "", - level: "error", - height: 18 - }); - }, - _init: function () { - BI.Bubble.superclass._init.apply(this, arguments); - var fn = function (e) { - e.stopPropagation(); - e.stopEvent(); - return false; - }; - this.element.bind({click: fn, mousedown: fn, mouseup: fn, mouseover: fn, mouseenter: fn, mouseleave: fn, mousemove: fn}); - BI.createWidget({ - type: "bi.adaptive", - element: this, - items: [this["_" + this.options.direction]()] - }); - }, - - _createBubbleText: function () { - var o = this.options; - return (this.text = BI.createWidget({ - type: "bi.label", - cls: "bubble-text" + " bubble-" + o.level, - text: o.text, - hgap: 5, - height: 18 - })); - }, - - _top: function () { - return BI.createWidget({ - type: "bi.vertical", - items: [{ - el: this._createBubbleText(), - height: 18 - }, { - el: { - type: "bi.layout" - }, - height: 3 - }] - }); - }, - - _bottom: function () { - return BI.createWidget({ - type: "bi.vertical", - items: [{ - el: { - type: "bi.layout" - }, - height: 3 - }, { - el: this._createBubbleText(), - height: 18 - }] - }); - }, - - _left: function () { - return BI.createWidget({ - type: "bi.right", - items: [{ - el: { - type: "bi.layout", - width: 3, - height: 18 - } - }, { - el: this._createBubbleText() - }] - }); - }, - - _right: function () { - return BI.createWidget({ - type: "bi.left", - items: [{ - el: { - type: "bi.layout", - width: 3, - height: 18 - } - }, { - el: this._createBubbleText() - }] - }); - }, - - setText: function (text) { - this.text.setText(text); - } -}); - -BI.shortcut("bi.bubble", BI.Bubble); - -BI.BubbleView = BI.inherit(BI.Single, { - _defaultConfig: function () { - return BI.extend(BI.BubbleView.superclass._defaultConfig.apply(this, arguments), { - extraCls: "bi-bubble", - direction: "top", - text: "", - level: "error", - height: 18 - }); - }, - _init: function () { - BI.BubbleView.superclass._init.apply(this, arguments); - var fn = function (e) { - e.stopPropagation(); - e.stopEvent(); - return false; - }; - this.element.bind({click: fn, mousedown: fn, mouseup: fn, mouseover: fn, mouseenter: fn, mouseleave: fn, mousemove: fn}); - BI.createWidget({ - type: "bi.adaptive", - element: this, - items: [this["_" + this.options.direction]()] - }); - }, - - _createBubbleText: function () { - var o = this.options; - return (this.text = BI.createWidget({ - type: "bi.label", - cls: "bubble-text" + " bubble-" + o.level, - text: o.text, - hgap: 5, - height: 18 - })); - }, - - _top: function () { - return BI.createWidget({ - type: "bi.vertical", - items: [{ - el: this._createBubbleText(), - height: 18 - }, { - el: { - type: "bi.layout" - }, - height: 3 - }] - }); - }, - - _bottom: function () { - return BI.createWidget({ - type: "bi.vertical", - items: [{ - el: { - type: "bi.layout" - }, - height: 3 - }, { - el: this._createBubbleText(), - height: 18 - }] - }); - }, - - _left: function () { - return BI.createWidget({ - type: "bi.right", - items: [{ - el: { - type: "bi.layout", - width: 3, - height: 18 - } - }, { - el: this._createBubbleText() - }] - }); - }, - - _right: function () { - return BI.createWidget({ - type: "bi.left", - items: [{ - el: { - type: "bi.layout", - width: 3, - height: 18 - } - }, { - el: this._createBubbleText() - }] - }); - }, - - setText: function (text) { - this.text.setText(text); - } -}); - -BI.shortcut("bi.bubble_view", BI.BubbleView); From ba2a96ac1df1889de7c805665b4b6b450e332d5c Mon Sep 17 00:00:00 2001 From: guy Date: Thu, 22 Jul 2021 17:57:48 +0800 Subject: [PATCH 4/6] bugfix --- src/core/5.shortcut.js | 6 +++--- src/core/6.inject.js | 31 +++++++++++++++++++++++-------- 2 files changed, 26 insertions(+), 11 deletions(-) diff --git a/src/core/5.shortcut.js b/src/core/5.shortcut.js index 54af3bdbe..330228b2c 100644 --- a/src/core/5.shortcut.js +++ b/src/core/5.shortcut.js @@ -2,7 +2,7 @@ var kv = {}; BI.shortcut = BI.component = BI.shortcut || function (xtype, cls) { if (kv[xtype] != null) { - _global.console && console.error("shortcut:[" + xtype + "] has been registed"); + _global.console && console.error("组件： [" + xtype + "] 已经注册过了"); } if (cls) { cls["xtype"] = xtype; @@ -15,7 +15,7 @@ var cls = kv[config.type]; if (!cls) { - throw new Error("组件" + config.type + "未定义"); + throw new Error("组件： [" + config.type + "] 未定义"); } var pushed = false; var widget = new cls(); @@ -88,7 +88,7 @@ if (BI.isWidget(item.el)) { return item.el; } - throw new Error("无法根据item创建组件"); + throw new Error("组件创建：无法根据item创建组件", item); }; BI._lazyCreateWidget = BI._lazyCreateWidget || function (item, options, context) { diff --git a/src/core/6.inject.js b/src/core/6.inject.js index c9d633e12..28f310b86 100644 --- a/src/core/6.inject.js +++ b/src/core/6.inject.js @@ -2,7 +2,7 @@ var moduleInjection = {}; BI.module = BI.module || function (xtype, cls) { if (moduleInjection[xtype] != null) { - _global.console && console.error("module:[" + xtype + "] has been registed"); + _global.console && console.error("module： [" + xtype + "] 已经注册过了"); } moduleInjection[xtype] = cls; }; @@ -10,7 +10,7 @@ var constantInjection = {}; BI.constant = BI.constant || function (xtype, cls) { if (constantInjection[xtype] != null) { - _global.console && console.error("constant:[" + xtype + "] has been registed"); + _global.console && console.error("constant: [" + xtype + "]已经注册过了"); } constantInjection[xtype] = cls; }; @@ -18,7 +18,7 @@ var modelInjection = {}; BI.model = BI.model || function (xtype, cls) { if (modelInjection[xtype] != null) { - _global.console && console.error("model:[" + xtype + "] has been registed"); + _global.console && console.error("model: [" + xtype + "] 已经注册过了"); } modelInjection[xtype] = cls; }; @@ -26,7 +26,7 @@ var storeInjection = {}; BI.store = BI.store || function (xtype, cls) { if (storeInjection[xtype] != null) { - _global.console && console.error("store:[" + xtype + "] has been registed"); + _global.console && console.error("store: [" + xtype + "] 已经注册过了"); } storeInjection[xtype] = cls; }; @@ -34,7 +34,7 @@ var serviceInjection = {}; BI.service = BI.service || function (xtype, cls) { if (serviceInjection[xtype] != null) { - _global.console && console.error("service:[" + xtype + "] has been registed"); + _global.console && console.error("service: [" + xtype + "] 已经注册过了"); } serviceInjection[xtype] = cls; }; @@ -42,7 +42,7 @@ var providerInjection = {}; BI.provider = BI.provider || function (xtype, cls) { if (providerInjection[xtype] != null) { - _global.console && console.error("provider:[" + xtype + "] has been registed"); + _global.console && console.error("provider: [" + xtype + "] 已经注册过了"); } providerInjection[xtype] = cls; }; @@ -138,8 +138,7 @@ BI.Modules = BI.Modules || { getModule: function (type) { if (!moduleInjection[type]) { - _global.console && console.error("module:[" + type + "] does not exists"); - return false; + throw new Error("module: [" + type + "] 未定义"); } return moduleInjection[type]; }, @@ -150,6 +149,9 @@ BI.Constants = BI.Constants || { getConstant: function (type) { + if (!constantInjection[type]) { + throw new Error("constant: [" + type + "] 未定义"); + } return constantInjection[type]; } }; @@ -194,6 +196,9 @@ BI.Models = BI.Models || { getModel: function (type, config) { + if (!modelInjection[type]) { + throw new Error("model: [" + type + "] 未定义"); + } var inst = new modelInjection[type](config); inst._constructor && inst._constructor(config); inst.mixins && callPoint(inst, inst.mixins); @@ -206,6 +211,9 @@ BI.Stores = BI.Stores || { getStore: function (type, config) { + if (!storeInjection[type]) { + throw new Error("store: [" + type + "] 未定义"); + } if (stores[type]) { return stores[type]; } @@ -222,6 +230,9 @@ BI.Services = BI.Services || { getService: function (type, config) { + if (!serviceInjection[type]) { + throw new Error("service: [" + type + "] 未定义"); + } if (services[type]) { return services[type]; } @@ -236,6 +247,9 @@ BI.Providers = BI.Providers || { getProvider: function (type, config) { + if (!providerInjection[type]) { + throw new Error("provider: [" + type + "] 未定义"); + } if (!providers[type]) { providers[type] = new providerInjection[type](); } @@ -284,5 +298,6 @@ if (providerInjection[type]) { return BI.Providers.getProvider(type, config); } + throw new Error("未知类型: [" + type + "] 未定义"); }; })(); From 3ef9f62df5b1811fce9643be65dc57def9f84f24 Mon Sep 17 00:00:00 2001 From: guy Date: Thu, 22 Jul 2021 18:06:28 +0800 Subject: [PATCH 5/6] =?UTF-8?q?=E4=BC=98=E5=8C=96=E9=94=99=E8=AF=AF?= =?UTF-8?q?=E6=8F=90=E7=A4=BA?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/base/combination/loader.js | 4 ++-- src/core/2.base.js | 2 +- src/core/4.widget.js | 2 +- src/core/5.shortcut.js | 2 +- src/core/controller/controller.layer.js | 2 +- src/core/listener/listener.show.js | 2 +- src/core/wrapper/layout/adapt/absolute.leftrightvertical.js | 6 +++--- src/core/wrapper/layout/adapt/adapt.leftrightvertical.js | 6 +++--- .../wrapper/layout/flex/flex.leftrightvertical.center.js | 2 +- src/core/wrapper/layout/layout.border.js | 2 +- src/core/wrapper/layout/layout.card.js | 6 +++--- src/core/wrapper/layout/layout.division.js | 4 ++-- src/core/wrapper/layout/layout.grid.js | 2 +- src/core/wrapper/layout/layout.inline.js | 2 +- src/core/wrapper/layout/layout.table.js | 4 ++-- src/core/wrapper/layout/layout.tape.js | 4 ++-- src/core/wrapper/layout/layout.td.js | 2 +- src/core/wrapper/layout/layout.window.js | 4 ++-- src/core/wrapper/layout/middle/middle.center.js | 2 +- src/core/wrapper/layout/middle/middle.float.center.js | 2 +- src/core/wrapper/layout/middle/middle.horizontal.js | 2 +- src/core/wrapper/layout/middle/middle.vertical.js | 2 +- src/data/pool/pool.buffer.js | 4 ++-- 23 files changed, 35 insertions(+), 35 deletions(-) diff --git a/src/base/combination/loader.js b/src/base/combination/loader.js index f4593d6ce..310c606b3 100644 --- a/src/base/combination/loader.js +++ b/src/base/combination/loader.js @@ -169,7 +169,7 @@ BI.Loader = BI.inherit(BI.Widget, { if (arguments.length === 0 && (BI.isFunction(o.itemsCreator))) { o.itemsCreator.apply(this, [{times: 1}, function () { if (arguments.length === 0) { - throw new Error("arguments can not be null!!!"); + throw new Error("参数不能为空"); } self.populate.apply(self, arguments); o.onLoaded(); @@ -257,4 +257,4 @@ BI.Loader = BI.inherit(BI.Widget, { } }); BI.Loader.EVENT_CHANGE = "EVENT_CHANGE"; -BI.shortcut("bi.loader", BI.Loader); \ No newline at end of file +BI.shortcut("bi.loader", BI.Loader); diff --git a/src/core/2.base.js b/src/core/2.base.js index e5188249c..c9e7b1699 100644 --- a/src/core/2.base.js +++ b/src/core/2.base.js @@ -75,7 +75,7 @@ if (!_global.BI) { createWidgets: function (items, options, context) { if (!BI.isArray(items)) { - throw new Error("cannot create Widgets"); + throw new Error("items必须是数组", items); } if (BI.isWidget(options)) { context = options; diff --git a/src/core/4.widget.js b/src/core/4.widget.js index 447aa9c75..69cf7e29a 100644 --- a/src/core/4.widget.js +++ b/src/core/4.widget.js @@ -449,7 +449,7 @@ } name = name || widget.getName() || BI.uniqueId("widget"); if (this._children[name]) { - throw new Error("name has already been existed"); + throw new Error("组件：组件名已存在，不能进行添加"); } widget._setParent && widget._setParent(this); widget.on(BI.Events.DESTROY, function () { diff --git a/src/core/5.shortcut.js b/src/core/5.shortcut.js index 330228b2c..b23ab983f 100644 --- a/src/core/5.shortcut.js +++ b/src/core/5.shortcut.js @@ -88,7 +88,7 @@ if (BI.isWidget(item.el)) { return item.el; } - throw new Error("组件创建：无法根据item创建组件", item); + throw new Error("组件：无法根据item创建组件", item); }; BI._lazyCreateWidget = BI._lazyCreateWidget || function (item, options, context) { diff --git a/src/core/controller/controller.layer.js b/src/core/controller/controller.layer.js index af245b133..d8bb9d2d0 100644 --- a/src/core/controller/controller.layer.js +++ b/src/core/controller/controller.layer.js @@ -124,7 +124,7 @@ BI.LayerController = BI.inherit(BI.Controller, { add: function (name, layer, layout) { if (this.has(name)) { - throw new Error("name is already exist"); + throw new Error("不能创建同名的Layer"); } layout.setVisible(false); this.layerManager[name] = layer; diff --git a/src/core/listener/listener.show.js b/src/core/listener/listener.show.js index 85c7309c3..af2236578 100644 --- a/src/core/listener/listener.show.js +++ b/src/core/listener/listener.show.js @@ -27,7 +27,7 @@ BI.ShowListener = BI.inherit(BI.OB, { v = v || o.eventObj.getValue(); v = BI.isArray(v) ? (v.length > 1 ? v.toString() : v[0]) : v; if (BI.isNull(v)) { - throw new Error("value cannot be null"); + throw new Error("不能为null"); } var cardName = o.cardNameCreator(v); if (!o.cardLayout.isCardExisted(cardName)) { diff --git a/src/core/wrapper/layout/adapt/absolute.leftrightvertical.js b/src/core/wrapper/layout/adapt/absolute.leftrightvertical.js index a9af9ce1a..1ac9c37b3 100644 --- a/src/core/wrapper/layout/adapt/absolute.leftrightvertical.js +++ b/src/core/wrapper/layout/adapt/absolute.leftrightvertical.js @@ -85,7 +85,7 @@ BI.AbsoluteLeftRightVerticalAdaptLayout = BI.inherit(BI.Layout, { addItem: function () { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, populate: function (items) { @@ -137,11 +137,11 @@ BI.AbsoluteRightVerticalAdaptLayout = BI.inherit(BI.Layout, { addItem: function () { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, populate: function (items) { this.layout.populate(items); } }); -BI.shortcut("bi.absolute_right_vertical_adapt", BI.AbsoluteRightVerticalAdaptLayout); \ No newline at end of file +BI.shortcut("bi.absolute_right_vertical_adapt", BI.AbsoluteRightVerticalAdaptLayout); diff --git a/src/core/wrapper/layout/adapt/adapt.leftrightvertical.js b/src/core/wrapper/layout/adapt/adapt.leftrightvertical.js index 26a121795..b2dabf32a 100644 --- a/src/core/wrapper/layout/adapt/adapt.leftrightvertical.js +++ b/src/core/wrapper/layout/adapt/adapt.leftrightvertical.js @@ -81,7 +81,7 @@ BI.LeftRightVerticalAdaptLayout = BI.inherit(BI.Layout, { addItem: function () { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, populate: function (items) { @@ -134,7 +134,7 @@ BI.LeftVerticalAdaptLayout = BI.inherit(BI.Layout, { addItem: function () { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, populate: function (items) { @@ -186,7 +186,7 @@ BI.RightVerticalAdaptLayout = BI.inherit(BI.Layout, { addItem: function () { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, populate: function (items) { diff --git a/src/core/wrapper/layout/flex/flex.leftrightvertical.center.js b/src/core/wrapper/layout/flex/flex.leftrightvertical.center.js index e0a5bdd13..dec32ca13 100644 --- a/src/core/wrapper/layout/flex/flex.leftrightvertical.center.js +++ b/src/core/wrapper/layout/flex/flex.leftrightvertical.center.js @@ -75,7 +75,7 @@ BI.FlexLeftRightVerticalAdaptLayout = BI.inherit(BI.Layout, { addItem: function () { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, populate: function (items) { diff --git a/src/core/wrapper/layout/layout.border.js b/src/core/wrapper/layout/layout.border.js index a6a412a51..47907c572 100644 --- a/src/core/wrapper/layout/layout.border.js +++ b/src/core/wrapper/layout/layout.border.js @@ -22,7 +22,7 @@ BI.BorderLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, stroke: function (regions) { diff --git a/src/core/wrapper/layout/layout.card.js b/src/core/wrapper/layout/layout.card.js index f0133de6e..65fa9fcf6 100644 --- a/src/core/wrapper/layout/layout.card.js +++ b/src/core/wrapper/layout/layout.card.js @@ -70,7 +70,7 @@ BI.CardLayout = BI.inherit(BI.Layout, { getCardByName: function (cardName) { if (!this.isCardExisted(cardName)) { - throw new Error("cardName is not exist"); + throw new Error("cardName不存在", cardName); } return this._children[this._getChildName(cardName)]; }, @@ -87,7 +87,7 @@ BI.CardLayout = BI.inherit(BI.Layout, { deleteCardByName: function (cardName) { if (!this.isCardExisted(cardName)) { - throw new Error("cardName is not exist"); + throw new Error("cardName不存在", cardName); } var child = this._children[this._getChildName(cardName)]; @@ -97,7 +97,7 @@ BI.CardLayout = BI.inherit(BI.Layout, { addCardByName: function (cardName, cardItem) { if (this.isCardExisted(cardName)) { - throw new Error("cardName is already exist"); + throw new Error("cardName 已存在", cardName); } var widget = BI._lazyCreateWidget(cardItem, this); widget.element.css({ diff --git a/src/core/wrapper/layout/layout.division.js b/src/core/wrapper/layout/layout.division.js index 7d2912317..1aac78bc8 100644 --- a/src/core/wrapper/layout/layout.division.js +++ b/src/core/wrapper/layout/layout.division.js @@ -47,7 +47,7 @@ BI.DivisionLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, stroke: function (items) { @@ -112,7 +112,7 @@ BI.DivisionLayout = BI.inherit(BI.Layout, { var totalW = 0; for (var j = 0; j < columns; j++) { if (!map[i][j]) { - throw new Error("item be required"); + throw new Error("item(" + i + "" + j + ") 必须", map); } if (!this.hasWidget(this._getChildName(i + "_" + j))) { var w = BI._lazyCreateWidget(map[i][j]); diff --git a/src/core/wrapper/layout/layout.grid.js b/src/core/wrapper/layout/layout.grid.js index 49f47bea6..a787c449b 100644 --- a/src/core/wrapper/layout/layout.grid.js +++ b/src/core/wrapper/layout/layout.grid.js @@ -41,7 +41,7 @@ BI.GridLayout = BI.inherit(BI.Layout, { addItem: function () { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, stroke: function (items) { diff --git a/src/core/wrapper/layout/layout.inline.js b/src/core/wrapper/layout/layout.inline.js index e8830b9c1..5fb598699 100644 --- a/src/core/wrapper/layout/layout.inline.js +++ b/src/core/wrapper/layout/layout.inline.js @@ -99,7 +99,7 @@ BI.InlineLayout = BI.inherit(BI.Layout, { }, addItem: function (item) { - throw new Error("不能添加元素"); + throw new Error("不能添加子组件"); }, populate: function (items) { diff --git a/src/core/wrapper/layout/layout.table.js b/src/core/wrapper/layout/layout.table.js index d665c5429..faec5d7fa 100644 --- a/src/core/wrapper/layout/layout.table.js +++ b/src/core/wrapper/layout/layout.table.js @@ -88,7 +88,7 @@ BI.TableLayout = BI.inherit(BI.Layout, { }, arr[j])); right += o.columnSize[j] + (o.columnSize[j] < 1 ? 0 : o.hgap); } else { - throw new Error("item with fill can only be one"); + throw new Error("构造错误", arr); } } if (i >= 0 && i < arr.length) { @@ -123,7 +123,7 @@ BI.TableLayout = BI.inherit(BI.Layout, { addItem: function (arr) { if (!BI.isArray(arr)) { - throw new Error("item must be array"); + throw new Error("必须是数组", arr); } return BI.TableLayout.superclass.addItem.apply(this, arguments); }, diff --git a/src/core/wrapper/layout/layout.tape.js b/src/core/wrapper/layout/layout.tape.js index 3a9430383..7c5a85b2f 100644 --- a/src/core/wrapper/layout/layout.tape.js +++ b/src/core/wrapper/layout/layout.tape.js @@ -28,7 +28,7 @@ BI.HTapeLayout = BI.inherit(BI.Layout, { }, addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, stroke: function (items) { @@ -168,7 +168,7 @@ BI.VTapeLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, stroke: function (items) { diff --git a/src/core/wrapper/layout/layout.td.js b/src/core/wrapper/layout/layout.td.js index e191015b4..fe2df2f70 100644 --- a/src/core/wrapper/layout/layout.td.js +++ b/src/core/wrapper/layout/layout.td.js @@ -163,7 +163,7 @@ BI.TdLayout = BI.inherit(BI.Layout, { addItem: function (arr) { if (!BI.isArray(arr)) { - throw new Error("item must be array"); + throw new Error("必须是数组", arr); } return BI.TdLayout.superclass.addItem.apply(this, arguments); }, diff --git a/src/core/wrapper/layout/layout.window.js b/src/core/wrapper/layout/layout.window.js index 98b5386ce..d7037f923 100644 --- a/src/core/wrapper/layout/layout.window.js +++ b/src/core/wrapper/layout/layout.window.js @@ -31,7 +31,7 @@ BI.WindowLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, stroke: function (items) { @@ -83,7 +83,7 @@ BI.WindowLayout = BI.inherit(BI.Layout, { for (var i = 0; i < o.rows; i++) { for (var j = 0; j < o.columns; j++) { if (!o.items[i][j]) { - throw new Error("item be required"); + throw new Error("构造错误", o.items); } if (!this.hasWidget(this._getChildName(i + "_" + j))) { var w = BI._lazyCreateWidget(o.items[i][j]); diff --git a/src/core/wrapper/layout/middle/middle.center.js b/src/core/wrapper/layout/middle/middle.center.js index f1a27125a..73af27053 100644 --- a/src/core/wrapper/layout/middle/middle.center.js +++ b/src/core/wrapper/layout/middle/middle.center.js @@ -62,7 +62,7 @@ BI.CenterLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, update: function (opt) { diff --git a/src/core/wrapper/layout/middle/middle.float.center.js b/src/core/wrapper/layout/middle/middle.float.center.js index b4e6bf090..f5b2de702 100644 --- a/src/core/wrapper/layout/middle/middle.float.center.js +++ b/src/core/wrapper/layout/middle/middle.float.center.js @@ -61,7 +61,7 @@ BI.FloatCenterLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, update: function (opt) { diff --git a/src/core/wrapper/layout/middle/middle.horizontal.js b/src/core/wrapper/layout/middle/middle.horizontal.js index 3cdc7c5cd..bf802e315 100644 --- a/src/core/wrapper/layout/middle/middle.horizontal.js +++ b/src/core/wrapper/layout/middle/middle.horizontal.js @@ -60,7 +60,7 @@ BI.HorizontalCenterLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, update: function (opt) { diff --git a/src/core/wrapper/layout/middle/middle.vertical.js b/src/core/wrapper/layout/middle/middle.vertical.js index a7040cbea..df4ca51ff 100644 --- a/src/core/wrapper/layout/middle/middle.vertical.js +++ b/src/core/wrapper/layout/middle/middle.vertical.js @@ -61,7 +61,7 @@ BI.VerticalCenterLayout = BI.inherit(BI.Layout, { addItem: function (item) { // do nothing - throw new Error("cannot be added"); + throw new Error("不能添加子组件"); }, update: function (opt) { diff --git a/src/data/pool/pool.buffer.js b/src/data/pool/pool.buffer.js index 4310f740e..9e85ba6f6 100644 --- a/src/data/pool/pool.buffer.js +++ b/src/data/pool/pool.buffer.js @@ -10,7 +10,7 @@ BI.BufferPool = { put: function (name, cache) { if (BI.isNotNull(Buffer[name])) { - throw new Error("Buffer Pool has the key already!"); + throw new Error("key值：[" + name + "] 已存在!", Buffer); } Buffer[name] = cache; }, @@ -19,4 +19,4 @@ return Buffer[name]; } }; -})(); \ No newline at end of file +})(); From 04f7acc10b60dacff45f8cedc09c6217b7a22412 Mon Sep 17 00:00:00 2001 From: guy Date: Thu, 22 Jul 2021 18:39:07 +0800 Subject: [PATCH 6/6] bugfix --- src/core/controller/controller.bubbles.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/core/controller/controller.bubbles.js b/src/core/controller/controller.bubbles.js index 048053b44..b31843d2f 100644 --- a/src/core/controller/controller.bubbles.js +++ b/src/core/controller/controller.bubbles.js @@ -30,7 +30,6 @@ BI.BubblesController = BI.inherit(BI.Controller, { if (!this.storeBubbles[name]) { this.storeBubbles[name] = BI.createWidget({ type: "bi.label", - root: true, cls: "bi-bubble" + " bubble-" + level, text: text, hgap: 5, @@ -52,6 +51,7 @@ BI.BubblesController = BI.inherit(BI.Controller, { center: "top", right: "top-end" })[offsetStyle], + strategy: "fixed", modifiers: [ { name: "offset",