@lynx-js/react 0.110.1 → 0.111.1

package/refresh/dist/index.js

@@ -1,311 +1,250 @@
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/catchError.js
-import { options } from "@lynx-js/react/internal";
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/constants.js
-var VNODE_COMPONENT = "__c";
-var NAMESPACE = "__PREFRESH__";
-var COMPONENT_HOOKS = "__H";
-var HOOKS_LIST = "__";
-var EFFECTS_LIST = "__h";
-var RERENDER_COUNT = "__r";
-var CATCH_ERROR_OPTION = "__e";
-var COMPONENT_DIRTY = "__d";
-var HOOK_VALUE = "__";
-var HOOK_ARGS = "__H";
-var HOOK_CLEANUP = "__c";
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/catchError.js
-var oldCatchError = options[CATCH_ERROR_OPTION];
-options[CATCH_ERROR_OPTION] = (error, vnode, oldVNode) => {
-  if (vnode[VNODE_COMPONENT] && vnode[VNODE_COMPONENT][COMPONENT_DIRTY]) {
-    vnode[VNODE_COMPONENT][COMPONENT_DIRTY] = false;
-  }
-  if (oldCatchError) oldCatchError(error, vnode, oldVNode);
+import { Component, options } from "@lynx-js/react/internal";
+const VNODE_COMPONENT = '__c';
+const NAMESPACE = '__PREFRESH__';
+const COMPONENT_HOOKS = '__H';
+const HOOKS_LIST = '__';
+const EFFECTS_LIST = '__h';
+const RERENDER_COUNT = '__r';
+const CATCH_ERROR_OPTION = '__e';
+const COMPONENT_DIRTY = '__d';
+const HOOK_VALUE = '__';
+const HOOK_ARGS = '__H';
+const HOOK_CLEANUP = '__c';
+const oldCatchError = options[CATCH_ERROR_OPTION];
+options[CATCH_ERROR_OPTION] = (error, vnode, oldVNode)=>{
+    if (vnode[VNODE_COMPONENT] && vnode[VNODE_COMPONENT][COMPONENT_DIRTY]) vnode[VNODE_COMPONENT][COMPONENT_DIRTY] = false;
+    if (oldCatchError) oldCatchError(error, vnode, oldVNode);
 };
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/debounceRendering.js
-import { options as options2 } from "@lynx-js/react/internal";
-var defer = typeof Promise == "function" ? Promise.prototype.then.bind(Promise.resolve()) : setTimeout;
-options2.debounceRendering = (process) => {
-  defer(() => {
-    try {
-      process();
-    } catch (e) {
-      process[RERENDER_COUNT] = 0;
-      throw e;
-    }
-  });
-};
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/vnode.js
-import { options as options3 } from "@lynx-js/react/internal";
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/vnodesForComponent.js
-var vnodesForComponent = /* @__PURE__ */ new WeakMap();
-var mappedVNodes = /* @__PURE__ */ new WeakMap();
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/vnode.js
-var getMappedVnode = (type) => {
-  if (mappedVNodes.has(type)) {
-    return getMappedVnode(mappedVNodes.get(type));
-  }
-  return type;
+const defer = 'function' == typeof Promise ? Promise.prototype.then.bind(Promise.resolve()) : setTimeout;
+options.debounceRendering = (process)=>{
+    defer(()=>{
+        try {
+            process();
+        } catch (e) {
+            process[RERENDER_COUNT] = 0;
+            throw e;
+        }
+    });
 };
-var BUILT_IN_COMPONENTS = ["Fragment", "Suspense", "SuspenseList"];
-var isBuiltIn = (type) => {
-  return BUILT_IN_COMPONENTS.includes(type.name);
+const vnodesForComponent = new WeakMap();
+const mappedVNodes = new WeakMap();
+const lastSeen = new Map();
+const getMappedVnode = (type)=>{
+    if (mappedVNodes.has(type)) return getMappedVnode(mappedVNodes.get(type));
+    return type;
 };
-var oldVnode = options3.vnode;
-options3.vnode = (vnode) => {
-  if (vnode && typeof vnode.type === "function" && !isBuiltIn(vnode.type)) {
-    const vnodes = vnodesForComponent.get(vnode.type);
-    if (!vnodes) {
-      vnodesForComponent.set(vnode.type, [vnode]);
-    } else {
-      vnodes.push(vnode);
-    }
-    const foundType = getMappedVnode(vnode.type);
-    if (foundType !== vnode.type) {
-      const vnodes2 = vnodesForComponent.get(foundType);
-      if (!vnodes2) {
-        vnodesForComponent.set(foundType, [vnode]);
-      } else {
-        vnodes2.push(vnode);
-      }
-    }
-    vnode.type = foundType;
-    if (vnode[VNODE_COMPONENT] && "prototype" in vnode.type && vnode.type.prototype.render) {
-      vnode[VNODE_COMPONENT].constructor = vnode.type;
+const BUILT_IN_COMPONENTS = [
+    'Fragment',
+    'Suspense',
+    'SuspenseList'
+];
+const isBuiltIn = (type)=>BUILT_IN_COMPONENTS.includes(type.name);
+const oldVnode = options.vnode;
+options.vnode = (vnode)=>{
+    if (vnode && 'function' == typeof vnode.type && !isBuiltIn(vnode.type)) {
+        const vnodes = vnodesForComponent.get(vnode.type);
+        if (vnodes) vnodes.push(vnode);
+        else vnodesForComponent.set(vnode.type, [
+            vnode
+        ]);
+        const foundType = getMappedVnode(vnode.type);
+        if (foundType !== vnode.type) {
+            const vnodes = vnodesForComponent.get(foundType);
+            if (vnodes) vnodes.push(vnode);
+            else vnodesForComponent.set(foundType, [
+                vnode
+            ]);
+        }
+        vnode.type = foundType;
+        if (vnode[VNODE_COMPONENT] && 'prototype' in vnode.type && vnode.type.prototype.render) vnode[VNODE_COMPONENT].constructor = vnode.type;
     }
-  }
-  if (oldVnode) oldVnode(vnode);
+    if (oldVnode) oldVnode(vnode);
 };
-var oldDiffed = options3.diffed;
-options3.diffed = (vnode) => {
-  if (vnode && typeof vnode.type === "function") {
-    const vnodes = vnodesForComponent.get(vnode.type);
-    if (vnodes) {
-      const matchingDom = vnodes.filter((p) => p.__c === vnode.__c);
-      if (matchingDom.length > 1) {
-        const i = vnodes.findIndex((p) => p === matchingDom[0]);
-        vnodes.splice(i, 1);
-      }
+const oldDiffed = options.diffed;
+options.diffed = (vnode)=>{
+    if (vnode && 'function' == typeof vnode.type) {
+        const vnodes = vnodesForComponent.get(vnode.type);
+        lastSeen.set(vnode.__v, vnode);
+        if (vnodes) {
+            const matchingDom = vnodes.filter((p)=>p.__c === vnode.__c);
+            if (matchingDom.length > 1) {
+                const i = vnodes.findIndex((p)=>p === matchingDom[0]);
+                vnodes.splice(i, 1);
+            }
+        }
     }
-  }
-  if (oldDiffed) oldDiffed(vnode);
+    if (oldDiffed) oldDiffed(vnode);
 };
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/unmount.js
-import { options as options4 } from "@lynx-js/react/internal";
-var oldUnmount = options4.unmount;
-options4.unmount = (vnode) => {
-  const type = (vnode || {}).type;
-  if (typeof type === "function" && vnodesForComponent.has(type)) {
-    const vnodes = vnodesForComponent.get(type);
-    if (vnodes) {
-      const index = vnodes.indexOf(vnode);
-      if (index !== -1) {
-        vnodes.splice(index, 1);
-      }
+const oldUnmount = options.unmount;
+options.unmount = (vnode)=>{
+    const type = (vnode || {}).type;
+    if ('function' == typeof type && vnodesForComponent.has(type)) {
+        const vnodes = vnodesForComponent.get(type);
+        if (vnodes) {
+            const index = vnodes.indexOf(vnode);
+            if (-1 !== index) vnodes.splice(index, 1);
+        }
     }
-  }
-  if (oldUnmount) oldUnmount(vnode);
+    if (oldUnmount) oldUnmount(vnode);
 };
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/index.js
-import { Component } from "@lynx-js/react/internal";
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/runtime/signaturesForType.js
-var signaturesForType = /* @__PURE__ */ new WeakMap();
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/computeKey.js
-var computeKey = (signature) => {
-  let fullKey = signature.key;
-  let hooks;
-  try {
-    hooks = signature.getCustomHooks();
-  } catch (err) {
-    signature.forceReset = true;
-    return fullKey;
-  }
-  for (let i = 0; i < hooks.length; i++) {
-    const hook = hooks[i];
-    if (typeof hook !== "function") {
-      signature.forceReset = true;
-      return fullKey;
+const signaturesForType = new WeakMap();
+const computeKey = (signature)=>{
+    let fullKey = signature.key;
+    let hooks;
+    try {
+        hooks = signature.getCustomHooks();
+    } catch (err) {
+        signature.forceReset = true;
+        return fullKey;
+    }
+    for(let i = 0; i < hooks.length; i++){
+        const hook = hooks[i];
+        if ('function' != typeof hook) {
+            signature.forceReset = true;
+            break;
+        }
+        const nestedHookSignature = signaturesForType.get(hook);
+        if (void 0 === nestedHookSignature) continue;
+        const nestedHookKey = computeKey(nestedHookSignature);
+        if (nestedHookSignature.forceReset) signature.forceReset = true;
+        fullKey += '\n---\n' + nestedHookKey;
     }
-    const nestedHookSignature = signaturesForType.get(hook);
-    if (nestedHookSignature === void 0) continue;
-    const nestedHookKey = computeKey(nestedHookSignature);
-    if (nestedHookSignature.forceReset) signature.forceReset = true;
-    fullKey += "\n---\n" + nestedHookKey;
-  }
-  return fullKey;
+    return fullKey;
 };
-
-// ../../../node_modules/.pnpm/@prefresh+core@1.5.3_preact@10.23.2/node_modules/@prefresh/core/src/index.js
-var typesById = /* @__PURE__ */ new Map();
-var pendingUpdates = [];
+let typesById = new Map();
+let pendingUpdates = [];
 function sign(type, key, forceReset, getCustomHooks, status) {
-  if (type) {
-    let signature = signaturesForType.get(type);
-    if (status === "begin") {
-      signaturesForType.set(type, {
-        type,
-        key,
-        forceReset,
-        getCustomHooks: getCustomHooks || (() => [])
-      });
-      return "needsHooks";
-    } else if (status === "needsHooks") {
-      signature.fullKey = computeKey(signature);
+    if (type) {
+        let signature = signaturesForType.get(type);
+        if ('begin' === status) {
+            signaturesForType.set(type, {
+                type,
+                key,
+                forceReset,
+                getCustomHooks: getCustomHooks || (()=>[])
+            });
+            return 'needsHooks';
+        }
+        if ('needsHooks' === status) signature.fullKey = computeKey(signature);
     }
-  }
 }
 function replaceComponent(OldType, NewType, resetHookState) {
-  const vnodes = vnodesForComponent.get(OldType);
-  if (!vnodes) return;
-  vnodesForComponent.delete(OldType);
-  vnodesForComponent.set(NewType, vnodes);
-  mappedVNodes.set(OldType, NewType);
-  pendingUpdates = pendingUpdates.filter((p) => p[0] !== OldType);
-  vnodes.forEach((vnode) => {
-    if (!vnode.__c || !vnode.__c.__P) return;
-    vnode.type = NewType;
-    if (vnode[VNODE_COMPONENT]) {
-      vnode[VNODE_COMPONENT].constructor = vnode.type;
-      try {
-        if (vnode[VNODE_COMPONENT] instanceof OldType) {
-          const oldInst = vnode[VNODE_COMPONENT];
-          const newInst = new NewType(
-            vnode[VNODE_COMPONENT].props,
-            vnode[VNODE_COMPONENT].context
-          );
-          vnode[VNODE_COMPONENT] = newInst;
-          for (let i in oldInst) {
-            const type = typeof oldInst[i];
-            if (!(i in newInst)) {
-              newInst[i] = oldInst[i];
-            } else if (type !== "function" && typeof newInst[i] === type) {
-              if (type === "object" && newInst[i] != null && newInst[i].constructor === oldInst[i].constructor) {
-                Object.assign(newInst[i], oldInst[i]);
-              } else {
-                newInst[i] = oldInst[i];
-              }
-            }
-          }
+    const vnodes = vnodesForComponent.get(OldType);
+    if (!vnodes) return;
+    vnodesForComponent["delete"](OldType);
+    vnodesForComponent.set(NewType, vnodes);
+    mappedVNodes.set(OldType, NewType);
+    pendingUpdates = pendingUpdates.filter((p)=>p[0] !== OldType);
+    vnodes.forEach((node)=>{
+        let vnode = node;
+        if (!vnode.__c) {
+            vnode = lastSeen.get(vnode.__v, vnode);
+            lastSeen["delete"](vnode.__v);
         }
-      } catch (e) {
-        vnode[VNODE_COMPONENT].constructor = NewType;
-      }
-      if (resetHookState) {
-        if (vnode[VNODE_COMPONENT][COMPONENT_HOOKS] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].length) {
-          vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].forEach(
-            (possibleEffect) => {
-              if (possibleEffect[HOOK_CLEANUP] && typeof possibleEffect[HOOK_CLEANUP] === "function") {
-                possibleEffect[HOOK_CLEANUP]();
-                possibleEffect[HOOK_CLEANUP] = void 0;
-              } else if (possibleEffect[HOOK_ARGS] && possibleEffect[HOOK_VALUE] && Object.keys(possibleEffect).length === 3) {
-                const cleanupKey = Object.keys(possibleEffect).find(
-                  (key) => key !== HOOK_ARGS && key !== HOOK_VALUE
-                );
-                if (cleanupKey && typeof possibleEffect[cleanupKey] == "function") {
-                  possibleEffect[cleanupKey]();
-                  possibleEffect[cleanupKey] = void 0;
+        if (!vnode || !vnode.__c || !vnode.__c.__P) return;
+        vnode.type = NewType;
+        if (vnode[VNODE_COMPONENT]) {
+            vnode[VNODE_COMPONENT].constructor = vnode.type;
+            try {
+                if (vnode[VNODE_COMPONENT] instanceof OldType) {
+                    const oldInst = vnode[VNODE_COMPONENT];
+                    const newInst = new NewType(vnode[VNODE_COMPONENT].props, vnode[VNODE_COMPONENT].context);
+                    vnode[VNODE_COMPONENT] = newInst;
+                    for(let i in oldInst){
+                        const type = typeof oldInst[i];
+                        if (i in newInst) {
+                            if ('function' !== type && typeof newInst[i] === type) if ('object' === type && null != newInst[i] && newInst[i].constructor === oldInst[i].constructor) Object.assign(newInst[i], oldInst[i]);
+                            else newInst[i] = oldInst[i];
+                        } else newInst[i] = oldInst[i];
+                    }
                 }
-              }
+            } catch (e) {
+                vnode[VNODE_COMPONENT].constructor = NewType;
             }
-          );
-        }
-        vnode[VNODE_COMPONENT][COMPONENT_HOOKS] = {
-          [HOOKS_LIST]: [],
-          [EFFECTS_LIST]: []
-        };
-      } else if (vnode[VNODE_COMPONENT][COMPONENT_HOOKS] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].length) {
-        vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].forEach(
-          (possibleEffect) => {
-            if (possibleEffect[HOOK_CLEANUP] && typeof possibleEffect[HOOK_CLEANUP] === "function") {
-              possibleEffect[HOOK_CLEANUP]();
-              possibleEffect[HOOK_CLEANUP] = void 0;
-            } else if (possibleEffect[HOOK_ARGS] && possibleEffect[HOOK_VALUE] && Object.keys(possibleEffect).length === 3) {
-              const cleanupKey = Object.keys(possibleEffect).find(
-                (key) => key !== HOOK_ARGS && key !== HOOK_VALUE
-              );
-              if (cleanupKey && typeof possibleEffect[cleanupKey] == "function")
-                possibleEffect[cleanupKey]();
-              possibleEffect[cleanupKey] = void 0;
+            if (resetHookState) {
+                if (vnode[VNODE_COMPONENT][COMPONENT_HOOKS] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].length) vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].forEach((possibleEffect)=>{
+                    if (possibleEffect[HOOK_CLEANUP] && 'function' == typeof possibleEffect[HOOK_CLEANUP]) {
+                        possibleEffect[HOOK_CLEANUP]();
+                        possibleEffect[HOOK_CLEANUP] = void 0;
+                    } else if (possibleEffect[HOOK_ARGS] && possibleEffect[HOOK_VALUE] && 3 === Object.keys(possibleEffect).length) {
+                        const cleanupKey = Object.keys(possibleEffect).find((key)=>key !== HOOK_ARGS && key !== HOOK_VALUE);
+                        if (cleanupKey && 'function' == typeof possibleEffect[cleanupKey]) {
+                            possibleEffect[cleanupKey]();
+                            possibleEffect[cleanupKey] = void 0;
+                        }
+                    }
+                });
+                vnode[VNODE_COMPONENT][COMPONENT_HOOKS] = {
+                    [HOOKS_LIST]: [],
+                    [EFFECTS_LIST]: []
+                };
+            } else if (vnode[VNODE_COMPONENT][COMPONENT_HOOKS] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST] && vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].length) {
+                vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].forEach((possibleEffect)=>{
+                    if (possibleEffect[HOOK_CLEANUP] && 'function' == typeof possibleEffect[HOOK_CLEANUP]) {
+                        possibleEffect[HOOK_CLEANUP]();
+                        possibleEffect[HOOK_CLEANUP] = void 0;
+                    } else if (possibleEffect[HOOK_ARGS] && possibleEffect[HOOK_VALUE] && 3 === Object.keys(possibleEffect).length) {
+                        const cleanupKey = Object.keys(possibleEffect).find((key)=>key !== HOOK_ARGS && key !== HOOK_VALUE);
+                        if (cleanupKey && 'function' == typeof possibleEffect[cleanupKey]) possibleEffect[cleanupKey]();
+                        possibleEffect[cleanupKey] = void 0;
+                    }
+                });
+                vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].forEach((hook)=>{
+                    if (hook.__H && Array.isArray(hook.__H)) hook.__H = void 0;
+                });
             }
-          }
-        );
-        vnode[VNODE_COMPONENT][COMPONENT_HOOKS][HOOKS_LIST].forEach((hook) => {
-          if (hook.__H && Array.isArray(hook.__H)) {
-            hook.__H = void 0;
-          }
-        });
-      }
-      Component.prototype.forceUpdate.call(vnode[VNODE_COMPONENT]);
-    }
-  });
+            Component.prototype.forceUpdate.call(vnode[VNODE_COMPONENT]);
+        }
+    });
 }
 globalThis[NAMESPACE] = {
-  getSignature: (type) => signaturesForType.get(type),
-  register: (type, id) => {
-    if (typeof type !== "function") return;
-    if (typesById.has(id)) {
-      const existing = typesById.get(id);
-      if (existing !== type) {
-        pendingUpdates.push([existing, type]);
-        typesById.set(id, type);
-      }
-    } else {
-      typesById.set(id, type);
-    }
-    if (!signaturesForType.has(type)) {
-      signaturesForType.set(type, {
-        getCustomHooks: () => [],
-        type
-      });
-    }
-  },
-  getPendingUpdates: () => pendingUpdates,
-  flush: () => {
-    pendingUpdates = [];
-  },
-  replaceComponent,
-  sign,
-  computeKey
+    getSignature: (type)=>signaturesForType.get(type),
+    register: (type, id)=>{
+        if ('function' != typeof type) return;
+        if (typesById.has(id)) {
+            const existing = typesById.get(id);
+            if (existing !== type) {
+                pendingUpdates.push([
+                    existing,
+                    type
+                ]);
+                typesById.set(id, type);
+            }
+        } else typesById.set(id, type);
+        if (!signaturesForType.has(type)) signaturesForType.set(type, {
+            getCustomHooks: ()=>[],
+            type
+        });
+    },
+    getPendingUpdates: ()=>pendingUpdates,
+    flush: ()=>{
+        pendingUpdates = [];
+    },
+    replaceComponent,
+    sign,
+    computeKey: computeKey
 };
-
-// ../../../node_modules/.pnpm/@prefresh+utils@1.2.0/node_modules/@prefresh/utils/src/index.js
-var compareSignatures = (prev, next) => {
-  const prevSignature = globalThis.__PREFRESH__.getSignature(prev) || {};
-  const nextSignature = globalThis.__PREFRESH__.getSignature(next) || {};
-  if (prevSignature.key !== nextSignature.key || globalThis.__PREFRESH__.computeKey(prevSignature) !== globalThis.__PREFRESH__.computeKey(nextSignature) || nextSignature.forceReset) {
-    globalThis.__PREFRESH__.replaceComponent(prev, next, true);
-  } else {
-    globalThis.__PREFRESH__.replaceComponent(prev, next, false);
-  }
+const compareSignatures = (prev, next)=>{
+    const prevSignature = globalThis.__PREFRESH__.getSignature(prev) || {};
+    const nextSignature = globalThis.__PREFRESH__.getSignature(next) || {};
+    if (prevSignature.key !== nextSignature.key || globalThis.__PREFRESH__.computeKey(prevSignature) !== globalThis.__PREFRESH__.computeKey(nextSignature) || nextSignature.forceReset) globalThis.__PREFRESH__.replaceComponent(prev, next, true);
+    else globalThis.__PREFRESH__.replaceComponent(prev, next, false);
 };
-var flush = () => {
-  const pending = [...globalThis.__PREFRESH__.getPendingUpdates()];
-  globalThis.__PREFRESH__.flush();
-  if (pending.length > 0) {
-    pending.forEach(([prev, next]) => {
-      compareSignatures(prev, next);
+const flush = ()=>{
+    const pending = [
+        ...globalThis.__PREFRESH__.getPendingUpdates()
+    ];
+    globalThis.__PREFRESH__.flush();
+    if (pending.length > 0) pending.forEach(([prev, next])=>{
+        compareSignatures(prev, next);
     });
-  }
 };
-var isComponent = (exportValue) => {
-  if (typeof exportValue === "function") {
-    if (exportValue.prototype != null && exportValue.prototype.isReactComponent) {
-      return true;
+const isComponent = (exportValue)=>{
+    if ('function' == typeof exportValue) {
+        if (null != exportValue.prototype && exportValue.prototype.isReactComponent) return true;
+        const name = exportValue.name || exportValue.displayName;
+        return 'string' == typeof name && name[0] && name[0] == name[0].toUpperCase();
     }
-    const name = exportValue.name || exportValue.displayName;
-    return typeof name === "string" && name[0] && name[0] == name[0].toUpperCase();
-  }
-  return false;
-};
-export {
-  flush,
-  isComponent
+    return false;
 };
+export { flush, isComponent };

package/refresh/package.json

@@ -10,12 +10,11 @@
     "src"
   ],
   "scripts": {
-    "build": "esbuild --bundle src/index.ts --outfile=dist/index.js --external:@lynx-js/react --define:self=globalThis --format=esm --alias:preact=@lynx-js/react/internal --alias:preact/hooks=@lynx-js/react"
+    "build": "rslib build"
   },
   "devDependencies": {
     "@lynx-js/react": "workspace:*",
-    "@prefresh/core": "^1.5.3",
-    "@prefresh/utils": "^1.2.0",
-    "esbuild": "^0.25.5"
+    "@prefresh/core": "^1.5.5",
+    "@prefresh/utils": "^1.2.1"
   }
 }

package/refresh/rslib.config.ts

@@ -0,0 +1,24 @@
+// Copyright 2025 The Lynx Authors. All rights reserved.
+// Licensed under the Apache License Version 2.0 that can be found in the
+// LICENSE file in the root directory of this source tree.
+
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig({
+  lib: [
+    { format: 'esm', syntax: 'es2019' },
+  ],
+  output: {
+    externals: [
+      {
+        'preact': '@lynx-js/react/internal',
+        'preact/hooks': '@lynx-js/react',
+      },
+    ],
+  },
+  source: {
+    define: {
+      self: 'globalThis',
+    },
+  },
+});

package/runtime/lazy/react-lepus.js

@@ -6,4 +6,5 @@ import { sExportsReactLepus, target } from './target';
 
 export const {
   createElement,
+  cloneElement,
 } = target[sExportsReactLepus];

package/runtime/lazy/react.js

@@ -13,6 +13,7 @@ export const {
   MainThreadRef,
   PureComponent,
   Suspense,
+  cloneElement,
   createContext,
   createElement,
   createRef,

package/runtime/lepus/index.d.ts

@@ -1,4 +1,4 @@
 // Copyright 2024 The Lynx Authors. All rights reserved.
 // Licensed under the Apache License Version 2.0 that can be found in the
 // LICENSE file in the root directory of this source tree.
-export { createElement } from 'react';
+export { cloneElement, createElement } from 'react';