@vitejs/plugin-react-swc 3.1.0-beta.2 → 3.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitejs/plugin-react-swc",
   "description": "Speed up your Vite dev server with SWC",
-  "version": "3.1.0-beta.2",
+  "version": "3.1.0",
   "author": "Arnaud Barré (https://github.com/ArnaudBarre)",
   "license": "MIT",
   "repository": "github:vitejs/vite-plugin-react-swc",
@@ -10,8 +10,8 @@
   "module": "index.mjs",
   "exports": {
     ".": {
-      "require": "./index.cjs",
       "types": "./index.d.ts",
+      "require": "./index.cjs",
       "import": "./index.mjs"
     }
   },
@@ -27,6 +27,6 @@
     "vite": "^4"
   },
   "dependencies": {
-    "@swc/core": "^1.3.26"
+    "@swc/core": "^1.3.30"
   }
 }

package/refresh-runtime.js

@@ -4,12 +4,12 @@ const REACT_MEMO_TYPE = Symbol.for("react.memo");
 let allFamiliesByID = /* @__PURE__ */ new Map();
 let allFamiliesByType = /* @__PURE__ */ new WeakMap();
 let allSignaturesByType = /* @__PURE__ */ new WeakMap();
-let updatedFamiliesByType = /* @__PURE__ */ new WeakMap();
+const updatedFamiliesByType = /* @__PURE__ */ new WeakMap();
 let pendingUpdates = [];
