@cedarjs/vite 0.0.4

package/dist/cjs/lib/registerFwGlobalsAndShims.js

@@ -0,0 +1,117 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var registerFwGlobalsAndShims_exports = {};
+__export(registerFwGlobalsAndShims_exports, {
+  registerFwGlobalsAndShims: () => registerFwGlobalsAndShims
+});
+module.exports = __toCommonJS(registerFwGlobalsAndShims_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_project_config = require("@cedarjs/project-config");
+const registerFwGlobalsAndShims = () => {
+  registerFwGlobals();
+  registerFwShims();
+};
+function registerFwGlobals() {
+  const rwConfig = (0, import_project_config.getConfig)();
+  const rwPaths = (0, import_project_config.getPaths)();
+  globalThis.RWJS_ENV = {
+    RWJS_API_GRAPHQL_URL: rwConfig.web.apiGraphQLUrl ?? rwConfig.web.apiUrl + "/graphql",
+    RWJS_API_URL: rwConfig.web.apiUrl,
+    __REDWOOD__APP_TITLE: rwConfig.web.title || import_node_path.default.basename(rwPaths.base),
+    RWJS_EXP_STREAMING_SSR: rwConfig.experimental.streamingSsr?.enabled,
+    RWJS_EXP_RSC: rwConfig.experimental?.rsc?.enabled,
+    RWJS_EXP_SSR_GRAPHQL_ENDPOINT: (() => {
+      const apiPath = rwConfig.web.apiGraphQLUrl ?? rwConfig.web.apiUrl + "/graphql";
+      if (/^[a-zA-Z][a-zA-Z\d+\-.]*?:/.test(apiPath)) {
+        return apiPath;
+      } else {
+        let webHost = process.env.REDWOOD_WEB_HOST;
+        webHost ??= rwConfig.web.host;
+        webHost ??= process.env.NODE_ENV === "production" ? "0.0.0.0" : "[::]";
+        let webPort;
+        if (process.env.REDWOOD_WEB_PORT) {
+          webPort = parseInt(process.env.REDWOOD_WEB_PORT);
+        } else {
+          webPort = rwConfig.web.port;
+        }
+        const proxiedApiUrl = swapLocalhostFor127(
+          "http://" + webHost + ":" + webPort + apiPath
+        );
+        if (process.env.NODE_ENV === "production" && !process.env.RWJS_EXP_SSR_GRAPHQL_ENDPOINT?.length) {
+          console.log("------------------ WARNING ! -------------------------");
+          console.warn();
+          console.warn();
+          console.warn(`You haven't configured your API absolute url.`);
+          console.warn(`Using ${proxiedApiUrl}`);
+          console.warn();
+          console.warn(
+            "You can override this for SSR by setting RWJS_EXP_SSR_GRAPHQL_ENDPOINT in your environment vars"
+          );
+          console.warn();
+          console.log("------------------ WARNING ! -------------------------");
+          return proxiedApiUrl;
+        }
+        return swapLocalhostFor127(
+          process.env.RWJS_EXP_SSR_GRAPHQL_ENDPOINT ?? proxiedApiUrl
+        );
+      }
+    })()
+  };
+  globalThis.RWJS_DEBUG_ENV = {
+    RWJS_SRC_ROOT: rwPaths.web.src,
+    REDWOOD_ENV_EDITOR: JSON.stringify(process.env.REDWOOD_ENV_EDITOR)
+  };
+}
+function registerFwShims() {
+  if (!(0, import_project_config.getConfig)().experimental?.rsc?.enabled) {
+    return;
+  }
+  globalThis.__rw_module_cache__ ||= /* @__PURE__ */ new Map();
+  globalThis.__webpack_chunk_load__ ||= async (id) => {
+    console.log("registerFwShims chunk load id", id);
+    return import(id).then((mod) => {
+      console.log("registerFwShims chunk load mod", mod);
+      if (mod.default && typeof mod.default === "object") {
+        return globalThis.__rw_module_cache__.set(id, mod.default);
+      }
+      return globalThis.__rw_module_cache__.set(id, mod);
+    });
+  };
+  globalThis.__webpack_require__ ||= (id) => {
+    console.log("registerFwShims require id", id);
+    return globalThis.__rw_module_cache__.get(id);
+  };
+}
+function swapLocalhostFor127(hostString) {
+  return hostString.replace("localhost", "127.0.0.1");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  registerFwGlobalsAndShims
+});

