122 lines
3.8 KiB
JavaScript
122 lines
3.8 KiB
JavaScript
/**
|
|
* Copyright (c) 2015-present, Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD-style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*
|
|
* @flow
|
|
* @format
|
|
* @providesModule asyncRequire
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
const dynamicRequire: number => mixed = (require: $FlowFixMe);
|
|
|
|
/**
|
|
* The bundler must register the dependency properly when generating a call to
|
|
* `asyncRequire`, that allows us to call `require` dynamically with confidence
|
|
* the module ID is indeed valid and available.
|
|
*/
|
|
function asyncRequire(moduleID: number): Promise<mixed> {
|
|
return Promise.resolve()
|
|
.then(() => {
|
|
const {segmentId} = (require: $FlowFixMe).unpackModuleId(moduleID);
|
|
return loadSegment(segmentId);
|
|
})
|
|
.then(() => dynamicRequire(moduleID));
|
|
}
|
|
|
|
let segmentLoaders = new Map();
|
|
|
|
/**
|
|
* Ensure that a bundle segment is ready for use, for example requiring some of
|
|
* its module. We cache load promises so as to avoid calling `fetchSegment`
|
|
* twice for the same bundle. We assume that once a segment is fetched/loaded,
|
|
* it is never gettting removed during this instance of the JavaScript VM.
|
|
*
|
|
* Segment #0 is the main segment, that is always available by definition, so
|
|
* we never try to load anything.
|
|
*
|
|
* We don't use async/await syntax to avoid depending on `regeneratorRuntime`.
|
|
*/
|
|
function loadSegment(segmentId: number): Promise<void> {
|
|
return Promise.resolve().then(() => {
|
|
if (segmentId === 0) {
|
|
return;
|
|
}
|
|
if (typeof global.__BUNDLE_DIGEST__ !== 'string') {
|
|
throw IncorrectBundleSetupError();
|
|
}
|
|
const globalDigest = global.__BUNDLE_DIGEST__;
|
|
let segmentLoader = segmentLoaders.get(segmentId);
|
|
if (segmentLoader != null) {
|
|
return segmentLoader;
|
|
}
|
|
const {fetchSegment} = global;
|
|
if (fetchSegment == null) {
|
|
throw new FetchSegmentNotAvailableError();
|
|
}
|
|
segmentLoader = new Promise((resolve, reject) => {
|
|
fetchSegment(segmentId, error => {
|
|
if (error != null) {
|
|
reject(error);
|
|
return;
|
|
}
|
|
resolve();
|
|
});
|
|
}).then(() => {
|
|
const metaModuleId = (require: $FlowFixMe).packModuleId({
|
|
segmentId,
|
|
localId: 0,
|
|
});
|
|
const metaModule = dynamicRequire(metaModuleId);
|
|
const digest: string =
|
|
typeof metaModule === 'object' && metaModule != null
|
|
? (metaModule.BUNDLE_DIGEST: $FlowFixMe)
|
|
: 'undefined';
|
|
if (digest !== globalDigest) {
|
|
throw new IncompatibleSegmentError(globalDigest, digest);
|
|
}
|
|
});
|
|
segmentLoaders.set(segmentId, segmentLoader);
|
|
return segmentLoader;
|
|
});
|
|
}
|
|
|
|
class FetchSegmentNotAvailableError extends Error {
|
|
constructor() {
|
|
super(
|
|
'When bundle splitting is enabled, the `global.fetchSegment` function ' +
|
|
'must be provided to be able to load particular bundle segments.',
|
|
);
|
|
}
|
|
}
|
|
|
|
class IncorrectBundleSetupError extends Error {
|
|
constructor() {
|
|
super(
|
|
'To be able to use split segments, the bundler must define a global ' +
|
|
'constant `__BUNDLE_DIGEST__` that identifies the bundle uniquely.',
|
|
);
|
|
}
|
|
}
|
|
asyncRequire.IncorrectBundleSetupError = IncorrectBundleSetupError;
|
|
|
|
class IncompatibleSegmentError extends Error {
|
|
constructor(globalDigest, segmentDigest) {
|
|
super(
|
|
'The split segment that is being loaded has been built from a ' +
|
|
'different version of the code than the main segment. Or, the ' +
|
|
'bundler is setting up the module #0 of the segment incorrectly. ' +
|
|
`The global digest is \`${globalDigest}\` while the segment is ` +
|
|
`\`${segmentDigest}\`.`,
|
|
);
|
|
}
|
|
}
|
|
asyncRequire.IncompatibleSegmentError = IncompatibleSegmentError;
|
|
|
|
module.exports = asyncRequire;
|