fix: prevent asset conflicts between React and Grid.js versions

Add coexistence checks to all enqueue methods to prevent loading
both React and Grid.js assets simultaneously.

Changes:
- ReactAdmin.php: Only enqueue React assets when ?react=1
- Init.php: Skip Grid.js when React active on admin pages
- Form.php, Coupon.php, Access.php: Restore classic assets when ?react=0
- Customer.php, Product.php, License.php: Add coexistence checks

Now the toggle between Classic and React versions works correctly.

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

node_modules/reakit/lib/Disclosure/Disclosure.js

@@ -0,0 +1,58 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var createComponent = require('reakit-system/createComponent');
+var createHook = require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+var React = require('react');
+require('reakit-utils/useForkRef');
+require('reakit-utils/isButton');
+require('reakit-warning');
+var useLiveRef = require('reakit-utils/useLiveRef');
+require('reakit-utils/isSelfTarget');
+require('reakit-utils/useIsomorphicEffect');
+require('reakit-utils/hasFocusWithin');
+require('reakit-utils/isPortalEvent');
+require('reakit-utils/dom');
+require('reakit-utils/tabbable');
+require('../Role/Role.js');
+require('../Tabbable/Tabbable.js');
+require('../Clickable/Clickable.js');
+var Button_Button = require('../Button/Button.js');
+var __keys = require('../__keys-f41a441b.js');
+
+var useDisclosure = createHook.createHook({
+  name: "Disclosure",
+  compose: Button_Button.useButton,
+  keys: __keys.DISCLOSURE_KEYS,
+  useProps: function useProps(options, _ref) {
+    var htmlOnClick = _ref.onClick,
+        ariaControls = _ref["aria-controls"],
+        htmlProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_ref, ["onClick", "aria-controls"]);
+
+    var onClickRef = useLiveRef.useLiveRef(htmlOnClick);
+    var controls = ariaControls ? ariaControls + " " + options.baseId : options.baseId;
+    var onClick = React.useCallback(function (event) {
+      var _onClickRef$current, _options$toggle;
+
+      (_onClickRef$current = onClickRef.current) === null || _onClickRef$current === void 0 ? void 0 : _onClickRef$current.call(onClickRef, event);
+      if (event.defaultPrevented) return;
+      (_options$toggle = options.toggle) === null || _options$toggle === void 0 ? void 0 : _options$toggle.call(options);
+    }, [options.toggle]);
+    return _rollupPluginBabelHelpers._objectSpread2({
+      "aria-expanded": !!options.visible,
+      "aria-controls": controls,
+      onClick: onClick
+    }, htmlProps);
+  }
+});
+var Disclosure = createComponent.createComponent({
+  as: "button",
+  memo: true,
+  useHook: useDisclosure
+});
+
+exports.Disclosure = Disclosure;
+exports.useDisclosure = useDisclosure;

