You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
143 lines
3.5 KiB
143 lines
3.5 KiB
/**
|
|
* 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 strict-local
|
|
* @format
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
import type {
|
|
DeltaResult,
|
|
Dependencies,
|
|
Graph,
|
|
// eslint-disable-next-line no-unused-vars
|
|
MixedOutput,
|
|
Options,
|
|
} from './DeltaBundler/types.flow';
|
|
import type EventEmitter from 'events';
|
|
|
|
const DeltaCalculator = require('./DeltaBundler/DeltaCalculator');
|
|
|
|
export type {
|
|
DeltaResult,
|
|
Graph,
|
|
Dependencies,
|
|
MixedOutput,
|
|
Module,
|
|
TransformFn,
|
|
TransformResult,
|
|
TransformResultDependency,
|
|
TransformResultWithSource,
|
|
} from './DeltaBundler/types.flow';
|
|
|
|
/**
|
|
* `DeltaBundler` uses the `DeltaTransformer` to build bundle deltas. This
|
|
* module handles all the transformer instances so it can support multiple
|
|
* concurrent clients requesting their own deltas. This is done through the
|
|
* `clientId` param (which maps a client to a specific delta transformer).
|
|
*/
|
|
class DeltaBundler<T = MixedOutput> {
|
|
_changeEventSource: EventEmitter;
|
|
_deltaCalculators: Map<Graph<T>, DeltaCalculator<T>> = new Map();
|
|
|
|
constructor(changeEventSource: EventEmitter) {
|
|
this._changeEventSource = changeEventSource;
|
|
}
|
|
|
|
end(): void {
|
|
this._deltaCalculators.forEach((deltaCalculator: DeltaCalculator<T>) =>
|
|
deltaCalculator.end(),
|
|
);
|
|
this._deltaCalculators = new Map();
|
|
}
|
|
|
|
async getDependencies(
|
|
entryPoints: $ReadOnlyArray<string>,
|
|
options: Options<T>,
|
|
): Promise<Dependencies<T>> {
|
|
const deltaCalculator = new DeltaCalculator(
|
|
new Set(entryPoints),
|
|
this._changeEventSource,
|
|
options,
|
|
);
|
|
|
|
await deltaCalculator.getDelta({reset: true, shallow: options.shallow});
|
|
const graph = deltaCalculator.getGraph();
|
|
|
|
deltaCalculator.end();
|
|
return graph.dependencies;
|
|
}
|
|
|
|
// Note: the graph returned by this function needs to be ended when finished
|
|
// so that we don't leak graphs that are not reachable.
|
|
// To get just the dependencies, use getDependencies which will not leak graphs.
|
|
async buildGraph(
|
|
entryPoints: $ReadOnlyArray<string>,
|
|
options: Options<T>,
|
|
): Promise<Graph<T>> {
|
|
const deltaCalculator = new DeltaCalculator(
|
|
new Set(entryPoints),
|
|
this._changeEventSource,
|
|
options,
|
|
);
|
|
|
|
await deltaCalculator.getDelta({reset: true, shallow: options.shallow});
|
|
const graph = deltaCalculator.getGraph();
|
|
|
|
this._deltaCalculators.set(graph, deltaCalculator);
|
|
return graph;
|
|
}
|
|
|
|
async getDelta(
|
|
graph: Graph<T>,
|
|
{
|
|
reset,
|
|
shallow,
|
|
}: {
|
|
reset: boolean,
|
|
shallow: boolean,
|
|
...
|
|
},
|
|
): Promise<DeltaResult<T>> {
|
|
const deltaCalculator = this._deltaCalculators.get(graph);
|
|
|
|
if (!deltaCalculator) {
|
|
throw new Error('Graph not found');
|
|
}
|
|
|
|
return await deltaCalculator.getDelta({reset, shallow});
|
|
}
|
|
|
|
listen(graph: Graph<T>, callback: () => Promise<void>): () => void {
|
|
const deltaCalculator = this._deltaCalculators.get(graph);
|
|
|
|
if (!deltaCalculator) {
|
|
throw new Error('Graph not found');
|
|
}
|
|
|
|
deltaCalculator.on('change', callback);
|
|
|
|
return () => {
|
|
deltaCalculator.removeListener('change', callback);
|
|
};
|
|
}
|
|
|
|
endGraph(graph: Graph<T>): void {
|
|
const deltaCalculator = this._deltaCalculators.get(graph);
|
|
|
|
if (!deltaCalculator) {
|
|
throw new Error('Graph not found');
|
|
}
|
|
|
|
deltaCalculator.end();
|
|
|
|
this._deltaCalculators.delete(graph);
|
|
}
|
|
}
|
|
|
|
module.exports = DeltaBundler;
|