package/dist/cjs/middleware/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+module.exports = __toCommonJS(middleware_exports);
+__reExport(middleware_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./types.js")
+});

package/dist/cjs/middleware/invokeMiddleware.js

@@ -0,0 +1,52 @@
+"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);
+var invokeMiddleware_exports = {};
+__export(invokeMiddleware_exports, {
+  invoke: () => invoke
+});
+module.exports = __toCommonJS(invokeMiddleware_exports);
+var import_server_store = require("@cedarjs/server-store");
+var import_middleware = require("@cedarjs/web/dist/server/middleware");
+const invoke = async (req, middleware, options) => {
+  const mwReq = new import_middleware.MiddlewareRequest(req);
+  if (typeof middleware !== "function") {
+    (0, import_server_store.setServerAuthState)(mwReq.serverAuthState.get());
+    return [import_middleware.MiddlewareResponse.next(), mwReq.serverAuthState.get()];
+  }
+  let mwRes = import_middleware.MiddlewareResponse.next();
+  try {
+    const output = await middleware(mwReq, import_middleware.MiddlewareResponse.next(), options) || import_middleware.MiddlewareResponse.next();
+    mwRes = output;
+  } catch (e) {
+    if (e instanceof import_middleware.MiddlewareShortCircuit) {
+      return [e.mwResponse, mwReq.serverAuthState.get()];
+    }
+    console.error("Error executing middleware > \n");
+    console.error("~".repeat(80));
+    console.error(e);
+    console.error("~".repeat(80));
+  } finally {
+    (0, import_server_store.setServerAuthState)(mwReq.serverAuthState.get());
+  }
+  return [mwRes, mwReq.serverAuthState.get()];
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  invoke
+});

package/dist/cjs/middleware/register.js

@@ -0,0 +1,106 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var register_exports = {};
+__export(register_exports, {
+  addMiddlewareHandlers: () => addMiddlewareHandlers,
+  chain: () => chain,
+  createMiddlewareRouter: () => createMiddlewareRouter,
+  groupByRoutePatterns: () => groupByRoutePatterns
+});
+module.exports = __toCommonJS(register_exports);
+var import_find_my_way = __toESM(require("find-my-way"), 1);
+var import_project_config = require("@cedarjs/project-config");
+var import_middleware = require("@cedarjs/web/middleware");
+var import_utils = require("../utils.js");
+const validateMw = (mw) => {
+  if (typeof mw === "function") {
+    return mw;
+  } else if (typeof mw === "object" && typeof mw.invoke === "function") {
+    return mw.invoke.bind(mw);
+  } else {
+    console.error("Received as middleware: ", mw);
+    throw new Error(
+      "Please check the return on registerMiddleware. Must be a Middleware function, Class or tuple of [Middleware, string]"
+    );
+  }
+};
+const groupByRoutePatterns = (mwRegList) => {
+  const grouped = {};
+  mwRegList.forEach((mwReg) => {
+    if (Array.isArray(mwReg)) {
+      const [mw, pattern = "*"] = mwReg;
+      const mwFunction = validateMw(mw);
+      if (!grouped[pattern]) {
+        grouped[pattern] = [];
+      }
+      grouped[pattern].push(mwFunction);
+    } else {
+      grouped["*"] = [...grouped["*"] || [], validateMw(mwReg)];
+    }
+  });
+  return grouped;
+};
+const chain = (mwList) => {
+  return async (req, res = import_middleware.MiddlewareResponse.next(), options) => {
+    let response = res;
+    for (const mw of mwList) {
+      const mwOutput = await mw(req, response, options);
+      if (mwOutput) {
+        response = mwOutput;
+      }
+    }
+    return response;
+  };
+};
+const addMiddlewareHandlers = (mwRegList = []) => {
+  const groupedMw = groupByRoutePatterns(mwRegList);
+  const mwRouter = (0, import_find_my_way.default)();
+  for (const pattern in groupedMw) {
+    const mwList = groupedMw[pattern];
+    const chainedMw = chain(mwList);
+    mwRouter.on(["GET", "POST"], pattern, chainedMw);
+  }
+  return mwRouter;
+};
+const createMiddlewareRouter = async (vite) => {
+  const rwPaths = (0, import_project_config.getPaths)();
+  const entryServerImport = vite ? await (0, import_utils.ssrLoadEntryServer)(vite) : await import((0, import_utils.makeFilePath)(rwPaths.web.distSsrEntryServer));
+  const { registerMiddleware } = entryServerImport;
+  if (!registerMiddleware) {
+    return (0, import_find_my_way.default)();
+  }
+  return addMiddlewareHandlers(await registerMiddleware());
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addMiddlewareHandlers,
+  chain,
+  createMiddlewareRouter,
+  groupByRoutePatterns
+});

