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/use-memo-one/dist/use-memo-one.cjs.js

@@ -0,0 +1,52 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var react = require('react');
+
+function areInputsEqual(newInputs, lastInputs) {
+  if (newInputs.length !== lastInputs.length) {
+    return false;
+  }
+
+  for (var i = 0; i < newInputs.length; i++) {
+    if (newInputs[i] !== lastInputs[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function useMemoOne(getResult, inputs) {
+  var initial = react.useState(function () {
+    return {
+      inputs: inputs,
+      result: getResult()
+    };
+  })[0];
+  var isFirstRun = react.useRef(true);
+  var committed = react.useRef(initial);
+  var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));
+  var cache = useCache ? committed.current : {
+    inputs: inputs,
+    result: getResult()
+  };
+  react.useEffect(function () {
+    isFirstRun.current = false;
+    committed.current = cache;
+  }, [cache]);
+  return cache.result;
+}
+function useCallbackOne(callback, inputs) {
+  return useMemoOne(function () {
+    return callback;
+  }, inputs);
+}
+var useMemo = useMemoOne;
+var useCallback = useCallbackOne;
+
+exports.useCallback = useCallback;
+exports.useCallbackOne = useCallbackOne;
+exports.useMemo = useMemo;
+exports.useMemoOne = useMemoOne;

node_modules/use-memo-one/dist/use-memo-one.cjs.js.flow

@@ -0,0 +1,3 @@
+// @flow
+
+export * from '../src';

node_modules/use-memo-one/dist/use-memo-one.esm.js

@@ -0,0 +1,45 @@
+import { useState, useRef, useEffect } from 'react';
+
+function areInputsEqual(newInputs, lastInputs) {
+  if (newInputs.length !== lastInputs.length) {
+    return false;
+  }
+
+  for (var i = 0; i < newInputs.length; i++) {
+    if (newInputs[i] !== lastInputs[i]) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function useMemoOne(getResult, inputs) {
+  var initial = useState(function () {
+    return {
+      inputs: inputs,
+      result: getResult()
+    };
+  })[0];
+  var isFirstRun = useRef(true);
+  var committed = useRef(initial);
+  var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));
+  var cache = useCache ? committed.current : {
+    inputs: inputs,
+    result: getResult()
+  };
+  useEffect(function () {
+    isFirstRun.current = false;
+    committed.current = cache;
+  }, [cache]);
+  return cache.result;
+}
+function useCallbackOne(callback, inputs) {
+  return useMemoOne(function () {
+    return callback;
+  }, inputs);
+}
+var useMemo = useMemoOne;
+var useCallback = useCallbackOne;
+
+export { useCallback, useCallbackOne, useMemo, useMemoOne };

node_modules/use-memo-one/dist/use-memo-one.js

@@ -0,0 +1,56 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
+  (global = global || self, factory(global.useMemoOne = {}, global.React));
+}(this, function (exports, react) { 'use strict';
+
+  function areInputsEqual(newInputs, lastInputs) {
+    if (newInputs.length !== lastInputs.length) {
+      return false;
+    }
+
+    for (var i = 0; i < newInputs.length; i++) {
+      if (newInputs[i] !== lastInputs[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  function useMemoOne(getResult, inputs) {
+    var initial = react.useState(function () {
+      return {
+        inputs: inputs,
+        result: getResult()
+      };
+    })[0];
+    var isFirstRun = react.useRef(true);
+    var committed = react.useRef(initial);
+    var useCache = isFirstRun.current || Boolean(inputs && committed.current.inputs && areInputsEqual(inputs, committed.current.inputs));
+    var cache = useCache ? committed.current : {
+      inputs: inputs,
+      result: getResult()
+    };
+    react.useEffect(function () {
+      isFirstRun.current = false;
+      committed.current = cache;
+    }, [cache]);
+    return cache.result;
+  }
+  function useCallbackOne(callback, inputs) {
+    return useMemoOne(function () {
+      return callback;
+    }, inputs);
+  }
+  var useMemo = useMemoOne;
+  var useCallback = useCallbackOne;
+
+  exports.useCallback = useCallback;
+  exports.useCallbackOne = useCallbackOne;
+  exports.useMemo = useMemo;
+  exports.useMemoOne = useMemoOne;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

node_modules/use-memo-one/dist/use-memo-one.min.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("react")):"function"==typeof define&&define.amd?define(["exports","react"],t):t((e=e||self).useMemoOne={},e.React)}(this,function(e,o){"use strict";function n(e,t){var n=o.useState(function(){return{inputs:t,result:e()}})[0],u=o.useRef(!0),r=o.useRef(n),f=u.current||Boolean(t&&r.current.inputs&&function(e,t){if(e.length!==t.length)return!1;for(var n=0;n<e.length;n++)if(e[n]!==t[n])return!1;return!0}(t,r.current.inputs))?r.current:{inputs:t,result:e()};return o.useEffect(function(){u.current=!1,r.current=f},[f]),f.result}function t(e,t){return n(function(){return e},t)}var u=n,r=t;e.useCallback=r,e.useCallbackOne=t,e.useMemo=u,e.useMemoOne=n,Object.defineProperty(e,"__esModule",{value:!0})});