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/rungen/src/controls/async.js

@@ -0,0 +1,89 @@
+import is from '../utils/is'
+import {error} from '../utils/helpers'
+import createDispatcher from '../utils/dispatcher'
+
+export const promise = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.promise(value)) return false
+  value.then(next, raiseNext)
+  return true
+}
+
+const forkedTasks = new Map()
+export const fork = (value, next, rungen) => {
+  if (!is.fork(value)) return false
+  const task = Symbol('fork')
+  const dispatcher = createDispatcher()
+  forkedTasks.set(task, dispatcher)
+  rungen(
+    value.iterator.apply(null, value.args),
+    result => dispatcher.dispatch(result),
+    err => dispatcher.dispatch(error(err))
+  )
+  const unsubscribe = dispatcher.subscribe(() => {
+    unsubscribe()
+    forkedTasks.delete(task)
+  })
+  next(task)
+  return true
+}
+
+export const join = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.join(value)) return false
+  const dispatcher = forkedTasks.get(value.task)
+  if (!dispatcher) {
+    raiseNext('join error : task not found')
+  } else {
+    const unsubscribe = dispatcher.subscribe(result => {
+      unsubscribe()
+      next(result)
+    })
+  }
+  return true
+}
+
+export const race = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.race(value)) return false
+  let finished = false
+  const success = (result, k, v) => {
+    if (finished) return
+    finished = true
+    result[k] = v
+    next(result)
+  }
+
+  const fail = err => {
+    if (finished) return
+    raiseNext(err)
+  }
+  if (is.array(value.competitors)) {
+    const result = value.competitors.map(() => false)
+    value.competitors.forEach((competitor, index) => {
+      rungen(competitor, output => success(result, index, output), fail)
+    })
+  }
+  else {
+    const result = Object.keys(value.competitors).reduce((p, c) => {
+      p[c] = false
+      return p
+    }, {})
+    Object.keys(value.competitors).forEach(index => {
+      rungen(value.competitors[index], output => success(result, index, output), fail)
+    })
+  }
+  return true
+}
+
+const subscribe = (value, next) => {
+  if (!is.subscribe(value)) return false
+  if (!is.channel(value.channel)) {
+    throw new Error('the first argument of "subscribe" must be a valid channel')
+  }
+  const unsubscribe = value.channel.subscribe(ret => {
+    unsubscribe && unsubscribe()
+    next(ret)
+  })
+
+  return true
+}
+
+export default [promise, fork, join, race, subscribe]

node_modules/rungen/src/controls/builtin.js

@@ -0,0 +1,83 @@
+import is from '../utils/is'
+
+export const any = (value, next, rungen, yieldNext) => {
+  yieldNext(value)
+  return true
+}
+
+export const error = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.error(value)) return false
+  raiseNext(value.error)
+  return true
+}
+
+export const object = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.all(value) || !is.obj(value.value)) return false
+  const result = {}
+  const keys = Object.keys(value.value)
+  let count = 0
+  let hasError = false
+  const gotResultSuccess = (key, ret) => {
+    if (hasError) return
+    result[key] = ret
+    count++
+    if (count === keys.length) {
+      yieldNext(result)
+    }
+  }
+
+  const gotResultError = (key, error) => {
+    if (hasError) return
+    hasError = true
+    raiseNext(error)
+  }
+
+  keys.map(key => {
+    rungen(
+      value.value[key],
+      ret => gotResultSuccess(key, ret),
+      err => gotResultError(key, err)
+    )
+  })
+
+  return true
+}
+
+export const array = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.all(value) || !is.array(value.value)) return false
+  const result = []
+  let count = 0
+  let hasError = false
+  const gotResultSuccess = (key, ret) => {
+    if (hasError) return
+    result[key] = ret
+    count++
+    if (count === value.value.length) {
+      yieldNext(result)
+    }
+  }
+
+  const gotResultError = (key, error) => {
+    if (hasError) return
+    hasError = true
+    raiseNext(error)
+  }
+
+  value.value.map((v, key) => {
+    rungen(
+      v,
+      ret => gotResultSuccess(key, ret),
+      err => gotResultError(key, err)
+    )
+  })
+
+  return true
+}
+
+export const iterator = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.iterator(value)) return false
+  rungen(value, next, raiseNext)
+  return true
+}
+
+export default [error, iterator, array, object, any]

node_modules/rungen/src/controls/wrap.js

@@ -0,0 +1,22 @@
+import is from '../utils/is'
+
+export const call = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.call(value)) return false
+  try {
+    next(value.func.apply(value.context, value.args))
+  } catch (err) {
+    raiseNext(err)
+  }
+  return true
+}
+
+export const cps = (value, next, rungen, yieldNext, raiseNext) => {
+  if (!is.cps(value)) return false
+  value.func.call(null, ...value.args, (err, result) => {
+    if (err) raiseNext(err)
+    else next(result)
+  })
+  return true
+}
+
+export default [call, cps]