package/dist/cjs/middleware/types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/plugins/vite-plugin-jsx-loader.js

@@ -0,0 +1,42 @@
+"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);
+var vite_plugin_jsx_loader_exports = {};
+__export(vite_plugin_jsx_loader_exports, {
+  handleJsAsJsx: () => handleJsAsJsx
+});
+module.exports = __toCommonJS(vite_plugin_jsx_loader_exports);
+var import_vite = require("vite");
+function handleJsAsJsx() {
+  return {
+    name: "transform-js-files-as-jsx",
+    async transform(code, id) {
+      if (!id.match(/src\/.*\.js$/)) {
+        return null;
+      }
+      return (0, import_vite.transformWithEsbuild)(code, id, {
+        loader: "jsx",
+        jsx: "automatic"
+      });
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleJsAsJsx
+});

package/dist/cjs/plugins/vite-plugin-remove-from-bundle.js

@@ -0,0 +1,56 @@
+"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);
+var vite_plugin_remove_from_bundle_exports = {};
+__export(vite_plugin_remove_from_bundle_exports, {
+  excludeOnMatch: () => excludeOnMatch,
+  removeFromBundle: () => removeFromBundle
+});
+module.exports = __toCommonJS(vite_plugin_remove_from_bundle_exports);
+function removeFromBundle(modulesToExclude, exportNames) {
+  const isMissingIdToExclude = modulesToExclude.some(
+    (module2) => module2.id === void 0
+  );
+  if (isMissingIdToExclude) {
+    throw new Error("You must specify an id to exclude");
+  }
+  return {
+    name: "remove-from-bundle",
+    apply: "build",
+    // <-- @MARK important
+    load: (id) => {
+      return excludeOnMatch(modulesToExclude, id, exportNames);
+    }
+  };
+}
+function generateModuleWithExports(exportNames) {
+  return {
+    code: `export default {}; ${exportNames.map((name) => `export const ${name} = undefined;`).join("\n")}`
+  };
+}
+function excludeOnMatch(modulesToExclude, id, exportNames = []) {
+  if (modulesToExclude.some((module2) => module2.id.test(id))) {
+    return generateModuleWithExports(exportNames);
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  excludeOnMatch,
+  removeFromBundle
+});

package/dist/cjs/plugins/vite-plugin-rsc-analyze.js

@@ -0,0 +1,104 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_rsc_analyze_exports = {};
+__export(vite_plugin_rsc_analyze_exports, {
+  rscAnalyzePlugin: () => rscAnalyzePlugin
+});
+module.exports = __toCommonJS(vite_plugin_rsc_analyze_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var swc = __toESM(require("@swc/core"), 1);
+function rscAnalyzePlugin(clientEntryCallback, serverEntryCallback) {
+  return {
+    name: "redwood-rsc-analyze-plugin",
+    transform(code, id) {
+      const ext = import_node_path.default.extname(id);
+      if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+        const mod = swc.parseSync(code, {
+          syntax: ext === ".ts" || ext === ".tsx" ? "typescript" : "ecmascript",
+          tsx: ext === ".tsx"
+        });
+        let directiveFound = false;
+        for (const item of mod.body) {
+          if (item.type === "ExpressionStatement" && item.expression.type === "StringLiteral") {
+            if (item.expression.value === "use client") {
+              clientEntryCallback(id);
+              directiveFound = true;
+            } else if (item.expression.value === "use server") {
+              serverEntryCallback(id);
+              directiveFound = true;
+            }
+          }
+        }
+        if (!directiveFound && code.includes("use server") && containsServerAction(mod)) {
+          serverEntryCallback(id);
+        }
+      }
+      return code;
+    }
+  };
+}
+function isServerAction(node) {
+  return node.body?.type === "BlockStatement" && node.body.stmts.some(
+    (s) => s.type === "ExpressionStatement" && s.expression.type === "StringLiteral" && s.expression.value === "use server"
+  );
+}
+function isFunctionDeclaration(node) {
+  return node.type === "FunctionDeclaration";
+}
+function isFunctionExpression(node) {
+  return node.type === "FunctionExpression";
+}
+function isArrowFunctionExpression(node) {
+  return node.type === "ArrowFunctionExpression";
+}
+function containsServerAction(mod) {
+  function walk(node) {
+    if (isFunctionDeclaration(node) || isFunctionExpression(node) || isArrowFunctionExpression(node)) {
+      if (isServerAction(node)) {
+        return true;
+      }
+    }
+    return Object.values(node).some(
+      (value) => (Array.isArray(value) ? value : [value]).some((v) => {
+        if (typeof v?.type === "string") {
+          return walk(v);
+        }
+        if (typeof v?.expression?.type === "string") {
+          return walk(v.expression);
+        }
+        return false;
+      })
+    );
+  }
+  return walk(mod);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscAnalyzePlugin
+});

