feat: 氧化铝数字孪生系统监控大屏完成

node_modules/react-popper/lib/cjs/Manager.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Manager = Manager;
+exports.ManagerReferenceNodeSetterContext = exports.ManagerReferenceNodeContext = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var ManagerReferenceNodeContext = React.createContext();
+exports.ManagerReferenceNodeContext = ManagerReferenceNodeContext;
+var ManagerReferenceNodeSetterContext = React.createContext();
+exports.ManagerReferenceNodeSetterContext = ManagerReferenceNodeSetterContext;
+
+function Manager(_ref) {
+  var children = _ref.children;
+
+  var _React$useState = React.useState(null),
+      referenceNode = _React$useState[0],
+      setReferenceNode = _React$useState[1];
+
+  var hasUnmounted = React.useRef(false);
+  React.useEffect(function () {
+    return function () {
+      hasUnmounted.current = true;
+    };
+  }, []);
+  var handleSetReferenceNode = React.useCallback(function (node) {
+    if (!hasUnmounted.current) {
+      setReferenceNode(node);
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(ManagerReferenceNodeContext.Provider, {
+    value: referenceNode
+  }, /*#__PURE__*/React.createElement(ManagerReferenceNodeSetterContext.Provider, {
+    value: handleSetReferenceNode
+  }, children));
+}

node_modules/react-popper/lib/cjs/Manager.js.flow

@@ -0,0 +1,38 @@
+// @flow strict
+import * as React from 'react';
+
+export const ManagerReferenceNodeContext: React.Context<?Element>  = React.createContext();
+export const ManagerReferenceNodeSetterContext: React.Context<
+  void | ((?Element) => void)
+> = React.createContext();
+
+export type ManagerProps = $ReadOnly<{
+  children: React.Node,
+}>;
+
+export function Manager({ children }: ManagerProps): React.Node {
+  const [referenceNode, setReferenceNode] = React.useState<?Element>(null);
+
+  const hasUnmounted = React.useRef(false);
+  React.useEffect(() => {
+    return () => {
+      hasUnmounted.current = true;
+    };
+  }, []);
+
+  const handleSetReferenceNode = React.useCallback((node) => {
+    if (!hasUnmounted.current) {
+      setReferenceNode(node);
+    }
+  }, []);
+
+  return (
+    <ManagerReferenceNodeContext.Provider value={referenceNode}>
+      <ManagerReferenceNodeSetterContext.Provider
+        value={handleSetReferenceNode}
+      >
+        {children}
+      </ManagerReferenceNodeSetterContext.Provider>
+    </ManagerReferenceNodeContext.Provider>
+  );
+}

node_modules/react-popper/lib/cjs/Popper.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Popper = Popper;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _Manager = require("./Manager");
+
+var _utils = require("./utils");
+
+var _usePopper2 = require("./usePopper");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var NOOP = function NOOP() {
+  return void 0;
+};
+
+var NOOP_PROMISE = function NOOP_PROMISE() {
+  return Promise.resolve(null);
+};
+
+var EMPTY_MODIFIERS = [];
+
+function Popper(_ref) {
+  var _ref$placement = _ref.placement,
+      placement = _ref$placement === void 0 ? 'bottom' : _ref$placement,
+      _ref$strategy = _ref.strategy,
+      strategy = _ref$strategy === void 0 ? 'absolute' : _ref$strategy,
+      _ref$modifiers = _ref.modifiers,
+      modifiers = _ref$modifiers === void 0 ? EMPTY_MODIFIERS : _ref$modifiers,
+      referenceElement = _ref.referenceElement,
+      onFirstUpdate = _ref.onFirstUpdate,
+      innerRef = _ref.innerRef,
+      children = _ref.children;
+  var referenceNode = React.useContext(_Manager.ManagerReferenceNodeContext);
+
+  var _React$useState = React.useState(null),
+      popperElement = _React$useState[0],
+      setPopperElement = _React$useState[1];
+
+  var _React$useState2 = React.useState(null),
+      arrowElement = _React$useState2[0],
+      setArrowElement = _React$useState2[1];
+
+  React.useEffect(function () {
+    (0, _utils.setRef)(innerRef, popperElement);
+  }, [innerRef, popperElement]);
+  var options = React.useMemo(function () {
+    return {
+      placement: placement,
+      strategy: strategy,
+      onFirstUpdate: onFirstUpdate,
+      modifiers: [].concat(modifiers, [{
+        name: 'arrow',
+        enabled: arrowElement != null,
+        options: {
+          element: arrowElement
+        }
+      }])
+    };
+  }, [placement, strategy, onFirstUpdate, modifiers, arrowElement]);
+
+  var _usePopper = (0, _usePopper2.usePopper)(referenceElement || referenceNode, popperElement, options),
+      state = _usePopper.state,
+      styles = _usePopper.styles,
+      forceUpdate = _usePopper.forceUpdate,
+      update = _usePopper.update;
+
+  var childrenProps = React.useMemo(function () {
+    return {
+      ref: setPopperElement,
+      style: styles.popper,
+      placement: state ? state.placement : placement,
+      hasPopperEscaped: state && state.modifiersData.hide ? state.modifiersData.hide.hasPopperEscaped : null,
+      isReferenceHidden: state && state.modifiersData.hide ? state.modifiersData.hide.isReferenceHidden : null,
+      arrowProps: {
+        style: styles.arrow,
+        ref: setArrowElement
+      },
+      forceUpdate: forceUpdate || NOOP,
+      update: update || NOOP_PROMISE
+    };
+  }, [setPopperElement, setArrowElement, placement, state, styles, update, forceUpdate]);
+  return (0, _utils.unwrapArray)(children)(childrenProps);
+}

node_modules/react-popper/lib/cjs/Popper.js.flow

@@ -0,0 +1,124 @@
+// @flow strict
+import * as React from 'react';
+import {
+  type State,
+  type Placement,
+  type PositioningStrategy,
+  type VirtualElement,
+  type StrictModifiers,
+  type Modifier,
+} from '@popperjs/core/lib';
+import { ManagerReferenceNodeContext } from './Manager';
+import type { Ref } from './RefTypes';
+import { unwrapArray, setRef } from './utils';
+import { usePopper } from './usePopper';
+
+type ReferenceElement = ?(VirtualElement | HTMLElement);
+type Modifiers = Array<StrictModifiers | $Shape<Modifier<string, {}>>>;
+
+export type PopperArrowProps = {|
+  ref: Ref,
+  style: CSSStyleDeclaration,
+|};
+export type PopperChildrenProps = {|
+  ref: Ref,
+  style: CSSStyleDeclaration,
+
+  placement: Placement,
+  isReferenceHidden: ?boolean,
+  hasPopperEscaped: ?boolean,
+
+  update: () => Promise<null | $Shape<State>>,
+  forceUpdate: () => void,
+  arrowProps: PopperArrowProps,
+|};
+export type PopperChildren = (PopperChildrenProps) => React.Node;
+
+export type PopperProps = $ReadOnly<{|
+  children: PopperChildren,
+  innerRef?: Ref,
+  modifiers?: Modifiers,
+  placement?: Placement,
+  strategy?: PositioningStrategy,
+  referenceElement?: ReferenceElement,
+  onFirstUpdate?: ($Shape<State>) => void,
+|}>;
+
+const NOOP = () => void 0;
+const NOOP_PROMISE = () => Promise.resolve(null);
+const EMPTY_MODIFIERS = [];
+
+export function Popper({
+  placement = 'bottom',
+  strategy = 'absolute',
+  modifiers = EMPTY_MODIFIERS,
+  referenceElement,
+  onFirstUpdate,
+  innerRef,
+  children,
+}: PopperProps): React.Node {
+  const referenceNode = React.useContext(ManagerReferenceNodeContext);
+
+  const [popperElement, setPopperElement] = React.useState(null);
+  const [arrowElement, setArrowElement] = React.useState(null);
+
+  React.useEffect(() => {
+    setRef(innerRef, popperElement)
+  }, [innerRef, popperElement]);
+
+  const options = React.useMemo(
+    () => ({
+      placement,
+      strategy,
+      onFirstUpdate,
+      modifiers: [
+        ...modifiers,
+        {
+          name: 'arrow',
+          enabled: arrowElement != null,
+          options: { element: arrowElement },
+        },
+      ],
+    }),
+    [placement, strategy, onFirstUpdate, modifiers, arrowElement]
+  );
+
+  const { state, styles, forceUpdate, update } = usePopper(
+    referenceElement || referenceNode,
+    popperElement,
+    options
+  );
+
+  const childrenProps = React.useMemo(
+    () => ({
+      ref: setPopperElement,
+      style: styles.popper,
+      placement: state ? state.placement : placement,
+      hasPopperEscaped:
+        state && state.modifiersData.hide
+          ? state.modifiersData.hide.hasPopperEscaped
+          : null,
+      isReferenceHidden:
+        state && state.modifiersData.hide
+          ? state.modifiersData.hide.isReferenceHidden
+          : null,
+      arrowProps: {
+        style: styles.arrow,
+        ref: setArrowElement,
+      },
+      forceUpdate: forceUpdate || NOOP,
+      update: update || NOOP_PROMISE,
+    }),
+    [
+      setPopperElement,
+      setArrowElement,
+      placement,
+      state,
+      styles,
+      update,
+      forceUpdate,
+    ]
+  );
+
+  return unwrapArray(children)(childrenProps);
+}

node_modules/react-popper/lib/cjs/RefTypes.js

@@ -0,0 +1 @@
+"use strict";

node_modules/react-popper/lib/cjs/RefTypes.js.flow

@@ -0,0 +1,5 @@
+// @flow strict
+type RefHandler = (?HTMLElement) => void;
+type RefObject = { current?: ?HTMLElement};
+
+export type Ref = RefHandler | RefObject;

node_modules/react-popper/lib/cjs/Reference.js

@@ -0,0 +1,43 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Reference = Reference;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _warning = _interopRequireDefault(require("warning"));
+
+var _Manager = require("./Manager");
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function Reference(_ref) {
+  var children = _ref.children,
+      innerRef = _ref.innerRef;
+  var setReferenceNode = React.useContext(_Manager.ManagerReferenceNodeSetterContext);
+  var refHandler = React.useCallback(function (node) {
+    (0, _utils.setRef)(innerRef, node);
+    (0, _utils.safeInvoke)(setReferenceNode, node);
+  }, [innerRef, setReferenceNode]); // ran on unmount
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  React.useEffect(function () {
+    return function () {
+      return (0, _utils.setRef)(innerRef, null);
+    };
+  }, []);
+  React.useEffect(function () {
+    (0, _warning["default"])(Boolean(setReferenceNode), '`Reference` should not be used outside of a `Manager` component.');
+  }, [setReferenceNode]);
+  return (0, _utils.unwrapArray)(children)({
+    ref: refHandler
+  });
+}

node_modules/react-popper/lib/cjs/Reference.js.flow

@@ -0,0 +1,37 @@
+// @flow strict
+import * as React from 'react';
+import warning from 'warning';
+import { ManagerReferenceNodeSetterContext } from './Manager';
+import { safeInvoke, unwrapArray, setRef } from './utils';
+import { type Ref } from './RefTypes';
+
+export type ReferenceChildrenProps = $ReadOnly<{ ref: Ref }>;
+export type ReferenceProps = $ReadOnly<{|
+  children: (ReferenceChildrenProps) => React.Node,
+  innerRef?: Ref,
+|}>;
+
+export function Reference({ children, innerRef }: ReferenceProps): React.Node {
+  const setReferenceNode = React.useContext(ManagerReferenceNodeSetterContext);
+
+  const refHandler = React.useCallback(
+    (node: ?HTMLElement) => {
+      setRef(innerRef, node);
+      safeInvoke(setReferenceNode, node);
+    },
+    [innerRef, setReferenceNode]
+  );
+
+  // ran on unmount
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  React.useEffect(() => () => setRef(innerRef, null), []);
+
+  React.useEffect(() => {
+    warning(
+      Boolean(setReferenceNode),
+      '`Reference` should not be used outside of a `Manager` component.'
+    );
+  }, [setReferenceNode]);
+
+  return unwrapArray(children)({ ref: refHandler });
+}

node_modules/react-popper/lib/cjs/__typings__/main-test.js

@@ -0,0 +1,69 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Test = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var _ = require("..");
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+var Test = function Test() {
+  var _React$createElement;
+
+  return /*#__PURE__*/React.createElement(_.Manager, null, /*#__PURE__*/React.createElement(_.Reference, null), /*#__PURE__*/React.createElement(_.Reference, null, function (_ref) {
+    var ref = _ref.ref;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    });
+  }), /*#__PURE__*/React.createElement(_.Popper // $FlowExpectError: should be one of allowed placements
+  , (_React$createElement = {
+    placement: "custom"
+  }, _React$createElement["placement"] = "top", _React$createElement.strategy = "custom", _React$createElement["strategy"] = "fixed", _React$createElement.modifiers = [{
+    name: 'flip',
+    enabled: 'bar',
+    order: 'foo'
+  }], _React$createElement["modifiers"] = [{
+    name: 'flip',
+    enabled: false
+  }], _React$createElement), function (_ref2) {
+    var ref = _ref2.ref,
+        style = _ref2.style,
+        placement = _ref2.placement,
+        isReferenceHidden = _ref2.isReferenceHidden,
+        hasPopperEscaped = _ref2.hasPopperEscaped,
+        update = _ref2.update,
+        arrowProps = _ref2.arrowProps;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: _extends({}, style, {
+        opacity: isReferenceHidden === true || hasPopperEscaped === true ? 0 : 1
+      }),
+      "data-placement": placement,
+      onClick: function onClick() {
+        return update();
+      }
+    }, "Popper", /*#__PURE__*/React.createElement("div", {
+      ref: arrowProps.ref,
+      style: arrowProps.style
+    }));
+  }), /*#__PURE__*/React.createElement(_.Popper, null, function (_ref3) {
+    var ref = _ref3.ref,
+        style = _ref3.style,
+        placement = _ref3.placement;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: style,
+      "data-placement": placement
+    }, "Popper");
+  }));
+};
+
+exports.Test = Test;

