react-server-dom-webpack 18.3.0-next-594093496-20230209 → 18.3.0-next-55542bc73-20230210

package/esm/react-server-dom-webpack-node-loader.js

@@ -8,58 +8,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED } from 'react';
 import { parse } from 'acorn';
 
-var ReactSharedInternals = __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+const assign = Object.assign;
 
-// by calls to these methods by a Babel plugin.
-//
-// In PROD (or in packages without access to React internals),
-// they are left as they are instead.
-
-function warn(format) {
-  {
-    {
-      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        args[_key - 1] = arguments[_key];
-      }
-
-      printWarning('warn', format, args);
-    }
-  }
-}
-
-function printWarning(level, format, args) {
-  // When changing this logic, you might want to also
-  // update consoleWithStackDev.www.js as well.
-  {
-    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
-    var stack = ReactDebugCurrentFrame.getStackAddendum();
-
-    if (stack !== '') {
-      format += '%s';
-      args = args.concat([stack]);
-    } // eslint-disable-next-line react-internal/safe-string-coercion
-
-
-    var argsWithFormat = args.map(function (item) {
-      return String(item);
-    }); // Careful: RN currently depends on this prefix
-
-    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
-    // breaks IE9: https://github.com/facebook/react/issues/13610
-    // eslint-disable-next-line react-internal/no-production-logging
-
-    Function.prototype.apply.call(console[level], console, argsWithFormat);
-  }
-}
-
-var assign = Object.assign;
-
-var warnedAboutConditionsFlag = false;
-var stashedGetSource = null;
-var stashedResolve = null;
+let warnedAboutConditionsFlag = false;
+let stashedGetSource = null;
+let stashedResolve = null;
 async function resolve(specifier, context, defaultResolve) {
   // We stash this in case we end up needing to resolve export * statements later.
   stashedResolve = defaultResolve;
@@ -72,7 +27,7 @@ async function resolve(specifier, context, defaultResolve) {
     if (!warnedAboutConditionsFlag) {
       warnedAboutConditionsFlag = true; // eslint-disable-next-line react-internal/no-production-logging
 
-      warn('You did not run Node.js with the `--conditions react-server` flag. ' + 'Any "react-server" override will only work with ESM imports.');
+      console.warn('You did not run Node.js with the `--conditions react-server` flag. ' + 'Any "react-server" override will only work with ESM imports.');
     }
   }
 
@@ -84,6 +39,116 @@ async function getSource(url, context, defaultGetSource) {
   return defaultGetSource(url, context, defaultGetSource);
 }
 
+function addLocalExportedNames(names, node) {
+  switch (node.type) {
+    case 'Identifier':
+      names.set(node.name, node.name);
+      return;
+
+    case 'ObjectPattern':
+      for (let i = 0; i < node.properties.length; i++) addLocalExportedNames(names, node.properties[i]);
+
+      return;
+
+    case 'ArrayPattern':
+      for (let i = 0; i < node.elements.length; i++) {
+        const element = node.elements[i];
+        if (element) addLocalExportedNames(names, element);
+      }
+
+      return;
+
+    case 'Property':
+      addLocalExportedNames(names, node.value);
+      return;
+
+    case 'AssignmentPattern':
+      addLocalExportedNames(names, node.left);
+      return;
+
+    case 'RestElement':
+      addLocalExportedNames(names, node.argument);
+      return;
+
+    case 'ParenthesizedExpression':
+      addLocalExportedNames(names, node.expression);
+      return;
+  }
+}
+
+function transformServerModule(source, body, url, loader) {
+  // If the same local name is exported more than once, we only need one of the names.
+  const localNames = new Map();
+  const localTypes = new Map();
+
+  for (let i = 0; i < body.length; i++) {
+    const node = body[i];
+
+    switch (node.type) {
+      case 'ExportAllDeclaration':
+        // If export * is used, the other file needs to explicitly opt into "use server" too.
+        break;
+
+      case 'ExportDefaultDeclaration':
+        if (node.declaration.type === 'Identifier') {
+          localNames.set(node.declaration.name, 'default');
+        } else if (node.declaration.type === 'FunctionDeclaration') {
+          if (node.declaration.id) {
+            localNames.set(node.declaration.id.name, 'default');
+            localTypes.set(node.declaration.id.name, 'function');
+          }
+        }
+
+        continue;
+
+      case 'ExportNamedDeclaration':
+        if (node.declaration) {
+          if (node.declaration.type === 'VariableDeclaration') {
+            const declarations = node.declaration.declarations;
+
+            for (let j = 0; j < declarations.length; j++) {
+              addLocalExportedNames(localNames, declarations[j].id);
+            }
+          } else {
+            const name = node.declaration.id.name;
+            localNames.set(name, name);
+
+            if (node.declaration.type === 'FunctionDeclaration') {
+              localTypes.set(name, 'function');
+            }
+          }
+        }
+
+        if (node.specifiers) {
+          const specifiers = node.specifiers;
+
+          for (let j = 0; j < specifiers.length; j++) {
+            const specifier = specifiers[j];
+            localNames.set(specifier.local.name, specifier.exported.name);
+          }
+        }
+
+        continue;
+    }
+  }
+
+  let newSrc = source + '\n\n;';
+  localNames.forEach(function (exported, local) {
+    if (localTypes.get(local) !== 'function') {
+      // We first check if the export is a function and if so annotate it.
+      newSrc += 'if (typeof ' + local + ' === "function") ';
+    }
+
+    newSrc += 'Object.defineProperties(' + local + ',{';
+    newSrc += '$$typeof: {value: Symbol.for("react.server.reference")},';
+    newSrc += '$$filepath: {value: ' + JSON.stringify(url) + '},';
+    newSrc += '$$name: { value: ' + JSON.stringify(exported) + '},';
+    newSrc += '$$bound: { value: [] }';
+    newSrc += '});\n';
+  });
+  return newSrc;
+}
+
 function addExportNames(names, node) {
   switch (node.type) {
     case 'Identifier':
@@ -91,15 +156,13 @@ function addExportNames(names, node) {
       return;
 
     case 'ObjectPattern':
-      for (var i = 0; i < node.properties.length; i++) {
-        addExportNames(names, node.properties[i]);
-      }
+      for (let i = 0; i < node.properties.length; i++) addExportNames(names, node.properties[i]);
 
       return;
 
     case 'ArrayPattern':
-      for (var _i = 0; _i < node.elements.length; _i++) {
-        var element = node.elements[_i];
+      for (let i = 0; i < node.elements.length; i++) {
+        const element = node.elements[i];
         if (element) addExportNames(names, element);
       }
 
@@ -129,21 +192,21 @@ function resolveClientImport(specifier, parentURL) {
   // This resolution algorithm will not necessarily have the same configuration
   // as the actual client loader. It should mostly work and if it doesn't you can
   // always convert to explicit exported names instead.
-  var conditions = ['node', 'import'];
+  const conditions = ['node', 'import'];
 
   if (stashedResolve === null) {
     throw new Error('Expected resolve to have been called before transformSource');
   }
 
   return stashedResolve(specifier, {
-    conditions: conditions,
-    parentURL: parentURL
+    conditions,
+    parentURL
   }, stashedResolve);
 }
 
 async function parseExportNamesInto(body, names, parentURL, loader) {
-  for (var i = 0; i < body.length; i++) {
-    var node = body[i];
+  for (let i = 0; i < body.length; i++) {
+    const node = body[i];
 
     switch (node.type) {
       case 'ExportAllDeclaration':
@@ -151,25 +214,25 @@ async function parseExportNamesInto(body, names, parentURL, loader) {
           addExportNames(names, node.exported);
           continue;
         } else {
-          var _await$resolveClientI = await resolveClientImport(node.source.value, parentURL),
-              url = _await$resolveClientI.url;
+          const _await$resolveClientI = await resolveClientImport(node.source.value, parentURL),
+                url = _await$resolveClientI.url;
 
-          var _await$loader = await loader(url, {
+          const _await$loader = await loader(url, {
             format: 'module',
             conditions: [],
             importAssertions: {}
           }, loader),
-              source = _await$loader.source;
+                source = _await$loader.source;
 
           if (typeof source !== 'string') {
             throw new Error('Expected the transformed source to be a string.');
           }
 
-          var _acorn$parse = parse(source, {
+          const _acorn$parse = parse(source, {
             ecmaVersion: '2019',
             sourceType: 'module'
           }),
-              childBody = _acorn$parse.body;
+                childBody = _acorn$parse.body;
 
           await parseExportNamesInto(childBody, names, url, loader);
           continue;
@@ -182,9 +245,9 @@ async function parseExportNamesInto(body, names, parentURL, loader) {
       case 'ExportNamedDeclaration':
         if (node.declaration) {
           if (node.declaration.type === 'VariableDeclaration') {
-            var declarations = node.declaration.declarations;
+            const declarations = node.declaration.declarations;
 
-            for (var j = 0; j < declarations.length; j++) {
+            for (let j = 0; j < declarations.length; j++) {
               addExportNames(names, declarations[j].id);
             }
           } else {
@@ -193,10 +256,10 @@ async function parseExportNamesInto(body, names, parentURL, loader) {
         }
 
         if (node.specifiers) {
-          var specifiers = node.specifiers;
+          const specifiers = node.specifiers;
 
-          for (var _j = 0; _j < specifiers.length; _j++) {
-            addExportNames(names, specifiers[_j].exported);
+          for (let j = 0; j < specifiers.length; j++) {
+            addExportNames(names, specifiers[j].exported);
           }
         }
 
@@ -205,44 +268,13 @@ async function parseExportNamesInto(body, names, parentURL, loader) {
   }
 }
 
-async function transformClientModule(source, url, loader) {
-  var names = []; // Do a quick check for the exact string. If it doesn't exist, don't
-  // bother parsing.
-
-  if (source.indexOf('use client') === -1) {
-    return source;
-  }
-
-  var _acorn$parse2 = parse(source, {
-    ecmaVersion: '2019',
-    sourceType: 'module'
-  }),
-      body = _acorn$parse2.body;
-
-  var useClient = false;
-
-  for (var i = 0; i < body.length; i++) {
-    var node = body[i];
-
-    if (node.type !== 'ExpressionStatement' || !node.directive) {
-      break;
-    }
-
-    if (node.directive === 'use client') {
-      useClient = true;
-      break;
-    }
-  }
-
-  if (!useClient) {
-    return source;
-  }
-
+async function transformClientModule(body, url, loader) {
+  const names = [];
   await parseExportNamesInto(body, names, url, loader);
-  var newSrc = "const CLIENT_REFERENCE = Symbol.for('react.client.reference');\n";
+  let newSrc = "const CLIENT_REFERENCE = Symbol.for('react.client.reference');\n";
 
-  for (var _i2 = 0; _i2 < names.length; _i2++) {
-    var name = names[_i2];
+  for (let i = 0; i < names.length; i++) {
+    const name = names[i];
 
     if (name === 'default') {
       newSrc += 'export default ';
@@ -270,14 +302,14 @@ async function loadClientImport(url, defaultTransformSource) {
   } // TODO: Validate that this is another module by calling getFormat.
 
 
-  var _await$stashedGetSour = await stashedGetSource(url, {
+  const _await$stashedGetSour = await stashedGetSource(url, {
     format: 'module'
   }, stashedGetSource),
-      source = _await$stashedGetSour.source;
+        source = _await$stashedGetSour.source;
 
-  var result = await defaultTransformSource(source, {
+  const result = await defaultTransformSource(source, {
     format: 'module',
-    url: url
+    url
   }, defaultTransformSource);
   return {
     format: 'module',
@@ -285,17 +317,64 @@ async function loadClientImport(url, defaultTransformSource) {
   };
 }
 
+async function transformModuleIfNeeded(source, url, loader) {
+  // Do a quick check for the exact string. If it doesn't exist, don't
+  // bother parsing.
+  if (source.indexOf('use client') === -1 && source.indexOf('use server') === -1) {
+    return source;
+  }
+
+  const _acorn$parse2 = parse(source, {
+    ecmaVersion: '2019',
+    sourceType: 'module'
+  }),
+        body = _acorn$parse2.body;
+
+  let useClient = false;
+  let useServer = false;
+
+  for (let i = 0; i < body.length; i++) {
+    const node = body[i];
+
+    if (node.type !== 'ExpressionStatement' || !node.directive) {
+      break;
+    }
+
+    if (node.directive === 'use client') {
+      useClient = true;
+    }
+
+    if (node.directive === 'use server') {
+      useServer = true;
+    }
+  }
+
+  if (!useClient && !useServer) {
+    return source;
+  }
+
+  if (useClient && useServer) {
+    throw new Error('Cannot have both "use client" and "use server" directives in the same file.');
+  }
+
+  if (useClient) {
+    return transformClientModule(body, url, loader);
+  }
+
+  return transformServerModule(source, body, url);
+}
+
 async function transformSource(source, context, defaultTransformSource) {
-  var transformed = await defaultTransformSource(source, context, defaultTransformSource);
+  const transformed = await defaultTransformSource(source, context, defaultTransformSource);
 
   if (context.format === 'module') {
-    var transformedSource = transformed.source;
+    const transformedSource = transformed.source;
 
     if (typeof transformedSource !== 'string') {
       throw new Error('Expected source to have been transformed to a string.');
     }
 
-    var newSrc = await transformClientModule(transformedSource, context.url, function (url, ctx, defaultLoad) {
+    const newSrc = await transformModuleIfNeeded(transformedSource, context.url, (url, ctx, defaultLoad) => {
       return loadClientImport(url, defaultTransformSource);
     });
     return {
@@ -307,13 +386,13 @@ async function transformSource(source, context, defaultTransformSource) {
 }
 async function load(url, context, defaultLoad) {
   if (context.format === 'module') {
-    var result = await defaultLoad(url, context, defaultLoad);
+    const result = await defaultLoad(url, context, defaultLoad);
 
     if (typeof result.source !== 'string') {
       throw new Error('Expected source to have been loaded into a string.');
     }
 
-    var newSrc = await transformClientModule(result.source, url, defaultLoad);
+    const newSrc = await transformModuleIfNeeded(result.source, url, defaultLoad);
     return {
       format: 'module',
       source: newSrc

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-server-dom-webpack",
   "description": "React Server Components bindings for DOM using Webpack. This is intended to be integrated into meta-frameworks. It is not intended to be imported directly.",
-  "version": "18.3.0-next-594093496-20230209",
+  "version": "18.3.0-next-55542bc73-20230210",
   "keywords": [
     "react"
   ],
@@ -54,8 +54,8 @@
     "node": ">=0.10.0"
   },
   "peerDependencies": {
-    "react": "18.3.0-next-594093496-20230209",
-    "react-dom": "18.3.0-next-594093496-20230209",
+    "react": "18.3.0-next-55542bc73-20230210",
+    "react-dom": "18.3.0-next-55542bc73-20230210",
     "webpack": "^5.59.0"
   },
   "dependencies": {