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

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;