node_modules/reakit/lib/Disclosure/DisclosureContent.js

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var createComponent = require('reakit-system/createComponent');
+var createHook = require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+var React = require('react');
+var useLiveRef = require('reakit-utils/useLiveRef');
+var isSelfTarget = require('reakit-utils/isSelfTarget');
+var Role_Role = require('../Role/Role.js');
+var __keys = require('../__keys-f41a441b.js');
+
+var useDisclosureContent = createHook.createHook({
+  name: "DisclosureContent",
+  compose: Role_Role.useRole,
+  keys: __keys.DISCLOSURE_CONTENT_KEYS,
+  useProps: function useProps(options, _ref) {
+    var htmlOnTransitionEnd = _ref.onTransitionEnd,
+        htmlOnAnimationEnd = _ref.onAnimationEnd,
+        htmlStyle = _ref.style,
+        htmlProps = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_ref, ["onTransitionEnd", "onAnimationEnd", "style"]);
+
+    var animating = options.animated && options.animating;
+
+    var _React$useState = React.useState(null),
+        transition = _React$useState[0],
+        setTransition = _React$useState[1];
+
+    var hidden = !options.visible && !animating;
+    var style = hidden ? _rollupPluginBabelHelpers._objectSpread2({
+      display: "none"
+    }, htmlStyle) : htmlStyle;
+    var onTransitionEndRef = useLiveRef.useLiveRef(htmlOnTransitionEnd);
+    var onAnimationEndRef = useLiveRef.useLiveRef(htmlOnAnimationEnd);
+    var raf = React.useRef(0);
+    React.useEffect(function () {
+      if (!options.animated) return undefined; // Double RAF is needed so the browser has enough time to paint the
+      // default styles before processing the `data-enter` attribute. Otherwise
+      // it wouldn't be considered a transition.
+      // See https://github.com/reakit/reakit/issues/643
+
+      raf.current = window.requestAnimationFrame(function () {
+        raf.current = window.requestAnimationFrame(function () {
+          if (options.visible) {
+            setTransition("enter");
+          } else if (animating) {
+            setTransition("leave");
+          } else {
+            setTransition(null);
+          }
+        });
+      });
+      return function () {
+        return window.cancelAnimationFrame(raf.current);
+      };
+    }, [options.animated, options.visible, animating]);
+    var onEnd = React.useCallback(function (event) {
+      if (!isSelfTarget.isSelfTarget(event)) return;
+      if (!animating) return; // Ignores number animated
+
+      if (options.animated === true) {
+        var _options$stopAnimatio;
+
+        (_options$stopAnimatio = options.stopAnimation) === null || _options$stopAnimatio === void 0 ? void 0 : _options$stopAnimatio.call(options);
+      }
+    }, [options.animated, animating, options.stopAnimation]);
+    var onTransitionEnd = React.useCallback(function (event) {
+      var _onTransitionEndRef$c;
+
+      (_onTransitionEndRef$c = onTransitionEndRef.current) === null || _onTransitionEndRef$c === void 0 ? void 0 : _onTransitionEndRef$c.call(onTransitionEndRef, event);
+      onEnd(event);
+    }, [onEnd]);
+    var onAnimationEnd = React.useCallback(function (event) {
+      var _onAnimationEndRef$cu;
+
+      (_onAnimationEndRef$cu = onAnimationEndRef.current) === null || _onAnimationEndRef$cu === void 0 ? void 0 : _onAnimationEndRef$cu.call(onAnimationEndRef, event);
+      onEnd(event);
+    }, [onEnd]);
+    return _rollupPluginBabelHelpers._objectSpread2({
+      id: options.baseId,
+      "data-enter": transition === "enter" ? "" : undefined,
+      "data-leave": transition === "leave" ? "" : undefined,
+      onTransitionEnd: onTransitionEnd,
+      onAnimationEnd: onAnimationEnd,
+      hidden: hidden,
+      style: style
+    }, htmlProps);
+  }
+});
+var DisclosureContent = createComponent.createComponent({
+  as: "div",
+  useHook: useDisclosureContent
+});
+
+exports.DisclosureContent = DisclosureContent;
+exports.useDisclosureContent = useDisclosureContent;

node_modules/reakit/lib/Disclosure/DisclosureState.js

