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/proxy-compare/dist/src/index.d.ts

@@ -0,0 +1,129 @@
+declare let newProxy: <T extends object>(target: T, handler: ProxyHandler<T>) => T;
+/**
+ * Create a proxy.
+ *
+ * This function will create a proxy at top level and proxy nested objects as you access them,
+ * in order to keep track of which properties were accessed via get/has proxy handlers:
+ *
+ * NOTE: Printing of WeakMap is hard to inspect and not very readable
+ * for this purpose you can use the `affectedToPathList` helper.
+ *
+ * @param {object} obj - Object that will be wrapped on the proxy.
+ * @param {WeakMap<object, unknown>} affected -
+ * WeakMap that will hold the tracking of which properties in the proxied object were accessed.
+ * @param {WeakMap<object, unknown>} [proxyCache] -
+ * WeakMap that will help keep referential identity for proxies.
+ * @returns {Proxy<object>} - Object wrapped in a proxy.
+ *
+ * @example
+ * import { createProxy } from 'proxy-compare';
+ *
+ * const original = { a: "1", c: "2", d: { e: "3" } };
+ * const affected = new WeakMap();
+ * const proxy = createProxy(original, affected);
+ *
+ * proxy.a // Will mark as used and track its value.
+ * // This will update the affected WeakMap with original as key
+ * // and a Set with "a"
+ *
+ * proxy.d // Will mark "d" as accessed to track and proxy itself ({ e: "3" }).
+ * // This will update the affected WeakMap with original as key
+ * // and a Set with "d"
+ */
+export declare const createProxy: <T>(obj: T, affected: WeakMap<object, unknown>, proxyCache?: WeakMap<object, unknown>) => T;
+/**
+ * Compare changes on objects.
+ *
+ * This will compare the affected properties on tracked objects inside the proxy
+ * to check if there were any changes made to it,
+ * by default if no property was accessed on the proxy it will attempt to do a
+ * reference equality check for the objects provided (Object.is(a, b)). If you access a property
+ * on the proxy, then isChanged will only compare the affected properties.
+ *
+ * @param {object} prevObj - The previous object to compare.
+ * @param {object} nextObj - Object to compare with the previous one.
+ * @param {WeakMap<object, unknown>} affected -
+ * WeakMap that holds the tracking of which properties in the proxied object were accessed.
+ * @param {WeakMap<object, unknown>} [cache] -
+ * WeakMap that holds a cache of the comparisons for better performance with repetitive comparisons,
+ * and to avoid infinite loop with circular structures.
+ * @returns {boolean} - Boolean indicating if the affected property on the object has changed.
+ *
+ * @example
+ * import { createProxy, isChanged } from 'proxy-compare';
+ *
+ * const obj = { a: "1", c: "2", d: { e: "3" } };
+ * const affected = new WeakMap();
+ *
+ * const proxy = createProxy(obj, affected);
+ *
+ * proxy.a
+ *
+ * isChanged(obj, { a: "1" }, affected) // false
+ *
+ * proxy.a = "2"
+ *
+ * isChanged(obj, { a: "1" }, affected) // true
+ */
+export declare const isChanged: (prevObj: unknown, nextObj: unknown, affected: WeakMap<object, unknown>, cache?: WeakMap<object, unknown>) => boolean;
+export declare const trackMemo: (obj: unknown) => boolean;
+/**
+ * Unwrap proxy to get the original object.
+ *
+ * Used to retrieve the original object used to create the proxy instance with `createProxy`.
+ *
+ * @param {Proxy<object>} obj -  The proxy wrapper of the originial object.
+ * @returns {object | null} - Return either the unwrapped object if exists.
+ *
+ * @example
+ * import { createProxy, getUntracked } from 'proxy-compare';
+ *
+ * const original = { a: "1", c: "2", d: { e: "3" } };
+ * const affected = new WeakMap();
+ *
+ * const proxy = createProxy(original, affected);
+ * const originalFromProxy = getUntracked(proxy)
+ *
+ * Object.is(original, originalFromProxy) // true
+ * isChanged(original, originalFromProxy, affected) // false
+ */
+export declare const getUntracked: <T>(obj: T) => T | null;
+/**
+ * Mark object to be tracked.
+ *
+ * This function marks an object that will be passed into `createProxy`
+ * as marked to track or not. By default only Array and Object are marked to track,
+ * so this is useful for example to mark a class instance to track or to mark a object
+ * to be untracked when creating your proxy.
+ *
+ * @param obj - Object to mark as tracked or not.
+ * @param mark - Boolean indicating whether you want to track this object or not.
+ * @returns No return.
+ *
+ * @example
+ * import { createProxy, markToTrack, isChanged } from 'proxy-compare';
+ *
+ * const nested = { e: "3" }
+ *
+ * markToTrack(nested, false)
+ *
+ * const original = { a: "1", c: "2", d: nested };
+ * const affected = new WeakMap();
+ *
+ * const proxy = createProxy(original, affected);
+ *
+ * proxy.d.e
+ *
+ * isChanged(original, { d: { e: "3" } }, affected) // true
+ */
+export declare const markToTrack: (obj: object, mark?: boolean) => void;
+export declare const affectedToPathList: (obj: unknown, affected: WeakMap<object, unknown>) => (string | symbol)[][];
+/**
+ * replace newProxy function.
+ *
+ * This can be used if you want to use proxy-polyfill.
+ * Note that proxy-polyfill can't polyfill everything.
+ * Use it at your own risk.
+ */
+export declare const replaceNewProxy: (fn: typeof newProxy) => void;
+export {};