Son CV dans un terminal web en Javascript!
https://terminal-cv.gregandev.fr
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.
496 lines
18 KiB
496 lines
18 KiB
"use strict";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.default = void 0;
|
|
|
|
function _assert() {
|
|
const data = _interopRequireDefault(require("assert"));
|
|
|
|
_assert = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _plugin() {
|
|
const data = require("@parcel/plugin");
|
|
|
|
_plugin = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _utils() {
|
|
const data = require("@parcel/utils");
|
|
|
|
_utils = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _hash() {
|
|
const data = require("@parcel/hash");
|
|
|
|
_hash = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _nullthrows() {
|
|
const data = _interopRequireDefault(require("nullthrows"));
|
|
|
|
_nullthrows = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _diagnostic() {
|
|
const data = require("@parcel/diagnostic");
|
|
|
|
_diagnostic = function () {
|
|
return data;
|
|
};
|
|
|
|
return data;
|
|
}
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
// Default options by http version.
|
|
const HTTP_OPTIONS = {
|
|
'1': {
|
|
minBundles: 1,
|
|
minBundleSize: 30000,
|
|
maxParallelRequests: 6
|
|
},
|
|
'2': {
|
|
minBundles: 1,
|
|
minBundleSize: 20000,
|
|
maxParallelRequests: 25
|
|
}
|
|
};
|
|
let skipOptimize = false;
|
|
|
|
var _default = new (_plugin().Bundler)({
|
|
// RULES:
|
|
// 1. If dep.isAsync or dep.isEntry, start a new bundle group.
|
|
// 2. If an asset is a different type than the current bundle, make a parallel bundle in the same bundle group.
|
|
// 3. If an asset is already in a parent bundle in the same entry point, exclude from child bundles.
|
|
// 4. If an asset is only in separate isolated entry points (e.g. workers, different HTML pages), duplicate it.
|
|
loadConfig({
|
|
config,
|
|
options
|
|
}) {
|
|
return loadBundlerConfig(config, options);
|
|
},
|
|
|
|
bundle({
|
|
bundleGraph,
|
|
config
|
|
}) {
|
|
let bundleRoots = new Map();
|
|
let bundlesByEntryAsset = new Map(); // Step 1: create bundles for each of the explicit code split points.
|
|
|
|
bundleGraph.traverse({
|
|
enter: (node, context, actions) => {
|
|
if (node.type !== 'dependency') {
|
|
var _bundlesByEntryAsset$;
|
|
|
|
return { ...context,
|
|
bundleGroup: context === null || context === void 0 ? void 0 : context.bundleGroup,
|
|
bundleByType: context === null || context === void 0 ? void 0 : context.bundleByType,
|
|
parentNode: node,
|
|
parentBundle: (_bundlesByEntryAsset$ = bundlesByEntryAsset.get(node.value)) !== null && _bundlesByEntryAsset$ !== void 0 ? _bundlesByEntryAsset$ : context === null || context === void 0 ? void 0 : context.parentBundle
|
|
};
|
|
}
|
|
|
|
let dependency = node.value;
|
|
|
|
if (bundleGraph.isDependencySkipped(dependency)) {
|
|
actions.skipChildren();
|
|
return;
|
|
}
|
|
|
|
let assets = bundleGraph.getDependencyAssets(dependency);
|
|
let resolution = bundleGraph.getResolvedAsset(dependency);
|
|
let bundleGroup = context === null || context === void 0 ? void 0 : context.bundleGroup; // Create a new bundle for entries, lazy/parallel dependencies, isolated/inline assets.
|
|
|
|
if (resolution && (!bundleGroup || dependency.priority === 'lazy' || dependency.priority === 'parallel' || resolution.bundleBehavior === 'isolated' || resolution.bundleBehavior === 'inline')) {
|
|
var _context$bundleByType;
|
|
|
|
let bundleByType = (_context$bundleByType = context === null || context === void 0 ? void 0 : context.bundleByType) !== null && _context$bundleByType !== void 0 ? _context$bundleByType : new Map(); // Only create a new bundle group for entries, lazy dependencies, and isolated assets.
|
|
// Otherwise, the bundle is loaded together with the parent bundle.
|
|
|
|
if (!bundleGroup || dependency.priority === 'lazy' || resolution.bundleBehavior === 'isolated') {
|
|
var _dependency$target, _context$bundleGroup;
|
|
|
|
bundleGroup = bundleGraph.createBundleGroup(dependency, (0, _nullthrows().default)((_dependency$target = dependency.target) !== null && _dependency$target !== void 0 ? _dependency$target : context === null || context === void 0 ? void 0 : (_context$bundleGroup = context.bundleGroup) === null || _context$bundleGroup === void 0 ? void 0 : _context$bundleGroup.target));
|
|
bundleByType = new Map();
|
|
}
|
|
|
|
for (let asset of assets) {
|
|
var _dependency$bundleBeh;
|
|
|
|
let bundle = bundleGraph.createBundle({
|
|
entryAsset: asset,
|
|
needsStableName: dependency.bundleBehavior === 'inline' || asset.bundleBehavior === 'inline' ? false : dependency.isEntry || dependency.needsStableName,
|
|
bundleBehavior: (_dependency$bundleBeh = dependency.bundleBehavior) !== null && _dependency$bundleBeh !== void 0 ? _dependency$bundleBeh : asset.bundleBehavior,
|
|
target: bundleGroup.target
|
|
});
|
|
bundleByType.set(bundle.type, bundle);
|
|
bundlesByEntryAsset.set(asset, bundle);
|
|
bundleGraph.addBundleToBundleGroup(bundle, bundleGroup); // The bundle may have already been created, and the graph gave us back the original one...
|
|
|
|
if (!bundleRoots.has(bundle)) {
|
|
bundleRoots.set(bundle, [asset]);
|
|
} // If the bundle is in the same bundle group as the parent, create an asset reference
|
|
// between the dependency, the asset, and the target bundle.
|
|
|
|
|
|
if (bundleGroup === (context === null || context === void 0 ? void 0 : context.bundleGroup)) {
|
|
bundleGraph.createAssetReference(dependency, asset, bundle);
|
|
}
|
|
}
|
|
|
|
return {
|
|
bundleGroup,
|
|
bundleByType,
|
|
parentNode: node,
|
|
parentBundle: context === null || context === void 0 ? void 0 : context.parentBundle
|
|
};
|
|
}
|
|
|
|
(0, _assert().default)(context != null);
|
|
(0, _assert().default)(context.parentNode.type === 'asset');
|
|
(0, _assert().default)(context.parentBundle != null);
|
|
(0, _assert().default)(bundleGroup != null);
|
|
let parentAsset = context.parentNode.value;
|
|
let parentBundle = context.parentBundle;
|
|
let bundleByType = (0, _nullthrows().default)(context.bundleByType);
|
|
|
|
for (let asset of assets) {
|
|
if (parentAsset.type === asset.type) {
|
|
continue;
|
|
}
|
|
|
|
let existingBundle = bundleByType.get(asset.type);
|
|
|
|
if (existingBundle) {
|
|
// If a bundle of this type has already been created in this group,
|
|
// merge this subgraph into it.
|
|
(0, _nullthrows().default)(bundleRoots.get(existingBundle)).push(asset);
|
|
bundlesByEntryAsset.set(asset, existingBundle);
|
|
bundleGraph.createAssetReference(dependency, asset, existingBundle);
|
|
} else {
|
|
var _dependency$bundleBeh2, _asset$isBundleSplitt;
|
|
|
|
let bundle = bundleGraph.createBundle({
|
|
uniqueKey: asset.id,
|
|
env: asset.env,
|
|
type: asset.type,
|
|
target: bundleGroup.target,
|
|
needsStableName: asset.bundleBehavior === 'inline' || dependency.bundleBehavior === 'inline' || dependency.priority === 'parallel' && !dependency.needsStableName ? false : parentBundle.needsStableName,
|
|
bundleBehavior: (_dependency$bundleBeh2 = dependency.bundleBehavior) !== null && _dependency$bundleBeh2 !== void 0 ? _dependency$bundleBeh2 : asset.bundleBehavior,
|
|
isSplittable: (_asset$isBundleSplitt = asset.isBundleSplittable) !== null && _asset$isBundleSplitt !== void 0 ? _asset$isBundleSplitt : true,
|
|
pipeline: asset.pipeline
|
|
});
|
|
bundleByType.set(bundle.type, bundle);
|
|
bundlesByEntryAsset.set(asset, bundle);
|
|
bundleGraph.createAssetReference(dependency, asset, bundle); // The bundle may have already been created, and the graph gave us back the original one...
|
|
|
|
if (!bundleRoots.has(bundle)) {
|
|
bundleRoots.set(bundle, [asset]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return { ...context,
|
|
parentNode: node
|
|
};
|
|
}
|
|
});
|
|
|
|
for (let [bundle, rootAssets] of bundleRoots) {
|
|
for (let asset of rootAssets) {
|
|
bundleGraph.addEntryToBundle(asset, bundle);
|
|
}
|
|
} // If there's only one bundle, we can skip the rest of the steps.
|
|
|
|
|
|
skipOptimize = bundleRoots.size === 1;
|
|
|
|
if (skipOptimize) {
|
|
return;
|
|
}
|
|
|
|
(0, _assert().default)(config != null); // Step 2: Remove asset graphs that begin with entries to other bundles.
|
|
|
|
bundleGraph.traverseBundles(bundle => {
|
|
if (bundle.bundleBehavior === 'inline' || bundle.bundleBehavior === 'isolated' || !bundle.isSplittable || bundle.env.isIsolated()) {
|
|
return;
|
|
} // Skip bundles where the entry is reachable in a parent bundle. This can occur when both synchronously and
|
|
// asynchronously importing an asset from a bundle. This asset will later be internalized into the parent.
|
|
|
|
|
|
let entries = bundle.getEntryAssets();
|
|
let mainEntry = entries[0];
|
|
|
|
if (mainEntry == null || entries.length !== 1 || bundleGraph.isAssetReachableFromBundle(mainEntry, bundle)) {
|
|
return;
|
|
}
|
|
|
|
let candidates = bundleGraph.getBundlesWithAsset(mainEntry).filter(containingBundle => containingBundle.id !== bundle.id && // Don't add to BundleGroups for entry bundles, as that would require
|
|
// another entry bundle depending on these conditions, making it difficult
|
|
// to predict and reference.
|
|
// TODO: reconsider this. This is only true for the global output format.
|
|
!containingBundle.needsStableName && containingBundle.bundleBehavior !== 'inline' && containingBundle.bundleBehavior !== 'isolated' && containingBundle.isSplittable);
|
|
|
|
for (let candidate of candidates) {
|
|
let bundleGroups = bundleGraph.getBundleGroupsContainingBundle(candidate);
|
|
|
|
if (Array.from(bundleGroups).every(group => bundleGraph.getBundlesInBundleGroup(group).length < config.maxParallelRequests)) {
|
|
bundleGraph.createBundleReference(candidate, bundle);
|
|
bundleGraph.removeAssetGraphFromBundle(mainEntry, candidate);
|
|
}
|
|
}
|
|
}); // Step 3: Remove assets that are duplicated in a parent bundle.
|
|
|
|
deduplicate(bundleGraph);
|
|
internalizeReachableAsyncDependencies(bundleGraph);
|
|
},
|
|
|
|
optimize({
|
|
bundleGraph,
|
|
config
|
|
}) {
|
|
// if only one bundle, no need to optimize
|
|
if (skipOptimize) {
|
|
return;
|
|
}
|
|
|
|
(0, _assert().default)(config != null); // Step 5: Find duplicated assets in different bundle groups, and separate them into their own parallel bundles.
|
|
// If multiple assets are always seen together in the same bundles, combine them together.
|
|
// If the sub-graph from an asset is >= 30kb, and the number of parallel requests in the bundle group is < 5, create a new bundle containing the sub-graph.
|
|
|
|
let candidateBundles = new Map();
|
|
bundleGraph.traverse((node, ctx, actions) => {
|
|
if (node.type !== 'asset') {
|
|
return;
|
|
}
|
|
|
|
let asset = node.value;
|
|
let containingBundles = bundleGraph.getBundlesWithAsset(asset) // Don't create shared bundles from entry bundles, as that would require
|
|
// another entry bundle depending on these conditions, making it difficult
|
|
// to predict and reference.
|
|
// TODO: reconsider this. This is only true for the global output format.
|
|
// This also currently affects other bundles with stable names, e.g. service workers.
|
|
.filter(b => {
|
|
let entries = b.getEntryAssets();
|
|
return !b.needsStableName && b.isSplittable && entries.every(entry => entry.id !== asset.id);
|
|
});
|
|
|
|
if (containingBundles.length > config.minBundles) {
|
|
let id = containingBundles.map(b => b.id).sort().join(':');
|
|
let candidate = candidateBundles.get(id);
|
|
|
|
if (candidate) {
|
|
candidate.assets.push(asset);
|
|
|
|
for (let bundle of containingBundles) {
|
|
candidate.sourceBundles.add(bundle);
|
|
}
|
|
|
|
candidate.size += bundleGraph.getTotalSize(asset);
|
|
} else {
|
|
candidateBundles.set(id, {
|
|
assets: [asset],
|
|
sourceBundles: new Set(containingBundles),
|
|
size: bundleGraph.getTotalSize(asset)
|
|
});
|
|
} // Skip children from consideration since we added a parent already.
|
|
|
|
|
|
actions.skipChildren();
|
|
}
|
|
}); // Sort candidates by size (consider larger bundles first), and ensure they meet the size threshold
|
|
|
|
let sortedCandidates = Array.from(candidateBundles.values()).filter(bundle => bundle.size >= config.minBundleSize).sort((a, b) => b.size - a.size);
|
|
|
|
for (let {
|
|
assets,
|
|
sourceBundles
|
|
} of sortedCandidates) {
|
|
let eligibleSourceBundles = new Set();
|
|
|
|
for (let bundle of sourceBundles) {
|
|
// Find all bundle groups connected to the original bundles
|
|
let bundleGroups = bundleGraph.getBundleGroupsContainingBundle(bundle); // Check if all bundle groups are within the parallel request limit
|
|
|
|
if (bundleGroups.every(group => bundleGraph.getBundlesInBundleGroup(group).length < config.maxParallelRequests)) {
|
|
eligibleSourceBundles.add(bundle);
|
|
}
|
|
} // Do not create a shared bundle unless there are at least 2 source bundles
|
|
|
|
|
|
if (eligibleSourceBundles.size < 2) {
|
|
continue;
|
|
}
|
|
|
|
let [firstBundle] = [...eligibleSourceBundles];
|
|
let sharedBundle = bundleGraph.createBundle({
|
|
uniqueKey: (0, _hash().hashString)([...eligibleSourceBundles].map(b => b.id).join(':')),
|
|
// Allow this bundle to be deduplicated. It shouldn't be further split.
|
|
// TODO: Reconsider bundle/asset flags.
|
|
isSplittable: true,
|
|
env: firstBundle.env,
|
|
target: firstBundle.target,
|
|
type: firstBundle.type
|
|
}); // Remove all of the root assets from each of the original bundles
|
|
// and reference the new shared bundle.
|
|
|
|
for (let asset of assets) {
|
|
bundleGraph.addAssetGraphToBundle(asset, sharedBundle);
|
|
|
|
for (let bundle of eligibleSourceBundles) {
|
|
{
|
|
bundleGraph.createBundleReference(bundle, sharedBundle);
|
|
bundleGraph.removeAssetGraphFromBundle(asset, bundle);
|
|
}
|
|
}
|
|
}
|
|
} // Remove assets that are duplicated between shared bundles.
|
|
|
|
|
|
deduplicate(bundleGraph);
|
|
internalizeReachableAsyncDependencies(bundleGraph);
|
|
}
|
|
|
|
});
|
|
|
|
exports.default = _default;
|
|
|
|
function deduplicate(bundleGraph) {
|
|
bundleGraph.traverse(node => {
|
|
if (node.type === 'asset') {
|
|
let asset = node.value; // Search in reverse order, so bundles that are loaded keep the duplicated asset, not later ones.
|
|
// This ensures that the earlier bundle is able to execute before the later one.
|
|
|
|
let bundles = bundleGraph.getBundlesWithAsset(asset).reverse();
|
|
|
|
for (let bundle of bundles) {
|
|
if (bundle.hasAsset(asset) && bundleGraph.isAssetReachableFromBundle(asset, bundle)) {
|
|
bundleGraph.removeAssetGraphFromBundle(asset, bundle);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
const CONFIG_SCHEMA = {
|
|
type: 'object',
|
|
properties: {
|
|
http: {
|
|
type: 'number',
|
|
enum: Object.keys(HTTP_OPTIONS).map(k => Number(k))
|
|
},
|
|
minBundles: {
|
|
type: 'number'
|
|
},
|
|
minBundleSize: {
|
|
type: 'number'
|
|
},
|
|
maxParallelRequests: {
|
|
type: 'number'
|
|
}
|
|
},
|
|
additionalProperties: false
|
|
};
|
|
|
|
async function loadBundlerConfig(config, options) {
|
|
var _conf$contents$http, _conf$contents$minBun, _conf$contents$minBun2, _conf$contents$maxPar;
|
|
|
|
let conf = await config.getConfig([], {
|
|
packageKey: '@parcel/bundler-default'
|
|
});
|
|
|
|
if (!conf) {
|
|
return HTTP_OPTIONS['2'];
|
|
}
|
|
|
|
(0, _assert().default)((conf === null || conf === void 0 ? void 0 : conf.contents) != null);
|
|
|
|
_utils().validateSchema.diagnostic(CONFIG_SCHEMA, {
|
|
data: conf === null || conf === void 0 ? void 0 : conf.contents,
|
|
source: await options.inputFS.readFile(conf.filePath, 'utf8'),
|
|
filePath: conf.filePath,
|
|
prependKey: `/${(0, _diagnostic().encodeJSONKeyComponent)('@parcel/bundler-default')}`
|
|
}, '@parcel/bundler-default', 'Invalid config for @parcel/bundler-default');
|
|
|
|
let http = (_conf$contents$http = conf.contents.http) !== null && _conf$contents$http !== void 0 ? _conf$contents$http : 2;
|
|
let defaults = HTTP_OPTIONS[http];
|
|
return {
|
|
minBundles: (_conf$contents$minBun = conf.contents.minBundles) !== null && _conf$contents$minBun !== void 0 ? _conf$contents$minBun : defaults.minBundles,
|
|
minBundleSize: (_conf$contents$minBun2 = conf.contents.minBundleSize) !== null && _conf$contents$minBun2 !== void 0 ? _conf$contents$minBun2 : defaults.minBundleSize,
|
|
maxParallelRequests: (_conf$contents$maxPar = conf.contents.maxParallelRequests) !== null && _conf$contents$maxPar !== void 0 ? _conf$contents$maxPar : defaults.maxParallelRequests
|
|
};
|
|
}
|
|
|
|
function internalizeReachableAsyncDependencies(bundleGraph) {
|
|
// Mark async dependencies on assets that are already available in
|
|
// the bundle as internally resolvable. This removes the dependency between
|
|
// the bundle and the bundle group providing that asset. If all connections
|
|
// to that bundle group are removed, remove that bundle group.
|
|
let asyncBundleGroups = new Set();
|
|
bundleGraph.traverse((node, _, actions) => {
|
|
if (node.type !== 'dependency' || node.value.isEntry || node.value.priority !== 'lazy') {
|
|
return;
|
|
}
|
|
|
|
if (bundleGraph.isDependencySkipped(node.value)) {
|
|
actions.skipChildren();
|
|
return;
|
|
}
|
|
|
|
let dependency = node.value;
|
|
|
|
if (dependency.specifierType === 'url') {
|
|
// Don't internalize dependencies on URLs, e.g. `new Worker('foo.js')`
|
|
return;
|
|
}
|
|
|
|
let resolution = bundleGraph.getResolvedAsset(dependency);
|
|
|
|
if (resolution == null) {
|
|
return;
|
|
}
|
|
|
|
let externalResolution = bundleGraph.resolveAsyncDependency(dependency);
|
|
|
|
if ((externalResolution === null || externalResolution === void 0 ? void 0 : externalResolution.type) === 'bundle_group') {
|
|
asyncBundleGroups.add(externalResolution.value);
|
|
}
|
|
|
|
for (let bundle of bundleGraph.getBundlesWithDependency(dependency)) {
|
|
if (bundle.hasAsset(resolution) || bundleGraph.isAssetReachableFromBundle(resolution, bundle)) {
|
|
bundleGraph.internalizeAsyncDependency(bundle, dependency);
|
|
}
|
|
}
|
|
}); // Remove any bundle groups that no longer have any parent bundles.
|
|
|
|
for (let bundleGroup of asyncBundleGroups) {
|
|
if (bundleGraph.getParentBundlesOfBundleGroup(bundleGroup).length === 0) {
|
|
bundleGraph.removeBundleGroup(bundleGroup);
|
|
}
|
|
}
|
|
} |