node_modules/react-popper/lib/cjs/index.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Popper", {
+  enumerable: true,
+  get: function get() {
+    return _Popper.Popper;
+  }
+});
+Object.defineProperty(exports, "Manager", {
+  enumerable: true,
+  get: function get() {
+    return _Manager.Manager;
+  }
+});
+Object.defineProperty(exports, "Reference", {
+  enumerable: true,
+  get: function get() {
+    return _Reference.Reference;
+  }
+});
+Object.defineProperty(exports, "usePopper", {
+  enumerable: true,
+  get: function get() {
+    return _usePopper.usePopper;
+  }
+});
+
+var _Popper = require("./Popper");
+
+var _Manager = require("./Manager");
+
+var _Reference = require("./Reference");
+
+var _usePopper = require("./usePopper");

node_modules/react-popper/lib/cjs/index.js.flow

@@ -0,0 +1,25 @@
+// @flow strict
+
+// Public components
+import { Popper } from './Popper';
+import { Manager } from './Manager';
+import { Reference } from './Reference';
+import { usePopper } from './usePopper';
+export { Popper, Manager, Reference, usePopper };
+
+// Public types
+import type { ManagerProps } from './Manager';
+import type { ReferenceProps, ReferenceChildrenProps } from './Reference';
+import type {
+  PopperChildrenProps,
+  PopperArrowProps,
+  PopperProps,
+} from './Popper';
+export type {
+  ManagerProps,
+  ReferenceProps,
+  ReferenceChildrenProps,
+  PopperChildrenProps,
+  PopperArrowProps,
+  PopperProps,
+};