-let helpersByRendererID = /* @__PURE__ */ new Map();
-let helpersByRoot = /* @__PURE__ */ new Map();
-let mountedRoots = /* @__PURE__ */ new Set();
-let failedRoots = /* @__PURE__ */ new Set();
+const helpersByRendererID = /* @__PURE__ */ new Map();
+const helpersByRoot = /* @__PURE__ */ new Map();
+const mountedRoots = /* @__PURE__ */ new Set();
+const failedRoots = /* @__PURE__ */ new Set();
 let rootElements = /* @__PURE__ */ new WeakMap();
 let isPerformingRefresh = false;
 function computeFullKey(signature) {
@@ -26,17 +26,17 @@ function computeFullKey(signature) {
     return fullKey;
   }
   for (let i = 0; i < hooks.length; i++) {
-    let hook = hooks[i];
+    const hook = hooks[i];
     if (typeof hook !== "function") {
       signature.forceReset = true;
       signature.fullKey = fullKey;
       return fullKey;
     }
-    let nestedHookSignature = allSignaturesByType.get(hook);
+    const nestedHookSignature = allSignaturesByType.get(hook);
     if (nestedHookSignature === void 0) {
       continue;
     }
-    let nestedHookKey = computeFullKey(nestedHookSignature);
+    const nestedHookKey = computeFullKey(nestedHookSignature);
     if (nestedHookSignature.forceReset) {
       signature.forceReset = true;
     }
@@ -46,8 +46,8 @@ function computeFullKey(signature) {
   return fullKey;
 }
 function haveEqualSignatures(prevType, nextType) {
-  let prevSignature = allSignaturesByType.get(prevType);
-  let nextSignature = allSignaturesByType.get(nextType);
+  const prevSignature = allSignaturesByType.get(prevType);
+  const nextSignature = allSignaturesByType.get(nextType);
   if (prevSignature === void 0 && nextSignature === void 0) {
     return true;
   }
@@ -93,13 +93,12 @@ function performReactRefresh() {
   }
   isPerformingRefresh = true;
   try {
-    let staleFamilies = /* @__PURE__ */ new Set();
-    let updatedFamilies = /* @__PURE__ */ new Set();
-    let updates = pendingUpdates;
+    const staleFamilies = /* @__PURE__ */ new Set();
+    const updatedFamilies = /* @__PURE__ */ new Set();
+    const updates = pendingUpdates;
     pendingUpdates = [];
-    updates.forEach(function(_ref) {
-      let family = _ref[0], nextType = _ref[1];
-      let prevType = family.current;
+    updates.forEach(([family, nextType]) => {
+      const prevType = family.current;
       updatedFamiliesByType.set(prevType, family);
       updatedFamiliesByType.set(nextType, family);
       family.current = nextType;
@@ -109,22 +108,22 @@ function performReactRefresh() {
         staleFamilies.add(family);
       }
     });
-    let update = {
+    const update = {
       updatedFamilies,
       // Families that will re-render preserving state
       staleFamilies
       // Families that will be remounted
     };
-    helpersByRendererID.forEach(function(helpers) {
+    helpersByRendererID.forEach((helpers) => {
       helpers.setRefreshHandler(resolveFamily);
     });
     let didError = false;
     let firstError = null;
-    let failedRootsSnapshot = new Set(failedRoots);
-    let mountedRootsSnapshot = new Set(mountedRoots);
-    let helpersByRootSnapshot = new Map(helpersByRoot);
-    failedRootsSnapshot.forEach(function(root) {
-      let helpers = helpersByRootSnapshot.get(root);
+    const failedRootsSnapshot = new Set(failedRoots);
+    const mountedRootsSnapshot = new Set(mountedRoots);
+    const helpersByRootSnapshot = new Map(helpersByRoot);
+    failedRootsSnapshot.forEach((root) => {
+      const helpers = helpersByRootSnapshot.get(root);
       if (helpers === void 0) {
         throw new Error(
           "Could not find helpers for a root. This is a bug in React Refresh."
@@ -132,10 +131,13 @@ function performReactRefresh() {
       }
       if (!failedRoots.has(root)) {
       }
+      if (rootElements === null) {
+        return;
+      }
       if (!rootElements.has(root)) {
         return;
       }
-      let element = rootElements.get(root);
+      const element = rootElements.get(root);
       try {
         helpers.scheduleRoot(root, element);
       } catch (err) {
@@ -145,8 +147,8 @@ function performReactRefresh() {
         }
       }
     });
-    mountedRootsSnapshot.forEach(function(root) {
-      let helpers = helpersByRootSnapshot.get(root);
+    mountedRootsSnapshot.forEach((root) => {
+      const helpers = helpersByRootSnapshot.get(root);
       if (helpers === void 0) {
         throw new Error(
           "Could not find helpers for a root. This is a bug in React Refresh."
@@ -171,14 +173,6 @@ function performReactRefresh() {
     isPerformingRefresh = false;
   }
 }
-function debounce(fn, delay) {
-  let handle;
-  return () => {
-    clearTimeout(handle);
-    handle = setTimeout(fn, delay);
-  };
-}
-const enqueueUpdate = debounce(performReactRefresh, 16);
 function register(type, id) {
   if (type === null) {
     return;
@@ -191,9 +185,7 @@ function register(type, id) {
   }
   let family = allFamiliesByID.get(id);
   if (family === void 0) {
-    family = {
-      current: type
-    };
+    family = { current: type };
     allFamiliesByID.set(id, family);
   } else {
     pendingUpdates.push([family, type]);
@@ -210,18 +202,13 @@ function register(type, id) {
     }
   }
 }
-function getRefreshReg(filename) {
-  return (type, id) => register(type, filename + " " + id);
-}
-function setSignature(type, key, forceReset = false, getCustomHooks) {
+function setSignature(type, key, forceReset, getCustomHooks) {
   if (!allSignaturesByType.has(type)) {
     allSignaturesByType.set(type, {
       forceReset,
       ownKey: key,
       fullKey: null,
-      getCustomHooks: getCustomHooks || function() {
-        return [];
-      }
+      getCustomHooks: getCustomHooks || (() => [])
     });
   }
   if (typeof type === "object" && type !== null) {
@@ -236,7 +223,7 @@ function setSignature(type, key, forceReset = false, getCustomHooks) {
   }
 }
 function collectCustomHooksForSignature(type) {
-  let signature = allSignaturesByType.get(type);
+  const signature = allSignaturesByType.get(type);
   if (signature !== void 0) {
     computeFullKey(signature);
   }
@@ -248,14 +235,12 @@ function injectIntoGlobalHook(globalObject) {
     globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
       renderers: /* @__PURE__ */ new Map(),
       supportsFiber: true,
-      inject: function(injected) {
-        return nextID++;
+      inject: (injected) => nextID++,
+      onScheduleFiberRoot: (id, root, children) => {
       },
-      onScheduleFiberRoot: function(id, root, children) {
+      onCommitFiberRoot: (id, root, maybePriorityLevel, didError) => {
       },
-      onCommitFiberRoot: function(id, root, maybePriorityLevel, didError) {
-      },
-      onCommitFiberUnmount: function() {
+      onCommitFiberUnmount() {
       }
     };
   }
@@ -265,38 +250,40 @@ function injectIntoGlobalHook(globalObject) {
     );
     return;
   }
-  let oldInject = hook.inject;
+  const oldInject = hook.inject;
   hook.inject = function(injected) {
-    let id = oldInject.apply(this, arguments);
+    const id = oldInject.apply(this, arguments);
     if (typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function") {
       helpersByRendererID.set(id, injected);
     }
     return id;
   };
-  hook.renderers.forEach(function(injected, id) {
+  hook.renderers.forEach((injected, id) => {
     if (typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function") {
       helpersByRendererID.set(id, injected);
     }
   });
-  let oldOnCommitFiberRoot = hook.onCommitFiberRoot;
-  let oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {
-  };
+  const oldOnCommitFiberRoot = hook.onCommitFiberRoot;
+  const oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || (() => {
+  });
   hook.onScheduleFiberRoot = function(id, root, children) {
     if (!isPerformingRefresh) {
       failedRoots.delete(root);
-      rootElements.set(root, children);
+      if (rootElements !== null) {
+        rootElements.set(root, children);
+      }
     }
     return oldOnScheduleFiberRoot.apply(this, arguments);
   };
   hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
-    let helpers = helpersByRendererID.get(id);
+    const helpers = helpersByRendererID.get(id);
     if (helpers !== void 0) {
       helpersByRoot.set(root, helpers);
-      let current = root.current;
-      let alternate = current.alternate;
+      const current = root.current;
+      const alternate = current.alternate;
       if (alternate !== null) {
-        let wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null;
-        let isMounted = current.memoizedState != null && current.memoizedState.element != null;
+        const wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null && mountedRoots.has(root);
+        const isMounted = current.memoizedState != null && current.memoizedState.element != null;
         if (!wasMounted && isMounted) {
           mountedRoots.add(root);
           failedRoots.delete(root);
@@ -377,6 +364,9 @@ function isLikelyComponentType(type) {
     }
   }
 }
+function getRefreshReg(filename) {
+  return (type, id) => register(type, filename + " " + id);
+}
 function registerExportsForReactRefresh(filename, moduleExports) {
   for (const key in moduleExports) {
     if (key === "__esModule")
@@ -387,6 +377,14 @@ function registerExportsForReactRefresh(filename, moduleExports) {
     }
   }
 }
+function debounce(fn, delay) {
+  let handle;
+  return () => {
+    clearTimeout(handle);
+    handle = setTimeout(fn, delay);
+  };
+}
+const enqueueUpdate = debounce(performReactRefresh, 16);
 function validateRefreshBoundaryAndEnqueueUpdate(prevExports, nextExports) {
   if (!predicateOnExport(prevExports, (key) => !!nextExports[key])) {
     return "Could not Fast Refresh (export removed)";