package/dist/cjs/plugins/vite-plugin-rsc-reload.js

@@ -0,0 +1,75 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vite_plugin_rsc_reload_exports = {};
+__export(vite_plugin_rsc_reload_exports, {
+  rscReloadPlugin: () => rscReloadPlugin
+});
+module.exports = __toCommonJS(vite_plugin_rsc_reload_exports);
+var import_node_path = __toESM(require("node:path"), 1);
+var swc = __toESM(require("@swc/core"), 1);
+function rscReloadPlugin(fn) {
+  let enabled = false;
+  const isClientEntry = (id, code) => {
+    const ext = import_node_path.default.extname(id);
+    if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
+      const mod = swc.parseSync(code, {
+        syntax: ext === ".ts" || ext === ".tsx" ? "typescript" : "ecmascript",
+        tsx: ext === ".tsx"
+      });
+      for (const item of mod.body) {
+        if (item.type === "ExpressionStatement" && item.expression.type === "StringLiteral" && item.expression.value === "use client") {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+  return {
+    name: "reload-plugin",
+    configResolved(config) {
+      if (config.mode === "development") {
+        enabled = true;
+      }
+    },
+    async handleHotUpdate(ctx) {
+      if (!enabled) {
+        return [];
+      }
+      if (ctx.modules.length && !isClientEntry(ctx.file, await ctx.read())) {
+        return fn("full-reload");
+      } else {
+        return [];
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  rscReloadPlugin
+});