node_modules/react-popper/lib/cjs/usePopper.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.usePopper = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+var ReactDOM = _interopRequireWildcard(require("react-dom"));
+
+var _core = require("@popperjs/core");
+
+var _reactFastCompare = _interopRequireDefault(require("react-fast-compare"));
+
+var _utils = require("./utils");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+var EMPTY_MODIFIERS = [];
+
+var usePopper = function usePopper(referenceElement, popperElement, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var prevOptions = React.useRef(null);
+  var optionsWithDefaults = {
+    onFirstUpdate: options.onFirstUpdate,
+    placement: options.placement || 'bottom',
+    strategy: options.strategy || 'absolute',
+    modifiers: options.modifiers || EMPTY_MODIFIERS
+  };
+
+  var _React$useState = React.useState({
+    styles: {
+      popper: {
+        position: optionsWithDefaults.strategy,
+        left: '0',
+        top: '0'
+      },
+      arrow: {
+        position: 'absolute'
+      }
+    },
+    attributes: {}
+  }),
+      state = _React$useState[0],
+      setState = _React$useState[1];
+
+  var updateStateModifier = React.useMemo(function () {
+    return {
+      name: 'updateState',
+      enabled: true,
+      phase: 'write',
+      fn: function fn(_ref) {
+        var state = _ref.state;
+        var elements = Object.keys(state.elements);
+        ReactDOM.flushSync(function () {
+          setState({
+            styles: (0, _utils.fromEntries)(elements.map(function (element) {
+              return [element, state.styles[element] || {}];
+            })),
+            attributes: (0, _utils.fromEntries)(elements.map(function (element) {
+              return [element, state.attributes[element]];
+            }))
+          });
+        });
+      },
+      requires: ['computeStyles']
+    };
+  }, []);
+  var popperOptions = React.useMemo(function () {
+    var newOptions = {
+      onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+      placement: optionsWithDefaults.placement,
+      strategy: optionsWithDefaults.strategy,
+      modifiers: [].concat(optionsWithDefaults.modifiers, [updateStateModifier, {
+        name: 'applyStyles',
+        enabled: false
+      }])
+    };
+
+    if ((0, _reactFastCompare["default"])(prevOptions.current, newOptions)) {
+      return prevOptions.current || newOptions;
+    } else {
+      prevOptions.current = newOptions;
+      return newOptions;
+    }
+  }, [optionsWithDefaults.onFirstUpdate, optionsWithDefaults.placement, optionsWithDefaults.strategy, optionsWithDefaults.modifiers, updateStateModifier]);
+  var popperInstanceRef = React.useRef();
+  (0, _utils.useIsomorphicLayoutEffect)(function () {
+    if (popperInstanceRef.current) {
+      popperInstanceRef.current.setOptions(popperOptions);
+    }
+  }, [popperOptions]);
+  (0, _utils.useIsomorphicLayoutEffect)(function () {
+    if (referenceElement == null || popperElement == null) {
+      return;
+    }
+
+    var createPopper = options.createPopper || _core.createPopper;
+    var popperInstance = createPopper(referenceElement, popperElement, popperOptions);
+    popperInstanceRef.current = popperInstance;
+    return function () {
+      popperInstance.destroy();
+      popperInstanceRef.current = null;
+    };
+  }, [referenceElement, popperElement, options.createPopper]);
+  return {
+    state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+    styles: state.styles,
+    attributes: state.attributes,
+    update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+    forceUpdate: popperInstanceRef.current ? popperInstanceRef.current.forceUpdate : null
+  };
+};
+
+exports.usePopper = usePopper;

