mirror of
https://github.com/harivansh-afk/sandbox-agent.git
synced 2026-04-17 03:03:48 +00:00
2689 lines
101 KiB
JavaScript
2689 lines
101 KiB
JavaScript
import {
|
|
require_overrides,
|
|
require_styles
|
|
} from "./chunk-B7I2HBKX.js";
|
|
import {
|
|
require_react_dom
|
|
} from "./chunk-JD3UC7WK.js";
|
|
import {
|
|
require_react
|
|
} from "./chunk-776SV3ZX.js";
|
|
import {
|
|
__commonJS,
|
|
__esm,
|
|
__export,
|
|
__toCommonJS,
|
|
__toESM
|
|
} from "./chunk-V4OQ3NZ2.js";
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/utils/focusVisible.js
|
|
var require_focusVisible = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/utils/focusVisible.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.forkFocus = exports.forkBlur = void 0;
|
|
exports.handleBlurVisible = handleBlurVisible;
|
|
exports.initFocusVisible = initFocusVisible;
|
|
exports.isFocusVisible = isFocusVisible;
|
|
exports.teardown = teardown;
|
|
var initialized = false;
|
|
var hadKeyboardEvent = true;
|
|
var hadFocusVisibleRecently = false;
|
|
var hadFocusVisibleRecentlyTimeout = null;
|
|
var inputTypesWhitelist = {
|
|
text: true,
|
|
search: true,
|
|
url: true,
|
|
tel: true,
|
|
email: true,
|
|
password: true,
|
|
number: true,
|
|
date: true,
|
|
month: true,
|
|
week: true,
|
|
time: true,
|
|
datetime: true,
|
|
"datetime-local": true
|
|
};
|
|
function focusTriggersKeyboardModality(node) {
|
|
const {
|
|
type,
|
|
tagName
|
|
} = node;
|
|
if (tagName === "INPUT" && inputTypesWhitelist[type] && !node.readOnly) {
|
|
return true;
|
|
}
|
|
if (tagName === "TEXTAREA" && !node.readOnly) {
|
|
return true;
|
|
}
|
|
if (node.isContentEditable) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
function handleKeyDown(event) {
|
|
if (event.metaKey || event.altKey || event.ctrlKey) {
|
|
return;
|
|
}
|
|
hadKeyboardEvent = true;
|
|
}
|
|
function handlePointerDown() {
|
|
hadKeyboardEvent = false;
|
|
}
|
|
function handleVisibilityChange() {
|
|
if (document.visibilityState === "hidden") {
|
|
if (hadFocusVisibleRecently) {
|
|
hadKeyboardEvent = true;
|
|
}
|
|
}
|
|
}
|
|
function prepare(doc) {
|
|
doc.addEventListener("keydown", handleKeyDown, true);
|
|
doc.addEventListener("mousedown", handlePointerDown, true);
|
|
doc.addEventListener("pointerdown", handlePointerDown, true);
|
|
doc.addEventListener("touchstart", handlePointerDown, true);
|
|
doc.addEventListener("visibilitychange", handleVisibilityChange, true);
|
|
}
|
|
function teardown(doc) {
|
|
doc.removeEventListener("keydown", handleKeyDown, true);
|
|
doc.removeEventListener("mousedown", handlePointerDown, true);
|
|
doc.removeEventListener("pointerdown", handlePointerDown, true);
|
|
doc.removeEventListener("touchstart", handlePointerDown, true);
|
|
doc.removeEventListener("visibilitychange", handleVisibilityChange, true);
|
|
}
|
|
function isFocusVisible(event) {
|
|
try {
|
|
return event.target.matches(":focus-visible");
|
|
} catch (error) {
|
|
}
|
|
return hadKeyboardEvent || focusTriggersKeyboardModality(event.target);
|
|
}
|
|
function handleBlurVisible() {
|
|
hadFocusVisibleRecently = true;
|
|
if (typeof document !== "undefined") {
|
|
window.clearTimeout(hadFocusVisibleRecentlyTimeout);
|
|
hadFocusVisibleRecentlyTimeout = window.setTimeout(() => {
|
|
hadFocusVisibleRecently = false;
|
|
}, 100);
|
|
}
|
|
}
|
|
function initFocusVisible(node) {
|
|
if (!initialized && node != null) {
|
|
initialized = true;
|
|
prepare(node.ownerDocument);
|
|
}
|
|
}
|
|
var forkFocus = (
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
(rootProps, handler) => (e) => {
|
|
if (typeof rootProps.onFocus === "function") {
|
|
rootProps.onFocus(e);
|
|
}
|
|
handler(e);
|
|
}
|
|
);
|
|
exports.forkFocus = forkFocus;
|
|
var forkBlur = (
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
(rootProps, handler) => (e) => {
|
|
if (typeof rootProps.onBlur === "function") {
|
|
rootProps.onBlur(e);
|
|
}
|
|
handler(e);
|
|
}
|
|
);
|
|
exports.forkBlur = forkBlur;
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/layers-manager.js
|
|
var require_layers_manager = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/layers-manager.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = exports.Provider = exports.LayersContext = exports.Consumer = void 0;
|
|
var React5 = _interopRequireWildcard(require_react());
|
|
var _styles = require_styles();
|
|
var _overrides = require_overrides();
|
|
var _focusVisible = require_focusVisible();
|
|
function _getRequireWildcardCache(e) {
|
|
if ("function" != typeof WeakMap) return null;
|
|
var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
|
|
return (_getRequireWildcardCache = function(e2) {
|
|
return e2 ? t : r;
|
|
})(e);
|
|
}
|
|
function _interopRequireWildcard(e, r) {
|
|
if (!r && e && e.__esModule) return e;
|
|
if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };
|
|
var t = _getRequireWildcardCache(r);
|
|
if (t && t.has(e)) return t.get(e);
|
|
var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
|
|
var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
|
|
i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
|
|
}
|
|
return n.default = e, t && t.set(e, n), n;
|
|
}
|
|
function _extends2() {
|
|
_extends2 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source2 = arguments[i];
|
|
for (var key in source2) {
|
|
if (Object.prototype.hasOwnProperty.call(source2, key)) {
|
|
target[key] = source2[key];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
return _extends2.apply(this, arguments);
|
|
}
|
|
function _defineProperty(obj, key, value) {
|
|
key = _toPropertyKey(key);
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
function _toPropertyKey(t) {
|
|
var i = _toPrimitive(t, "string");
|
|
return "symbol" == typeof i ? i : String(i);
|
|
}
|
|
function _toPrimitive(t, r) {
|
|
if ("object" != typeof t || !t) return t;
|
|
var e = t[Symbol.toPrimitive];
|
|
if (void 0 !== e) {
|
|
var i = e.call(t, r || "default");
|
|
if ("object" != typeof i) return i;
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
return ("string" === r ? String : Number)(t);
|
|
}
|
|
var StyledAppContainer = (0, _styles.styled)("div", {});
|
|
StyledAppContainer.displayName = "StyledAppContainer";
|
|
var StyledLayersContainer = (0, _styles.styled)("div", {});
|
|
StyledLayersContainer.displayName = "StyledLayersContainer";
|
|
function defaultEventHandlerFn() {
|
|
if (true) {
|
|
console.warn("`LayersManager` was not found. This occurs if you are attempting to use a component requiring `Layer` without using the `BaseProvider` at the root of your app. Please visit https://baseweb.design/components/base-provider/ for more information");
|
|
}
|
|
}
|
|
var LayersContext = exports.LayersContext = React5.createContext({
|
|
addEscapeHandler: defaultEventHandlerFn,
|
|
removeEscapeHandler: defaultEventHandlerFn,
|
|
addKeyDownHandler: defaultEventHandlerFn,
|
|
removeKeyDownHandler: defaultEventHandlerFn,
|
|
addKeyUpHandler: defaultEventHandlerFn,
|
|
removeKeyUpHandler: defaultEventHandlerFn,
|
|
addKeyPressHandler: defaultEventHandlerFn,
|
|
removeKeyPressHandler: defaultEventHandlerFn,
|
|
addDocClickHandler: defaultEventHandlerFn,
|
|
removeDocClickHandler: defaultEventHandlerFn,
|
|
host: void 0,
|
|
zIndex: void 0
|
|
});
|
|
var Provider = exports.Provider = LayersContext.Provider;
|
|
var Consumer = exports.Consumer = LayersContext.Consumer;
|
|
var LayersManager = class extends React5.Component {
|
|
constructor(props) {
|
|
super(props);
|
|
_defineProperty(this, "host", React5.createRef());
|
|
_defineProperty(this, "containerRef", React5.createRef());
|
|
_defineProperty(this, "onDocumentClick", (event) => {
|
|
const docClickHandler = this.state.docClickHandlers[this.state.docClickHandlers.length - 1];
|
|
if (docClickHandler) {
|
|
docClickHandler(event);
|
|
}
|
|
});
|
|
_defineProperty(this, "onKeyDown", (event) => {
|
|
const keyDownHandler = this.state.keyDownHandlers[this.state.keyDownHandlers.length - 1];
|
|
if (keyDownHandler) {
|
|
keyDownHandler(event);
|
|
}
|
|
});
|
|
_defineProperty(this, "onKeyUp", (event) => {
|
|
if (event.key === "Escape") {
|
|
const escapeKeyHandler = this.state.escapeKeyHandlers[this.state.escapeKeyHandlers.length - 1];
|
|
if (escapeKeyHandler) {
|
|
escapeKeyHandler();
|
|
}
|
|
}
|
|
const keyUpHandler = this.state.keyUpHandlers[this.state.keyUpHandlers.length - 1];
|
|
if (keyUpHandler) {
|
|
keyUpHandler(event);
|
|
}
|
|
});
|
|
_defineProperty(this, "onKeyPress", (event) => {
|
|
const keyPressHandler = this.state.keyPressHandlers[this.state.keyPressHandlers.length - 1];
|
|
if (keyPressHandler) {
|
|
keyPressHandler(event);
|
|
}
|
|
});
|
|
_defineProperty(this, "onAddEscapeHandler", (escapeKeyHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
escapeKeyHandlers: [...prev.escapeKeyHandlers, escapeKeyHandler]
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onRemoveEscapeHandler", (escapeKeyHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
escapeKeyHandlers: prev.escapeKeyHandlers.filter((handler) => handler !== escapeKeyHandler)
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onAddKeyDownHandler", (keyDownHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
keyDownHandlers: [...prev.keyDownHandlers, keyDownHandler]
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onRemoveKeyDownHandler", (keyDownHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
keyDownHandlers: prev.keyDownHandlers.filter((handler) => handler !== keyDownHandler)
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onAddKeyUpHandler", (keyUpHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
keyUpHandlers: [...prev.keyUpHandlers, keyUpHandler]
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onRemoveKeyUpHandler", (keyUpHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
keyUpHandlers: prev.keyUpHandlers.filter((handler) => handler !== keyUpHandler)
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onAddKeyPressHandler", (keyPressHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
keyPressHandlers: [...prev.keyPressHandlers, keyPressHandler]
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onRemoveKeyPressHandler", (keyPressHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
keyPressHandlers: prev.keyPressHandlers.filter((handler) => handler !== keyPressHandler)
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onAddDocClickHandler", (docClickHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
docClickHandlers: [...prev.docClickHandlers, docClickHandler]
|
|
};
|
|
});
|
|
});
|
|
_defineProperty(this, "onRemoveDocClickHandler", (docClickHandler) => {
|
|
this.setState((prev) => {
|
|
return {
|
|
docClickHandlers: prev.docClickHandlers.filter((handler) => handler !== docClickHandler)
|
|
};
|
|
});
|
|
});
|
|
this.state = {
|
|
escapeKeyHandlers: [],
|
|
keyDownHandlers: [],
|
|
keyUpHandlers: [],
|
|
keyPressHandlers: [],
|
|
docClickHandlers: []
|
|
};
|
|
}
|
|
componentDidMount() {
|
|
this.forceUpdate();
|
|
(0, _focusVisible.initFocusVisible)(this.containerRef.current);
|
|
if (typeof document !== "undefined") {
|
|
document.addEventListener("keydown", this.onKeyDown);
|
|
document.addEventListener("keyup", this.onKeyUp);
|
|
document.addEventListener("keypress", this.onKeyPress);
|
|
document.addEventListener("mousedown", this.onDocumentClick);
|
|
}
|
|
}
|
|
componentWillUnmount() {
|
|
if (typeof document !== "undefined") {
|
|
document.removeEventListener("keydown", this.onKeyDown);
|
|
document.removeEventListener("keyup", this.onKeyUp);
|
|
document.removeEventListener("keypress", this.onKeyPress);
|
|
document.removeEventListener("mousedown", this.onDocumentClick);
|
|
}
|
|
}
|
|
render() {
|
|
const {
|
|
overrides = {}
|
|
} = this.props;
|
|
const [AppContainer, appContainerProps] = (0, _overrides.getOverrides)(overrides.AppContainer, StyledAppContainer);
|
|
const [LayersContainer, layersContainerProps] = (0, _overrides.getOverrides)(overrides.LayersContainer, StyledLayersContainer);
|
|
return React5.createElement(Consumer, null, ({
|
|
host
|
|
}) => {
|
|
if (true) {
|
|
if (host !== void 0) {
|
|
console.warn("There is a LayersManager already exists in your application. It is not recommended to have more than one LayersManager in an application.");
|
|
}
|
|
}
|
|
return React5.createElement(Provider, {
|
|
value: {
|
|
host: host || this.host.current,
|
|
zIndex: this.props.zIndex,
|
|
addEscapeHandler: this.onAddEscapeHandler,
|
|
removeEscapeHandler: this.onRemoveEscapeHandler,
|
|
addKeyDownHandler: this.onAddKeyDownHandler,
|
|
removeKeyDownHandler: this.onRemoveKeyDownHandler,
|
|
addKeyUpHandler: this.onAddKeyUpHandler,
|
|
removeKeyUpHandler: this.onRemoveKeyUpHandler,
|
|
addKeyPressHandler: this.onAddKeyPressHandler,
|
|
removeKeyPressHandler: this.onRemoveKeyPressHandler,
|
|
addDocClickHandler: this.onAddDocClickHandler,
|
|
removeDocClickHandler: this.onRemoveDocClickHandler
|
|
}
|
|
}, React5.createElement(AppContainer, _extends2({}, appContainerProps, {
|
|
ref: this.containerRef
|
|
}), this.props.children), React5.createElement(LayersContainer, _extends2({}, layersContainerProps, {
|
|
ref: this.host
|
|
})));
|
|
});
|
|
}
|
|
};
|
|
exports.default = LayersManager;
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/layer.js
|
|
var require_layer = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/layer.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = Layer;
|
|
var React5 = _interopRequireWildcard(require_react());
|
|
var _reactDom = _interopRequireDefault(require_react_dom());
|
|
var _styles = require_styles();
|
|
var _layersManager = require_layers_manager();
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
function _getRequireWildcardCache(e) {
|
|
if ("function" != typeof WeakMap) return null;
|
|
var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
|
|
return (_getRequireWildcardCache = function(e2) {
|
|
return e2 ? t : r;
|
|
})(e);
|
|
}
|
|
function _interopRequireWildcard(e, r) {
|
|
if (!r && e && e.__esModule) return e;
|
|
if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };
|
|
var t = _getRequireWildcardCache(r);
|
|
if (t && t.has(e)) return t.get(e);
|
|
var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
|
|
var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
|
|
i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
|
|
}
|
|
return n.default = e, t && t.set(e, n), n;
|
|
}
|
|
function _extends2() {
|
|
_extends2 = Object.assign ? Object.assign.bind() : function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source2 = arguments[i];
|
|
for (var key in source2) {
|
|
if (Object.prototype.hasOwnProperty.call(source2, key)) {
|
|
target[key] = source2[key];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
return _extends2.apply(this, arguments);
|
|
}
|
|
function _defineProperty(obj, key, value) {
|
|
key = _toPropertyKey(key);
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
function _toPropertyKey(t) {
|
|
var i = _toPrimitive(t, "string");
|
|
return "symbol" == typeof i ? i : String(i);
|
|
}
|
|
function _toPrimitive(t, r) {
|
|
if ("object" != typeof t || !t) return t;
|
|
var e = t[Symbol.toPrimitive];
|
|
if (void 0 !== e) {
|
|
var i = e.call(t, r || "default");
|
|
if ("object" != typeof i) return i;
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
return ("string" === r ? String : Number)(t);
|
|
}
|
|
var Container = (0, _styles.styled)("div", ({
|
|
$zIndex
|
|
}) => ({
|
|
position: "absolute",
|
|
top: 0,
|
|
left: 0,
|
|
right: 0,
|
|
zIndex: $zIndex || null
|
|
}));
|
|
Container.displayName = "Container";
|
|
var LayerComponent = class extends React5.Component {
|
|
constructor(...args) {
|
|
super(...args);
|
|
_defineProperty(this, "context", void 0);
|
|
_defineProperty(this, "state", {
|
|
container: null
|
|
});
|
|
_defineProperty(this, "onEscape", () => {
|
|
if (this.props.onEscape) {
|
|
this.props.onEscape();
|
|
}
|
|
});
|
|
_defineProperty(this, "onKeyDown", (event) => {
|
|
if (this.props.onKeyDown) {
|
|
this.props.onKeyDown(event);
|
|
}
|
|
});
|
|
_defineProperty(this, "onKeyUp", (event) => {
|
|
if (this.props.onKeyUp) {
|
|
this.props.onKeyUp(event);
|
|
}
|
|
});
|
|
_defineProperty(this, "onKeyPress", (event) => {
|
|
if (this.props.onKeyPress) {
|
|
this.props.onKeyPress(event);
|
|
}
|
|
});
|
|
_defineProperty(this, "onDocumentClick", (event) => {
|
|
if (this.props.onDocumentClick) {
|
|
this.props.onDocumentClick(event);
|
|
}
|
|
});
|
|
}
|
|
componentDidMount() {
|
|
this.context.addEscapeHandler(this.onEscape);
|
|
this.context.addKeyDownHandler(this.onKeyDown);
|
|
this.context.addKeyUpHandler(this.onKeyUp);
|
|
this.context.addKeyPressHandler(this.onKeyPress);
|
|
if (!this.props.isHoverLayer) {
|
|
this.context.addDocClickHandler(this.onDocumentClick);
|
|
}
|
|
const {
|
|
onMount,
|
|
mountNode,
|
|
host: layersManagerHost
|
|
} = this.props;
|
|
if (mountNode) {
|
|
onMount && onMount();
|
|
return;
|
|
}
|
|
const hasLayersManager = layersManagerHost !== void 0;
|
|
if (true) {
|
|
if (!hasLayersManager) {
|
|
console.warn("`LayersManager` was not found. This occurs if you are attempting to use a component requiring `Layer` without using the `BaseProvider` at the root of your app. Please visit https://baseweb.design/components/base-provider/ for more information");
|
|
}
|
|
}
|
|
const host = hasLayersManager ? layersManagerHost : document.body;
|
|
if (host) {
|
|
this.addContainer(host);
|
|
}
|
|
}
|
|
// @ts-ignore
|
|
componentDidUpdate(prevProps) {
|
|
const {
|
|
host,
|
|
mountNode
|
|
} = this.props;
|
|
if (mountNode) {
|
|
return;
|
|
}
|
|
if (host && host !== prevProps.host && prevProps.host === null) {
|
|
this.addContainer(host);
|
|
}
|
|
if (prevProps.isHoverLayer != this.props.isHoverLayer) {
|
|
if (this.props.isHoverLayer) {
|
|
this.context.removeDocClickHandler(this.onDocumentClick);
|
|
} else {
|
|
this.context.addDocClickHandler(this.onDocumentClick);
|
|
}
|
|
}
|
|
}
|
|
componentWillUnmount() {
|
|
this.context.removeEscapeHandler(this.onEscape);
|
|
this.context.removeKeyDownHandler(this.onKeyDown);
|
|
this.context.removeKeyUpHandler(this.onKeyUp);
|
|
this.context.removeKeyPressHandler(this.onKeyPress);
|
|
this.context.removeDocClickHandler(this.onDocumentClick);
|
|
if (this.props.onUnmount) {
|
|
this.props.onUnmount();
|
|
}
|
|
const host = this.props.host;
|
|
const container = this.state.container;
|
|
if (host && container) {
|
|
if (host.contains(container)) {
|
|
host.removeChild(container);
|
|
}
|
|
}
|
|
}
|
|
// @ts-ignore
|
|
addContainer(host) {
|
|
const {
|
|
index,
|
|
mountNode,
|
|
onMount
|
|
} = this.props;
|
|
if (mountNode) {
|
|
return;
|
|
}
|
|
if (host) {
|
|
const container = host.ownerDocument.createElement("div");
|
|
const sibling = typeof index === "number" ? host.children[index] : null;
|
|
sibling ? host.insertBefore(container, sibling) : host.appendChild(container);
|
|
this.setState({
|
|
container
|
|
}, () => {
|
|
onMount && onMount();
|
|
});
|
|
}
|
|
}
|
|
render() {
|
|
const {
|
|
container
|
|
} = this.state;
|
|
const {
|
|
children,
|
|
mountNode,
|
|
zIndex
|
|
} = this.props;
|
|
const childrenToRender = zIndex ? React5.createElement(Container, {
|
|
$zIndex: zIndex
|
|
}, children) : children;
|
|
if (typeof document !== "undefined") {
|
|
if (mountNode) {
|
|
return _reactDom.default.createPortal(childrenToRender, mountNode);
|
|
} else if (container) {
|
|
return _reactDom.default.createPortal(childrenToRender, container);
|
|
}
|
|
return null;
|
|
}
|
|
return null;
|
|
}
|
|
};
|
|
_defineProperty(LayerComponent, "contextType", _layersManager.LayersContext);
|
|
function Layer(props) {
|
|
return React5.createElement(_layersManager.Consumer, null, ({
|
|
host,
|
|
zIndex
|
|
}) => React5.createElement(LayerComponent, _extends2({}, props, {
|
|
host,
|
|
zIndex
|
|
})));
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/popper.js@1.16.1/node_modules/popper.js/dist/esm/popper.js
|
|
var popper_exports = {};
|
|
__export(popper_exports, {
|
|
default: () => popper_default
|
|
});
|
|
function microtaskDebounce(fn) {
|
|
var called = false;
|
|
return function() {
|
|
if (called) {
|
|
return;
|
|
}
|
|
called = true;
|
|
window.Promise.resolve().then(function() {
|
|
called = false;
|
|
fn();
|
|
});
|
|
};
|
|
}
|
|
function taskDebounce(fn) {
|
|
var scheduled = false;
|
|
return function() {
|
|
if (!scheduled) {
|
|
scheduled = true;
|
|
setTimeout(function() {
|
|
scheduled = false;
|
|
fn();
|
|
}, timeoutDuration);
|
|
}
|
|
};
|
|
}
|
|
function isFunction(functionToCheck) {
|
|
var getType = {};
|
|
return functionToCheck && getType.toString.call(functionToCheck) === "[object Function]";
|
|
}
|
|
function getStyleComputedProperty(element, property) {
|
|
if (element.nodeType !== 1) {
|
|
return [];
|
|
}
|
|
var window2 = element.ownerDocument.defaultView;
|
|
var css = window2.getComputedStyle(element, null);
|
|
return property ? css[property] : css;
|
|
}
|
|
function getParentNode(element) {
|
|
if (element.nodeName === "HTML") {
|
|
return element;
|
|
}
|
|
return element.parentNode || element.host;
|
|
}
|
|
function getScrollParent(element) {
|
|
if (!element) {
|
|
return document.body;
|
|
}
|
|
switch (element.nodeName) {
|
|
case "HTML":
|
|
case "BODY":
|
|
return element.ownerDocument.body;
|
|
case "#document":
|
|
return element.body;
|
|
}
|
|
var _getStyleComputedProp = getStyleComputedProperty(element), overflow = _getStyleComputedProp.overflow, overflowX = _getStyleComputedProp.overflowX, overflowY = _getStyleComputedProp.overflowY;
|
|
if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) {
|
|
return element;
|
|
}
|
|
return getScrollParent(getParentNode(element));
|
|
}
|
|
function getReferenceNode(reference) {
|
|
return reference && reference.referenceNode ? reference.referenceNode : reference;
|
|
}
|
|
function isIE(version) {
|
|
if (version === 11) {
|
|
return isIE11;
|
|
}
|
|
if (version === 10) {
|
|
return isIE10;
|
|
}
|
|
return isIE11 || isIE10;
|
|
}
|
|
function getOffsetParent(element) {
|
|
if (!element) {
|
|
return document.documentElement;
|
|
}
|
|
var noOffsetParent = isIE(10) ? document.body : null;
|
|
var offsetParent = element.offsetParent || null;
|
|
while (offsetParent === noOffsetParent && element.nextElementSibling) {
|
|
offsetParent = (element = element.nextElementSibling).offsetParent;
|
|
}
|
|
var nodeName = offsetParent && offsetParent.nodeName;
|
|
if (!nodeName || nodeName === "BODY" || nodeName === "HTML") {
|
|
return element ? element.ownerDocument.documentElement : document.documentElement;
|
|
}
|
|
if (["TH", "TD", "TABLE"].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, "position") === "static") {
|
|
return getOffsetParent(offsetParent);
|
|
}
|
|
return offsetParent;
|
|
}
|
|
function isOffsetContainer(element) {
|
|
var nodeName = element.nodeName;
|
|
if (nodeName === "BODY") {
|
|
return false;
|
|
}
|
|
return nodeName === "HTML" || getOffsetParent(element.firstElementChild) === element;
|
|
}
|
|
function getRoot(node) {
|
|
if (node.parentNode !== null) {
|
|
return getRoot(node.parentNode);
|
|
}
|
|
return node;
|
|
}
|
|
function findCommonOffsetParent(element1, element2) {
|
|
if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) {
|
|
return document.documentElement;
|
|
}
|
|
var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING;
|
|
var start = order ? element1 : element2;
|
|
var end = order ? element2 : element1;
|
|
var range = document.createRange();
|
|
range.setStart(start, 0);
|
|
range.setEnd(end, 0);
|
|
var commonAncestorContainer = range.commonAncestorContainer;
|
|
if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) {
|
|
if (isOffsetContainer(commonAncestorContainer)) {
|
|
return commonAncestorContainer;
|
|
}
|
|
return getOffsetParent(commonAncestorContainer);
|
|
}
|
|
var element1root = getRoot(element1);
|
|
if (element1root.host) {
|
|
return findCommonOffsetParent(element1root.host, element2);
|
|
} else {
|
|
return findCommonOffsetParent(element1, getRoot(element2).host);
|
|
}
|
|
}
|
|
function getScroll(element) {
|
|
var side = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "top";
|
|
var upperSide = side === "top" ? "scrollTop" : "scrollLeft";
|
|
var nodeName = element.nodeName;
|
|
if (nodeName === "BODY" || nodeName === "HTML") {
|
|
var html = element.ownerDocument.documentElement;
|
|
var scrollingElement = element.ownerDocument.scrollingElement || html;
|
|
return scrollingElement[upperSide];
|
|
}
|
|
return element[upperSide];
|
|
}
|
|
function includeScroll(rect, element) {
|
|
var subtract = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
|
|
var scrollTop = getScroll(element, "top");
|
|
var scrollLeft = getScroll(element, "left");
|
|
var modifier = subtract ? -1 : 1;
|
|
rect.top += scrollTop * modifier;
|
|
rect.bottom += scrollTop * modifier;
|
|
rect.left += scrollLeft * modifier;
|
|
rect.right += scrollLeft * modifier;
|
|
return rect;
|
|
}
|
|
function getBordersSize(styles, axis) {
|
|
var sideA = axis === "x" ? "Left" : "Top";
|
|
var sideB = sideA === "Left" ? "Right" : "Bottom";
|
|
return parseFloat(styles["border" + sideA + "Width"]) + parseFloat(styles["border" + sideB + "Width"]);
|
|
}
|
|
function getSize(axis, body, html, computedStyle) {
|
|
return Math.max(body["offset" + axis], body["scroll" + axis], html["client" + axis], html["offset" + axis], html["scroll" + axis], isIE(10) ? parseInt(html["offset" + axis]) + parseInt(computedStyle["margin" + (axis === "Height" ? "Top" : "Left")]) + parseInt(computedStyle["margin" + (axis === "Height" ? "Bottom" : "Right")]) : 0);
|
|
}
|
|
function getWindowSizes(document2) {
|
|
var body = document2.body;
|
|
var html = document2.documentElement;
|
|
var computedStyle = isIE(10) && getComputedStyle(html);
|
|
return {
|
|
height: getSize("Height", body, html, computedStyle),
|
|
width: getSize("Width", body, html, computedStyle)
|
|
};
|
|
}
|
|
function getClientRect(offsets) {
|
|
return _extends({}, offsets, {
|
|
right: offsets.left + offsets.width,
|
|
bottom: offsets.top + offsets.height
|
|
});
|
|
}
|
|
function getBoundingClientRect(element) {
|
|
var rect = {};
|
|
try {
|
|
if (isIE(10)) {
|
|
rect = element.getBoundingClientRect();
|
|
var scrollTop = getScroll(element, "top");
|
|
var scrollLeft = getScroll(element, "left");
|
|
rect.top += scrollTop;
|
|
rect.left += scrollLeft;
|
|
rect.bottom += scrollTop;
|
|
rect.right += scrollLeft;
|
|
} else {
|
|
rect = element.getBoundingClientRect();
|
|
}
|
|
} catch (e) {
|
|
}
|
|
var result = {
|
|
left: rect.left,
|
|
top: rect.top,
|
|
width: rect.right - rect.left,
|
|
height: rect.bottom - rect.top
|
|
};
|
|
var sizes = element.nodeName === "HTML" ? getWindowSizes(element.ownerDocument) : {};
|
|
var width = sizes.width || element.clientWidth || result.width;
|
|
var height = sizes.height || element.clientHeight || result.height;
|
|
var horizScrollbar = element.offsetWidth - width;
|
|
var vertScrollbar = element.offsetHeight - height;
|
|
if (horizScrollbar || vertScrollbar) {
|
|
var styles = getStyleComputedProperty(element);
|
|
horizScrollbar -= getBordersSize(styles, "x");
|
|
vertScrollbar -= getBordersSize(styles, "y");
|
|
result.width -= horizScrollbar;
|
|
result.height -= vertScrollbar;
|
|
}
|
|
return getClientRect(result);
|
|
}
|
|
function getOffsetRectRelativeToArbitraryNode(children, parent) {
|
|
var fixedPosition = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
|
|
var isIE102 = isIE(10);
|
|
var isHTML = parent.nodeName === "HTML";
|
|
var childrenRect = getBoundingClientRect(children);
|
|
var parentRect = getBoundingClientRect(parent);
|
|
var scrollParent = getScrollParent(children);
|
|
var styles = getStyleComputedProperty(parent);
|
|
var borderTopWidth = parseFloat(styles.borderTopWidth);
|
|
var borderLeftWidth = parseFloat(styles.borderLeftWidth);
|
|
if (fixedPosition && isHTML) {
|
|
parentRect.top = Math.max(parentRect.top, 0);
|
|
parentRect.left = Math.max(parentRect.left, 0);
|
|
}
|
|
var offsets = getClientRect({
|
|
top: childrenRect.top - parentRect.top - borderTopWidth,
|
|
left: childrenRect.left - parentRect.left - borderLeftWidth,
|
|
width: childrenRect.width,
|
|
height: childrenRect.height
|
|
});
|
|
offsets.marginTop = 0;
|
|
offsets.marginLeft = 0;
|
|
if (!isIE102 && isHTML) {
|
|
var marginTop = parseFloat(styles.marginTop);
|
|
var marginLeft = parseFloat(styles.marginLeft);
|
|
offsets.top -= borderTopWidth - marginTop;
|
|
offsets.bottom -= borderTopWidth - marginTop;
|
|
offsets.left -= borderLeftWidth - marginLeft;
|
|
offsets.right -= borderLeftWidth - marginLeft;
|
|
offsets.marginTop = marginTop;
|
|
offsets.marginLeft = marginLeft;
|
|
}
|
|
if (isIE102 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== "BODY") {
|
|
offsets = includeScroll(offsets, parent);
|
|
}
|
|
return offsets;
|
|
}
|
|
function getViewportOffsetRectRelativeToArtbitraryNode(element) {
|
|
var excludeScroll = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
|
|
var html = element.ownerDocument.documentElement;
|
|
var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html);
|
|
var width = Math.max(html.clientWidth, window.innerWidth || 0);
|
|
var height = Math.max(html.clientHeight, window.innerHeight || 0);
|
|
var scrollTop = !excludeScroll ? getScroll(html) : 0;
|
|
var scrollLeft = !excludeScroll ? getScroll(html, "left") : 0;
|
|
var offset2 = {
|
|
top: scrollTop - relativeOffset.top + relativeOffset.marginTop,
|
|
left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft,
|
|
width,
|
|
height
|
|
};
|
|
return getClientRect(offset2);
|
|
}
|
|
function isFixed(element) {
|
|
var nodeName = element.nodeName;
|
|
if (nodeName === "BODY" || nodeName === "HTML") {
|
|
return false;
|
|
}
|
|
if (getStyleComputedProperty(element, "position") === "fixed") {
|
|
return true;
|
|
}
|
|
var parentNode = getParentNode(element);
|
|
if (!parentNode) {
|
|
return false;
|
|
}
|
|
return isFixed(parentNode);
|
|
}
|
|
function getFixedPositionOffsetParent(element) {
|
|
if (!element || !element.parentElement || isIE()) {
|
|
return document.documentElement;
|
|
}
|
|
var el = element.parentElement;
|
|
while (el && getStyleComputedProperty(el, "transform") === "none") {
|
|
el = el.parentElement;
|
|
}
|
|
return el || document.documentElement;
|
|
}
|
|
function getBoundaries(popper, reference, padding, boundariesElement) {
|
|
var fixedPosition = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : false;
|
|
var boundaries = { top: 0, left: 0 };
|
|
var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
|
|
if (boundariesElement === "viewport") {
|
|
boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition);
|
|
} else {
|
|
var boundariesNode = void 0;
|
|
if (boundariesElement === "scrollParent") {
|
|
boundariesNode = getScrollParent(getParentNode(reference));
|
|
if (boundariesNode.nodeName === "BODY") {
|
|
boundariesNode = popper.ownerDocument.documentElement;
|
|
}
|
|
} else if (boundariesElement === "window") {
|
|
boundariesNode = popper.ownerDocument.documentElement;
|
|
} else {
|
|
boundariesNode = boundariesElement;
|
|
}
|
|
var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition);
|
|
if (boundariesNode.nodeName === "HTML" && !isFixed(offsetParent)) {
|
|
var _getWindowSizes = getWindowSizes(popper.ownerDocument), height = _getWindowSizes.height, width = _getWindowSizes.width;
|
|
boundaries.top += offsets.top - offsets.marginTop;
|
|
boundaries.bottom = height + offsets.top;
|
|
boundaries.left += offsets.left - offsets.marginLeft;
|
|
boundaries.right = width + offsets.left;
|
|
} else {
|
|
boundaries = offsets;
|
|
}
|
|
}
|
|
padding = padding || 0;
|
|
var isPaddingNumber = typeof padding === "number";
|
|
boundaries.left += isPaddingNumber ? padding : padding.left || 0;
|
|
boundaries.top += isPaddingNumber ? padding : padding.top || 0;
|
|
boundaries.right -= isPaddingNumber ? padding : padding.right || 0;
|
|
boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0;
|
|
return boundaries;
|
|
}
|
|
function getArea(_ref) {
|
|
var width = _ref.width, height = _ref.height;
|
|
return width * height;
|
|
}
|
|
function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) {
|
|
var padding = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : 0;
|
|
if (placement.indexOf("auto") === -1) {
|
|
return placement;
|
|
}
|
|
var boundaries = getBoundaries(popper, reference, padding, boundariesElement);
|
|
var rects = {
|
|
top: {
|
|
width: boundaries.width,
|
|
height: refRect.top - boundaries.top
|
|
},
|
|
right: {
|
|
width: boundaries.right - refRect.right,
|
|
height: boundaries.height
|
|
},
|
|
bottom: {
|
|
width: boundaries.width,
|
|
height: boundaries.bottom - refRect.bottom
|
|
},
|
|
left: {
|
|
width: refRect.left - boundaries.left,
|
|
height: boundaries.height
|
|
}
|
|
};
|
|
var sortedAreas = Object.keys(rects).map(function(key) {
|
|
return _extends({
|
|
key
|
|
}, rects[key], {
|
|
area: getArea(rects[key])
|
|
});
|
|
}).sort(function(a, b) {
|
|
return b.area - a.area;
|
|
});
|
|
var filteredAreas = sortedAreas.filter(function(_ref2) {
|
|
var width = _ref2.width, height = _ref2.height;
|
|
return width >= popper.clientWidth && height >= popper.clientHeight;
|
|
});
|
|
var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key;
|
|
var variation = placement.split("-")[1];
|
|
return computedPlacement + (variation ? "-" + variation : "");
|
|
}
|
|
function getReferenceOffsets(state, popper, reference) {
|
|
var fixedPosition = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : null;
|
|
var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference));
|
|
return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition);
|
|
}
|
|
function getOuterSizes(element) {
|
|
var window2 = element.ownerDocument.defaultView;
|
|
var styles = window2.getComputedStyle(element);
|
|
var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0);
|
|
var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0);
|
|
var result = {
|
|
width: element.offsetWidth + y,
|
|
height: element.offsetHeight + x
|
|
};
|
|
return result;
|
|
}
|
|
function getOppositePlacement(placement) {
|
|
var hash = { left: "right", right: "left", bottom: "top", top: "bottom" };
|
|
return placement.replace(/left|right|bottom|top/g, function(matched) {
|
|
return hash[matched];
|
|
});
|
|
}
|
|
function getPopperOffsets(popper, referenceOffsets, placement) {
|
|
placement = placement.split("-")[0];
|
|
var popperRect = getOuterSizes(popper);
|
|
var popperOffsets = {
|
|
width: popperRect.width,
|
|
height: popperRect.height
|
|
};
|
|
var isHoriz = ["right", "left"].indexOf(placement) !== -1;
|
|
var mainSide = isHoriz ? "top" : "left";
|
|
var secondarySide = isHoriz ? "left" : "top";
|
|
var measurement = isHoriz ? "height" : "width";
|
|
var secondaryMeasurement = !isHoriz ? "height" : "width";
|
|
popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2;
|
|
if (placement === secondarySide) {
|
|
popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement];
|
|
} else {
|
|
popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)];
|
|
}
|
|
return popperOffsets;
|
|
}
|
|
function find(arr, check) {
|
|
if (Array.prototype.find) {
|
|
return arr.find(check);
|
|
}
|
|
return arr.filter(check)[0];
|
|
}
|
|
function findIndex(arr, prop, value) {
|
|
if (Array.prototype.findIndex) {
|
|
return arr.findIndex(function(cur) {
|
|
return cur[prop] === value;
|
|
});
|
|
}
|
|
var match = find(arr, function(obj) {
|
|
return obj[prop] === value;
|
|
});
|
|
return arr.indexOf(match);
|
|
}
|
|
function runModifiers(modifiers2, data, ends) {
|
|
var modifiersToRun = ends === void 0 ? modifiers2 : modifiers2.slice(0, findIndex(modifiers2, "name", ends));
|
|
modifiersToRun.forEach(function(modifier) {
|
|
if (modifier["function"]) {
|
|
console.warn("`modifier.function` is deprecated, use `modifier.fn`!");
|
|
}
|
|
var fn = modifier["function"] || modifier.fn;
|
|
if (modifier.enabled && isFunction(fn)) {
|
|
data.offsets.popper = getClientRect(data.offsets.popper);
|
|
data.offsets.reference = getClientRect(data.offsets.reference);
|
|
data = fn(data, modifier);
|
|
}
|
|
});
|
|
return data;
|
|
}
|
|
function update() {
|
|
if (this.state.isDestroyed) {
|
|
return;
|
|
}
|
|
var data = {
|
|
instance: this,
|
|
styles: {},
|
|
arrowStyles: {},
|
|
attributes: {},
|
|
flipped: false,
|
|
offsets: {}
|
|
};
|
|
data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed);
|
|
data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding);
|
|
data.originalPlacement = data.placement;
|
|
data.positionFixed = this.options.positionFixed;
|
|
data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement);
|
|
data.offsets.popper.position = this.options.positionFixed ? "fixed" : "absolute";
|
|
data = runModifiers(this.modifiers, data);
|
|
if (!this.state.isCreated) {
|
|
this.state.isCreated = true;
|
|
this.options.onCreate(data);
|
|
} else {
|
|
this.options.onUpdate(data);
|
|
}
|
|
}
|
|
function isModifierEnabled(modifiers2, modifierName) {
|
|
return modifiers2.some(function(_ref) {
|
|
var name = _ref.name, enabled = _ref.enabled;
|
|
return enabled && name === modifierName;
|
|
});
|
|
}
|
|
function getSupportedPropertyName(property) {
|
|
var prefixes = [false, "ms", "Webkit", "Moz", "O"];
|
|
var upperProp = property.charAt(0).toUpperCase() + property.slice(1);
|
|
for (var i = 0; i < prefixes.length; i++) {
|
|
var prefix = prefixes[i];
|
|
var toCheck = prefix ? "" + prefix + upperProp : property;
|
|
if (typeof document.body.style[toCheck] !== "undefined") {
|
|
return toCheck;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
function destroy() {
|
|
this.state.isDestroyed = true;
|
|
if (isModifierEnabled(this.modifiers, "applyStyle")) {
|
|
this.popper.removeAttribute("x-placement");
|
|
this.popper.style.position = "";
|
|
this.popper.style.top = "";
|
|
this.popper.style.left = "";
|
|
this.popper.style.right = "";
|
|
this.popper.style.bottom = "";
|
|
this.popper.style.willChange = "";
|
|
this.popper.style[getSupportedPropertyName("transform")] = "";
|
|
}
|
|
this.disableEventListeners();
|
|
if (this.options.removeOnDestroy) {
|
|
this.popper.parentNode.removeChild(this.popper);
|
|
}
|
|
return this;
|
|
}
|
|
function getWindow(element) {
|
|
var ownerDocument = element.ownerDocument;
|
|
return ownerDocument ? ownerDocument.defaultView : window;
|
|
}
|
|
function attachToScrollParents(scrollParent, event, callback, scrollParents) {
|
|
var isBody = scrollParent.nodeName === "BODY";
|
|
var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent;
|
|
target.addEventListener(event, callback, { passive: true });
|
|
if (!isBody) {
|
|
attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents);
|
|
}
|
|
scrollParents.push(target);
|
|
}
|
|
function setupEventListeners(reference, options, state, updateBound) {
|
|
state.updateBound = updateBound;
|
|
getWindow(reference).addEventListener("resize", state.updateBound, { passive: true });
|
|
var scrollElement = getScrollParent(reference);
|
|
attachToScrollParents(scrollElement, "scroll", state.updateBound, state.scrollParents);
|
|
state.scrollElement = scrollElement;
|
|
state.eventsEnabled = true;
|
|
return state;
|
|
}
|
|
function enableEventListeners() {
|
|
if (!this.state.eventsEnabled) {
|
|
this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate);
|
|
}
|
|
}
|
|
function removeEventListeners(reference, state) {
|
|
getWindow(reference).removeEventListener("resize", state.updateBound);
|
|
state.scrollParents.forEach(function(target) {
|
|
target.removeEventListener("scroll", state.updateBound);
|
|
});
|
|
state.updateBound = null;
|
|
state.scrollParents = [];
|
|
state.scrollElement = null;
|
|
state.eventsEnabled = false;
|
|
return state;
|
|
}
|
|
function disableEventListeners() {
|
|
if (this.state.eventsEnabled) {
|
|
cancelAnimationFrame(this.scheduleUpdate);
|
|
this.state = removeEventListeners(this.reference, this.state);
|
|
}
|
|
}
|
|
function isNumeric(n) {
|
|
return n !== "" && !isNaN(parseFloat(n)) && isFinite(n);
|
|
}
|
|
function setStyles(element, styles) {
|
|
Object.keys(styles).forEach(function(prop) {
|
|
var unit = "";
|
|
if (["width", "height", "top", "right", "bottom", "left"].indexOf(prop) !== -1 && isNumeric(styles[prop])) {
|
|
unit = "px";
|
|
}
|
|
element.style[prop] = styles[prop] + unit;
|
|
});
|
|
}
|
|
function setAttributes(element, attributes) {
|
|
Object.keys(attributes).forEach(function(prop) {
|
|
var value = attributes[prop];
|
|
if (value !== false) {
|
|
element.setAttribute(prop, attributes[prop]);
|
|
} else {
|
|
element.removeAttribute(prop);
|
|
}
|
|
});
|
|
}
|
|
function applyStyle(data) {
|
|
setStyles(data.instance.popper, data.styles);
|
|
setAttributes(data.instance.popper, data.attributes);
|
|
if (data.arrowElement && Object.keys(data.arrowStyles).length) {
|
|
setStyles(data.arrowElement, data.arrowStyles);
|
|
}
|
|
return data;
|
|
}
|
|
function applyStyleOnLoad(reference, popper, options, modifierOptions, state) {
|
|
var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed);
|
|
var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding);
|
|
popper.setAttribute("x-placement", placement);
|
|
setStyles(popper, { position: options.positionFixed ? "fixed" : "absolute" });
|
|
return options;
|
|
}
|
|
function getRoundedOffsets(data, shouldRound) {
|
|
var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
|
|
var round = Math.round, floor = Math.floor;
|
|
var noRound = function noRound2(v) {
|
|
return v;
|
|
};
|
|
var referenceWidth = round(reference.width);
|
|
var popperWidth = round(popper.width);
|
|
var isVertical = ["left", "right"].indexOf(data.placement) !== -1;
|
|
var isVariation = data.placement.indexOf("-") !== -1;
|
|
var sameWidthParity = referenceWidth % 2 === popperWidth % 2;
|
|
var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1;
|
|
var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor;
|
|
var verticalToInteger = !shouldRound ? noRound : round;
|
|
return {
|
|
left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left),
|
|
top: verticalToInteger(popper.top),
|
|
bottom: verticalToInteger(popper.bottom),
|
|
right: horizontalToInteger(popper.right)
|
|
};
|
|
}
|
|
function computeStyle(data, options) {
|
|
var x = options.x, y = options.y;
|
|
var popper = data.offsets.popper;
|
|
var legacyGpuAccelerationOption = find(data.instance.modifiers, function(modifier) {
|
|
return modifier.name === "applyStyle";
|
|
}).gpuAcceleration;
|
|
if (legacyGpuAccelerationOption !== void 0) {
|
|
console.warn("WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!");
|
|
}
|
|
var gpuAcceleration = legacyGpuAccelerationOption !== void 0 ? legacyGpuAccelerationOption : options.gpuAcceleration;
|
|
var offsetParent = getOffsetParent(data.instance.popper);
|
|
var offsetParentRect = getBoundingClientRect(offsetParent);
|
|
var styles = {
|
|
position: popper.position
|
|
};
|
|
var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox);
|
|
var sideA = x === "bottom" ? "top" : "bottom";
|
|
var sideB = y === "right" ? "left" : "right";
|
|
var prefixedProperty = getSupportedPropertyName("transform");
|
|
var left = void 0, top = void 0;
|
|
if (sideA === "bottom") {
|
|
if (offsetParent.nodeName === "HTML") {
|
|
top = -offsetParent.clientHeight + offsets.bottom;
|
|
} else {
|
|
top = -offsetParentRect.height + offsets.bottom;
|
|
}
|
|
} else {
|
|
top = offsets.top;
|
|
}
|
|
if (sideB === "right") {
|
|
if (offsetParent.nodeName === "HTML") {
|
|
left = -offsetParent.clientWidth + offsets.right;
|
|
} else {
|
|
left = -offsetParentRect.width + offsets.right;
|
|
}
|
|
} else {
|
|
left = offsets.left;
|
|
}
|
|
if (gpuAcceleration && prefixedProperty) {
|
|
styles[prefixedProperty] = "translate3d(" + left + "px, " + top + "px, 0)";
|
|
styles[sideA] = 0;
|
|
styles[sideB] = 0;
|
|
styles.willChange = "transform";
|
|
} else {
|
|
var invertTop = sideA === "bottom" ? -1 : 1;
|
|
var invertLeft = sideB === "right" ? -1 : 1;
|
|
styles[sideA] = top * invertTop;
|
|
styles[sideB] = left * invertLeft;
|
|
styles.willChange = sideA + ", " + sideB;
|
|
}
|
|
var attributes = {
|
|
"x-placement": data.placement
|
|
};
|
|
data.attributes = _extends({}, attributes, data.attributes);
|
|
data.styles = _extends({}, styles, data.styles);
|
|
data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles);
|
|
return data;
|
|
}
|
|
function isModifierRequired(modifiers2, requestingName, requestedName) {
|
|
var requesting = find(modifiers2, function(_ref) {
|
|
var name = _ref.name;
|
|
return name === requestingName;
|
|
});
|
|
var isRequired = !!requesting && modifiers2.some(function(modifier) {
|
|
return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order;
|
|
});
|
|
if (!isRequired) {
|
|
var _requesting = "`" + requestingName + "`";
|
|
var requested = "`" + requestedName + "`";
|
|
console.warn(requested + " modifier is required by " + _requesting + " modifier in order to work, be sure to include it before " + _requesting + "!");
|
|
}
|
|
return isRequired;
|
|
}
|
|
function arrow(data, options) {
|
|
var _data$offsets$arrow;
|
|
if (!isModifierRequired(data.instance.modifiers, "arrow", "keepTogether")) {
|
|
return data;
|
|
}
|
|
var arrowElement = options.element;
|
|
if (typeof arrowElement === "string") {
|
|
arrowElement = data.instance.popper.querySelector(arrowElement);
|
|
if (!arrowElement) {
|
|
return data;
|
|
}
|
|
} else {
|
|
if (!data.instance.popper.contains(arrowElement)) {
|
|
console.warn("WARNING: `arrow.element` must be child of its popper element!");
|
|
return data;
|
|
}
|
|
}
|
|
var placement = data.placement.split("-")[0];
|
|
var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
|
|
var isVertical = ["left", "right"].indexOf(placement) !== -1;
|
|
var len = isVertical ? "height" : "width";
|
|
var sideCapitalized = isVertical ? "Top" : "Left";
|
|
var side = sideCapitalized.toLowerCase();
|
|
var altSide = isVertical ? "left" : "top";
|
|
var opSide = isVertical ? "bottom" : "right";
|
|
var arrowElementSize = getOuterSizes(arrowElement)[len];
|
|
if (reference[opSide] - arrowElementSize < popper[side]) {
|
|
data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize);
|
|
}
|
|
if (reference[side] + arrowElementSize > popper[opSide]) {
|
|
data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide];
|
|
}
|
|
data.offsets.popper = getClientRect(data.offsets.popper);
|
|
var center = reference[side] + reference[len] / 2 - arrowElementSize / 2;
|
|
var css = getStyleComputedProperty(data.instance.popper);
|
|
var popperMarginSide = parseFloat(css["margin" + sideCapitalized]);
|
|
var popperBorderSide = parseFloat(css["border" + sideCapitalized + "Width"]);
|
|
var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide;
|
|
sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0);
|
|
data.arrowElement = arrowElement;
|
|
data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ""), _data$offsets$arrow);
|
|
return data;
|
|
}
|
|
function getOppositeVariation(variation) {
|
|
if (variation === "end") {
|
|
return "start";
|
|
} else if (variation === "start") {
|
|
return "end";
|
|
}
|
|
return variation;
|
|
}
|
|
function clockwise(placement) {
|
|
var counter2 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
|
|
var index = validPlacements.indexOf(placement);
|
|
var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index));
|
|
return counter2 ? arr.reverse() : arr;
|
|
}
|
|
function flip(data, options) {
|
|
if (isModifierEnabled(data.instance.modifiers, "inner")) {
|
|
return data;
|
|
}
|
|
if (data.flipped && data.placement === data.originalPlacement) {
|
|
return data;
|
|
}
|
|
var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed);
|
|
var placement = data.placement.split("-")[0];
|
|
var placementOpposite = getOppositePlacement(placement);
|
|
var variation = data.placement.split("-")[1] || "";
|
|
var flipOrder = [];
|
|
switch (options.behavior) {
|
|
case BEHAVIORS.FLIP:
|
|
flipOrder = [placement, placementOpposite];
|
|
break;
|
|
case BEHAVIORS.CLOCKWISE:
|
|
flipOrder = clockwise(placement);
|
|
break;
|
|
case BEHAVIORS.COUNTERCLOCKWISE:
|
|
flipOrder = clockwise(placement, true);
|
|
break;
|
|
default:
|
|
flipOrder = options.behavior;
|
|
}
|
|
flipOrder.forEach(function(step, index) {
|
|
if (placement !== step || flipOrder.length === index + 1) {
|
|
return data;
|
|
}
|
|
placement = data.placement.split("-")[0];
|
|
placementOpposite = getOppositePlacement(placement);
|
|
var popperOffsets = data.offsets.popper;
|
|
var refOffsets = data.offsets.reference;
|
|
var floor = Math.floor;
|
|
var overlapsRef = placement === "left" && floor(popperOffsets.right) > floor(refOffsets.left) || placement === "right" && floor(popperOffsets.left) < floor(refOffsets.right) || placement === "top" && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === "bottom" && floor(popperOffsets.top) < floor(refOffsets.bottom);
|
|
var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left);
|
|
var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right);
|
|
var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top);
|
|
var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom);
|
|
var overflowsBoundaries = placement === "left" && overflowsLeft || placement === "right" && overflowsRight || placement === "top" && overflowsTop || placement === "bottom" && overflowsBottom;
|
|
var isVertical = ["top", "bottom"].indexOf(placement) !== -1;
|
|
var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === "start" && overflowsLeft || isVertical && variation === "end" && overflowsRight || !isVertical && variation === "start" && overflowsTop || !isVertical && variation === "end" && overflowsBottom);
|
|
var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === "start" && overflowsRight || isVertical && variation === "end" && overflowsLeft || !isVertical && variation === "start" && overflowsBottom || !isVertical && variation === "end" && overflowsTop);
|
|
var flippedVariation = flippedVariationByRef || flippedVariationByContent;
|
|
if (overlapsRef || overflowsBoundaries || flippedVariation) {
|
|
data.flipped = true;
|
|
if (overlapsRef || overflowsBoundaries) {
|
|
placement = flipOrder[index + 1];
|
|
}
|
|
if (flippedVariation) {
|
|
variation = getOppositeVariation(variation);
|
|
}
|
|
data.placement = placement + (variation ? "-" + variation : "");
|
|
data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement));
|
|
data = runModifiers(data.instance.modifiers, data, "flip");
|
|
}
|
|
});
|
|
return data;
|
|
}
|
|
function keepTogether(data) {
|
|
var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
|
|
var placement = data.placement.split("-")[0];
|
|
var floor = Math.floor;
|
|
var isVertical = ["top", "bottom"].indexOf(placement) !== -1;
|
|
var side = isVertical ? "right" : "bottom";
|
|
var opSide = isVertical ? "left" : "top";
|
|
var measurement = isVertical ? "width" : "height";
|
|
if (popper[side] < floor(reference[opSide])) {
|
|
data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement];
|
|
}
|
|
if (popper[opSide] > floor(reference[side])) {
|
|
data.offsets.popper[opSide] = floor(reference[side]);
|
|
}
|
|
return data;
|
|
}
|
|
function toValue(str, measurement, popperOffsets, referenceOffsets) {
|
|
var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/);
|
|
var value = +split[1];
|
|
var unit = split[2];
|
|
if (!value) {
|
|
return str;
|
|
}
|
|
if (unit.indexOf("%") === 0) {
|
|
var element = void 0;
|
|
switch (unit) {
|
|
case "%p":
|
|
element = popperOffsets;
|
|
break;
|
|
case "%":
|
|
case "%r":
|
|
default:
|
|
element = referenceOffsets;
|
|
}
|
|
var rect = getClientRect(element);
|
|
return rect[measurement] / 100 * value;
|
|
} else if (unit === "vh" || unit === "vw") {
|
|
var size = void 0;
|
|
if (unit === "vh") {
|
|
size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0);
|
|
} else {
|
|
size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0);
|
|
}
|
|
return size / 100 * value;
|
|
} else {
|
|
return value;
|
|
}
|
|
}
|
|
function parseOffset(offset2, popperOffsets, referenceOffsets, basePlacement) {
|
|
var offsets = [0, 0];
|
|
var useHeight = ["right", "left"].indexOf(basePlacement) !== -1;
|
|
var fragments = offset2.split(/(\+|\-)/).map(function(frag) {
|
|
return frag.trim();
|
|
});
|
|
var divider = fragments.indexOf(find(fragments, function(frag) {
|
|
return frag.search(/,|\s/) !== -1;
|
|
}));
|
|
if (fragments[divider] && fragments[divider].indexOf(",") === -1) {
|
|
console.warn("Offsets separated by white space(s) are deprecated, use a comma (,) instead.");
|
|
}
|
|
var splitRegex = /\s*,\s*|\s+/;
|
|
var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments];
|
|
ops = ops.map(function(op, index) {
|
|
var measurement = (index === 1 ? !useHeight : useHeight) ? "height" : "width";
|
|
var mergeWithPrevious = false;
|
|
return op.reduce(function(a, b) {
|
|
if (a[a.length - 1] === "" && ["+", "-"].indexOf(b) !== -1) {
|
|
a[a.length - 1] = b;
|
|
mergeWithPrevious = true;
|
|
return a;
|
|
} else if (mergeWithPrevious) {
|
|
a[a.length - 1] += b;
|
|
mergeWithPrevious = false;
|
|
return a;
|
|
} else {
|
|
return a.concat(b);
|
|
}
|
|
}, []).map(function(str) {
|
|
return toValue(str, measurement, popperOffsets, referenceOffsets);
|
|
});
|
|
});
|
|
ops.forEach(function(op, index) {
|
|
op.forEach(function(frag, index2) {
|
|
if (isNumeric(frag)) {
|
|
offsets[index] += frag * (op[index2 - 1] === "-" ? -1 : 1);
|
|
}
|
|
});
|
|
});
|
|
return offsets;
|
|
}
|
|
function offset(data, _ref) {
|
|
var offset2 = _ref.offset;
|
|
var placement = data.placement, _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
|
|
var basePlacement = placement.split("-")[0];
|
|
var offsets = void 0;
|
|
if (isNumeric(+offset2)) {
|
|
offsets = [+offset2, 0];
|
|
} else {
|
|
offsets = parseOffset(offset2, popper, reference, basePlacement);
|
|
}
|
|
if (basePlacement === "left") {
|
|
popper.top += offsets[0];
|
|
popper.left -= offsets[1];
|
|
} else if (basePlacement === "right") {
|
|
popper.top += offsets[0];
|
|
popper.left += offsets[1];
|
|
} else if (basePlacement === "top") {
|
|
popper.left += offsets[0];
|
|
popper.top -= offsets[1];
|
|
} else if (basePlacement === "bottom") {
|
|
popper.left += offsets[0];
|
|
popper.top += offsets[1];
|
|
}
|
|
data.popper = popper;
|
|
return data;
|
|
}
|
|
function preventOverflow(data, options) {
|
|
var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper);
|
|
if (data.instance.reference === boundariesElement) {
|
|
boundariesElement = getOffsetParent(boundariesElement);
|
|
}
|
|
var transformProp = getSupportedPropertyName("transform");
|
|
var popperStyles = data.instance.popper.style;
|
|
var top = popperStyles.top, left = popperStyles.left, transform = popperStyles[transformProp];
|
|
popperStyles.top = "";
|
|
popperStyles.left = "";
|
|
popperStyles[transformProp] = "";
|
|
var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed);
|
|
popperStyles.top = top;
|
|
popperStyles.left = left;
|
|
popperStyles[transformProp] = transform;
|
|
options.boundaries = boundaries;
|
|
var order = options.priority;
|
|
var popper = data.offsets.popper;
|
|
var check = {
|
|
primary: function primary(placement) {
|
|
var value = popper[placement];
|
|
if (popper[placement] < boundaries[placement] && !options.escapeWithReference) {
|
|
value = Math.max(popper[placement], boundaries[placement]);
|
|
}
|
|
return defineProperty({}, placement, value);
|
|
},
|
|
secondary: function secondary(placement) {
|
|
var mainSide = placement === "right" ? "left" : "top";
|
|
var value = popper[mainSide];
|
|
if (popper[placement] > boundaries[placement] && !options.escapeWithReference) {
|
|
value = Math.min(popper[mainSide], boundaries[placement] - (placement === "right" ? popper.width : popper.height));
|
|
}
|
|
return defineProperty({}, mainSide, value);
|
|
}
|
|
};
|
|
order.forEach(function(placement) {
|
|
var side = ["left", "top"].indexOf(placement) !== -1 ? "primary" : "secondary";
|
|
popper = _extends({}, popper, check[side](placement));
|
|
});
|
|
data.offsets.popper = popper;
|
|
return data;
|
|
}
|
|
function shift(data) {
|
|
var placement = data.placement;
|
|
var basePlacement = placement.split("-")[0];
|
|
var shiftvariation = placement.split("-")[1];
|
|
if (shiftvariation) {
|
|
var _data$offsets = data.offsets, reference = _data$offsets.reference, popper = _data$offsets.popper;
|
|
var isVertical = ["bottom", "top"].indexOf(basePlacement) !== -1;
|
|
var side = isVertical ? "left" : "top";
|
|
var measurement = isVertical ? "width" : "height";
|
|
var shiftOffsets = {
|
|
start: defineProperty({}, side, reference[side]),
|
|
end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement])
|
|
};
|
|
data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]);
|
|
}
|
|
return data;
|
|
}
|
|
function hide(data) {
|
|
if (!isModifierRequired(data.instance.modifiers, "hide", "preventOverflow")) {
|
|
return data;
|
|
}
|
|
var refRect = data.offsets.reference;
|
|
var bound = find(data.instance.modifiers, function(modifier) {
|
|
return modifier.name === "preventOverflow";
|
|
}).boundaries;
|
|
if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) {
|
|
if (data.hide === true) {
|
|
return data;
|
|
}
|
|
data.hide = true;
|
|
data.attributes["x-out-of-boundaries"] = "";
|
|
} else {
|
|
if (data.hide === false) {
|
|
return data;
|
|
}
|
|
data.hide = false;
|
|
data.attributes["x-out-of-boundaries"] = false;
|
|
}
|
|
return data;
|
|
}
|
|
function inner(data) {
|
|
var placement = data.placement;
|
|
var basePlacement = placement.split("-")[0];
|
|
var _data$offsets = data.offsets, popper = _data$offsets.popper, reference = _data$offsets.reference;
|
|
var isHoriz = ["left", "right"].indexOf(basePlacement) !== -1;
|
|
var subtractLength = ["top", "left"].indexOf(basePlacement) === -1;
|
|
popper[isHoriz ? "left" : "top"] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? "width" : "height"] : 0);
|
|
data.placement = getOppositePlacement(placement);
|
|
data.offsets.popper = getClientRect(popper);
|
|
return data;
|
|
}
|
|
var isBrowser, timeoutDuration, supportsMicroTasks, debounce, isIE11, isIE10, classCallCheck, createClass, defineProperty, _extends, isFirefox, placements, validPlacements, BEHAVIORS, modifiers, Defaults, Popper, popper_default;
|
|
var init_popper = __esm({
|
|
"../../../node_modules/.pnpm/popper.js@1.16.1/node_modules/popper.js/dist/esm/popper.js"() {
|
|
isBrowser = typeof window !== "undefined" && typeof document !== "undefined" && typeof navigator !== "undefined";
|
|
timeoutDuration = (function() {
|
|
var longerTimeoutBrowsers = ["Edge", "Trident", "Firefox"];
|
|
for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) {
|
|
if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) {
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
})();
|
|
supportsMicroTasks = isBrowser && window.Promise;
|
|
debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce;
|
|
isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode);
|
|
isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent);
|
|
classCallCheck = function(instance, Constructor) {
|
|
if (!(instance instanceof Constructor)) {
|
|
throw new TypeError("Cannot call a class as a function");
|
|
}
|
|
};
|
|
createClass = /* @__PURE__ */ (function() {
|
|
function defineProperties(target, props) {
|
|
for (var i = 0; i < props.length; i++) {
|
|
var descriptor = props[i];
|
|
descriptor.enumerable = descriptor.enumerable || false;
|
|
descriptor.configurable = true;
|
|
if ("value" in descriptor) descriptor.writable = true;
|
|
Object.defineProperty(target, descriptor.key, descriptor);
|
|
}
|
|
}
|
|
return function(Constructor, protoProps, staticProps) {
|
|
if (protoProps) defineProperties(Constructor.prototype, protoProps);
|
|
if (staticProps) defineProperties(Constructor, staticProps);
|
|
return Constructor;
|
|
};
|
|
})();
|
|
defineProperty = function(obj, key, value) {
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, {
|
|
value,
|
|
enumerable: true,
|
|
configurable: true,
|
|
writable: true
|
|
});
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
};
|
|
_extends = Object.assign || function(target) {
|
|
for (var i = 1; i < arguments.length; i++) {
|
|
var source2 = arguments[i];
|
|
for (var key in source2) {
|
|
if (Object.prototype.hasOwnProperty.call(source2, key)) {
|
|
target[key] = source2[key];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent);
|
|
placements = ["auto-start", "auto", "auto-end", "top-start", "top", "top-end", "right-start", "right", "right-end", "bottom-end", "bottom", "bottom-start", "left-end", "left", "left-start"];
|
|
validPlacements = placements.slice(3);
|
|
BEHAVIORS = {
|
|
FLIP: "flip",
|
|
CLOCKWISE: "clockwise",
|
|
COUNTERCLOCKWISE: "counterclockwise"
|
|
};
|
|
modifiers = {
|
|
/**
|
|
* Modifier used to shift the popper on the start or end of its reference
|
|
* element.<br />
|
|
* It will read the variation of the `placement` property.<br />
|
|
* It can be one either `-end` or `-start`.
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
shift: {
|
|
/** @prop {number} order=100 - Index used to define the order of execution */
|
|
order: 100,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: shift
|
|
},
|
|
/**
|
|
* The `offset` modifier can shift your popper on both its axis.
|
|
*
|
|
* It accepts the following units:
|
|
* - `px` or unit-less, interpreted as pixels
|
|
* - `%` or `%r`, percentage relative to the length of the reference element
|
|
* - `%p`, percentage relative to the length of the popper element
|
|
* - `vw`, CSS viewport width unit
|
|
* - `vh`, CSS viewport height unit
|
|
*
|
|
* For length is intended the main axis relative to the placement of the popper.<br />
|
|
* This means that if the placement is `top` or `bottom`, the length will be the
|
|
* `width`. In case of `left` or `right`, it will be the `height`.
|
|
*
|
|
* You can provide a single value (as `Number` or `String`), or a pair of values
|
|
* as `String` divided by a comma or one (or more) white spaces.<br />
|
|
* The latter is a deprecated method because it leads to confusion and will be
|
|
* removed in v2.<br />
|
|
* Additionally, it accepts additions and subtractions between different units.
|
|
* Note that multiplications and divisions aren't supported.
|
|
*
|
|
* Valid examples are:
|
|
* ```
|
|
* 10
|
|
* '10%'
|
|
* '10, 10'
|
|
* '10%, 10'
|
|
* '10 + 10%'
|
|
* '10 - 5vh + 3%'
|
|
* '-10px + 5vh, 5px - 6%'
|
|
* ```
|
|
* > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap
|
|
* > with their reference element, unfortunately, you will have to disable the `flip` modifier.
|
|
* > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373).
|
|
*
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
offset: {
|
|
/** @prop {number} order=200 - Index used to define the order of execution */
|
|
order: 200,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: offset,
|
|
/** @prop {Number|String} offset=0
|
|
* The offset value as described in the modifier description
|
|
*/
|
|
offset: 0
|
|
},
|
|
/**
|
|
* Modifier used to prevent the popper from being positioned outside the boundary.
|
|
*
|
|
* A scenario exists where the reference itself is not within the boundaries.<br />
|
|
* We can say it has "escaped the boundaries" — or just "escaped".<br />
|
|
* In this case we need to decide whether the popper should either:
|
|
*
|
|
* - detach from the reference and remain "trapped" in the boundaries, or
|
|
* - if it should ignore the boundary and "escape with its reference"
|
|
*
|
|
* When `escapeWithReference` is set to`true` and reference is completely
|
|
* outside its boundaries, the popper will overflow (or completely leave)
|
|
* the boundaries in order to remain attached to the edge of the reference.
|
|
*
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
preventOverflow: {
|
|
/** @prop {number} order=300 - Index used to define the order of execution */
|
|
order: 300,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: preventOverflow,
|
|
/**
|
|
* @prop {Array} [priority=['left','right','top','bottom']]
|
|
* Popper will try to prevent overflow following these priorities by default,
|
|
* then, it could overflow on the left and on top of the `boundariesElement`
|
|
*/
|
|
priority: ["left", "right", "top", "bottom"],
|
|
/**
|
|
* @prop {number} padding=5
|
|
* Amount of pixel used to define a minimum distance between the boundaries
|
|
* and the popper. This makes sure the popper always has a little padding
|
|
* between the edges of its container
|
|
*/
|
|
padding: 5,
|
|
/**
|
|
* @prop {String|HTMLElement} boundariesElement='scrollParent'
|
|
* Boundaries used by the modifier. Can be `scrollParent`, `window`,
|
|
* `viewport` or any DOM element.
|
|
*/
|
|
boundariesElement: "scrollParent"
|
|
},
|
|
/**
|
|
* Modifier used to make sure the reference and its popper stay near each other
|
|
* without leaving any gap between the two. Especially useful when the arrow is
|
|
* enabled and you want to ensure that it points to its reference element.
|
|
* It cares only about the first axis. You can still have poppers with margin
|
|
* between the popper and its reference element.
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
keepTogether: {
|
|
/** @prop {number} order=400 - Index used to define the order of execution */
|
|
order: 400,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: keepTogether
|
|
},
|
|
/**
|
|
* This modifier is used to move the `arrowElement` of the popper to make
|
|
* sure it is positioned between the reference element and its popper element.
|
|
* It will read the outer size of the `arrowElement` node to detect how many
|
|
* pixels of conjunction are needed.
|
|
*
|
|
* It has no effect if no `arrowElement` is provided.
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
arrow: {
|
|
/** @prop {number} order=500 - Index used to define the order of execution */
|
|
order: 500,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: arrow,
|
|
/** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */
|
|
element: "[x-arrow]"
|
|
},
|
|
/**
|
|
* Modifier used to flip the popper's placement when it starts to overlap its
|
|
* reference element.
|
|
*
|
|
* Requires the `preventOverflow` modifier before it in order to work.
|
|
*
|
|
* **NOTE:** this modifier will interrupt the current update cycle and will
|
|
* restart it if it detects the need to flip the placement.
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
flip: {
|
|
/** @prop {number} order=600 - Index used to define the order of execution */
|
|
order: 600,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: flip,
|
|
/**
|
|
* @prop {String|Array} behavior='flip'
|
|
* The behavior used to change the popper's placement. It can be one of
|
|
* `flip`, `clockwise`, `counterclockwise` or an array with a list of valid
|
|
* placements (with optional variations)
|
|
*/
|
|
behavior: "flip",
|
|
/**
|
|
* @prop {number} padding=5
|
|
* The popper will flip if it hits the edges of the `boundariesElement`
|
|
*/
|
|
padding: 5,
|
|
/**
|
|
* @prop {String|HTMLElement} boundariesElement='viewport'
|
|
* The element which will define the boundaries of the popper position.
|
|
* The popper will never be placed outside of the defined boundaries
|
|
* (except if `keepTogether` is enabled)
|
|
*/
|
|
boundariesElement: "viewport",
|
|
/**
|
|
* @prop {Boolean} flipVariations=false
|
|
* The popper will switch placement variation between `-start` and `-end` when
|
|
* the reference element overlaps its boundaries.
|
|
*
|
|
* The original placement should have a set variation.
|
|
*/
|
|
flipVariations: false,
|
|
/**
|
|
* @prop {Boolean} flipVariationsByContent=false
|
|
* The popper will switch placement variation between `-start` and `-end` when
|
|
* the popper element overlaps its reference boundaries.
|
|
*
|
|
* The original placement should have a set variation.
|
|
*/
|
|
flipVariationsByContent: false
|
|
},
|
|
/**
|
|
* Modifier used to make the popper flow toward the inner of the reference element.
|
|
* By default, when this modifier is disabled, the popper will be placed outside
|
|
* the reference element.
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
inner: {
|
|
/** @prop {number} order=700 - Index used to define the order of execution */
|
|
order: 700,
|
|
/** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */
|
|
enabled: false,
|
|
/** @prop {ModifierFn} */
|
|
fn: inner
|
|
},
|
|
/**
|
|
* Modifier used to hide the popper when its reference element is outside of the
|
|
* popper boundaries. It will set a `x-out-of-boundaries` attribute which can
|
|
* be used to hide with a CSS selector the popper when its reference is
|
|
* out of boundaries.
|
|
*
|
|
* Requires the `preventOverflow` modifier before it in order to work.
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
hide: {
|
|
/** @prop {number} order=800 - Index used to define the order of execution */
|
|
order: 800,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: hide
|
|
},
|
|
/**
|
|
* Computes the style that will be applied to the popper element to gets
|
|
* properly positioned.
|
|
*
|
|
* Note that this modifier will not touch the DOM, it just prepares the styles
|
|
* so that `applyStyle` modifier can apply it. This separation is useful
|
|
* in case you need to replace `applyStyle` with a custom implementation.
|
|
*
|
|
* This modifier has `850` as `order` value to maintain backward compatibility
|
|
* with previous versions of Popper.js. Expect the modifiers ordering method
|
|
* to change in future major versions of the library.
|
|
*
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
computeStyle: {
|
|
/** @prop {number} order=850 - Index used to define the order of execution */
|
|
order: 850,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: computeStyle,
|
|
/**
|
|
* @prop {Boolean} gpuAcceleration=true
|
|
* If true, it uses the CSS 3D transformation to position the popper.
|
|
* Otherwise, it will use the `top` and `left` properties
|
|
*/
|
|
gpuAcceleration: true,
|
|
/**
|
|
* @prop {string} [x='bottom']
|
|
* Where to anchor the X axis (`bottom` or `top`). AKA X offset origin.
|
|
* Change this if your popper should grow in a direction different from `bottom`
|
|
*/
|
|
x: "bottom",
|
|
/**
|
|
* @prop {string} [x='left']
|
|
* Where to anchor the Y axis (`left` or `right`). AKA Y offset origin.
|
|
* Change this if your popper should grow in a direction different from `right`
|
|
*/
|
|
y: "right"
|
|
},
|
|
/**
|
|
* Applies the computed styles to the popper element.
|
|
*
|
|
* All the DOM manipulations are limited to this modifier. This is useful in case
|
|
* you want to integrate Popper.js inside a framework or view library and you
|
|
* want to delegate all the DOM manipulations to it.
|
|
*
|
|
* Note that if you disable this modifier, you must make sure the popper element
|
|
* has its position set to `absolute` before Popper.js can do its work!
|
|
*
|
|
* Just disable this modifier and define your own to achieve the desired effect.
|
|
*
|
|
* @memberof modifiers
|
|
* @inner
|
|
*/
|
|
applyStyle: {
|
|
/** @prop {number} order=900 - Index used to define the order of execution */
|
|
order: 900,
|
|
/** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */
|
|
enabled: true,
|
|
/** @prop {ModifierFn} */
|
|
fn: applyStyle,
|
|
/** @prop {Function} */
|
|
onLoad: applyStyleOnLoad,
|
|
/**
|
|
* @deprecated since version 1.10.0, the property moved to `computeStyle` modifier
|
|
* @prop {Boolean} gpuAcceleration=true
|
|
* If true, it uses the CSS 3D transformation to position the popper.
|
|
* Otherwise, it will use the `top` and `left` properties
|
|
*/
|
|
gpuAcceleration: void 0
|
|
}
|
|
};
|
|
Defaults = {
|
|
/**
|
|
* Popper's placement.
|
|
* @prop {Popper.placements} placement='bottom'
|
|
*/
|
|
placement: "bottom",
|
|
/**
|
|
* Set this to true if you want popper to position it self in 'fixed' mode
|
|
* @prop {Boolean} positionFixed=false
|
|
*/
|
|
positionFixed: false,
|
|
/**
|
|
* Whether events (resize, scroll) are initially enabled.
|
|
* @prop {Boolean} eventsEnabled=true
|
|
*/
|
|
eventsEnabled: true,
|
|
/**
|
|
* Set to true if you want to automatically remove the popper when
|
|
* you call the `destroy` method.
|
|
* @prop {Boolean} removeOnDestroy=false
|
|
*/
|
|
removeOnDestroy: false,
|
|
/**
|
|
* Callback called when the popper is created.<br />
|
|
* By default, it is set to no-op.<br />
|
|
* Access Popper.js instance with `data.instance`.
|
|
* @prop {onCreate}
|
|
*/
|
|
onCreate: function onCreate() {
|
|
},
|
|
/**
|
|
* Callback called when the popper is updated. This callback is not called
|
|
* on the initialization/creation of the popper, but only on subsequent
|
|
* updates.<br />
|
|
* By default, it is set to no-op.<br />
|
|
* Access Popper.js instance with `data.instance`.
|
|
* @prop {onUpdate}
|
|
*/
|
|
onUpdate: function onUpdate() {
|
|
},
|
|
/**
|
|
* List of modifiers used to modify the offsets before they are applied to the popper.
|
|
* They provide most of the functionalities of Popper.js.
|
|
* @prop {modifiers}
|
|
*/
|
|
modifiers
|
|
};
|
|
Popper = (function() {
|
|
function Popper2(reference, popper) {
|
|
var _this = this;
|
|
var options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
|
|
classCallCheck(this, Popper2);
|
|
this.scheduleUpdate = function() {
|
|
return requestAnimationFrame(_this.update);
|
|
};
|
|
this.update = debounce(this.update.bind(this));
|
|
this.options = _extends({}, Popper2.Defaults, options);
|
|
this.state = {
|
|
isDestroyed: false,
|
|
isCreated: false,
|
|
scrollParents: []
|
|
};
|
|
this.reference = reference && reference.jquery ? reference[0] : reference;
|
|
this.popper = popper && popper.jquery ? popper[0] : popper;
|
|
this.options.modifiers = {};
|
|
Object.keys(_extends({}, Popper2.Defaults.modifiers, options.modifiers)).forEach(function(name) {
|
|
_this.options.modifiers[name] = _extends({}, Popper2.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {});
|
|
});
|
|
this.modifiers = Object.keys(this.options.modifiers).map(function(name) {
|
|
return _extends({
|
|
name
|
|
}, _this.options.modifiers[name]);
|
|
}).sort(function(a, b) {
|
|
return a.order - b.order;
|
|
});
|
|
this.modifiers.forEach(function(modifierOptions) {
|
|
if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) {
|
|
modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state);
|
|
}
|
|
});
|
|
this.update();
|
|
var eventsEnabled = this.options.eventsEnabled;
|
|
if (eventsEnabled) {
|
|
this.enableEventListeners();
|
|
}
|
|
this.state.eventsEnabled = eventsEnabled;
|
|
}
|
|
createClass(Popper2, [{
|
|
key: "update",
|
|
value: function update$$1() {
|
|
return update.call(this);
|
|
}
|
|
}, {
|
|
key: "destroy",
|
|
value: function destroy$$1() {
|
|
return destroy.call(this);
|
|
}
|
|
}, {
|
|
key: "enableEventListeners",
|
|
value: function enableEventListeners$$1() {
|
|
return enableEventListeners.call(this);
|
|
}
|
|
}, {
|
|
key: "disableEventListeners",
|
|
value: function disableEventListeners$$1() {
|
|
return disableEventListeners.call(this);
|
|
}
|
|
/**
|
|
* Schedules an update. It will run on the next UI update available.
|
|
* @method scheduleUpdate
|
|
* @memberof Popper
|
|
*/
|
|
/**
|
|
* Collection of utilities useful when writing custom modifiers.
|
|
* Starting from version 1.7, this method is available only if you
|
|
* include `popper-utils.js` before `popper.js`.
|
|
*
|
|
* **DEPRECATION**: This way to access PopperUtils is deprecated
|
|
* and will be removed in v2! Use the PopperUtils module directly instead.
|
|
* Due to the high instability of the methods contained in Utils, we can't
|
|
* guarantee them to follow semver. Use them at your own risk!
|
|
* @static
|
|
* @private
|
|
* @type {Object}
|
|
* @deprecated since version 1.8
|
|
* @member Utils
|
|
* @memberof Popper
|
|
*/
|
|
}]);
|
|
return Popper2;
|
|
})();
|
|
Popper.Utils = (typeof window !== "undefined" ? window : global).PopperUtils;
|
|
Popper.placements = placements;
|
|
Popper.Defaults = Defaults;
|
|
popper_default = Popper;
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/utils.js
|
|
var require_utils = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/utils.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.parsePopperOffset = parsePopperOffset;
|
|
exports.toPopperPlacement = toPopperPlacement;
|
|
function toPopperPlacement(placement) {
|
|
return placement.replace(/(Top|Left)$/, "-start").replace(/(Right|Bottom)$/, "-end");
|
|
}
|
|
function parsePopperOffset(offset2) {
|
|
return {
|
|
top: Math.floor(offset2.top || 0),
|
|
left: Math.floor(offset2.left || 0)
|
|
};
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/constants.js
|
|
var require_constants = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/constants.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.TETHER_PLACEMENT = void 0;
|
|
var TETHER_PLACEMENT = exports.TETHER_PLACEMENT = {
|
|
auto: "auto",
|
|
topLeft: "topLeft",
|
|
top: "top",
|
|
topRight: "topRight",
|
|
rightTop: "rightTop",
|
|
right: "right",
|
|
rightBottom: "rightBottom",
|
|
bottomRight: "bottomRight",
|
|
bottom: "bottom",
|
|
bottomLeft: "bottomLeft",
|
|
leftBottom: "leftBottom",
|
|
left: "left",
|
|
leftTop: "leftTop"
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/tether.js
|
|
var require_tether = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/tether.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
var React5 = _interopRequireWildcard(require_react());
|
|
var _popper = _interopRequireDefault((init_popper(), __toCommonJS(popper_exports)));
|
|
var _utils = require_utils();
|
|
var _constants = require_constants();
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
function _getRequireWildcardCache(e) {
|
|
if ("function" != typeof WeakMap) return null;
|
|
var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
|
|
return (_getRequireWildcardCache = function(e2) {
|
|
return e2 ? t : r;
|
|
})(e);
|
|
}
|
|
function _interopRequireWildcard(e, r) {
|
|
if (!r && e && e.__esModule) return e;
|
|
if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };
|
|
var t = _getRequireWildcardCache(r);
|
|
if (t && t.has(e)) return t.get(e);
|
|
var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
|
|
var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
|
|
i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
|
|
}
|
|
return n.default = e, t && t.set(e, n), n;
|
|
}
|
|
function _defineProperty(obj, key, value) {
|
|
key = _toPropertyKey(key);
|
|
if (key in obj) {
|
|
Object.defineProperty(obj, key, { value, enumerable: true, configurable: true, writable: true });
|
|
} else {
|
|
obj[key] = value;
|
|
}
|
|
return obj;
|
|
}
|
|
function _toPropertyKey(t) {
|
|
var i = _toPrimitive(t, "string");
|
|
return "symbol" == typeof i ? i : String(i);
|
|
}
|
|
function _toPrimitive(t, r) {
|
|
if ("object" != typeof t || !t) return t;
|
|
var e = t[Symbol.toPrimitive];
|
|
if (void 0 !== e) {
|
|
var i = e.call(t, r || "default");
|
|
if ("object" != typeof i) return i;
|
|
throw new TypeError("@@toPrimitive must return a primitive value.");
|
|
}
|
|
return ("string" === r ? String : Number)(t);
|
|
}
|
|
var Tether = class extends React5.Component {
|
|
constructor(...args) {
|
|
super(...args);
|
|
_defineProperty(this, "popper", void 0);
|
|
_defineProperty(this, "popperHeight", 0);
|
|
_defineProperty(this, "popperWidth", 0);
|
|
_defineProperty(this, "anchorHeight", 0);
|
|
_defineProperty(this, "anchorWidth", 0);
|
|
_defineProperty(this, "state", {
|
|
isMounted: false
|
|
});
|
|
_defineProperty(this, "onPopperUpdate", (data) => {
|
|
const normalizedOffsets = {
|
|
popper: (0, _utils.parsePopperOffset)(data.offsets.popper),
|
|
arrow: data.offsets.arrow ? (0, _utils.parsePopperOffset)(data.offsets.arrow) : {
|
|
top: 0,
|
|
left: 0
|
|
}
|
|
};
|
|
this.props.onPopperUpdate(normalizedOffsets, data);
|
|
});
|
|
}
|
|
componentDidMount() {
|
|
this.setState({
|
|
isMounted: true
|
|
});
|
|
}
|
|
componentDidUpdate(prevProps, prevState) {
|
|
if (this.props.anchorRef) {
|
|
const {
|
|
height,
|
|
width
|
|
} = this.props.anchorRef.getBoundingClientRect();
|
|
if (this.anchorHeight !== height || this.anchorWidth !== width) {
|
|
this.anchorHeight = height;
|
|
this.anchorWidth = width;
|
|
this.popper && this.popper.scheduleUpdate();
|
|
}
|
|
}
|
|
if (this.props.popperRef) {
|
|
const {
|
|
height,
|
|
width
|
|
} = this.props.popperRef.getBoundingClientRect();
|
|
if (this.popperHeight !== height || this.popperWidth !== width) {
|
|
this.popperHeight = height;
|
|
this.popperWidth = width;
|
|
this.popper && this.popper.scheduleUpdate();
|
|
}
|
|
if (this.state.isMounted !== prevState.isMounted) {
|
|
if (!this.props.anchorRef) {
|
|
if (true) {
|
|
console.warn(`[baseui][TetherBehavior] ref has not been passed to the Popper's anchor element.
|
|
See how to pass the ref to an anchor element in the Popover example
|
|
https://baseweb.design/components/popover/#anchor-ref-handling-example`);
|
|
}
|
|
} else {
|
|
this.initializePopper();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
componentWillUnmount() {
|
|
this.destroyPopover();
|
|
}
|
|
initializePopper() {
|
|
const {
|
|
placement,
|
|
popperOptions
|
|
} = this.props;
|
|
const {
|
|
modifiers: modifiers2,
|
|
...restOptions
|
|
} = popperOptions;
|
|
if (!this.props.anchorRef || !this.props.popperRef) return;
|
|
this.popper = new _popper.default(this.props.anchorRef, this.props.popperRef, {
|
|
// Recommended placement (popper may ignore if it causes a viewport overflow, etc)
|
|
placement: (0, _utils.toPopperPlacement)(placement),
|
|
modifiers: {
|
|
// Passing the arrow ref will measure the arrow when calculating styles
|
|
arrow: {
|
|
element: this.props.arrowRef,
|
|
enabled: !!this.props.arrowRef
|
|
},
|
|
computeStyle: {
|
|
// Make popper use top/left instead of transform translate, this is because
|
|
// we use transform for animations and we dont want them to conflict
|
|
gpuAcceleration: false
|
|
},
|
|
applyStyle: {
|
|
// Disable default styling modifier, we'll apply styles on our own
|
|
enabled: false
|
|
},
|
|
applyReactStyle: {
|
|
enabled: true,
|
|
fn: this.onPopperUpdate,
|
|
order: 900
|
|
},
|
|
preventOverflow: {
|
|
enabled: true
|
|
},
|
|
...modifiers2
|
|
},
|
|
...restOptions
|
|
});
|
|
}
|
|
destroyPopover() {
|
|
if (this.popper) {
|
|
this.popper.destroy();
|
|
delete this.popper;
|
|
}
|
|
}
|
|
render() {
|
|
return this.props.children || null;
|
|
}
|
|
};
|
|
_defineProperty(Tether, "defaultProps", {
|
|
// @ts-ignore
|
|
anchorRef: null,
|
|
// @ts-ignore
|
|
onPopperUpdate: () => null,
|
|
placement: _constants.TETHER_PLACEMENT.auto,
|
|
// @ts-ignore
|
|
popperRef: null,
|
|
popperOptions: {}
|
|
});
|
|
var _default = exports.default = Tether;
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/types.js
|
|
var require_types = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/types.js"() {
|
|
"use strict";
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/index.js
|
|
var require_layer2 = __commonJS({
|
|
"../../../node_modules/.pnpm/baseui@16.1.1_@types+react@18.3.27_react-dom@19.2.4_react@19.2.4__react@19.2.4_styletron-react@6.1.1_react@19.2.4_/node_modules/baseui/layer/index.js"(exports) {
|
|
"use strict";
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
var _exportNames = {
|
|
LayersManager: true,
|
|
LayersContext: true,
|
|
Layer: true,
|
|
TetherBehavior: true,
|
|
TETHER_PLACEMENT: true
|
|
};
|
|
Object.defineProperty(exports, "Layer", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _layer.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "LayersContext", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _layersManager.LayersContext;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "LayersManager", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _layersManager.default;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "TETHER_PLACEMENT", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _constants.TETHER_PLACEMENT;
|
|
}
|
|
});
|
|
Object.defineProperty(exports, "TetherBehavior", {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _tether.default;
|
|
}
|
|
});
|
|
var _layersManager = _interopRequireWildcard(require_layers_manager());
|
|
var _layer = _interopRequireDefault(require_layer());
|
|
var _tether = _interopRequireDefault(require_tether());
|
|
var _constants = require_constants();
|
|
var _types = require_types();
|
|
Object.keys(_types).forEach(function(key) {
|
|
if (key === "default" || key === "__esModule") return;
|
|
if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
|
|
if (key in exports && exports[key] === _types[key]) return;
|
|
Object.defineProperty(exports, key, {
|
|
enumerable: true,
|
|
get: function() {
|
|
return _types[key];
|
|
}
|
|
});
|
|
});
|
|
function _interopRequireDefault(obj) {
|
|
return obj && obj.__esModule ? obj : { default: obj };
|
|
}
|
|
function _getRequireWildcardCache(e) {
|
|
if ("function" != typeof WeakMap) return null;
|
|
var r = /* @__PURE__ */ new WeakMap(), t = /* @__PURE__ */ new WeakMap();
|
|
return (_getRequireWildcardCache = function(e2) {
|
|
return e2 ? t : r;
|
|
})(e);
|
|
}
|
|
function _interopRequireWildcard(e, r) {
|
|
if (!r && e && e.__esModule) return e;
|
|
if (null === e || "object" != typeof e && "function" != typeof e) return { default: e };
|
|
var t = _getRequireWildcardCache(r);
|
|
if (t && t.has(e)) return t.get(e);
|
|
var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor;
|
|
for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) {
|
|
var i = a ? Object.getOwnPropertyDescriptor(e, u) : null;
|
|
i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u];
|
|
}
|
|
return n.default = e, t && t.set(e, n), n;
|
|
}
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/uid.js
|
|
var generateUID, uid;
|
|
var init_uid = __esm({
|
|
"../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/uid.js"() {
|
|
generateUID = function() {
|
|
var counter2 = 1;
|
|
var map = /* @__PURE__ */ new WeakMap();
|
|
var uid2 = function(item, index) {
|
|
if (typeof item === "number" || typeof item === "string") {
|
|
return index ? "idx-" + index : "val-" + item;
|
|
}
|
|
if (!map.has(item)) {
|
|
map.set(item, counter2++);
|
|
return uid2(item);
|
|
}
|
|
return "uid" + map.get(item);
|
|
};
|
|
return uid2;
|
|
};
|
|
uid = generateUID();
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/context.js
|
|
var React, createSource, counter, source, getId, getPrefix;
|
|
var init_context = __esm({
|
|
"../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/context.js"() {
|
|
React = __toESM(require_react());
|
|
init_uid();
|
|
createSource = function(prefix) {
|
|
if (prefix === void 0) {
|
|
prefix = "";
|
|
}
|
|
return {
|
|
value: 1,
|
|
prefix,
|
|
uid: generateUID()
|
|
};
|
|
};
|
|
counter = createSource();
|
|
source = React.createContext(createSource());
|
|
getId = function(source2) {
|
|
return source2.value++;
|
|
};
|
|
getPrefix = function(source2) {
|
|
return source2 ? source2.prefix : "";
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js
|
|
function __extends(d, b) {
|
|
extendStatics(d, b);
|
|
function __() {
|
|
this.constructor = d;
|
|
}
|
|
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
|
}
|
|
var extendStatics;
|
|
var init_tslib_es6 = __esm({
|
|
"../../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js"() {
|
|
extendStatics = function(d, b) {
|
|
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
|
|
d2.__proto__ = b2;
|
|
} || function(d2, b2) {
|
|
for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
|
|
};
|
|
return extendStatics(d, b);
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/UIDComponent.js
|
|
var React2, prefixId, UID;
|
|
var init_UIDComponent = __esm({
|
|
"../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/UIDComponent.js"() {
|
|
init_tslib_es6();
|
|
React2 = __toESM(require_react());
|
|
init_context();
|
|
prefixId = function(id, prefix, name) {
|
|
var uid2 = prefix + id;
|
|
return String(name ? name(uid2) : uid2);
|
|
};
|
|
UID = /** @class */
|
|
(function(_super) {
|
|
__extends(UID2, _super);
|
|
function UID2() {
|
|
var _this = _super !== null && _super.apply(this, arguments) || this;
|
|
_this.state = {
|
|
quartz: _this.props.idSource || counter,
|
|
prefix: getPrefix(_this.props.idSource),
|
|
id: getId(_this.props.idSource || counter)
|
|
};
|
|
_this.uid = function(item) {
|
|
return prefixId(_this.state.id + "-" + _this.state.quartz.uid(item), _this.state.prefix, _this.props.name);
|
|
};
|
|
return _this;
|
|
}
|
|
UID2.prototype.render = function() {
|
|
var _a = this.props, children = _a.children, name = _a.name;
|
|
var _b = this.state, id = _b.id, prefix = _b.prefix;
|
|
return children(prefixId(id, prefix, name), this.uid);
|
|
};
|
|
return UID2;
|
|
})(React2.Component);
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/Control.js
|
|
var React3, UIDReset, UIDFork, UIDConsumer;
|
|
var init_Control = __esm({
|
|
"../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/Control.js"() {
|
|
React3 = __toESM(require_react());
|
|
init_context();
|
|
init_UIDComponent();
|
|
UIDReset = function(_a) {
|
|
var children = _a.children, _b = _a.prefix, prefix = _b === void 0 ? "" : _b;
|
|
return React3.createElement(source.Provider, { value: createSource(prefix) }, children);
|
|
};
|
|
UIDFork = function(_a) {
|
|
var children = _a.children, _b = _a.prefix, prefix = _b === void 0 ? "" : _b;
|
|
return React3.createElement(UIDConsumer, null, function(id) {
|
|
return React3.createElement(source.Provider, { value: createSource(id + "-" + prefix) }, children);
|
|
});
|
|
};
|
|
UIDConsumer = function(_a) {
|
|
var name = _a.name, children = _a.children;
|
|
return React3.createElement(source.Consumer, null, function(value) {
|
|
return React3.createElement(UID, { name, idSource: value, children });
|
|
});
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/hooks.js
|
|
var React4, generateUID2, useUIDState, useUID, useUIDSeed;
|
|
var init_hooks = __esm({
|
|
"../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/hooks.js"() {
|
|
React4 = __toESM(require_react());
|
|
init_context();
|
|
generateUID2 = function(context) {
|
|
var quartz = context || counter;
|
|
var prefix = getPrefix(quartz);
|
|
var id = getId(quartz);
|
|
var uid2 = prefix + id;
|
|
var gen = function(item) {
|
|
return uid2 + quartz.uid(item);
|
|
};
|
|
return { uid: uid2, gen };
|
|
};
|
|
useUIDState = function() {
|
|
if (true) {
|
|
if (!("useContext" in React4)) {
|
|
throw new Error("Hooks API requires React 16.8+");
|
|
}
|
|
}
|
|
return React4.useState(generateUID2(React4.useContext(source)));
|
|
};
|
|
useUID = function() {
|
|
var uid2 = useUIDState()[0].uid;
|
|
return uid2;
|
|
};
|
|
useUIDSeed = function() {
|
|
var gen = useUIDState()[0].gen;
|
|
return gen;
|
|
};
|
|
}
|
|
});
|
|
|
|
// ../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/index.js
|
|
var es2015_exports = {};
|
|
__export(es2015_exports, {
|
|
UID: () => UID,
|
|
UIDConsumer: () => UIDConsumer,
|
|
UIDFork: () => UIDFork,
|
|
UIDReset: () => UIDReset,
|
|
generateUID: () => generateUID,
|
|
uid: () => uid,
|
|
useUID: () => useUID,
|
|
useUIDSeed: () => useUIDSeed
|
|
});
|
|
var init_es2015 = __esm({
|
|
"../../../node_modules/.pnpm/react-uid@2.3.0_@types+react@18.3.27_react@19.2.4/node_modules/react-uid/dist/es2015/index.js"() {
|
|
init_uid();
|
|
init_Control();
|
|
init_hooks();
|
|
init_UIDComponent();
|
|
}
|
|
});
|
|
|
|
export {
|
|
require_focusVisible,
|
|
require_layer2 as require_layer,
|
|
es2015_exports,
|
|
init_es2015
|
|
};
|
|
//# sourceMappingURL=chunk-W6BYZAPA.js.map
|