mirror of
https://github.com/facebook/react.git
synced 2025-11-01 09:12:30 +00:00
Sebastian Markbåge
da6c23a45c
We currently don't just "require" a module by its module id/path. We encode the pair of module id/path AND its export name. That's because with module splitting, a single original module can end up in two or more separate modules by name. Therefore the manifest files need to encode how to require the whole module as well as how to require each export name. In practice, we don't currently use this because we end up forcing Webpack to deopt and keep it together as a single module, and we don't even have the code in the Webpack plugin to write separate values for each export name. The problem is with CJS we don't statically know what all the export names will be. Since these cases will never be module split, we don't really need to know. This changes the Flight requires to first look for the specific name we're loading and then if that name doesn't exist in the manifest we fallback to looking for the `"*"` name containing the entire module and look for the name in there at runtime. We could probably optimize this a bit if we assume that CJS modules on the server never get built with a name. That way we don't have to do the failed lookup. Additionally, since we've recently merged filepath + name into a single string instead of two values, we now have to split those back out by parsing the string. This is especially unfortunate for server references since those should really not reveal what they are but be a hash or something. The solution might just be to split them back out into two separate fields again. cc @shuding
107 lines
2.9 KiB
JavaScript
107 lines
2.9 KiB
JavaScript
/**
|
|
* 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.
|
|
*
|
|
* @flow
|
|
*/
|
|
|
|
import type {ReactClientValue} from 'react-server/src/ReactFlightServer';
|
|
|
|
export type ClientManifest = {
|
|
[id: string]: ClientReferenceMetadata,
|
|
};
|
|
|
|
export type ServerReference<T: Function> = T & {
|
|
$$typeof: symbol,
|
|
$$id: string,
|
|
$$bound: null | Array<ReactClientValue>,
|
|
};
|
|
|
|
export type ServerReferenceId = string;
|
|
|
|
// eslint-disable-next-line no-unused-vars
|
|
export type ClientReference<T> = {
|
|
$$typeof: symbol,
|
|
$$id: string,
|
|
$$async: boolean,
|
|
};
|
|
|
|
export type ClientReferenceMetadata = {
|
|
id: string,
|
|
chunks: Array<string>,
|
|
name: string,
|
|
async: boolean,
|
|
};
|
|
|
|
export type ClientReferenceKey = string;
|
|
|
|
const CLIENT_REFERENCE_TAG = Symbol.for('react.client.reference');
|
|
const SERVER_REFERENCE_TAG = Symbol.for('react.server.reference');
|
|
|
|
export function getClientReferenceKey(
|
|
reference: ClientReference<any>,
|
|
): ClientReferenceKey {
|
|
return reference.$$async ? reference.$$id + '#async' : reference.$$id;
|
|
}
|
|
|
|
export function isClientReference(reference: Object): boolean {
|
|
return reference.$$typeof === CLIENT_REFERENCE_TAG;
|
|
}
|
|
|
|
export function isServerReference(reference: Object): boolean {
|
|
return reference.$$typeof === SERVER_REFERENCE_TAG;
|
|
}
|
|
|
|
export function resolveClientReferenceMetadata<T>(
|
|
config: ClientManifest,
|
|
clientReference: ClientReference<T>,
|
|
): ClientReferenceMetadata {
|
|
const modulePath = clientReference.$$id;
|
|
let name = '';
|
|
let resolvedModuleData = config[modulePath];
|
|
if (resolvedModuleData) {
|
|
// The potentially aliased name.
|
|
name = resolvedModuleData.name;
|
|
} else {
|
|
// We didn't find this specific export name but we might have the * export
|
|
// which contains this name as well.
|
|
// TODO: It's unfortunate that we now have to parse this string. We should
|
|
// probably go back to encoding path and name separately on the client reference.
|
|
const idx = modulePath.lastIndexOf('#');
|
|
if (idx !== -1) {
|
|
name = modulePath.substr(idx + 1);
|
|
resolvedModuleData = config[modulePath.substr(0, idx)];
|
|
}
|
|
if (!resolvedModuleData) {
|
|
throw new Error(
|
|
'Could not find the module "' +
|
|
modulePath +
|
|
'" in the React Client Manifest. ' +
|
|
'This is probably a bug in the React Server Components bundler.',
|
|
);
|
|
}
|
|
}
|
|
return {
|
|
id: resolvedModuleData.id,
|
|
chunks: resolvedModuleData.chunks,
|
|
name: name,
|
|
async: !!clientReference.$$async,
|
|
};
|
|
}
|
|
|
|
export function getServerReferenceId<T>(
|
|
config: ClientManifest,
|
|
serverReference: ServerReference<T>,
|
|
): ServerReferenceId {
|
|
return serverReference.$$id;
|
|
}
|
|
|
|
export function getServerReferenceBoundArguments<T>(
|
|
config: ClientManifest,
|
|
serverReference: ServerReference<T>,
|
|
): null | Array<ReactClientValue> {
|
|
return serverReference.$$bound;
|
|
}
|