node_modules/react-popper/lib/cjs/usePopper.js.flow

@@ -0,0 +1,157 @@
+// @flow strict
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import {
+  createPopper as defaultCreatePopper,
+  type Options as PopperOptions,
+  type VirtualElement,
+  type State as PopperState,
+  type Instance as PopperInstance,
+} from '@popperjs/core';
+import isEqual from 'react-fast-compare';
+import { fromEntries, useIsomorphicLayoutEffect } from './utils';
+
+type Options = $Shape<{
+  ...PopperOptions,
+  createPopper: typeof defaultCreatePopper,
+}>;
+
+type Styles = {
+  [key: string]: $Shape<CSSStyleDeclaration>,
+};
+
+type Attributes = {
+  [key: string]: { [key: string]: string },
+};
+
+type State = {
+  styles: Styles,
+  attributes: Attributes,
+};
+
+const EMPTY_MODIFIERS = [];
+
+type UsePopperResult = $ReadOnly<{
+  state: ?PopperState,
+  styles: Styles,
+  attributes: Attributes,
+  update: ?$PropertyType<PopperInstance, 'update'>,
+  forceUpdate: ?$PropertyType<PopperInstance, 'forceUpdate'>,
+}>;
+
+export const usePopper = (
+  referenceElement: ?(Element | VirtualElement),
+  popperElement: ?HTMLElement,
+  options: Options = {}
+): UsePopperResult => {
+  const prevOptions = React.useRef<?PopperOptions>(null);
+
+  const optionsWithDefaults = {
+    onFirstUpdate: options.onFirstUpdate,
+    placement: options.placement || 'bottom',
+    strategy: options.strategy || 'absolute',
+    modifiers: options.modifiers || EMPTY_MODIFIERS,
+  };
+
+  const [state, setState] = React.useState<State>({
+    styles: {
+      popper: {
+        position: optionsWithDefaults.strategy,
+        left: '0',
+        top: '0',
+      },
+      arrow: {
+        position: 'absolute',
+      },
+    },
+    attributes: {},
+  });
+
+  const updateStateModifier = React.useMemo(
+    () => ({
+      name: 'updateState',
+      enabled: true,
+      phase: 'write',
+      fn: ({ state }) => {
+        const elements = Object.keys(state.elements);
+
+        ReactDOM.flushSync(() => {
+          setState({
+            styles: fromEntries(
+              elements.map((element) => [element, state.styles[element] || {}])
+            ),
+            attributes: fromEntries(
+              elements.map((element) => [element, state.attributes[element]])
+            ),
+          });
+        });
+      },
+      requires: ['computeStyles'],
+    }),
+    []
+  );
+
+  const popperOptions = React.useMemo(() => {
+    const newOptions = {
+      onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+      placement: optionsWithDefaults.placement,
+      strategy: optionsWithDefaults.strategy,
+      modifiers: [
+        ...optionsWithDefaults.modifiers,
+        updateStateModifier,
+        { name: 'applyStyles', enabled: false },
+      ],
+    };
+
+    if (isEqual(prevOptions.current, newOptions)) {
+      return prevOptions.current || newOptions;
+    } else {
+      prevOptions.current = newOptions;
+      return newOptions;
+    }
+  }, [
+    optionsWithDefaults.onFirstUpdate,
+    optionsWithDefaults.placement,
+    optionsWithDefaults.strategy,
+    optionsWithDefaults.modifiers,
+    updateStateModifier,
+  ]);
+
+  const popperInstanceRef = React.useRef();
+
+  useIsomorphicLayoutEffect(() => {
+    if (popperInstanceRef.current) {
+      popperInstanceRef.current.setOptions(popperOptions);
+    }
+  }, [popperOptions]);
+
+  useIsomorphicLayoutEffect(() => {
+    if (referenceElement == null || popperElement == null) {
+      return;
+    }
+
+    const createPopper = options.createPopper || defaultCreatePopper;
+    const popperInstance = createPopper(
+      referenceElement,
+      popperElement,
+      popperOptions
+    );
+
+    popperInstanceRef.current = popperInstance;
+
+    return () => {
+      popperInstance.destroy();
+      popperInstanceRef.current = null;
+    };
+  }, [referenceElement, popperElement, options.createPopper]);
+
+  return {
+    state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+    styles: state.styles,
+    attributes: state.attributes,
+    update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+    forceUpdate: popperInstanceRef.current
+      ? popperInstanceRef.current.forceUpdate
+      : null,
+  };
+};

