@vitejs/plugin-react-swc 3.0.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Arnaud Barré (https://github.com/ArnaudBarre)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @vitejs/plugin-react-swc [![npm](https://img.shields.io/npm/v/@vitejs/plugin-react-swc)](https://www.npmjs.com/package/@vitejs/plugin-react-swc)
+
+Use the versatility of [SWC](https://swc.rs/) for development and the maturity of [esbuild](https://esbuild.github.io/) for production.
+
+- ✅ A fast Fast Refresh (~20x faster than Babel)
+- ✅ Enable [automatic JSX runtime](https://reactjs.org/blog/2020/09/22/introducing-the-new-jsx-transform.html)
+
+> ⚠️ This is an alpha release for Vite 4, for the v2 named `vite-plugin-swc-react-refresh`, see the [v2 branch](https://github.com/vitejs/vite-plugin-react-swc/tree/v2).
+
+## Installation
+
+```sh
+npm i -D @vitejs/plugin-react-swc
+```
+
+## Usage
+
+```ts
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react-swc";
+
+export default defineConfig({
+  plugins: [react()],
+});
+```
+
+## Caveats
+
+This plugin is only used in development and aims to be kept simple to enable good performances and be transpiler agnostic. Here is the list of non-configurable options that impact runtime behaviour:
+
+- [useDefineForClassFields](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#the-usedefineforclassfields-flag-and-the-declare-property-modifier) is always activated, as this matches the current ECMAScript spec
+- `jsx runtime` is always `automatic`
+- In development:
+  - esbuild is disabled, so the [esbuild configuration](https://vitejs.dev/config/shared-options.html#esbuild) has no effect
+  - `target` is `es2020`
+  - JS files are not transformed
+  - tsconfig is not resolved, so properties other than the ones listed above behaves like TS defaults
+
+## Consistent components exports
+
+For React refresh to work, your file should only export React components. The best explanation I've read is the one from the [Gatsby docs](https://www.gatsbyjs.com/docs/reference/local-development/fast-refresh/#how-it-works).
+
+You can catch mistakes and get more detailed warning with this [eslint rule](https://github.com/ArnaudBarre/eslint-plugin-react-refresh).

package/index.cjs

@@ -0,0 +1,129 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+var import_fs = require("fs");
+var import_path = require("path");
+var import_url = require("url");
+var import_core = require("@swc/core");
+var import_meta = {};
+var runtimePublicPath = "/@react-refresh";
+var preambleCode = `import { injectIntoGlobalHook } from "${runtimePublicPath}";
+injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;`;
+var _dirname = typeof __dirname !== "undefined" ? __dirname : (0, import_path.dirname)((0, import_url.fileURLToPath)(import_meta.url));
+var react = () => [
+  {
+    name: "@vitejs/plugin-react-swc",
+    apply: "serve",
+    config: () => ({
+      esbuild: false,
+      optimizeDeps: { include: ["react/jsx-dev-runtime"] }
+    }),
+    resolveId: (id) => id === runtimePublicPath ? id : void 0,
+    load: (id) => id === runtimePublicPath ? (0, import_fs.readFileSync)((0, import_path.join)(_dirname, "refresh-runtime.js"), "utf-8") : void 0,
+    transformIndexHtml: () => [
+      { tag: "script", attrs: { type: "module" }, children: preambleCode }
+    ],
+    async transform(code, id, transformOptions) {
+      if (id.includes("node_modules"))
+        return;
+      const parser = id.endsWith(".tsx") ? { syntax: "typescript", tsx: true } : id.endsWith(".ts") ? { syntax: "typescript", tsx: false } : id.endsWith(".jsx") ? { syntax: "ecmascript", jsx: true } : void 0;
+      if (!parser)
+        return;
+      let result;
+      try {
+        result = await (0, import_core.transform)(code, {
+          filename: id,
+          swcrc: false,
+          configFile: false,
+          sourceMaps: true,
+          jsc: {
+            target: "es2020",
+            parser,
+            transform: {
+              useDefineForClassFields: true,
+              react: {
+                refresh: !(transformOptions == null ? void 0 : transformOptions.ssr),
+                development: true,
+                useBuiltins: true,
+                runtime: "automatic"
+              }
+            }
+          }
+        });
+      } catch (e) {
+        const message = e.message;
+        const fileStartIndex = message.indexOf("\u256D\u2500[");
+        if (fileStartIndex !== -1) {
+          const match = message.slice(fileStartIndex).match(/:(\d+):(\d+)]/);
+          if (match) {
+            e.line = match[1];
+            e.column = match[2];
+          }
+        }
+        throw e;
+      }
+      if (!result.code.includes("$RefreshReg$"))
+        return result;
+      result.code = `import * as RefreshRuntime from "${runtimePublicPath}";
+  
+  if (!window.$RefreshReg$) throw new Error("React refresh preamble was not loaded. Something is wrong.");
+  const prevRefreshReg = window.$RefreshReg$;
+  const prevRefreshSig = window.$RefreshSig$;
+  window.$RefreshReg$ = RefreshRuntime.getRefreshReg("${id}");
+  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+  
+  ${result.code}
+  
+  window.$RefreshReg$ = prevRefreshReg;
+  window.$RefreshSig$ = prevRefreshSig;
+  import.meta.hot.accept((nextExports) => {
+  if (!nextExports) return;
+  import(/* @vite-ignore */ import.meta.url).then((current) => {
+    const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(current, nextExports);
+    if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
+  });
+});
+  `;
+      const sourceMap = JSON.parse(result.map);
+      sourceMap.mappings = ";;;;;;;;" + sourceMap.mappings;
+      return { code: result.code, map: sourceMap };
+    }
+  },
+  {
+    name: "@vitejs/plugin-react-swc",
+    apply: "build",
+    config: () => ({
+      esbuild: {
+        jsx: "automatic",
+        tsconfigRaw: { compilerOptions: { useDefineForClassFields: true } }
+      }
+    })
+  }
+];
+var src_default = react;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {});

package/index.d.ts

@@ -0,0 +1,3 @@
+import { PluginOption } from "vite";
+declare const react: () => PluginOption[];
+export default react;

package/index.mjs

@@ -0,0 +1,105 @@
+// src/index.ts
+import { readFileSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { transform } from "@swc/core";
+var runtimePublicPath = "/@react-refresh";
+var preambleCode = `import { injectIntoGlobalHook } from "${runtimePublicPath}";
+injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;`;
+var _dirname = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
+var react = () => [
+  {
+    name: "@vitejs/plugin-react-swc",
+    apply: "serve",
+    config: () => ({
+      esbuild: false,
+      optimizeDeps: { include: ["react/jsx-dev-runtime"] }
+    }),
+    resolveId: (id) => id === runtimePublicPath ? id : void 0,
+    load: (id) => id === runtimePublicPath ? readFileSync(join(_dirname, "refresh-runtime.js"), "utf-8") : void 0,
+    transformIndexHtml: () => [
+      { tag: "script", attrs: { type: "module" }, children: preambleCode }
+    ],
+    async transform(code, id, transformOptions) {
+      if (id.includes("node_modules"))
+        return;
+      const parser = id.endsWith(".tsx") ? { syntax: "typescript", tsx: true } : id.endsWith(".ts") ? { syntax: "typescript", tsx: false } : id.endsWith(".jsx") ? { syntax: "ecmascript", jsx: true } : void 0;
+      if (!parser)
+        return;
+      let result;
+      try {
+        result = await transform(code, {
+          filename: id,
+          swcrc: false,
+          configFile: false,
+          sourceMaps: true,
+          jsc: {
+            target: "es2020",
+            parser,
+            transform: {
+              useDefineForClassFields: true,
+              react: {
+                refresh: !(transformOptions == null ? void 0 : transformOptions.ssr),
+                development: true,
+                useBuiltins: true,
+                runtime: "automatic"
+              }
+            }
+          }
+        });
+      } catch (e) {
+        const message = e.message;
+        const fileStartIndex = message.indexOf("\u256D\u2500[");
+        if (fileStartIndex !== -1) {
+          const match = message.slice(fileStartIndex).match(/:(\d+):(\d+)]/);
+          if (match) {
+            e.line = match[1];
+            e.column = match[2];
+          }
+        }
+        throw e;
+      }
+      if (!result.code.includes("$RefreshReg$"))
+        return result;
+      result.code = `import * as RefreshRuntime from "${runtimePublicPath}";
+  
+  if (!window.$RefreshReg$) throw new Error("React refresh preamble was not loaded. Something is wrong.");
+  const prevRefreshReg = window.$RefreshReg$;
+  const prevRefreshSig = window.$RefreshSig$;
+  window.$RefreshReg$ = RefreshRuntime.getRefreshReg("${id}");
+  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+  
+  ${result.code}
+  
+  window.$RefreshReg$ = prevRefreshReg;
+  window.$RefreshSig$ = prevRefreshSig;
+  import.meta.hot.accept((nextExports) => {
+  if (!nextExports) return;
+  import(/* @vite-ignore */ import.meta.url).then((current) => {
+    const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(current, nextExports);
+    if (invalidateMessage) import.meta.hot.invalidate(invalidateMessage);
+  });
+});
+  `;
+      const sourceMap = JSON.parse(result.map);
+      sourceMap.mappings = ";;;;;;;;" + sourceMap.mappings;
+      return { code: result.code, map: sourceMap };
+    }
+  },
+  {
+    name: "@vitejs/plugin-react-swc",
+    apply: "build",
+    config: () => ({
+      esbuild: {
+        jsx: "automatic",
+        tsconfigRaw: { compilerOptions: { useDefineForClassFields: true } }
+      }
+    })
+  }
+];
+var src_default = react;
+export {
+  src_default as default
+};

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@vitejs/plugin-react-swc",
+  "description": "Use the versatility of SWC for development and the maturity of esbuild for production",
+  "version": "3.0.0-beta.0",
+  "author": "Arnaud Barré (https://github.com/ArnaudBarre)",
+  "license": "MIT",
+  "repository": "github:vitejs/vite-plugin-react-swc",
+  "main": "index.cjs",
+  "types": "index.d.ts",
+  "module": "index.mjs",
+  "exports": {
+    ".": {
+      "require": "index.cjs",
+      "types": "index.d.ts",
+      "import": "index.mjs"
+    }
+  },
+  "keywords": [
+    "vite",
+    "vite-plugin",
+    "react",
+    "swc",
+    "react-refresh",
+    "fast refresh"
+  ],
+  "peerDependencies": {
+    "vite": "^4.0.0-alpha.5"
+  },
+  "dependencies": {
+    "@swc/core": "^1.3.21"
+  }
+}

package/refresh-runtime.js

@@ -0,0 +1,417 @@
+/*! Copyright (c) Meta Platforms, Inc. and affiliates. **/
+const REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref");
+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();
+let pendingUpdates = [];
+let helpersByRendererID = /* @__PURE__ */ new Map();
+let helpersByRoot = /* @__PURE__ */ new Map();
+let mountedRoots = /* @__PURE__ */ new Set();
+let failedRoots = /* @__PURE__ */ new Set();
+let rootElements = /* @__PURE__ */ new WeakMap();
+let isPerformingRefresh = false;
+function computeFullKey(signature) {
+  if (signature.fullKey !== null) {
+    return signature.fullKey;
+  }
+  let fullKey = signature.ownKey;
+  let hooks;
+  try {
+    hooks = signature.getCustomHooks();
+  } catch (err) {
+    signature.forceReset = true;
+    signature.fullKey = fullKey;
+    return fullKey;
+  }
+  for (let i = 0; i < hooks.length; i++) {
+    let hook = hooks[i];
+    if (typeof hook !== "function") {
+      signature.forceReset = true;
+      signature.fullKey = fullKey;
+      return fullKey;
+    }
+    let nestedHookSignature = allSignaturesByType.get(hook);
+    if (nestedHookSignature === void 0) {
+      continue;
+    }
+    let nestedHookKey = computeFullKey(nestedHookSignature);
+    if (nestedHookSignature.forceReset) {
+      signature.forceReset = true;
+    }
+    fullKey += "\n---\n" + nestedHookKey;
+  }
+  signature.fullKey = fullKey;
+  return fullKey;
+}
+function haveEqualSignatures(prevType, nextType) {
+  let prevSignature = allSignaturesByType.get(prevType);
+  let nextSignature = allSignaturesByType.get(nextType);
+  if (prevSignature === void 0 && nextSignature === void 0) {
+    return true;
+  }
+  if (prevSignature === void 0 || nextSignature === void 0) {
+    return false;
+  }
+  if (computeFullKey(prevSignature) !== computeFullKey(nextSignature)) {
+    return false;
+  }
+  if (nextSignature.forceReset) {
+    return false;
+  }
+  return true;
+}
+function isReactClass(type) {
+  return type.prototype && type.prototype.isReactComponent;
+}
+function canPreserveStateBetween(prevType, nextType) {
+  if (isReactClass(prevType) || isReactClass(nextType)) {
+    return false;
+  }
+  if (haveEqualSignatures(prevType, nextType)) {
+    return true;
+  }
+  return false;
+}
+function resolveFamily(type) {
+  return updatedFamiliesByType.get(type);
+}
+function getProperty(object, property) {
+  try {
+    return object[property];
+  } catch (err) {
+    return void 0;
+  }
+}
+function performReactRefresh() {
+  if (pendingUpdates.length === 0) {
+    return null;
+  }
+  if (isPerformingRefresh) {
+    return null;
+  }
+  isPerformingRefresh = true;
+  try {
+    let staleFamilies = /* @__PURE__ */ new Set();
+    let updatedFamilies = /* @__PURE__ */ new Set();
+    let updates = pendingUpdates;
+    pendingUpdates = [];
+    updates.forEach(function(_ref) {
+      let family = _ref[0], nextType = _ref[1];
+      let prevType = family.current;
+      updatedFamiliesByType.set(prevType, family);
+      updatedFamiliesByType.set(nextType, family);
+      family.current = nextType;
+      if (canPreserveStateBetween(prevType, nextType)) {
+        updatedFamilies.add(family);
+      } else {
+        staleFamilies.add(family);
+      }
+    });
+    let update = {
+      updatedFamilies,
+      staleFamilies
+    };
+    helpersByRendererID.forEach(function(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);
+      if (helpers === void 0) {
+        throw new Error(
+          "Could not find helpers for a root. This is a bug in React Refresh."
+        );
+      }
+      if (!failedRoots.has(root)) {
+      }
+      if (!rootElements.has(root)) {
+        return;
+      }
+      let element = rootElements.get(root);
+      try {
+        helpers.scheduleRoot(root, element);
+      } catch (err) {
+        if (!didError) {
+          didError = true;
+          firstError = err;
+        }
+      }
+    });
+    mountedRootsSnapshot.forEach(function(root) {
+      let 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."
+        );
+      }
+      if (!mountedRoots.has(root)) {
+      }
+      try {
+        helpers.scheduleRefresh(root, update);
+      } catch (err) {
+        if (!didError) {
+          didError = true;
+          firstError = err;
+        }
+      }
+    });
+    if (didError) {
+      throw firstError;
+    }
+    return update;
+  } finally {
+    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;
+  }
+  if (typeof type !== "function" && typeof type !== "object") {
+    return;
+  }
+  if (allFamiliesByType.has(type)) {
+    return;
+  }
+  let family = allFamiliesByID.get(id);
+  if (family === void 0) {
+    family = {
+      current: type
+    };
+    allFamiliesByID.set(id, family);
+  } else {
+    pendingUpdates.push([family, type]);
+  }
+  allFamiliesByType.set(type, family);
+  if (typeof type === "object" && type !== null) {
+    switch (getProperty(type, "$$typeof")) {
+      case REACT_FORWARD_REF_TYPE:
+        register(type.render, id + "$render");
+        break;
+      case REACT_MEMO_TYPE:
+        register(type.type, id + "$type");
+        break;
+    }
+  }
+}
+function getRefreshReg(filename) {
+  return (type, id) => register(type, filename + " " + id);
+}
+function setSignature(type, key, forceReset = false, getCustomHooks) {
+  if (!allSignaturesByType.has(type)) {
+    allSignaturesByType.set(type, {
+      forceReset,
+      ownKey: key,
+      fullKey: null,
+      getCustomHooks: getCustomHooks || function() {
+        return [];
+      }
+    });
+  }
+  if (typeof type === "object" && type !== null) {
+    switch (getProperty(type, "$$typeof")) {
+      case REACT_FORWARD_REF_TYPE:
+        setSignature(type.render, key, forceReset, getCustomHooks);
+        break;
+      case REACT_MEMO_TYPE:
+        setSignature(type.type, key, forceReset, getCustomHooks);
+        break;
+    }
+  }
+}
+function collectCustomHooksForSignature(type) {
+  let signature = allSignaturesByType.get(type);
+  if (signature !== void 0) {
+    computeFullKey(signature);
+  }
+}
+function injectIntoGlobalHook(globalObject) {
+  let hook = globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+  if (hook === void 0) {
+    let nextID = 0;
+    globalObject.__REACT_DEVTOOLS_GLOBAL_HOOK__ = hook = {
+      renderers: /* @__PURE__ */ new Map(),
+      supportsFiber: true,
+      inject: function(injected) {
+        return nextID++;
+      },
+      onScheduleFiberRoot: function(id, root, children) {
+      },
+      onCommitFiberRoot: function(id, root, maybePriorityLevel, didError) {
+      },
+      onCommitFiberUnmount: function() {
+      }
+    };
+  }
+  if (hook.isDisabled) {
+    console["warn"](
+      "Something has shimmed the React DevTools global hook (__REACT_DEVTOOLS_GLOBAL_HOOK__). Fast Refresh is not compatible with this shim and will be disabled."
+    );
+    return;
+  }
+  let oldInject = hook.inject;
+  hook.inject = function(injected) {
+    let 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) {
+    if (typeof injected.scheduleRefresh === "function" && typeof injected.setRefreshHandler === "function") {
+      helpersByRendererID.set(id, injected);
+    }
+  });
+  let oldOnCommitFiberRoot = hook.onCommitFiberRoot;
+  let oldOnScheduleFiberRoot = hook.onScheduleFiberRoot || function() {
+  };
+  hook.onScheduleFiberRoot = function(id, root, children) {
+    if (!isPerformingRefresh) {
+      failedRoots.delete(root);
+      rootElements.set(root, children);
+    }
+    return oldOnScheduleFiberRoot.apply(this, arguments);
+  };
+  hook.onCommitFiberRoot = function(id, root, maybePriorityLevel, didError) {
+    let helpers = helpersByRendererID.get(id);
+    if (helpers !== void 0) {
+      helpersByRoot.set(root, helpers);
+      let current = root.current;
+      let alternate = current.alternate;
+      if (alternate !== null) {
+        let wasMounted = alternate.memoizedState != null && alternate.memoizedState.element != null;
+        let isMounted = current.memoizedState != null && current.memoizedState.element != null;
+        if (!wasMounted && isMounted) {
+          mountedRoots.add(root);
+          failedRoots.delete(root);
+        } else if (wasMounted && isMounted) {
+        } else if (wasMounted && !isMounted) {
+          mountedRoots.delete(root);
+          if (didError) {
+            failedRoots.add(root);
+          } else {
+            helpersByRoot.delete(root);
+          }
+        } else if (!wasMounted && !isMounted) {
+          if (didError) {
+            failedRoots.add(root);
+          }
+        }
+      } else {
+        mountedRoots.add(root);
+      }
+    }
+    return oldOnCommitFiberRoot.apply(this, arguments);
+  };
+}
+function createSignatureFunctionForTransform() {
+  let savedType;
+  let hasCustomHooks;
+  let didCollectHooks = false;
+  return function(type, key, forceReset, getCustomHooks) {
+    if (typeof key === "string") {
+      if (!savedType) {
+        savedType = type;
+        hasCustomHooks = typeof getCustomHooks === "function";
+      }
+      if (type != null && (typeof type === "function" || typeof type === "object")) {
+        setSignature(type, key, forceReset, getCustomHooks);
+      }
+      return type;
+    } else {
+      if (!didCollectHooks && hasCustomHooks) {
+        didCollectHooks = true;
+        collectCustomHooksForSignature(savedType);
+      }
+    }
+  };
+}
+function isLikelyComponentType(type) {
+  switch (typeof type) {
+    case "function": {
+      if (type.prototype != null) {
+        if (type.prototype.isReactComponent) {
+          return true;
+        }
+        const ownNames = Object.getOwnPropertyNames(type.prototype);
+        if (ownNames.length > 1 || ownNames[0] !== "constructor") {
+          return false;
+        }
+        if (type.prototype.__proto__ !== Object.prototype) {
+          return false;
+        }
+      }
+      const name = type.name || type.displayName;
+      return typeof name === "string" && /^[A-Z]/.test(name);
+    }
+    case "object": {
+      if (type != null) {
+        switch (getProperty(type, "$$typeof")) {
+          case REACT_FORWARD_REF_TYPE:
+          case REACT_MEMO_TYPE:
+            return true;
+          default:
+            return false;
+        }
+      }
+      return false;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+function validateRefreshBoundaryAndEnqueueUpdate(prevExports, nextExports) {
+  if (!predicateOnExport(prevExports, (key) => !!nextExports[key])) {
+    return "Could not Fast Refresh (export removed)";
+  }
+  let hasExports = false;
+  const allExportsAreComponentsOrUnchanged = predicateOnExport(
+    nextExports,
+    (key, value) => {
+      hasExports = true;
+      if (isLikelyComponentType(value))
+        return true;
+      if (!prevExports[key])
+        return false;
+      return prevExports[key] === nextExports[key];
+    }
+  );
+  if (hasExports && allExportsAreComponentsOrUnchanged) {
+    enqueueUpdate();
+  } else {
+    return "Could not Fast Refresh. Learn more at https://github.com/vitejs/vite-plugin-react-swc#consistent-components-exports";
+  }
+}
+function predicateOnExport(moduleExports, predicate) {
+  for (const key in moduleExports) {
+    if (key === "__esModule")
+      continue;
+    const desc = Object.getOwnPropertyDescriptor(moduleExports, key);
+    if (desc && desc.get)
+      return false;
+    if (!predicate(key, moduleExports[key]))
+      return false;
+  }
+  return true;
+}
+export {
+  createSignatureFunctionForTransform,
+  getRefreshReg,
+  injectIntoGlobalHook,
+  validateRefreshBoundaryAndEnqueueUpdate
+};