react-server-dom-webpack 0.0.1 → 18.3.0-next-d925a8d0b-20221024

package/cjs/react-server-dom-webpack-client.production.min.js

@@ -0,0 +1,26 @@
+/**
+ * @license React
+ * react-server-dom-webpack-client.production.min.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var h=require("react"),k={stream:!0};function m(a,b){return a?(a=a[b.id][b.name],b.async?{id:a.id,chunks:a.chunks,name:a.name,async:!0}:a):b}var n=new Map,p=new Map;function q(){}
+function r(a){for(var b=a.chunks,c=[],d=0;d<b.length;d++){var e=b[d],f=n.get(e);if(void 0===f){f=__webpack_chunk_load__(e);c.push(f);var l=n.set.bind(n,e,null);f.then(l,q);n.set(e,f)}else null!==f&&c.push(f)}if(a.async){if(b=p.get(a.id))return"fulfilled"===b.status?null:b;var g=Promise.all(c).then(function(){return __webpack_require__(a.id)});g.then(function(a){g.status="fulfilled";g.value=a},function(a){g.status="rejected";g.reason=a});p.set(a.id,g);return g}return 0<c.length?Promise.all(c):null}
+var t=Symbol.for("react.element"),u=Symbol.for("react.lazy"),v=Symbol.for("react.default_value"),w=h.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ContextRegistry;function x(a){w[a]||(w[a]=h.createServerContext(a,v));return w[a]}function y(a,b,c,d){this.status=a;this.value=b;this.reason=c;this._response=d}y.prototype=Object.create(Promise.prototype);
+y.prototype.then=function(a,b){switch(this.status){case "resolved_model":z(this);break;case "resolved_module":B(this)}switch(this.status){case "fulfilled":a(this.value);break;case "pending":case "blocked":a&&(null===this.value&&(this.value=[]),this.value.push(a));b&&(null===this.reason&&(this.reason=[]),this.reason.push(b));break;default:b(this.reason)}};
+function C(a){switch(a.status){case "resolved_model":z(a);break;case "resolved_module":B(a)}switch(a.status){case "fulfilled":return a.value;case "pending":case "blocked":throw a;default:throw a.reason;}}function D(a,b){return new y("fulfilled",b,null,a)}function E(a,b){for(var c=0;c<a.length;c++)(0,a[c])(b)}function F(a,b,c){switch(a.status){case "fulfilled":E(b,a.value);break;case "pending":case "blocked":a.value=b;a.reason=c;break;case "rejected":c&&E(c,a.reason)}}
+function G(a,b){if("pending"===a.status||"blocked"===a.status){var c=a.reason;a.status="rejected";a.reason=b;null!==c&&E(c,b)}}function H(a,b){if("pending"===a.status||"blocked"===a.status){var c=a.value,d=a.reason;a.status="resolved_module";a.value=b;null!==c&&(B(a),F(a,c,d))}}var I=null,J=null;
+function z(a){var b=I,c=J;I=a;J=null;try{var d=JSON.parse(a.value,a._response._fromJSON);null!==J&&0<J.deps?(J.value=d,a.status="blocked",a.value=null,a.reason=null):(a.status="fulfilled",a.value=d)}catch(e){a.status="rejected",a.reason=e}finally{I=b,J=c}}
+function B(a){try{var b=a.value;if(b.async){var c=p.get(b.id);if("fulfilled"===c.status)var d=c.value;else throw c.reason;}else d=__webpack_require__(b.id);var e="*"===b.name?d:""===b.name?d.__esModule?d.default:d:d[b.name];a.status="fulfilled";a.value=e}catch(f){a.status="rejected",a.reason=f}}function K(a,b){a._chunks.forEach(function(a){"pending"===a.status&&G(a,b)})}function L(a,b){var c=a._chunks,d=c.get(b);d||(d=new y("pending",null,null,a),c.set(b,d));return d}
+function N(a,b,c){if(J){var d=J;d.deps++}else d=J={deps:1,value:null};return function(e){b[c]=e;d.deps--;0===d.deps&&"blocked"===a.status&&(e=a.value,a.status="fulfilled",a.value=d.value,null!==e&&E(e,d.value))}}function O(a){return function(b){return G(a,b)}}
+function P(a,b,c,d){switch(d[0]){case "$":if("$"===d)return t;if("$"===d[1]||"@"===d[1])return d.substring(1);d=parseInt(d.substring(1),16);a=L(a,d);switch(a.status){case "resolved_model":z(a);break;case "resolved_module":B(a)}switch(a.status){case "fulfilled":return a.value;case "pending":case "blocked":return d=I,a.then(N(d,b,c),O(d)),null;default:throw a.reason;}case "@":return b=parseInt(d.substring(1),16),b=L(a,b),{$$typeof:u,_payload:b,_init:C}}return d}
+function Q(a,b,c){var d=a._chunks,e=d.get(b);c=JSON.parse(c,a._fromJSON);var f=m(a._bundlerConfig,c);if(c=r(f)){if(e){var l=e;l.status="blocked"}else l=new y("blocked",null,null,a),d.set(b,l);c.then(function(){return H(l,f)},function(a){return G(l,a)})}else e?H(e,f):d.set(b,new y("resolved_module",f,null,a))}function R(a){K(a,Error("Connection closed."))}
+function S(a,b){if(""!==b){var c=b[0],d=b.indexOf(":",1),e=parseInt(b.substring(1,d),16);b=b.substring(d+1);switch(c){case "J":d=a._chunks;(c=d.get(e))?"pending"===c.status&&(a=c.value,e=c.reason,c.status="resolved_model",c.value=b,null!==a&&(z(c),F(c,a,e))):d.set(e,new y("resolved_model",b,null,a));break;case "M":Q(a,e,b);break;case "P":a._chunks.set(e,D(a,x(b).Provider));break;case "S":b=JSON.parse(b);a._chunks.set(e,D(a,Symbol.for(b)));break;case "E":c=JSON.parse(b).digest;b=Error("An error occurred in the Server Components render. The specific message is omitted in production builds to avoid leaking sensitive details. A digest property is included on this error instance which may provide additional details about the nature of the error.");
+b.stack="Error: "+b.message;b.digest=c;c=a._chunks;(d=c.get(e))?G(d,b):c.set(e,new y("rejected",null,b,a));break;default:throw Error("Error parsing the data. It's probably an error code or network corruption.");}}}function T(a){return function(b,c){return"string"===typeof c?P(a,this,b,c):"object"===typeof c&&null!==c?(b=c[0]===t?{$$typeof:t,type:c[1],key:c[2],ref:null,props:c[3],_owner:null}:c,b):c}}
+function U(a){var b=new TextDecoder,c=new Map;a={_bundlerConfig:a,_chunks:c,_partialRow:"",_stringDecoder:b};a._fromJSON=T(a);return a}function V(a,b){function c(b){var f=b.value;if(b.done)R(a);else{b=f;f=a._stringDecoder;for(var g=b.indexOf(10);-1<g;){var M=a._partialRow;var A=b.subarray(0,g);A=f.decode(A);S(a,M+A);a._partialRow="";b=b.subarray(g+1);g=b.indexOf(10)}a._partialRow+=f.decode(b,k);return e.read().then(c).catch(d)}}function d(b){K(a,b)}var e=b.getReader();e.read().then(c).catch(d)}
+exports.createFromFetch=function(a,b){var c=U(b&&b.moduleMap?b.moduleMap:null);a.then(function(a){V(c,a.body)},function(a){K(c,a)});return L(c,0)};exports.createFromReadableStream=function(a,b){b=U(b&&b.moduleMap?b.moduleMap:null);V(b,a);return L(b,0)};
+exports.createFromXHR=function(a,b){function c(){for(var b=a.responseText,c=f,d=b.indexOf("\n",c);-1<d;)c=e._partialRow+b.substring(c,d),S(e,c),e._partialRow="",c=d+1,d=b.indexOf("\n",c);e._partialRow+=b.substring(c);f=b.length}function d(){K(e,new TypeError("Network error"))}var e=U(b&&b.moduleMap?b.moduleMap:null),f=0;a.addEventListener("progress",c);a.addEventListener("load",function(){c();R(e)});a.addEventListener("error",d);a.addEventListener("abort",d);a.addEventListener("timeout",d);return L(e,
+0)};

package/cjs/react-server-dom-webpack-node-register.js

@@ -0,0 +1,143 @@
+/**
+ * @license React
+ * react-server-dom-webpack-node-register.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+'use strict';
+
+var url = require('url');
+
+var Module = require('module');
+
+module.exports = function register() {
+  var MODULE_REFERENCE = Symbol.for('react.module.reference');
+  var PROMISE_PROTOTYPE = Promise.prototype;
+  var proxyHandlers = {
+    get: function (target, name, receiver) {
+      switch (name) {
+        // These names are read by the Flight runtime if you end up using the exports object.
+        case '$$typeof':
+          // These names are a little too common. We should probably have a way to
+          // have the Flight runtime extract the inner target instead.
+          return target.$$typeof;
+
+        case 'filepath':
+          return target.filepath;
+
+        case 'name':
+          return target.name;
+
+        case 'async':
+          return target.async;
+        // We need to special case this because createElement reads it if we pass this
+        // reference.
+
+        case 'defaultProps':
+          return undefined;
+
+        case '__esModule':
+          // Something is conditionally checking which export to use. We'll pretend to be
+          // an ESM compat module but then we'll check again on the client.
+          target.default = {
+            $$typeof: MODULE_REFERENCE,
+            filepath: target.filepath,
+            // This a placeholder value that tells the client to conditionally use the
+            // whole object or just the default export.
+            name: '',
+            async: target.async
+          };
+          return true;
+
+        case 'then':
+          if (!target.async) {
+            // If this module is expected to return a Promise (such as an AsyncModule) then
+            // we should resolve that with a client reference that unwraps the Promise on
+            // the client.
+            var then = function then(resolve, reject) {
+              var moduleReference = {
+                $$typeof: MODULE_REFERENCE,
+                filepath: target.filepath,
+                name: '*',
+                // Represents the whole object instead of a particular import.
+                async: true
+              };
+              return Promise.resolve( // $FlowFixMe[incompatible-call] found when upgrading Flow
+              resolve(new Proxy(moduleReference, proxyHandlers)));
+            }; // If this is not used as a Promise but is treated as a reference to a `.then`
+            // export then we should treat it as a reference to that name.
+
+
+            then.$$typeof = MODULE_REFERENCE;
+            then.filepath = target.filepath; // then.name is conveniently already "then" which is the export name we need.
+            // This will break if it's minified though.
+
+            return then;
+          }
+
+      }
+
+      var cachedReference = target[name];
+
+      if (!cachedReference) {
+        cachedReference = target[name] = {
+          $$typeof: MODULE_REFERENCE,
+          filepath: target.filepath,
+          name: name,
+          async: target.async
+        };
+      }
+
+      return cachedReference;
+    },
+    getPrototypeOf: function (target) {
+      // Pretend to be a Promise in case anyone asks.
+      return PROMISE_PROTOTYPE;
+    },
+    set: function () {
+      throw new Error('Cannot assign to a client module from a server module.');
+    }
+  }; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+  Module._extensions['.client.js'] = function (module, path) {
+    var moduleId = url.pathToFileURL(path).href;
+    var moduleReference = {
+      $$typeof: MODULE_REFERENCE,
+      filepath: moduleId,
+      name: '*',
+      // Represents the whole object instead of a particular import.
+      async: false
+    }; // $FlowFixMe[incompatible-call] found when upgrading Flow
+
+    module.exports = new Proxy(moduleReference, proxyHandlers);
+  }; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+
+  var originalResolveFilename = Module._resolveFilename; // $FlowFixMe[prop-missing] found when upgrading Flow
+
+  Module._resolveFilename = function (request, parent, isMain, options) {
+    var resolved = originalResolveFilename.apply(this, arguments);
+
+    if (resolved.endsWith('.server.js')) {
+      if (parent && parent.filename && !parent.filename.endsWith('.server.js')) {
+        var reason;
+
+        if (request.endsWith('.server.js')) {
+          reason = "\"" + request + "\"";
+        } else {
+          reason = "\"" + request + "\" (which expands to \"" + resolved + "\")";
+        }
+
+        throw new Error("Cannot import " + reason + " from \"" + parent.filename + "\". " + 'By react-server convention, .server.js files can only be imported from other .server.js files. ' + 'That way nobody accidentally sends these to the client by indirectly importing it.');
+      }
+    }
+
+    return resolved;
+  };
+};

package/cjs/react-server-dom-webpack-plugin.js

@@ -0,0 +1,255 @@
+/**
+ * @license React
+ * react-server-dom-webpack-plugin.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+'use strict';
+
+'use strict';
+
+var path = require('path');
+var url = require('url');
+var asyncLib = require('neo-async');
+var ModuleDependency = require('webpack/lib/dependencies/ModuleDependency');
+var NullDependency = require('webpack/lib/dependencies/NullDependency');
+var Template = require('webpack/lib/Template');
+var webpack = require('webpack');
+
+var isArrayImpl = Array.isArray; // eslint-disable-next-line no-redeclare
+
+function isArray(a) {
+  return isArrayImpl(a);
+}
+
+class ClientReferenceDependency extends ModuleDependency {
+  constructor(request) {
+    super(request);
+  }
+
+  get type() {
+    return 'client-reference';
+  }
+
+} // This is the module that will be used to anchor all client references to.
+// I.e. it will have all the client files as async deps from this point on.
+// We use the Flight client implementation because you can't get to these
+// without the client runtime so it's the first time in the loading sequence
+// you might want them.
+
+
+var clientImportName = 'react-server-dom-webpack/client';
+
+var clientFileName = require.resolve('../client');
+
+var PLUGIN_NAME = 'React Server Plugin';
+class ReactFlightWebpackPlugin {
+  constructor(options) {
+    if (!options || typeof options.isServer !== 'boolean') {
+      throw new Error(PLUGIN_NAME + ': You must specify the isServer option as a boolean.');
+    }
+
+    if (options.isServer) {
+      throw new Error('TODO: Implement the server compiler.');
+    }
+
+    if (!options.clientReferences) {
+      this.clientReferences = [{
+        directory: '.',
+        recursive: true,
+        include: /\.client\.(js|ts|jsx|tsx)$/
+      }];
+    } else if (typeof options.clientReferences === 'string' || !isArray(options.clientReferences)) {
+      this.clientReferences = [options.clientReferences];
+    } else {
+      // $FlowFixMe[incompatible-type] found when upgrading Flow
+      this.clientReferences = options.clientReferences;
+    }
+
+    if (typeof options.chunkName === 'string') {
+      this.chunkName = options.chunkName;
+
+      if (!/\[(index|request)\]/.test(this.chunkName)) {
+        this.chunkName += '[index]';
+      }
+    } else {
+      this.chunkName = 'client[index]';
+    }
+
+    this.manifestFilename = options.manifestFilename || 'react-client-manifest.json';
+  }
+
+  apply(compiler) {
+    var _this = this;
+
+    var resolvedClientReferences;
+    var clientFileNameFound = false; // Find all client files on the file system
+
+    compiler.hooks.beforeCompile.tapAsync(PLUGIN_NAME, function (_ref, callback) {
+      var contextModuleFactory = _ref.contextModuleFactory;
+      var contextResolver = compiler.resolverFactory.get('context', {});
+
+      _this.resolveAllClientFiles(compiler.context, contextResolver, compiler.inputFileSystem, contextModuleFactory, function (err, resolvedClientRefs) {
+        if (err) {
+          callback(err);
+          return;
+        }
+
+        resolvedClientReferences = resolvedClientRefs;
+        callback();
+      });
+    });
+    compiler.hooks.thisCompilation.tap(PLUGIN_NAME, function (compilation, _ref2) {
+      var normalModuleFactory = _ref2.normalModuleFactory;
+      compilation.dependencyFactories.set(ClientReferenceDependency, normalModuleFactory);
+      compilation.dependencyTemplates.set(ClientReferenceDependency, new NullDependency.Template());
+
+      var handler = function (parser) {
+        // We need to add all client references as dependency of something in the graph so
+        // Webpack knows which entries need to know about the relevant chunks and include the
+        // map in their runtime. The things that actually resolves the dependency is the Flight
+        // client runtime. So we add them as a dependency of the Flight client runtime.
+        // Anything that imports the runtime will be made aware of these chunks.
+        parser.hooks.program.tap(PLUGIN_NAME, function () {
+          var module = parser.state.module;
+
+          if (module.resource !== clientFileName) {
+            return;
+          }
+
+          clientFileNameFound = true;
+
+          if (resolvedClientReferences) {
+            // $FlowFixMe[incompatible-use] found when upgrading Flow
+            for (var i = 0; i < resolvedClientReferences.length; i++) {
+              // $FlowFixMe[incompatible-use] found when upgrading Flow
+              var dep = resolvedClientReferences[i];
+
+              var chunkName = _this.chunkName.replace(/\[index\]/g, '' + i).replace(/\[request\]/g, Template.toPath(dep.userRequest));
+
+              var block = new webpack.AsyncDependenciesBlock({
+                name: chunkName
+              }, null, dep.request);
+              block.addDependency(dep);
+              module.addBlock(block);
+            }
+          }
+        });
+      };
+
+      normalModuleFactory.hooks.parser.for('javascript/auto').tap('HarmonyModulesPlugin', handler);
+      normalModuleFactory.hooks.parser.for('javascript/esm').tap('HarmonyModulesPlugin', handler);
+      normalModuleFactory.hooks.parser.for('javascript/dynamic').tap('HarmonyModulesPlugin', handler);
+    });
+    compiler.hooks.make.tap(PLUGIN_NAME, function (compilation) {
+      compilation.hooks.processAssets.tap({
+        name: PLUGIN_NAME,
+        stage: webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT
+      }, function () {
+        if (clientFileNameFound === false) {
+          compilation.warnings.push(new webpack.WebpackError("Client runtime at " + clientImportName + " was not found. React Server Components module map file " + _this.manifestFilename + " was not created."));
+          return;
+        }
+
+        var json = {};
+        compilation.chunkGroups.forEach(function (chunkGroup) {
+          var chunkIds = chunkGroup.chunks.map(function (c) {
+            return c.id;
+          });
+
+          function recordModule(id, module) {
+            // TODO: Hook into deps instead of the target module.
+            // That way we know by the type of dep whether to include.
+            // It also resolves conflicts when the same module is in multiple chunks.
+            if (!/\.client\.(js|ts)x?$/.test(module.resource)) {
+              return;
+            }
+
+            var moduleProvidedExports = compilation.moduleGraph.getExportsInfo(module).getProvidedExports();
+            var moduleExports = {};
+            ['', '*'].concat(Array.isArray(moduleProvidedExports) ? moduleProvidedExports : []).forEach(function (name) {
+              moduleExports[name] = {
+                id: id,
+                chunks: chunkIds,
+                name: name
+              };
+            });
+            var href = url.pathToFileURL(module.resource).href;
+
+            if (href !== undefined) {
+              json[href] = moduleExports;
+            }
+          }
+
+          chunkGroup.chunks.forEach(function (chunk) {
+            var chunkModules = compilation.chunkGraph.getChunkModulesIterable(chunk);
+            Array.from(chunkModules).forEach(function (module) {
+              var moduleId = compilation.chunkGraph.getModuleId(module);
+              recordModule(moduleId, module); // If this is a concatenation, register each child to the parent ID.
+
+              if (module.modules) {
+                module.modules.forEach(function (concatenatedMod) {
+                  recordModule(moduleId, concatenatedMod);
+                });
+              }
+            });
+          });
+        });
+        var output = JSON.stringify(json, null, 2);
+        compilation.emitAsset(_this.manifestFilename, new webpack.sources.RawSource(output, false));
+      });
+    });
+  } // This attempts to replicate the dynamic file path resolution used for other wildcard
+  // resolution in Webpack is using.
+
+
+  resolveAllClientFiles(context, contextResolver, fs, contextModuleFactory, callback) {
+    asyncLib.map(this.clientReferences, function (clientReferencePath, cb) {
+      if (typeof clientReferencePath === 'string') {
+        cb(null, [new ClientReferenceDependency(clientReferencePath)]);
+        return;
+      }
+
+      var clientReferenceSearch = clientReferencePath;
+      contextResolver.resolve({}, context, clientReferencePath.directory, {}, function (err, resolvedDirectory) {
+        if (err) return cb(err);
+        var options = {
+          resource: resolvedDirectory,
+          resourceQuery: '',
+          recursive: clientReferenceSearch.recursive === undefined ? true : clientReferenceSearch.recursive,
+          regExp: clientReferenceSearch.include,
+          include: undefined,
+          exclude: clientReferenceSearch.exclude
+        };
+        contextModuleFactory.resolveDependencies(fs, options, function (err2, deps) {
+          if (err2) return cb(err2);
+          var clientRefDeps = deps.map(function (dep) {
+            // use userRequest instead of request. request always end with undefined which is wrong
+            var request = path.join(resolvedDirectory, dep.userRequest);
+            var clientRefDep = new ClientReferenceDependency(request);
+            clientRefDep.userRequest = dep.userRequest;
+            return clientRefDep;
+          });
+          cb(null, clientRefDeps);
+        });
+      });
+    }, function (err, result) {
+      if (err) return callback(err);
+      var flat = [];
+
+      for (var i = 0; i < result.length; i++) {
+        // $FlowFixMe[method-unbinding]
+        flat.push.apply(flat, result[i]);
+      }
+
+      callback(null, flat);
+    });
+  }
+
+}
+
+module.exports = ReactFlightWebpackPlugin;