node_modules/react-popper/lib/cjs/utils.js

@@ -0,0 +1,76 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useIsomorphicLayoutEffect = exports.fromEntries = exports.setRef = exports.safeInvoke = exports.unwrapArray = void 0;
+
+var React = _interopRequireWildcard(require("react"));
+
+function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function _getRequireWildcardCache() { return cache; }; return cache; }
+
+function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+/**
+ * Takes an argument and if it's an array, returns the first item in the array,
+ * otherwise returns the argument. Used for Preact compatibility.
+ */
+var unwrapArray = function unwrapArray(arg) {
+  return Array.isArray(arg) ? arg[0] : arg;
+};
+/**
+ * Takes a maybe-undefined function and arbitrary args and invokes the function
+ * only if it is defined.
+ */
+
+
+exports.unwrapArray = unwrapArray;
+
+var safeInvoke = function safeInvoke(fn) {
+  if (typeof fn === 'function') {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return fn.apply(void 0, args);
+  }
+};
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+
+
+exports.safeInvoke = safeInvoke;
+
+var setRef = function setRef(ref, node) {
+  // if its a function call it
+  if (typeof ref === 'function') {
+    return safeInvoke(ref, node);
+  } // otherwise we should treat it as a ref object
+  else if (ref != null) {
+      ref.current = node;
+    }
+};
+/**
+ * Simple ponyfill for Object.fromEntries
+ */
+
+
+exports.setRef = setRef;
+
+var fromEntries = function fromEntries(entries) {
+  return entries.reduce(function (acc, _ref) {
+    var key = _ref[0],
+        value = _ref[1];
+    acc[key] = value;
+    return acc;
+  }, {});
+};
+/**
+ * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+ */
+
+
+exports.fromEntries = fromEntries;
+var useIsomorphicLayoutEffect = typeof window !== 'undefined' && window.document && window.document.createElement ? React.useLayoutEffect : React.useEffect;
+exports.useIsomorphicLayoutEffect = useIsomorphicLayoutEffect;