@@ -0,0 +1,104 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _rollupPluginBabelHelpers = require('../_rollupPluginBabelHelpers-8f9a8751.js');
+var React = require('react');
+var reakitWarning = require('reakit-warning');
+var useIsomorphicEffect = require('reakit-utils/useIsomorphicEffect');
+var useSealedState = require('reakit-utils/useSealedState');
+require('../Id/IdProvider.js');
+var Id_IdState = require('../Id/IdState.js');
+
+function useLastValue(value) {
+  var lastValue = React.useRef(null);
+  useIsomorphicEffect.useIsomorphicEffect(function () {
+    lastValue.current = value;
+  }, [value]);
+  return lastValue;
+}
+
+function useDisclosureState(initialState) {
+  if (initialState === void 0) {
+    initialState = {};
+  }
+
+  var _useSealedState = useSealedState.useSealedState(initialState),
+      _useSealedState$visib = _useSealedState.visible,
+      initialVisible = _useSealedState$visib === void 0 ? false : _useSealedState$visib,
+      _useSealedState$anima = _useSealedState.animated,
+      initialAnimated = _useSealedState$anima === void 0 ? false : _useSealedState$anima,
+      sealed = _rollupPluginBabelHelpers._objectWithoutPropertiesLoose(_useSealedState, ["visible", "animated"]);
+
+  var id = Id_IdState.unstable_useIdState(sealed);
+
+  var _React$useState = React.useState(initialVisible),
+      visible = _React$useState[0],
+      setVisible = _React$useState[1];
+
+  var _React$useState2 = React.useState(initialAnimated),
+      animated = _React$useState2[0],
+      setAnimated = _React$useState2[1];
+
+  var _React$useState3 = React.useState(false),
+      animating = _React$useState3[0],
+      setAnimating = _React$useState3[1];
+
+  var lastVisible = useLastValue(visible);
+  var visibleHasChanged = lastVisible.current != null && lastVisible.current !== visible;
+
+  if (animated && !animating && visibleHasChanged) {
+    // Sets animating to true when when visible is updated
+    setAnimating(true);
+  }
+
+  React.useEffect(function () {
+    if (typeof animated === "number" && animating) {
+      var timeout = setTimeout(function () {
+        return setAnimating(false);
+      }, animated);
+      return function () {
+        clearTimeout(timeout);
+      };
+    }
+
+    if (animated && animating && process.env.NODE_ENV === "development") {
+      var _timeout = setTimeout(function () {
+        process.env.NODE_ENV !== "production" ? reakitWarning.warning(animating, "It's been 8 seconds but stopAnimation has not been called. Does the disclousure element have a CSS transition?") : void 0;
+      }, 8000);
+
+      return function () {
+        clearTimeout(_timeout);
+      };
+    }
+
+    return function () {};
+  }, [animated, animating]);
+  var show = React.useCallback(function () {
+    return setVisible(true);
+  }, []);
+  var hide = React.useCallback(function () {
+    return setVisible(false);
+  }, []);
+  var toggle = React.useCallback(function () {
+    return setVisible(function (v) {
+      return !v;
+    });
+  }, []);
+  var stopAnimation = React.useCallback(function () {
+    return setAnimating(false);
+  }, []);
+  return _rollupPluginBabelHelpers._objectSpread2(_rollupPluginBabelHelpers._objectSpread2({}, id), {}, {
+    visible: visible,
+    animated: animated,
+    animating: animating,
+    show: show,
+    hide: hide,
+    toggle: toggle,
+    setVisible: setVisible,
+    setAnimated: setAnimated,
+    stopAnimation: stopAnimation
+  });
+}
+
+exports.useDisclosureState = useDisclosureState;

node_modules/reakit/lib/Disclosure/index.js

@@ -0,0 +1,38 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('../_rollupPluginBabelHelpers-8f9a8751.js');
+require('reakit-system/createComponent');
+require('reakit-system/createHook');
+require('reakit-utils/shallowEqual');
+require('react');
+require('reakit-utils/useForkRef');
+require('reakit-utils/isButton');
+require('reakit-warning');
+require('reakit-utils/useLiveRef');
+require('reakit-utils/isSelfTarget');
+require('reakit-utils/useIsomorphicEffect');
+require('reakit-utils/hasFocusWithin');
+require('reakit-utils/isPortalEvent');
+require('reakit-utils/dom');
+require('reakit-utils/tabbable');
+require('../Role/Role.js');
+require('../Tabbable/Tabbable.js');
+require('../Clickable/Clickable.js');
+require('../Button/Button.js');
+require('reakit-utils/useSealedState');
+require('../Id/IdProvider.js');
+require('../Id/IdState.js');
+var Disclosure_DisclosureState = require('./DisclosureState.js');
+require('../__keys-f41a441b.js');
+var Disclosure_DisclosureContent = require('./DisclosureContent.js');
+var Disclosure_Disclosure = require('./Disclosure.js');
+
+
+
+exports.useDisclosureState = Disclosure_DisclosureState.useDisclosureState;
+exports.DisclosureContent = Disclosure_DisclosureContent.DisclosureContent;
+exports.useDisclosureContent = Disclosure_DisclosureContent.useDisclosureContent;
+exports.Disclosure = Disclosure_Disclosure.Disclosure;
+exports.useDisclosure = Disclosure_Disclosure.useDisclosure;