node_modules/react-popper/lib/cjs/utils.js.flow

@@ -0,0 +1,59 @@
+// @flow strict
+import * as React from 'react';
+import { type Ref } from './RefTypes';
+
+/**
+ * Takes an argument and if it's an array, returns the first item in the array,
+ * otherwise returns the argument. Used for Preact compatibility.
+ */
+export const unwrapArray = (arg: *): * => (Array.isArray(arg) ? arg[0] : arg);
+
+/**
+ * Takes a maybe-undefined function and arbitrary args and invokes the function
+ * only if it is defined.
+ */
+export const safeInvoke = <F: Function>(
+  fn: ?F,
+  ...args: Array<mixed>
+): $Call<F> => {
+  if (typeof fn === 'function') {
+    return fn(...args);
+  }
+};
+
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+export const setRef = (ref: ?Ref, node: ?HTMLElement): void => {
+  // if its a function call it
+  if (typeof ref === 'function') {
+    return safeInvoke(ref, node);
+  }
+  // otherwise we should treat it as a ref object
+  else if (ref != null) {
+    ref.current = node;
+  }
+};
+
+/**
+ * Simple ponyfill for Object.fromEntries
+ */
+export const fromEntries = (
+  entries: Array<[string, any]>
+): { [key: string]: any } =>
+  entries.reduce((acc, [key, value]) => {
+    acc[key] = value;
+    return acc;
+  }, {});
+
+/**
+ * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+ */
+export const useIsomorphicLayoutEffect:
+  | typeof React.useEffect
+  | typeof React.useLayoutEffect =
+  typeof window !== 'undefined' &&
+  window.document &&
+  window.document.createElement
+    ? React.useLayoutEffect
+    : React.useEffect;

node_modules/react-popper/lib/esm/Manager.js

@@ -0,0 +1,27 @@
+import * as React from 'react';
+export var ManagerReferenceNodeContext = React.createContext();
+export var ManagerReferenceNodeSetterContext = React.createContext();
+export function Manager(_ref) {
+  var children = _ref.children;
+
+  var _React$useState = React.useState(null),
+      referenceNode = _React$useState[0],
+      setReferenceNode = _React$useState[1];
+
+  var hasUnmounted = React.useRef(false);
+  React.useEffect(function () {
+    return function () {
+      hasUnmounted.current = true;
+    };
+  }, []);
+  var handleSetReferenceNode = React.useCallback(function (node) {
+    if (!hasUnmounted.current) {
+      setReferenceNode(node);
+    }
+  }, []);
+  return /*#__PURE__*/React.createElement(ManagerReferenceNodeContext.Provider, {
+    value: referenceNode
+  }, /*#__PURE__*/React.createElement(ManagerReferenceNodeSetterContext.Provider, {
+    value: handleSetReferenceNode
+  }, children));
+}

node_modules/react-popper/lib/esm/Popper.js

@@ -0,0 +1,76 @@
+import * as React from 'react';
+import { ManagerReferenceNodeContext } from './Manager';
+import { unwrapArray, setRef } from './utils';
+import { usePopper } from './usePopper';
+
+var NOOP = function NOOP() {
+  return void 0;
+};
+
+var NOOP_PROMISE = function NOOP_PROMISE() {
+  return Promise.resolve(null);
+};
+
+var EMPTY_MODIFIERS = [];
+export function Popper(_ref) {
+  var _ref$placement = _ref.placement,
+      placement = _ref$placement === void 0 ? 'bottom' : _ref$placement,
+      _ref$strategy = _ref.strategy,
+      strategy = _ref$strategy === void 0 ? 'absolute' : _ref$strategy,
+      _ref$modifiers = _ref.modifiers,
+      modifiers = _ref$modifiers === void 0 ? EMPTY_MODIFIERS : _ref$modifiers,
+      referenceElement = _ref.referenceElement,
+      onFirstUpdate = _ref.onFirstUpdate,
+      innerRef = _ref.innerRef,
+      children = _ref.children;
+  var referenceNode = React.useContext(ManagerReferenceNodeContext);
+
+  var _React$useState = React.useState(null),
+      popperElement = _React$useState[0],
+      setPopperElement = _React$useState[1];
+
+  var _React$useState2 = React.useState(null),
+      arrowElement = _React$useState2[0],
+      setArrowElement = _React$useState2[1];
+
+  React.useEffect(function () {
+    setRef(innerRef, popperElement);
+  }, [innerRef, popperElement]);
+  var options = React.useMemo(function () {
+    return {
+      placement: placement,
+      strategy: strategy,
+      onFirstUpdate: onFirstUpdate,
+      modifiers: [].concat(modifiers, [{
+        name: 'arrow',
+        enabled: arrowElement != null,
+        options: {
+          element: arrowElement
+        }
+      }])
+    };
+  }, [placement, strategy, onFirstUpdate, modifiers, arrowElement]);
+
+  var _usePopper = usePopper(referenceElement || referenceNode, popperElement, options),
+      state = _usePopper.state,
+      styles = _usePopper.styles,
+      forceUpdate = _usePopper.forceUpdate,
+      update = _usePopper.update;
+
+  var childrenProps = React.useMemo(function () {
+    return {
+      ref: setPopperElement,
+      style: styles.popper,
+      placement: state ? state.placement : placement,
+      hasPopperEscaped: state && state.modifiersData.hide ? state.modifiersData.hide.hasPopperEscaped : null,
+      isReferenceHidden: state && state.modifiersData.hide ? state.modifiersData.hide.isReferenceHidden : null,
+      arrowProps: {
+        style: styles.arrow,
+        ref: setArrowElement
+      },
+      forceUpdate: forceUpdate || NOOP,
+      update: update || NOOP_PROMISE
+    };
+  }, [setPopperElement, setArrowElement, placement, state, styles, update, forceUpdate]);
+  return unwrapArray(children)(childrenProps);
+}

node_modules/react-popper/lib/esm/Reference.js

@@ -0,0 +1,26 @@
+import * as React from 'react';
+import warning from 'warning';
+import { ManagerReferenceNodeSetterContext } from './Manager';
+import { safeInvoke, unwrapArray, setRef } from './utils';
+export function Reference(_ref) {
+  var children = _ref.children,
+      innerRef = _ref.innerRef;
+  var setReferenceNode = React.useContext(ManagerReferenceNodeSetterContext);
+  var refHandler = React.useCallback(function (node) {
+    setRef(innerRef, node);
+    safeInvoke(setReferenceNode, node);
+  }, [innerRef, setReferenceNode]); // ran on unmount
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+
+  React.useEffect(function () {
+    return function () {
+      return setRef(innerRef, null);
+    };
+  }, []);
+  React.useEffect(function () {
+    warning(Boolean(setReferenceNode), '`Reference` should not be used outside of a `Manager` component.');
+  }, [setReferenceNode]);
+  return unwrapArray(children)({
+    ref: refHandler
+  });
+}

node_modules/react-popper/lib/esm/__typings__/main-test.js

@@ -0,0 +1,56 @@
+function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
+
+// Please remember to update also the TypeScript test files that can
+// be found under `/typings/tests` please. Thanks! 🤗
+import * as React from 'react';
+import { Manager, Reference, Popper } from '..';
+export var Test = function Test() {
+  var _React$createElement;
+
+  return /*#__PURE__*/React.createElement(Manager, null, /*#__PURE__*/React.createElement(Reference, null), /*#__PURE__*/React.createElement(Reference, null, function (_ref) {
+    var ref = _ref.ref;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref
+    });
+  }), /*#__PURE__*/React.createElement(Popper // $FlowExpectError: should be one of allowed placements
+  , (_React$createElement = {
+    placement: "custom"
+  }, _React$createElement["placement"] = "top", _React$createElement.strategy = "custom", _React$createElement["strategy"] = "fixed", _React$createElement.modifiers = [{
+    name: 'flip',
+    enabled: 'bar',
+    order: 'foo'
+  }], _React$createElement["modifiers"] = [{
+    name: 'flip',
+    enabled: false
+  }], _React$createElement), function (_ref2) {
+    var ref = _ref2.ref,
+        style = _ref2.style,
+        placement = _ref2.placement,
+        isReferenceHidden = _ref2.isReferenceHidden,
+        hasPopperEscaped = _ref2.hasPopperEscaped,
+        update = _ref2.update,
+        arrowProps = _ref2.arrowProps;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: _extends({}, style, {
+        opacity: isReferenceHidden === true || hasPopperEscaped === true ? 0 : 1
+      }),
+      "data-placement": placement,
+      onClick: function onClick() {
+        return update();
+      }
+    }, "Popper", /*#__PURE__*/React.createElement("div", {
+      ref: arrowProps.ref,
+      style: arrowProps.style
+    }));
+  }), /*#__PURE__*/React.createElement(Popper, null, function (_ref3) {
+    var ref = _ref3.ref,
+        style = _ref3.style,
+        placement = _ref3.placement;
+    return /*#__PURE__*/React.createElement("div", {
+      ref: ref,
+      style: style,
+      "data-placement": placement
+    }, "Popper");
+  }));
+};

node_modules/react-popper/lib/esm/index.js

@@ -0,0 +1,6 @@
+// Public components
+import { Popper } from './Popper';
+import { Manager } from './Manager';
+import { Reference } from './Reference';
+import { usePopper } from './usePopper';
+export { Popper, Manager, Reference, usePopper }; // Public types

node_modules/react-popper/lib/esm/usePopper.js

@@ -0,0 +1,102 @@
+import * as React from 'react';
+import * as ReactDOM from 'react-dom';
+import { createPopper as defaultCreatePopper } from '@popperjs/core';
+import isEqual from 'react-fast-compare';
+import { fromEntries, useIsomorphicLayoutEffect } from './utils';
+var EMPTY_MODIFIERS = [];
+export var usePopper = function usePopper(referenceElement, popperElement, options) {
+  if (options === void 0) {
+    options = {};
+  }
+
+  var prevOptions = React.useRef(null);
+  var optionsWithDefaults = {
+    onFirstUpdate: options.onFirstUpdate,
+    placement: options.placement || 'bottom',
+    strategy: options.strategy || 'absolute',
+    modifiers: options.modifiers || EMPTY_MODIFIERS
+  };
+
+  var _React$useState = React.useState({
+    styles: {
+      popper: {
+        position: optionsWithDefaults.strategy,
+        left: '0',
+        top: '0'
+      },
+      arrow: {
+        position: 'absolute'
+      }
+    },
+    attributes: {}
+  }),
+      state = _React$useState[0],
+      setState = _React$useState[1];
+
+  var updateStateModifier = React.useMemo(function () {
+    return {
+      name: 'updateState',
+      enabled: true,
+      phase: 'write',
+      fn: function fn(_ref) {
+        var state = _ref.state;
+        var elements = Object.keys(state.elements);
+        ReactDOM.flushSync(function () {
+          setState({
+            styles: fromEntries(elements.map(function (element) {
+              return [element, state.styles[element] || {}];
+            })),
+            attributes: fromEntries(elements.map(function (element) {
+              return [element, state.attributes[element]];
+            }))
+          });
+        });
+      },
+      requires: ['computeStyles']
+    };
+  }, []);
+  var popperOptions = React.useMemo(function () {
+    var newOptions = {
+      onFirstUpdate: optionsWithDefaults.onFirstUpdate,
+      placement: optionsWithDefaults.placement,
+      strategy: optionsWithDefaults.strategy,
+      modifiers: [].concat(optionsWithDefaults.modifiers, [updateStateModifier, {
+        name: 'applyStyles',
+        enabled: false
+      }])
+    };
+
+    if (isEqual(prevOptions.current, newOptions)) {
+      return prevOptions.current || newOptions;
+    } else {
+      prevOptions.current = newOptions;
+      return newOptions;
+    }
+  }, [optionsWithDefaults.onFirstUpdate, optionsWithDefaults.placement, optionsWithDefaults.strategy, optionsWithDefaults.modifiers, updateStateModifier]);
+  var popperInstanceRef = React.useRef();
+  useIsomorphicLayoutEffect(function () {
+    if (popperInstanceRef.current) {
+      popperInstanceRef.current.setOptions(popperOptions);
+    }
+  }, [popperOptions]);
+  useIsomorphicLayoutEffect(function () {
+    if (referenceElement == null || popperElement == null) {
+      return;
+    }
+
+    var createPopper = options.createPopper || defaultCreatePopper;
+    var popperInstance = createPopper(referenceElement, popperElement, popperOptions);
+    popperInstanceRef.current = popperInstance;
+    return function () {
+      popperInstance.destroy();
+      popperInstanceRef.current = null;
+    };
+  }, [referenceElement, popperElement, options.createPopper]);
+  return {
+    state: popperInstanceRef.current ? popperInstanceRef.current.state : null,
+    styles: state.styles,
+    attributes: state.attributes,
+    update: popperInstanceRef.current ? popperInstanceRef.current.update : null,
+    forceUpdate: popperInstanceRef.current ? popperInstanceRef.current.forceUpdate : null
+  };
+};

node_modules/react-popper/lib/esm/utils.js

@@ -0,0 +1,53 @@
+import * as React from 'react';
+
+/**
+ * Takes an argument and if it's an array, returns the first item in the array,
+ * otherwise returns the argument. Used for Preact compatibility.
+ */
+export var unwrapArray = function unwrapArray(arg) {
+  return Array.isArray(arg) ? arg[0] : arg;
+};
+/**
+ * Takes a maybe-undefined function and arbitrary args and invokes the function
+ * only if it is defined.
+ */
+
+export var safeInvoke = function safeInvoke(fn) {
+  if (typeof fn === 'function') {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
+    return fn.apply(void 0, args);
+  }
+};
+/**
+ * Sets a ref using either a ref callback or a ref object
+ */
+
+export var setRef = function setRef(ref, node) {
+  // if its a function call it
+  if (typeof ref === 'function') {
+    return safeInvoke(ref, node);
+  } // otherwise we should treat it as a ref object
+  else if (ref != null) {
+      ref.current = node;
+    }
+};
+/**
+ * Simple ponyfill for Object.fromEntries
+ */
+
+export var fromEntries = function fromEntries(entries) {
+  return entries.reduce(function (acc, _ref) {
+    var key = _ref[0],
+        value = _ref[1];
+    acc[key] = value;
+    return acc;
+  }, {});
+};
+/**
+ * Small wrapper around `useLayoutEffect` to get rid of the warning on SSR envs
+ */
+
+export var useIsomorphicLayoutEffect = typeof window !== 'undefined' && window.document && window.document.createElement ? React.useLayoutEffect : React.useEffect;