first commit
This commit is contained in:
monjack
20
app_vue/node_modules/webpack-bundle-analyzer/LICENSE
generated
vendored
Normal file
20
app_vue/node_modules/webpack-bundle-analyzer/LICENSE
generated
vendored
Normal file
@ -0,0 +1,20 @@
|
||||
Copyright JS Foundation and other contributors
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
'Software'), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
221
app_vue/node_modules/webpack-bundle-analyzer/README.md
generated
vendored
Normal file
221
app_vue/node_modules/webpack-bundle-analyzer/README.md
generated
vendored
Normal file
@ -0,0 +1,221 @@
|
||||
[![npm][npm]][npm-url]
|
||||
[![node][node]][node-url]
|
||||
[![tests][tests]][tests-url]
|
||||
[![downloads][downloads]][downloads-url]
|
||||
|
||||
<div align="center">
|
||||
<a href="https://github.com/webpack/webpack">
|
||||
<img width="200" height="200"
|
||||
src="https://webpack.js.org/assets/icon-square-big.svg">
|
||||
</a>
|
||||
<h1>Webpack Bundle Analyzer</h1>
|
||||
<p>Visualize size of webpack output files with an interactive zoomable treemap.</p>
|
||||
</div>
|
||||
|
||||
<h2 align="center">Install</h2>
|
||||
|
||||
```bash
|
||||
# NPM
|
||||
npm install --save-dev webpack-bundle-analyzer
|
||||
# Yarn
|
||||
yarn add -D webpack-bundle-analyzer
|
||||
```
|
||||
|
||||
<h2 align="center">Usage (as a plugin)</h2>
|
||||
|
||||
```js
|
||||
const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;
|
||||
|
||||
module.exports = {
|
||||
plugins: [
|
||||
new BundleAnalyzerPlugin()
|
||||
]
|
||||
}
|
||||
```
|
||||
|
||||
It will create an interactive treemap visualization of the contents of all your bundles.
|
||||
|
||||
|
||||
|
||||
This module will help you:
|
||||
|
||||
1. Realize what's *really* inside your bundle
|
||||
2. Find out what modules make up the most of its size
|
||||
3. Find modules that got there by mistake
|
||||
4. Optimize it!
|
||||
|
||||
And the best thing is it supports minified bundles! It parses them to get real size of bundled modules.
|
||||
And it also shows their gzipped sizes!
|
||||
|
||||
<h2 align="center">Options (for plugin)</h2>
|
||||
|
||||
```js
|
||||
new BundleAnalyzerPlugin(options?: object)
|
||||
```
|
||||
|
||||
|Name|Type|Description|
|
||||
|:--:|:--:|:----------|
|
||||
|**`analyzerMode`**|One of: `server`, `static`, `json`, `disabled`|Default: `server`. In `server` mode analyzer will start HTTP server to show bundle report. In `static` mode single HTML file with bundle report will be generated. In `json` mode single JSON file with bundle report will be generated. In `disabled` mode you can use this plugin to just generate Webpack Stats JSON file by setting `generateStatsFile` to `true`. |
|
||||
|**`analyzerHost`**|`{String}`|Default: `127.0.0.1`. Host that will be used in `server` mode to start HTTP server.|
|
||||
|**`analyzerPort`**|`{Number}` or `auto`|Default: `8888`. Port that will be used in `server` mode to start HTTP server. If `analyzerPort` is `auto`, the operating system will assign an arbitrary unused port |
|
||||
|**`analyzerUrl`**|`{Function}` called with `{ listenHost: string, listenHost: string, boundAddress: server.address}`. [server.address comes from Node.js](https://nodejs.org/api/net.html#serveraddress)| Default: `http://${listenHost}:${boundAddress.port}`. The URL printed to console with server mode.|
|
||||
|**`reportFilename`**|`{String}`|Default: `report.html`. Path to bundle report file that will be generated in `static` mode. It can be either an absolute path or a path relative to a bundle output directory (which is output.path in webpack config).|
|
||||
|**`reportTitle`**|`{String\|function}`|Default: function that returns pretty printed current date and time. Content of the HTML `title` element; or a function of the form `() => string` that provides the content.|
|
||||
|**`defaultSizes`**|One of: `stat`, `parsed`, `gzip`|Default: `parsed`. Module sizes to show in report by default. [Size definitions](#size-definitions) section describes what these values mean.|
|
||||
|**`openAnalyzer`**|`{Boolean}`|Default: `true`. Automatically open report in default browser.|
|
||||
|**`generateStatsFile`**|`{Boolean}`|Default: `false`. If `true`, webpack stats JSON file will be generated in bundle output directory|
|
||||
|**`statsFilename`**|`{String}`|Default: `stats.json`. Name of webpack stats JSON file that will be generated if `generateStatsFile` is `true`. It can be either an absolute path or a path relative to a bundle output directory (which is output.path in webpack config).|
|
||||
|**`statsOptions`**|`null` or `{Object}`|Default: `null`. Options for `stats.toJson()` method. For example you can exclude sources of your modules from stats file with `source: false` option. [See more options here](https://webpack.js.org/configuration/stats/). |
|
||||
|**`excludeAssets`**|`{null\|pattern\|pattern[]}` where `pattern` equals to `{String\|RegExp\|function}`|Default: `null`. Patterns that will be used to match against asset names to exclude them from the report. If pattern is a string it will be converted to RegExp via `new RegExp(str)`. If pattern is a function it should have the following signature `(assetName: string) => boolean` and should return `true` to *exclude* matching asset. If multiple patterns are provided asset should match at least one of them to be excluded. |
|
||||
|**`logLevel`**|One of: `info`, `warn`, `error`, `silent`|Default: `info`. Used to control how much details the plugin outputs.|
|
||||
|
||||
<h2 align="center">Usage (as a CLI utility)</h2>
|
||||
|
||||
You can analyze an existing bundle if you have a webpack stats JSON file.
|
||||
|
||||
You can generate it using `BundleAnalyzerPlugin` with `generateStatsFile` option set to `true` or with this simple
|
||||
command:
|
||||
|
||||
```bash
|
||||
webpack --profile --json > stats.json
|
||||
```
|
||||
|
||||
If you're on Windows and using PowerShell, you can generate the stats file with this command to [avoid BOM issues](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/47):
|
||||
|
||||
```
|
||||
webpack --profile --json | Out-file 'stats.json' -Encoding OEM
|
||||
```
|
||||
|
||||
Then you can run the CLI tool.
|
||||
|
||||
```
|
||||
webpack-bundle-analyzer bundle/output/path/stats.json
|
||||
```
|
||||
|
||||
<h2 align="center">Options (for CLI)</h2>
|
||||
|
||||
```bash
|
||||
webpack-bundle-analyzer <bundleStatsFile> [bundleDir] [options]
|
||||
```
|
||||
|
||||
Arguments are documented below:
|
||||
|
||||
### `bundleStatsFile`
|
||||
|
||||
Path to webpack stats JSON file
|
||||
|
||||
### `bundleDir`
|
||||
|
||||
Directory containing all generated bundles.
|
||||
|
||||
### `options`
|
||||
|
||||
```
|
||||
-V, --version output the version number
|
||||
-m, --mode <mode> Analyzer mode. Should be `server`, `static` or `json`.
|
||||
In `server` mode analyzer will start HTTP server to show bundle report.
|
||||
In `static` mode single HTML file with bundle report will be generated.
|
||||
In `json` mode single JSON file with bundle report will be generated. (default: server)
|
||||
-h, --host <host> Host that will be used in `server` mode to start HTTP server. (default: 127.0.0.1)
|
||||
-p, --port <n> Port that will be used in `server` mode to start HTTP server. Should be a number or `auto` (default: 8888)
|
||||
-r, --report <file> Path to bundle report file that will be generated in `static` mode. (default: report.html)
|
||||
-t, --title <title> String to use in title element of html report. (default: pretty printed current date)
|
||||
-s, --default-sizes <type> Module sizes to show in treemap by default.
|
||||
Possible values: stat, parsed, gzip (default: parsed)
|
||||
-O, --no-open Don't open report in default browser automatically.
|
||||
-e, --exclude <regexp> Assets that should be excluded from the report.
|
||||
Can be specified multiple times.
|
||||
-l, --log-level <level> Log level.
|
||||
Possible values: debug, info, warn, error, silent (default: info)
|
||||
-h, --help output usage information
|
||||
```
|
||||
|
||||
<h2 align="center" id="size-definitions">Size definitions</h2>
|
||||
|
||||
webpack-bundle-analyzer reports three values for sizes. `defaultSizes` can be used to control which of these is shown by default. The different reported sizes are:
|
||||
|
||||
### `stat`
|
||||
|
||||
This is the "input" size of your files, before any transformations like
|
||||
minification.
|
||||
|
||||
It is called "stat size" because it's obtained from Webpack's
|
||||
[stats object](https://webpack.js.org/configuration/stats/).
|
||||
|
||||
### `parsed`
|
||||
|
||||
This is the "output" size of your files. If you're using a Webpack plugin such
|
||||
as Uglify, then this value will reflect the minified size of your code.
|
||||
|
||||
### `gzip`
|
||||
|
||||
This is the size of running the parsed bundles/modules through gzip compression.
|
||||
|
||||
<h2 align="center">Selecting Which Chunks to Display</h2>
|
||||
|
||||
When opened, the report displays all of the Webpack chunks for your project. It's possible to filter to a more specific list of chunks by using the sidebar or the chunk context menu.
|
||||
|
||||
### Sidebar
|
||||
|
||||
The Sidebar Menu can be opened by clicking the `>` button at the top left of the report. You can select or deselect chunks to display under the "Show chunks" heading there.
|
||||
|
||||
### Chunk Context Menu
|
||||
|
||||
The Chunk Context Menu can be opened by right-clicking or `Ctrl`-clicking on a specific chunk in the report. It provides the following options:
|
||||
|
||||
* **Hide chunk:** Hides the selected chunk
|
||||
* **Hide all other chunks:** Hides all chunks besides the selected one
|
||||
* **Show all chunks:** Un-hides any hidden chunks, returning the report to its initial, unfiltered view
|
||||
|
||||
<h2 align="center">Troubleshooting</h2>
|
||||
|
||||
### I don't see `gzip` or `parsed` sizes, it only shows `stat` size
|
||||
|
||||
It happens when `webpack-bundle-analyzer` analyzes files that don't actually exist in your file system, for example when you work with `webpack-dev-server` that keeps all the files in RAM. If you use `webpack-bundle-analyzer` as a plugin you won't get any errors, however if you run it via CLI you get the error message in terminal:
|
||||
```
|
||||
Error parsing bundle asset "your_bundle_name.bundle.js": no such file
|
||||
No bundles were parsed. Analyzer will show only original module sizes from stats file.
|
||||
```
|
||||
To get more information about it you can read [issue #147](https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/147).
|
||||
|
||||
<h2 align="center">Other tools</h2>
|
||||
|
||||
- [Statoscope](https://github.com/smelukov/statoscope/blob/master/packages/ui-webpack/README.md) - Webpack bundle analyzing tool to find out why a certain module was bundled (and more features, including interactive treemap)
|
||||
|
||||
<h2 align="center">Maintainers</h2>
|
||||
|
||||
<table>
|
||||
<tbody>
|
||||
<tr>
|
||||
<td align="center">
|
||||
<img width="150" height="150"
|
||||
src="https://avatars3.githubusercontent.com/u/302213?v=4&s=150">
|
||||
</br>
|
||||
<a href="https://github.com/th0r">Yuriy Grunin</a>
|
||||
</td>
|
||||
<td align="center">
|
||||
<img width="150" height="150"
|
||||
src="https://avatars3.githubusercontent.com/u/482561?v=4&s=150">
|
||||
</br>
|
||||
<a href="https://github.com/valscion">Vesa Laakso</a>
|
||||
</td>
|
||||
</tr>
|
||||
<tbody>
|
||||
</table>
|
||||
|
||||
|
||||
[npm]: https://img.shields.io/npm/v/webpack-bundle-analyzer.svg
|
||||
[npm-url]: https://npmjs.com/package/webpack-bundle-analyzer
|
||||
|
||||
[node]: https://img.shields.io/node/v/webpack-bundle-analyzer.svg
|
||||
[node-url]: https://nodejs.org
|
||||
|
||||
[tests]: http://img.shields.io/travis/webpack-contrib/webpack-bundle-analyzer.svg
|
||||
[tests-url]: https://travis-ci.org/webpack-contrib/webpack-bundle-analyzer
|
||||
|
||||
[downloads]: https://img.shields.io/npm/dt/webpack-bundle-analyzer.svg
|
||||
[downloads-url]: https://npmjs.com/package/webpack-bundle-analyzer
|
||||
|
||||
<h2 align="center">Contributing</h2>
|
||||
|
||||
Check out [CONTRIBUTING.md](./CONTRIBUTING.md) for instructions on contributing :tada:
|
||||
166
app_vue/node_modules/webpack-bundle-analyzer/lib/BundleAnalyzerPlugin.js
generated
vendored
Normal file
166
app_vue/node_modules/webpack-bundle-analyzer/lib/BundleAnalyzerPlugin.js
generated
vendored
Normal file
@ -0,0 +1,166 @@
|
||||
"use strict";
|
||||
|
||||
const fs = require('fs');
|
||||
|
||||
const path = require('path');
|
||||
|
||||
const {
|
||||
bold
|
||||
} = require('picocolors');
|
||||
|
||||
const Logger = require('./Logger');
|
||||
|
||||
const viewer = require('./viewer');
|
||||
|
||||
const utils = require('./utils');
|
||||
|
||||
const {
|
||||
writeStats
|
||||
} = require('./statsUtils');
|
||||
|
||||
class BundleAnalyzerPlugin {
|
||||
constructor(opts = {}) {
|
||||
this.opts = {
|
||||
analyzerMode: 'server',
|
||||
analyzerHost: '127.0.0.1',
|
||||
reportFilename: null,
|
||||
reportTitle: utils.defaultTitle,
|
||||
defaultSizes: 'parsed',
|
||||
openAnalyzer: true,
|
||||
generateStatsFile: false,
|
||||
statsFilename: 'stats.json',
|
||||
statsOptions: null,
|
||||
excludeAssets: null,
|
||||
logLevel: 'info',
|
||||
// deprecated
|
||||
startAnalyzer: true,
|
||||
analyzerUrl: utils.defaultAnalyzerUrl,
|
||||
...opts,
|
||||
analyzerPort: 'analyzerPort' in opts ? opts.analyzerPort === 'auto' ? 0 : opts.analyzerPort : 8888
|
||||
};
|
||||
this.server = null;
|
||||
this.logger = new Logger(this.opts.logLevel);
|
||||
}
|
||||
|
||||
apply(compiler) {
|
||||
this.compiler = compiler;
|
||||
|
||||
const done = (stats, callback) => {
|
||||
callback = callback || (() => {});
|
||||
|
||||
const actions = [];
|
||||
|
||||
if (this.opts.generateStatsFile) {
|
||||
actions.push(() => this.generateStatsFile(stats.toJson(this.opts.statsOptions)));
|
||||
} // Handling deprecated `startAnalyzer` flag
|
||||
|
||||
|
||||
if (this.opts.analyzerMode === 'server' && !this.opts.startAnalyzer) {
|
||||
this.opts.analyzerMode = 'disabled';
|
||||
}
|
||||
|
||||
if (this.opts.analyzerMode === 'server') {
|
||||
actions.push(() => this.startAnalyzerServer(stats.toJson()));
|
||||
} else if (this.opts.analyzerMode === 'static') {
|
||||
actions.push(() => this.generateStaticReport(stats.toJson()));
|
||||
} else if (this.opts.analyzerMode === 'json') {
|
||||
actions.push(() => this.generateJSONReport(stats.toJson()));
|
||||
}
|
||||
|
||||
if (actions.length) {
|
||||
// Making analyzer logs to be after all webpack logs in the console
|
||||
setImmediate(async () => {
|
||||
try {
|
||||
await Promise.all(actions.map(action => action()));
|
||||
callback();
|
||||
} catch (e) {
|
||||
callback(e);
|
||||
}
|
||||
});
|
||||
} else {
|
||||
callback();
|
||||
}
|
||||
};
|
||||
|
||||
if (compiler.hooks) {
|
||||
compiler.hooks.done.tapAsync('webpack-bundle-analyzer', done);
|
||||
} else {
|
||||
compiler.plugin('done', done);
|
||||
}
|
||||
}
|
||||
|
||||
async generateStatsFile(stats) {
|
||||
const statsFilepath = path.resolve(this.compiler.outputPath, this.opts.statsFilename);
|
||||
await fs.promises.mkdir(path.dirname(statsFilepath), {
|
||||
recursive: true
|
||||
});
|
||||
|
||||
try {
|
||||
await writeStats(stats, statsFilepath);
|
||||
this.logger.info(`${bold('Webpack Bundle Analyzer')} saved stats file to ${bold(statsFilepath)}`);
|
||||
} catch (error) {
|
||||
this.logger.error(`${bold('Webpack Bundle Analyzer')} error saving stats file to ${bold(statsFilepath)}: ${error}`);
|
||||
}
|
||||
}
|
||||
|
||||
async startAnalyzerServer(stats) {
|
||||
if (this.server) {
|
||||
(await this.server).updateChartData(stats);
|
||||
} else {
|
||||
this.server = viewer.startServer(stats, {
|
||||
openBrowser: this.opts.openAnalyzer,
|
||||
host: this.opts.analyzerHost,
|
||||
port: this.opts.analyzerPort,
|
||||
reportTitle: this.opts.reportTitle,
|
||||
bundleDir: this.getBundleDirFromCompiler(),
|
||||
logger: this.logger,
|
||||
defaultSizes: this.opts.defaultSizes,
|
||||
excludeAssets: this.opts.excludeAssets,
|
||||
analyzerUrl: this.opts.analyzerUrl
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
async generateJSONReport(stats) {
|
||||
await viewer.generateJSONReport(stats, {
|
||||
reportFilename: path.resolve(this.compiler.outputPath, this.opts.reportFilename || 'report.json'),
|
||||
bundleDir: this.getBundleDirFromCompiler(),
|
||||
logger: this.logger,
|
||||
excludeAssets: this.opts.excludeAssets
|
||||
});
|
||||
}
|
||||
|
||||
async generateStaticReport(stats) {
|
||||
await viewer.generateReport(stats, {
|
||||
openBrowser: this.opts.openAnalyzer,
|
||||
reportFilename: path.resolve(this.compiler.outputPath, this.opts.reportFilename || 'report.html'),
|
||||
reportTitle: this.opts.reportTitle,
|
||||
bundleDir: this.getBundleDirFromCompiler(),
|
||||
logger: this.logger,
|
||||
defaultSizes: this.opts.defaultSizes,
|
||||
excludeAssets: this.opts.excludeAssets
|
||||
});
|
||||
}
|
||||
|
||||
getBundleDirFromCompiler() {
|
||||
if (typeof this.compiler.outputFileSystem.constructor === 'undefined') {
|
||||
return this.compiler.outputPath;
|
||||
}
|
||||
|
||||
switch (this.compiler.outputFileSystem.constructor.name) {
|
||||
case 'MemoryFileSystem':
|
||||
return null;
|
||||
// Detect AsyncMFS used by Nuxt 2.5 that replaces webpack's MFS during development
|
||||
// Related: #274
|
||||
|
||||
case 'AsyncMFS':
|
||||
return null;
|
||||
|
||||
default:
|
||||
return this.compiler.outputPath;
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
module.exports = BundleAnalyzerPlugin;
|
||||
38
app_vue/node_modules/webpack-bundle-analyzer/lib/Logger.js
generated
vendored
Normal file
38
app_vue/node_modules/webpack-bundle-analyzer/lib/Logger.js
generated
vendored
Normal file
@ -0,0 +1,38 @@
|
||||
"use strict";
|
||||
|
||||
const LEVELS = ['debug', 'info', 'warn', 'error', 'silent'];
|
||||
const LEVEL_TO_CONSOLE_METHOD = new Map([['debug', 'log'], ['info', 'log'], ['warn', 'log']]);
|
||||
|
||||
class Logger {
|
||||
constructor(level = Logger.defaultLevel) {
|
||||
this.activeLevels = new Set();
|
||||
this.setLogLevel(level);
|
||||
}
|
||||
|
||||
setLogLevel(level) {
|
||||
const levelIndex = LEVELS.indexOf(level);
|
||||
if (levelIndex === -1) throw new Error(`Invalid log level "${level}". Use one of these: ${LEVELS.join(', ')}`);
|
||||
this.activeLevels.clear();
|
||||
|
||||
for (const [i, level] of LEVELS.entries()) {
|
||||
if (i >= levelIndex) this.activeLevels.add(level);
|
||||
}
|
||||
}
|
||||
|
||||
_log(level, ...args) {
|
||||
console[LEVEL_TO_CONSOLE_METHOD.get(level) || level](...args);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Logger.levels = LEVELS;
|
||||
Logger.defaultLevel = 'info';
|
||||
;
|
||||
LEVELS.forEach(level => {
|
||||
if (level === 'silent') return;
|
||||
|
||||
Logger.prototype[level] = function (...args) {
|
||||
if (this.activeLevels.has(level)) this._log(level, ...args);
|
||||
};
|
||||
});
|
||||
module.exports = Logger;
|
||||
280
app_vue/node_modules/webpack-bundle-analyzer/lib/analyzer.js
generated
vendored
Normal file
280
app_vue/node_modules/webpack-bundle-analyzer/lib/analyzer.js
generated
vendored
Normal file
@ -0,0 +1,280 @@
|
||||
"use strict";
|
||||
|
||||
const fs = require('fs');
|
||||
|
||||
const path = require('path');
|
||||
|
||||
const gzipSize = require('gzip-size');
|
||||
|
||||
const {
|
||||
parseChunked
|
||||
} = require('@discoveryjs/json-ext');
|
||||
|
||||
const Logger = require('./Logger');
|
||||
|
||||
const Folder = require('./tree/Folder').default;
|
||||
|
||||
const {
|
||||
parseBundle
|
||||
} = require('./parseUtils');
|
||||
|
||||
const {
|
||||
createAssetsFilter
|
||||
} = require('./utils');
|
||||
|
||||
const FILENAME_QUERY_REGEXP = /\?.*$/u;
|
||||
const FILENAME_EXTENSIONS = /\.(js|mjs|cjs)$/iu;
|
||||
module.exports = {
|
||||
getViewerData,
|
||||
readStatsFromFile
|
||||
};
|
||||
|
||||
function getViewerData(bundleStats, bundleDir, opts) {
|
||||
const {
|
||||
logger = new Logger(),
|
||||
excludeAssets = null
|
||||
} = opts || {};
|
||||
const isAssetIncluded = createAssetsFilter(excludeAssets); // Sometimes all the information is located in `children` array (e.g. problem in #10)
|
||||
|
||||
if ((bundleStats.assets == null || bundleStats.assets.length === 0) && bundleStats.children && bundleStats.children.length > 0) {
|
||||
const {
|
||||
children
|
||||
} = bundleStats;
|
||||
bundleStats = bundleStats.children[0]; // Sometimes if there are additional child chunks produced add them as child assets,
|
||||
// leave the 1st one as that is considered the 'root' asset.
|
||||
|
||||
for (let i = 1; i < children.length; i++) {
|
||||
children[i].assets.forEach(asset => {
|
||||
asset.isChild = true;
|
||||
bundleStats.assets.push(asset);
|
||||
});
|
||||
}
|
||||
} else if (bundleStats.children && bundleStats.children.length > 0) {
|
||||
// Sometimes if there are additional child chunks produced add them as child assets
|
||||
bundleStats.children.forEach(child => {
|
||||
child.assets.forEach(asset => {
|
||||
asset.isChild = true;
|
||||
bundleStats.assets.push(asset);
|
||||
});
|
||||
});
|
||||
} // Picking only `*.js, *.cjs or *.mjs` assets from bundle that has non-empty `chunks` array
|
||||
|
||||
|
||||
bundleStats.assets = bundleStats.assets.filter(asset => {
|
||||
// Filter out non 'asset' type asset if type is provided (Webpack 5 add a type to indicate asset types)
|
||||
if (asset.type && asset.type !== 'asset') {
|
||||
return false;
|
||||
} // Removing query part from filename (yes, somebody uses it for some reason and Webpack supports it)
|
||||
// See #22
|
||||
|
||||
|
||||
asset.name = asset.name.replace(FILENAME_QUERY_REGEXP, '');
|
||||
return FILENAME_EXTENSIONS.test(asset.name) && asset.chunks.length > 0 && isAssetIncluded(asset.name);
|
||||
}); // Trying to parse bundle assets and get real module sizes if `bundleDir` is provided
|
||||
|
||||
let bundlesSources = null;
|
||||
let parsedModules = null;
|
||||
|
||||
if (bundleDir) {
|
||||
bundlesSources = {};
|
||||
parsedModules = {};
|
||||
|
||||
for (const statAsset of bundleStats.assets) {
|
||||
const assetFile = path.join(bundleDir, statAsset.name);
|
||||
let bundleInfo;
|
||||
|
||||
try {
|
||||
bundleInfo = parseBundle(assetFile);
|
||||
} catch (err) {
|
||||
const msg = err.code === 'ENOENT' ? 'no such file' : err.message;
|
||||
logger.warn(`Error parsing bundle asset "${assetFile}": ${msg}`);
|
||||
continue;
|
||||
}
|
||||
|
||||
bundlesSources[statAsset.name] = {
|
||||
src: bundleInfo.src,
|
||||
runtimeSrc: bundleInfo.runtimeSrc
|
||||
};
|
||||
Object.assign(parsedModules, bundleInfo.modules);
|
||||
}
|
||||
|
||||
if (Object.keys(bundlesSources).length === 0) {
|
||||
bundlesSources = null;
|
||||
parsedModules = null;
|
||||
logger.warn('\nNo bundles were parsed. Analyzer will show only original module sizes from stats file.\n');
|
||||
}
|
||||
}
|
||||
|
||||
const assets = bundleStats.assets.reduce((result, statAsset) => {
|
||||
// If asset is a childAsset, then calculate appropriate bundle modules by looking through stats.children
|
||||
const assetBundles = statAsset.isChild ? getChildAssetBundles(bundleStats, statAsset.name) : bundleStats;
|
||||
const modules = assetBundles ? getBundleModules(assetBundles) : [];
|
||||
const asset = result[statAsset.name] = {
|
||||
size: statAsset.size
|
||||
};
|
||||
const assetSources = bundlesSources && Object.prototype.hasOwnProperty.call(bundlesSources, statAsset.name) ? bundlesSources[statAsset.name] : null;
|
||||
|
||||
if (assetSources) {
|
||||
asset.parsedSize = Buffer.byteLength(assetSources.src);
|
||||
asset.gzipSize = gzipSize.sync(assetSources.src);
|
||||
} // Picking modules from current bundle script
|
||||
|
||||
|
||||
let assetModules = modules.filter(statModule => assetHasModule(statAsset, statModule)); // Adding parsed sources
|
||||
|
||||
if (parsedModules) {
|
||||
const unparsedEntryModules = [];
|
||||
|
||||
for (const statModule of assetModules) {
|
||||
if (parsedModules[statModule.id]) {
|
||||
statModule.parsedSrc = parsedModules[statModule.id];
|
||||
} else if (isEntryModule(statModule)) {
|
||||
unparsedEntryModules.push(statModule);
|
||||
}
|
||||
} // Webpack 5 changed bundle format and now entry modules are concatenated and located at the end of it.
|
||||
// Because of this they basically become a concatenated module, for which we can't even precisely determine its
|
||||
// parsed source as it's located in the same scope as all Webpack runtime helpers.
|
||||
|
||||
|
||||
if (unparsedEntryModules.length && assetSources) {
|
||||
if (unparsedEntryModules.length === 1) {
|
||||
// So if there is only one entry we consider its parsed source to be all the bundle code excluding code
|
||||
// from parsed modules.
|
||||
unparsedEntryModules[0].parsedSrc = assetSources.runtimeSrc;
|
||||
} else {
|
||||
// If there are multiple entry points we move all of them under synthetic concatenated module.
|
||||
assetModules = assetModules.filter(mod => !unparsedEntryModules.includes(mod));
|
||||
assetModules.unshift({
|
||||
identifier: './entry modules',
|
||||
name: './entry modules',
|
||||
modules: unparsedEntryModules,
|
||||
size: unparsedEntryModules.reduce((totalSize, module) => totalSize + module.size, 0),
|
||||
parsedSrc: assetSources.runtimeSrc
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
asset.modules = assetModules;
|
||||
asset.tree = createModulesTree(asset.modules);
|
||||
return result;
|
||||
}, {});
|
||||
const chunkToInitialByEntrypoint = getChunkToInitialByEntrypoint(bundleStats);
|
||||
return Object.entries(assets).map(([filename, asset]) => {
|
||||
var _chunkToInitialByEntr;
|
||||
|
||||
return {
|
||||
label: filename,
|
||||
isAsset: true,
|
||||
// Not using `asset.size` here provided by Webpack because it can be very confusing when `UglifyJsPlugin` is used.
|
||||
// In this case all module sizes from stats file will represent unminified module sizes, but `asset.size` will
|
||||
// be the size of minified bundle.
|
||||
// Using `asset.size` only if current asset doesn't contain any modules (resulting size equals 0)
|
||||
statSize: asset.tree.size || asset.size,
|
||||
parsedSize: asset.parsedSize,
|
||||
gzipSize: asset.gzipSize,
|
||||
groups: Object.values(asset.tree.children).map(i => i.toChartData()),
|
||||
isInitialByEntrypoint: (_chunkToInitialByEntr = chunkToInitialByEntrypoint[filename]) !== null && _chunkToInitialByEntr !== void 0 ? _chunkToInitialByEntr : {}
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
function readStatsFromFile(filename) {
|
||||
return parseChunked(fs.createReadStream(filename, {
|
||||
encoding: 'utf8'
|
||||
}));
|
||||
}
|
||||
|
||||
function getChildAssetBundles(bundleStats, assetName) {
|
||||
return flatten((bundleStats.children || []).find(c => Object.values(c.assetsByChunkName))).includes(assetName);
|
||||
}
|
||||
|
||||
function getBundleModules(bundleStats) {
|
||||
var _bundleStats$chunks;
|
||||
|
||||
const seenIds = new Set();
|
||||
return flatten((((_bundleStats$chunks = bundleStats.chunks) === null || _bundleStats$chunks === void 0 ? void 0 : _bundleStats$chunks.map(chunk => chunk.modules)) || []).concat(bundleStats.modules).filter(Boolean)).filter(mod => {
|
||||
// Filtering out Webpack's runtime modules as they don't have ids and can't be parsed (introduced in Webpack 5)
|
||||
if (isRuntimeModule(mod)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (seenIds.has(mod.id)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
seenIds.add(mod.id);
|
||||
return true;
|
||||
});
|
||||
}
|
||||
|
||||
function assetHasModule(statAsset, statModule) {
|
||||
// Checking if this module is the part of asset chunks
|
||||
return (statModule.chunks || []).some(moduleChunk => statAsset.chunks.includes(moduleChunk));
|
||||
}
|
||||
|
||||
function isEntryModule(statModule) {
|
||||
return statModule.depth === 0;
|
||||
}
|
||||
|
||||
function isRuntimeModule(statModule) {
|
||||
return statModule.moduleType === 'runtime';
|
||||
}
|
||||
|
||||
function createModulesTree(modules) {
|
||||
const root = new Folder('.');
|
||||
modules.forEach(module => root.addModule(module));
|
||||
root.mergeNestedFolders();
|
||||
return root;
|
||||
}
|
||||
|
||||
function getChunkToInitialByEntrypoint(bundleStats) {
|
||||
if (bundleStats == null) {
|
||||
return {};
|
||||
}
|
||||
|
||||
const chunkToEntrypointInititalMap = {};
|
||||
Object.values(bundleStats.entrypoints || {}).forEach(entrypoint => {
|
||||
for (const asset of entrypoint.assets) {
|
||||
var _chunkToEntrypointIni;
|
||||
|
||||
chunkToEntrypointInititalMap[asset.name] = (_chunkToEntrypointIni = chunkToEntrypointInititalMap[asset.name]) !== null && _chunkToEntrypointIni !== void 0 ? _chunkToEntrypointIni : {};
|
||||
chunkToEntrypointInititalMap[asset.name][entrypoint.name] = true;
|
||||
}
|
||||
});
|
||||
return chunkToEntrypointInititalMap;
|
||||
}
|
||||
|
||||
;
|
||||
/**
|
||||
* arr-flatten <https://github.com/jonschlinkert/arr-flatten>
|
||||
*
|
||||
* Copyright (c) 2014-2017, Jon Schlinkert.
|
||||
* Released under the MIT License.
|
||||
*
|
||||
* Modified by Sukka <https://skk.moe>
|
||||
*
|
||||
* Replace recursively flatten with one-level deep flatten to match lodash.flatten
|
||||
*
|
||||
* TODO: replace with Array.prototype.flat once Node.js 10 support is dropped
|
||||
*/
|
||||
|
||||
function flatten(arr) {
|
||||
if (!arr) return [];
|
||||
const len = arr.length;
|
||||
if (!len) return [];
|
||||
let cur;
|
||||
const res = [];
|
||||
|
||||
for (let i = 0; i < len; i++) {
|
||||
cur = arr[i];
|
||||
|
||||
if (Array.isArray(cur)) {
|
||||
res.push(...cur);
|
||||
} else {
|
||||
res.push(cur);
|
||||
}
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
126
app_vue/node_modules/webpack-bundle-analyzer/lib/bin/analyzer.js
generated
vendored
Normal file
126
app_vue/node_modules/webpack-bundle-analyzer/lib/bin/analyzer.js
generated
vendored
Normal file
@ -0,0 +1,126 @@
|
||||
#! /usr/bin/env node
|
||||
"use strict";
|
||||
|
||||
const {
|
||||
resolve,
|
||||
dirname
|
||||
} = require('path');
|
||||
|
||||
const commander = require('commander');
|
||||
|
||||
const {
|
||||
magenta
|
||||
} = require('picocolors');
|
||||
|
||||
const analyzer = require('../analyzer');
|
||||
|
||||
const viewer = require('../viewer');
|
||||
|
||||
const Logger = require('../Logger');
|
||||
|
||||
const utils = require('../utils');
|
||||
|
||||
const SIZES = new Set(['stat', 'parsed', 'gzip']);
|
||||
const program = commander.version(require('../../package.json').version).usage(`<bundleStatsFile> [bundleDir] [options]
|
||||
|
||||
Arguments:
|
||||
|
||||
bundleStatsFile Path to Webpack Stats JSON file.
|
||||
bundleDir Directory containing all generated bundles.
|
||||
You should provided it if you want analyzer to show you the real parsed module sizes.
|
||||
By default a directory of stats file is used.`).option('-m, --mode <mode>', 'Analyzer mode. Should be `server`,`static` or `json`.' + br('In `server` mode analyzer will start HTTP server to show bundle report.') + br('In `static` mode single HTML file with bundle report will be generated.') + br('In `json` mode single JSON file with bundle report will be generated.'), 'server').option( // Had to make `host` parameter optional in order to let `-h` flag output help message
|
||||
// Fixes https://github.com/webpack-contrib/webpack-bundle-analyzer/issues/239
|
||||
'-h, --host [host]', 'Host that will be used in `server` mode to start HTTP server.', '127.0.0.1').option('-p, --port <n>', 'Port that will be used in `server` mode to start HTTP server.', 8888).option('-r, --report <file>', 'Path to bundle report file that will be generated in `static` mode.').option('-t, --title <title>', 'String to use in title element of html report.').option('-s, --default-sizes <type>', 'Module sizes to show in treemap by default.' + br(`Possible values: ${[...SIZES].join(', ')}`), 'parsed').option('-O, --no-open', "Don't open report in default browser automatically.").option('-e, --exclude <regexp>', 'Assets that should be excluded from the report.' + br('Can be specified multiple times.'), array()).option('-l, --log-level <level>', 'Log level.' + br(`Possible values: ${[...Logger.levels].join(', ')}`), Logger.defaultLevel).parse(process.argv);
|
||||
let [bundleStatsFile, bundleDir] = program.args;
|
||||
let {
|
||||
mode,
|
||||
host,
|
||||
port,
|
||||
report: reportFilename,
|
||||
title: reportTitle,
|
||||
defaultSizes,
|
||||
logLevel,
|
||||
open: openBrowser,
|
||||
exclude: excludeAssets
|
||||
} = program.opts();
|
||||
const logger = new Logger(logLevel);
|
||||
|
||||
if (typeof reportTitle === 'undefined') {
|
||||
reportTitle = utils.defaultTitle;
|
||||
}
|
||||
|
||||
if (!bundleStatsFile) showHelp('Provide path to Webpack Stats file as first argument');
|
||||
|
||||
if (mode !== 'server' && mode !== 'static' && mode !== 'json') {
|
||||
showHelp('Invalid mode. Should be either `server`, `static` or `json`.');
|
||||
}
|
||||
|
||||
if (mode === 'server') {
|
||||
if (!host) showHelp('Invalid host name');
|
||||
port = port === 'auto' ? 0 : Number(port);
|
||||
if (isNaN(port)) showHelp('Invalid port. Should be a number or `auto`');
|
||||
}
|
||||
|
||||
if (!SIZES.has(defaultSizes)) showHelp(`Invalid default sizes option. Possible values are: ${[...SIZES].join(', ')}`);
|
||||
bundleStatsFile = resolve(bundleStatsFile);
|
||||
if (!bundleDir) bundleDir = dirname(bundleStatsFile);
|
||||
parseAndAnalyse(bundleStatsFile);
|
||||
|
||||
async function parseAndAnalyse(bundleStatsFile) {
|
||||
try {
|
||||
const bundleStats = await analyzer.readStatsFromFile(bundleStatsFile);
|
||||
|
||||
if (mode === 'server') {
|
||||
viewer.startServer(bundleStats, {
|
||||
openBrowser,
|
||||
port,
|
||||
host,
|
||||
defaultSizes,
|
||||
reportTitle,
|
||||
bundleDir,
|
||||
excludeAssets,
|
||||
logger: new Logger(logLevel),
|
||||
analyzerUrl: utils.defaultAnalyzerUrl
|
||||
});
|
||||
} else if (mode === 'static') {
|
||||
viewer.generateReport(bundleStats, {
|
||||
openBrowser,
|
||||
reportFilename: resolve(reportFilename || 'report.html'),
|
||||
reportTitle,
|
||||
defaultSizes,
|
||||
bundleDir,
|
||||
excludeAssets,
|
||||
logger: new Logger(logLevel)
|
||||
});
|
||||
} else if (mode === 'json') {
|
||||
viewer.generateJSONReport(bundleStats, {
|
||||
reportFilename: resolve(reportFilename || 'report.json'),
|
||||
bundleDir,
|
||||
excludeAssets,
|
||||
logger: new Logger(logLevel)
|
||||
});
|
||||
}
|
||||
} catch (err) {
|
||||
logger.error(`Couldn't read webpack bundle stats from "${bundleStatsFile}":\n${err}`);
|
||||
logger.debug(err.stack);
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
function showHelp(error) {
|
||||
if (error) console.log(`\n ${magenta(error)}\n`);
|
||||
program.outputHelp();
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
function br(str) {
|
||||
return `\n${' '.repeat(28)}${str}`;
|
||||
}
|
||||
|
||||
function array() {
|
||||
const arr = [];
|
||||
return val => {
|
||||
arr.push(val);
|
||||
return arr;
|
||||
};
|
||||
}
|
||||
10
app_vue/node_modules/webpack-bundle-analyzer/lib/index.js
generated
vendored
Normal file
10
app_vue/node_modules/webpack-bundle-analyzer/lib/index.js
generated
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
"use strict";
|
||||
|
||||
const {
|
||||
start
|
||||
} = require('./viewer');
|
||||
|
||||
module.exports = {
|
||||
start,
|
||||
BundleAnalyzerPlugin: require('./BundleAnalyzerPlugin')
|
||||
};
|
||||
274
app_vue/node_modules/webpack-bundle-analyzer/lib/parseUtils.js
generated
vendored
Normal file
274
app_vue/node_modules/webpack-bundle-analyzer/lib/parseUtils.js
generated
vendored
Normal file
@ -0,0 +1,274 @@
|
||||
"use strict";
|
||||
|
||||
const fs = require('fs');
|
||||
|
||||
const acorn = require('acorn');
|
||||
|
||||
const walk = require('acorn-walk');
|
||||
|
||||
module.exports = {
|
||||
parseBundle
|
||||
};
|
||||
|
||||
function parseBundle(bundlePath) {
|
||||
const content = fs.readFileSync(bundlePath, 'utf8');
|
||||
const ast = acorn.parse(content, {
|
||||
sourceType: 'script',
|
||||
// I believe in a bright future of ECMAScript!
|
||||
// Actually, it's set to `2050` to support the latest ECMAScript version that currently exists.
|
||||
// Seems like `acorn` supports such weird option value.
|
||||
ecmaVersion: 2050
|
||||
});
|
||||
const walkState = {
|
||||
locations: null,
|
||||
expressionStatementDepth: 0
|
||||
};
|
||||
walk.recursive(ast, walkState, {
|
||||
ExpressionStatement(node, state, c) {
|
||||
if (state.locations) return;
|
||||
state.expressionStatementDepth++;
|
||||
|
||||
if ( // Webpack 5 stores modules in the the top-level IIFE
|
||||
state.expressionStatementDepth === 1 && ast.body.includes(node) && isIIFE(node)) {
|
||||
const fn = getIIFECallExpression(node);
|
||||
|
||||
if ( // It should not contain neither arguments
|
||||
fn.arguments.length === 0 && // ...nor parameters
|
||||
fn.callee.params.length === 0) {
|
||||
// Modules are stored in the very first variable declaration as hash
|
||||
const firstVariableDeclaration = fn.callee.body.body.find(node => node.type === 'VariableDeclaration');
|
||||
|
||||
if (firstVariableDeclaration) {
|
||||
for (const declaration of firstVariableDeclaration.declarations) {
|
||||
if (declaration.init) {
|
||||
state.locations = getModulesLocations(declaration.init);
|
||||
|
||||
if (state.locations) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!state.locations) {
|
||||
c(node.expression, state);
|
||||
}
|
||||
|
||||
state.expressionStatementDepth--;
|
||||
},
|
||||
|
||||
AssignmentExpression(node, state) {
|
||||
if (state.locations) return; // Modules are stored in exports.modules:
|
||||
// exports.modules = {};
|
||||
|
||||
const {
|
||||
left,
|
||||
right
|
||||
} = node;
|
||||
|
||||
if (left && left.object && left.object.name === 'exports' && left.property && left.property.name === 'modules' && isModulesHash(right)) {
|
||||
state.locations = getModulesLocations(right);
|
||||
}
|
||||
},
|
||||
|
||||
CallExpression(node, state, c) {
|
||||
if (state.locations) return;
|
||||
const args = node.arguments; // Main chunk with webpack loader.
|
||||
// Modules are stored in first argument:
|
||||
// (function (...) {...})(<modules>)
|
||||
|
||||
if (node.callee.type === 'FunctionExpression' && !node.callee.id && args.length === 1 && isSimpleModulesList(args[0])) {
|
||||
state.locations = getModulesLocations(args[0]);
|
||||
return;
|
||||
} // Async Webpack < v4 chunk without webpack loader.
|
||||
// webpackJsonp([<chunks>], <modules>, ...)
|
||||
// As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
|
||||
|
||||
|
||||
if (node.callee.type === 'Identifier' && mayBeAsyncChunkArguments(args) && isModulesList(args[1])) {
|
||||
state.locations = getModulesLocations(args[1]);
|
||||
return;
|
||||
} // Async Webpack v4 chunk without webpack loader.
|
||||
// (window.webpackJsonp=window.webpackJsonp||[]).push([[<chunks>], <modules>, ...]);
|
||||
// As function name may be changed with `output.jsonpFunction` option we can't rely on it's default name.
|
||||
|
||||
|
||||
if (isAsyncChunkPushExpression(node)) {
|
||||
state.locations = getModulesLocations(args[0].elements[1]);
|
||||
return;
|
||||
} // Webpack v4 WebWorkerChunkTemplatePlugin
|
||||
// globalObject.chunkCallbackName([<chunks>],<modules>, ...);
|
||||
// Both globalObject and chunkCallbackName can be changed through the config, so we can't check them.
|
||||
|
||||
|
||||
if (isAsyncWebWorkerChunkExpression(node)) {
|
||||
state.locations = getModulesLocations(args[1]);
|
||||
return;
|
||||
} // Walking into arguments because some of plugins (e.g. `DedupePlugin`) or some Webpack
|
||||
// features (e.g. `umd` library output) can wrap modules list into additional IIFE.
|
||||
|
||||
|
||||
args.forEach(arg => c(arg, state));
|
||||
}
|
||||
|
||||
});
|
||||
const modules = {};
|
||||
|
||||
if (walkState.locations) {
|
||||
Object.entries(walkState.locations).forEach(([id, loc]) => {
|
||||
modules[id] = content.slice(loc.start, loc.end);
|
||||
});
|
||||
}
|
||||
|
||||
return {
|
||||
modules,
|
||||
src: content,
|
||||
runtimeSrc: getBundleRuntime(content, walkState.locations)
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Returns bundle source except modules
|
||||
*/
|
||||
|
||||
|
||||
function getBundleRuntime(content, modulesLocations) {
|
||||
const sortedLocations = Object.values(modulesLocations || {}).sort((a, b) => a.start - b.start);
|
||||
let result = '';
|
||||
let lastIndex = 0;
|
||||
|
||||
for (const {
|
||||
start,
|
||||
end
|
||||
} of sortedLocations) {
|
||||
result += content.slice(lastIndex, start);
|
||||
lastIndex = end;
|
||||
}
|
||||
|
||||
return result + content.slice(lastIndex, content.length);
|
||||
}
|
||||
|
||||
function isIIFE(node) {
|
||||
return node.type === 'ExpressionStatement' && (node.expression.type === 'CallExpression' || node.expression.type === 'UnaryExpression' && node.expression.argument.type === 'CallExpression');
|
||||
}
|
||||
|
||||
function getIIFECallExpression(node) {
|
||||
if (node.expression.type === 'UnaryExpression') {
|
||||
return node.expression.argument;
|
||||
} else {
|
||||
return node.expression;
|
||||
}
|
||||
}
|
||||
|
||||
function isModulesList(node) {
|
||||
return isSimpleModulesList(node) || // Modules are contained in expression `Array([minimum ID]).concat([<module>, <module>, ...])`
|
||||
isOptimizedModulesArray(node);
|
||||
}
|
||||
|
||||
function isSimpleModulesList(node) {
|
||||
return (// Modules are contained in hash. Keys are module ids.
|
||||
isModulesHash(node) || // Modules are contained in array. Indexes are module ids.
|
||||
isModulesArray(node)
|
||||
);
|
||||
}
|
||||
|
||||
function isModulesHash(node) {
|
||||
return node.type === 'ObjectExpression' && node.properties.map(node => node.value).every(isModuleWrapper);
|
||||
}
|
||||
|
||||
function isModulesArray(node) {
|
||||
return node.type === 'ArrayExpression' && node.elements.every(elem => // Some of array items may be skipped because there is no module with such id
|
||||
!elem || isModuleWrapper(elem));
|
||||
}
|
||||
|
||||
function isOptimizedModulesArray(node) {
|
||||
// Checking whether modules are contained in `Array(<minimum ID>).concat(...modules)` array:
|
||||
// https://github.com/webpack/webpack/blob/v1.14.0/lib/Template.js#L91
|
||||
// The `<minimum ID>` + array indexes are module ids
|
||||
return node.type === 'CallExpression' && node.callee.type === 'MemberExpression' && // Make sure the object called is `Array(<some number>)`
|
||||
node.callee.object.type === 'CallExpression' && node.callee.object.callee.type === 'Identifier' && node.callee.object.callee.name === 'Array' && node.callee.object.arguments.length === 1 && isNumericId(node.callee.object.arguments[0]) && // Make sure the property X called for `Array(<some number>).X` is `concat`
|
||||
node.callee.property.type === 'Identifier' && node.callee.property.name === 'concat' && // Make sure exactly one array is passed in to `concat`
|
||||
node.arguments.length === 1 && isModulesArray(node.arguments[0]);
|
||||
}
|
||||
|
||||
function isModuleWrapper(node) {
|
||||
return (// It's an anonymous function expression that wraps module
|
||||
(node.type === 'FunctionExpression' || node.type === 'ArrowFunctionExpression') && !node.id || // If `DedupePlugin` is used it can be an ID of duplicated module...
|
||||
isModuleId(node) || // or an array of shape [<module_id>, ...args]
|
||||
node.type === 'ArrayExpression' && node.elements.length > 1 && isModuleId(node.elements[0])
|
||||
);
|
||||
}
|
||||
|
||||
function isModuleId(node) {
|
||||
return node.type === 'Literal' && (isNumericId(node) || typeof node.value === 'string');
|
||||
}
|
||||
|
||||
function isNumericId(node) {
|
||||
return node.type === 'Literal' && Number.isInteger(node.value) && node.value >= 0;
|
||||
}
|
||||
|
||||
function isChunkIds(node) {
|
||||
// Array of numeric or string ids. Chunk IDs are strings when NamedChunksPlugin is used
|
||||
return node.type === 'ArrayExpression' && node.elements.every(isModuleId);
|
||||
}
|
||||
|
||||
function isAsyncChunkPushExpression(node) {
|
||||
const {
|
||||
callee,
|
||||
arguments: args
|
||||
} = node;
|
||||
return callee.type === 'MemberExpression' && callee.property.name === 'push' && callee.object.type === 'AssignmentExpression' && args.length === 1 && args[0].type === 'ArrayExpression' && mayBeAsyncChunkArguments(args[0].elements) && isModulesList(args[0].elements[1]);
|
||||
}
|
||||
|
||||
function mayBeAsyncChunkArguments(args) {
|
||||
return args.length >= 2 && isChunkIds(args[0]);
|
||||
}
|
||||
|
||||
function isAsyncWebWorkerChunkExpression(node) {
|
||||
const {
|
||||
callee,
|
||||
type,
|
||||
arguments: args
|
||||
} = node;
|
||||
return type === 'CallExpression' && callee.type === 'MemberExpression' && args.length === 2 && isChunkIds(args[0]) && isModulesList(args[1]);
|
||||
}
|
||||
|
||||
function getModulesLocations(node) {
|
||||
if (node.type === 'ObjectExpression') {
|
||||
// Modules hash
|
||||
const modulesNodes = node.properties;
|
||||
return modulesNodes.reduce((result, moduleNode) => {
|
||||
const moduleId = moduleNode.key.name || moduleNode.key.value;
|
||||
result[moduleId] = getModuleLocation(moduleNode.value);
|
||||
return result;
|
||||
}, {});
|
||||
}
|
||||
|
||||
const isOptimizedArray = node.type === 'CallExpression';
|
||||
|
||||
if (node.type === 'ArrayExpression' || isOptimizedArray) {
|
||||
// Modules array or optimized array
|
||||
const minId = isOptimizedArray ? // Get the [minId] value from the Array() call first argument literal value
|
||||
node.callee.object.arguments[0].value : // `0` for simple array
|
||||
0;
|
||||
const modulesNodes = isOptimizedArray ? // The modules reside in the `concat()` function call arguments
|
||||
node.arguments[0].elements : node.elements;
|
||||
return modulesNodes.reduce((result, moduleNode, i) => {
|
||||
if (moduleNode) {
|
||||
result[i + minId] = getModuleLocation(moduleNode);
|
||||
}
|
||||
|
||||
return result;
|
||||
}, {});
|
||||
}
|
||||
|
||||
return {};
|
||||
}
|
||||
|
||||
function getModuleLocation(node) {
|
||||
return {
|
||||
start: node.start,
|
||||
end: node.end
|
||||
};
|
||||
}
|
||||
90
app_vue/node_modules/webpack-bundle-analyzer/lib/statsUtils.js
generated
vendored
Normal file
90
app_vue/node_modules/webpack-bundle-analyzer/lib/statsUtils.js
generated
vendored
Normal file
@ -0,0 +1,90 @@
|
||||
"use strict";
|
||||
|
||||
const {
|
||||
createWriteStream
|
||||
} = require('fs');
|
||||
|
||||
const {
|
||||
Readable
|
||||
} = require('stream');
|
||||
|
||||
class StatsSerializeStream extends Readable {
|
||||
constructor(stats) {
|
||||
super();
|
||||
this._indentLevel = 0;
|
||||
this._stringifier = this._stringify(stats);
|
||||
}
|
||||
|
||||
get _indent() {
|
||||
return ' '.repeat(this._indentLevel);
|
||||
}
|
||||
|
||||
_read() {
|
||||
let readMore = true;
|
||||
|
||||
while (readMore) {
|
||||
const {
|
||||
value,
|
||||
done
|
||||
} = this._stringifier.next();
|
||||
|
||||
if (done) {
|
||||
this.push(null);
|
||||
readMore = false;
|
||||
} else {
|
||||
readMore = this.push(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
*_stringify(obj) {
|
||||
if (typeof obj === 'string' || typeof obj === 'number' || typeof obj === 'boolean' || obj === null) {
|
||||
yield JSON.stringify(obj);
|
||||
} else if (Array.isArray(obj)) {
|
||||
yield '[';
|
||||
this._indentLevel++;
|
||||
let isFirst = true;
|
||||
|
||||
for (let item of obj) {
|
||||
if (item === undefined) {
|
||||
item = null;
|
||||
}
|
||||
|
||||
yield `${isFirst ? '' : ','}\n${this._indent}`;
|
||||
yield* this._stringify(item);
|
||||
isFirst = false;
|
||||
}
|
||||
|
||||
this._indentLevel--;
|
||||
yield obj.length ? `\n${this._indent}]` : ']';
|
||||
} else {
|
||||
yield '{';
|
||||
this._indentLevel++;
|
||||
let isFirst = true;
|
||||
const entries = Object.entries(obj);
|
||||
|
||||
for (const [itemKey, itemValue] of entries) {
|
||||
if (itemValue === undefined) {
|
||||
continue;
|
||||
}
|
||||
|
||||
yield `${isFirst ? '' : ','}\n${this._indent}${JSON.stringify(itemKey)}: `;
|
||||
yield* this._stringify(itemValue);
|
||||
isFirst = false;
|
||||
}
|
||||
|
||||
this._indentLevel--;
|
||||
yield entries.length ? `\n${this._indent}}` : '}';
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.StatsSerializeStream = StatsSerializeStream;
|
||||
exports.writeStats = writeStats;
|
||||
|
||||
async function writeStats(stats, filepath) {
|
||||
return new Promise((resolve, reject) => {
|
||||
new StatsSerializeStream(stats).on('end', resolve).on('error', reject).pipe(createWriteStream(filepath));
|
||||
});
|
||||
}
|
||||
77
app_vue/node_modules/webpack-bundle-analyzer/lib/template.js
generated
vendored
Normal file
77
app_vue/node_modules/webpack-bundle-analyzer/lib/template.js
generated
vendored
Normal file
@ -0,0 +1,77 @@
|
||||
"use strict";
|
||||
|
||||
/* eslint-disable max-len */
|
||||
const path = require('path');
|
||||
|
||||
const fs = require('fs');
|
||||
|
||||
const {
|
||||
escape
|
||||
} = require('html-escaper');
|
||||
|
||||
const projectRoot = path.resolve(__dirname, '..');
|
||||
const assetsRoot = path.join(projectRoot, 'public');
|
||||
exports.renderViewer = renderViewer;
|
||||
/**
|
||||
* Escapes `<` characters in JSON to safely use it in `<script>` tag.
|
||||
*/
|
||||
|
||||
function escapeJson(json) {
|
||||
return JSON.stringify(json).replace(/</gu, '\\u003c');
|
||||
}
|
||||
|
||||
function getAssetContent(filename) {
|
||||
const assetPath = path.join(assetsRoot, filename);
|
||||
|
||||
if (!assetPath.startsWith(assetsRoot)) {
|
||||
throw new Error(`"${filename}" is outside of the assets root`);
|
||||
}
|
||||
|
||||
return fs.readFileSync(assetPath, 'utf8');
|
||||
}
|
||||
|
||||
function html(strings, ...values) {
|
||||
return strings.map((string, index) => `${string}${values[index] || ''}`).join('');
|
||||
}
|
||||
|
||||
function getScript(filename, mode) {
|
||||
if (mode === 'static') {
|
||||
return `<!-- ${escape(filename)} -->
|
||||
<script>${getAssetContent(filename)}</script>`;
|
||||
} else {
|
||||
return `<script src="${escape(filename)}"></script>`;
|
||||
}
|
||||
}
|
||||
|
||||
function renderViewer({
|
||||
title,
|
||||
enableWebSocket,
|
||||
chartData,
|
||||
entrypoints,
|
||||
defaultSizes,
|
||||
mode
|
||||
} = {}) {
|
||||
return html`<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="UTF-8"/>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1"/>
|
||||
<title>${escape(title)}</title>
|
||||
<link rel="shortcut icon" href="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAMAAACdt4HsAAABrVBMVEUAAAD///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////+O1foceMD///+J0/qK1Pr7/v8Xdr/9///W8P4UdL7L7P0Scr2r4Pyj3vwad8D5/f/2/f+55f3E6f34+/2H0/ojfMKpzOd0rNgQcb3F3O/j9f7c8v6g3Pz0/P/w+v/q+P7n9v6T1/uQ1vuE0vqLut/y+v+Z2fvt+f+15Pzv9fuc2/vR7v2V2Pvd6/bg9P7I6/285/2y4/yp3/zp8vk8i8kqgMT7/P31+fyv4vxGkcz6/P6/6P3j7vfS5PNnpNUxhcbO7f7F6v3O4vHK3/DA2u631Ouy0eqXweKJud5wqthfoNMMbLvY8f73+v2dxeR8sNtTmdDx9/zX6PSjyeaCtd1YnNGX2PuQveCGt95Nls42h8dLlM3F4vBtAAAAM3RSTlMAAyOx0/sKBvik8opWGBMOAe3l1snDm2E9LSb06eHcu5JpHbarfHZCN9CBb08zzkdNS0kYaptYAAAFV0lEQVRYw92X51/aYBDHHS2O2qqttVbrqNq9m+TJIAYIShBkWwqIiCgoWvfeq7Z2/s29hyQNyUcR7LveGwVyXy6XH8/9rqxglLfUPLxVduUor3h0rfp2TYvpivk37929TkG037hffoX0+peVtZQc1589rigVUdXS/ABSAyEmGIO/1XfvldSK8vs3OqB6u3m0nxmIrvgB0dj7rr7Y9IbuF68hnfFaiHA/sxqm0wciIG43P60qKv9WXWc1RXGh/mFESFABTSBi0sNAKzqet17eCtOb3kZIDwxEEU0oAIJGYxNBDhBND29e0rtXXbcpuPmED9IhEAAQ/AXEaF8EPmnrrKsv0LvWR3fg5sWDNAFZOgAgaKvZDogHNU9MFwnnYROkc56RD5CjAbQX9Ow4g7upCsvYu55aSI/Nj0H1akgKQEUM94dwK65hYRmFU9MIcH/fqJYOZYcnuJSU/waKDgTOEVaVKhwrTRP5XzgSpAITYzom7UvkhFX5VutmxeNnWDjjswTKTyfgluNDGbUpWissXhF3s7mlSml+czWkg3D0l1nNjGNjz3myOQOa1KM/jOS6ebdbAVTCi4gljHSFrviza7tOgRWcS0MOUX9zdNgag5w7rRqA44Lzw0hr1WqES36dFliSJFlh2rXIae3FFcDDgKdxrUIDePr8jGcSClV1u7A9xeN0ModY/pHMxmR1EzRh8TJiwqsHmKW0l4FCEZI+jHio+JdPPE9qwQtTRxku2D8sIeRL2LnxWSllANCQGOIiqVHAz2ye2JR0DcH+HoxDkaADLjgxjKQ+AwCX/g0+DNgdG0ukYCONAe+dbc2IAc6fwt1ARoDSezNHxV2Cmzwv3O6lDMV55edBGwGK9n1+x2F8EDfAGCxug8MhpsMEcTEAWf3rx2vZhe/LAmtIn/6apE6PN0ULKgywD9mmdxbmFl3OvD5AS5fW5zLbv/YHmcsBTjf/afDz3MaZTVCfAP9z6/Bw6ycv8EUBWJIn9zYcoAWWlW9+OzO3vkTy8H+RANLmdrpOuYWdZYEXpo+TlCJrW5EARb7fF+bWdqf3hhyZI1nWJQHgznErZhbjoEsWqi8dQNoE294aldzFurwSABL2XXMf9+H1VQGke9exw5P/AnA5Pv5ngMul7LOvO922iwACu8WkCwLCafvM4CeWPxfA8lNHcWZSoi8EwMAIciKX2Z4SWCMAa3snCZ/G4EA8D6CMLNFsGQhkkz/gQNEBbPCbWsxGUpYVu3z8IyNAknwJkfPMEhLyrdi5RTyUVACkw4GSFRNWJNEW+fgPGwHD8/JxnRuLabN4CGNRkAE23na2+VmEAUmrYymSGjMAYqH84YUIyzgzs3XC7gNgH36Vcc4zKY9o9fgPBXUAiHHwVboBHGLiX6Zcjp1f2wu4tvzZKo0ecPnDtQYDQvJXaBeNzce45Fp28ZQLrEZVuFqgBwOalArKXnW1UzlnSusQKJqKYNuz4tOnI6sZG4zanpemv+7ySU2jbA9h6uhcgpfy6G2PahirDZ6zvq6zDduMVFTKvzw8wgyEdelwY9in3XkEPs3osJuwRQ4qTkfzifndg9Gfc4pdsu82+tTnHZTBa2EAMrqr2t43pguc8tNm7JQVQ2S0ukj2d22dhXYP0/veWtwKrCkNoNimAN5+Xr/oLrxswKbVJjteWrX7eR63o4j9q0GxnaBdWgGA5VStpanIjQmEhV0/nVt5VOFUvix6awJhPcAaTEShgrG+iGyvb5a0Ndb1YGHFPEwoqAinoaykaID1o1pdPNu7XsnCKQ3R+hwWIIhGvORcJUBYXe3Xa3vq/mF/N9V13ugufMkfXn+KHsRD0B8AAAAASUVORK5CYII=" type="image/x-icon" />
|
||||
|
||||
<script>
|
||||
window.enableWebSocket = ${escapeJson(enableWebSocket)};
|
||||
</script>
|
||||
${getScript('viewer.js', mode)}
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<div id="app"></div>
|
||||
<script>
|
||||
window.chartData = ${escapeJson(chartData)};
|
||||
window.entrypoints = ${escapeJson(entrypoints)};
|
||||
window.defaultSizes = ${escapeJson(defaultSizes)};
|
||||
</script>
|
||||
</body>
|
||||
</html>`;
|
||||
}
|
||||
125
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/BaseFolder.js
generated
vendored
Normal file
125
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/BaseFolder.js
generated
vendored
Normal file
@ -0,0 +1,125 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _Node = _interopRequireDefault(require("./Node"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
class BaseFolder extends _Node.default {
|
||||
constructor(name, parent) {
|
||||
super(name, parent);
|
||||
this.children = Object.create(null);
|
||||
}
|
||||
|
||||
get src() {
|
||||
if (!Object.prototype.hasOwnProperty.call(this, '_src')) {
|
||||
this._src = this.walk((node, src) => src += node.src || '', '', false);
|
||||
}
|
||||
|
||||
return this._src;
|
||||
}
|
||||
|
||||
get size() {
|
||||
if (!Object.prototype.hasOwnProperty.call(this, '_size')) {
|
||||
this._size = this.walk((node, size) => size + node.size, 0, false);
|
||||
}
|
||||
|
||||
return this._size;
|
||||
}
|
||||
|
||||
getChild(name) {
|
||||
return this.children[name];
|
||||
}
|
||||
|
||||
addChildModule(module) {
|
||||
const {
|
||||
name
|
||||
} = module;
|
||||
const currentChild = this.children[name]; // For some reason we already have this node in children and it's a folder.
|
||||
|
||||
if (currentChild && currentChild instanceof BaseFolder) return;
|
||||
|
||||
if (currentChild) {
|
||||
// We already have this node in children and it's a module.
|
||||
// Merging it's data.
|
||||
currentChild.mergeData(module.data);
|
||||
} else {
|
||||
// Pushing new module
|
||||
module.parent = this;
|
||||
this.children[name] = module;
|
||||
}
|
||||
|
||||
delete this._size;
|
||||
delete this._src;
|
||||
}
|
||||
|
||||
addChildFolder(folder) {
|
||||
folder.parent = this;
|
||||
this.children[folder.name] = folder;
|
||||
delete this._size;
|
||||
delete this._src;
|
||||
return folder;
|
||||
}
|
||||
|
||||
walk(walker, state = {}, deep = true) {
|
||||
let stopped = false;
|
||||
Object.values(this.children).forEach(child => {
|
||||
if (deep && child.walk) {
|
||||
state = child.walk(walker, state, stop);
|
||||
} else {
|
||||
state = walker(child, state, stop);
|
||||
}
|
||||
|
||||
if (stopped) return false;
|
||||
});
|
||||
return state;
|
||||
|
||||
function stop(finalState) {
|
||||
stopped = true;
|
||||
return finalState;
|
||||
}
|
||||
}
|
||||
|
||||
mergeNestedFolders() {
|
||||
if (!this.isRoot) {
|
||||
let childNames;
|
||||
|
||||
while ((childNames = Object.keys(this.children)).length === 1) {
|
||||
const childName = childNames[0];
|
||||
const onlyChild = this.children[childName];
|
||||
|
||||
if (onlyChild instanceof this.constructor) {
|
||||
this.name += `/${onlyChild.name}`;
|
||||
this.children = onlyChild.children;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
this.walk(child => {
|
||||
child.parent = this;
|
||||
|
||||
if (child.mergeNestedFolders) {
|
||||
child.mergeNestedFolders();
|
||||
}
|
||||
}, null, false);
|
||||
}
|
||||
|
||||
toChartData() {
|
||||
return {
|
||||
label: this.name,
|
||||
path: this.path,
|
||||
statSize: this.size,
|
||||
groups: Object.values(this.children).map(child => child.toChartData())
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = BaseFolder;
|
||||
;
|
||||
106
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/ConcatenatedModule.js
generated
vendored
Normal file
106
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/ConcatenatedModule.js
generated
vendored
Normal file
@ -0,0 +1,106 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _Module = _interopRequireDefault(require("./Module"));
|
||||
|
||||
var _ContentModule = _interopRequireDefault(require("./ContentModule"));
|
||||
|
||||
var _ContentFolder = _interopRequireDefault(require("./ContentFolder"));
|
||||
|
||||
var _utils = require("./utils");
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
class ConcatenatedModule extends _Module.default {
|
||||
constructor(name, data, parent) {
|
||||
super(name, data, parent);
|
||||
this.name += ' (concatenated)';
|
||||
this.children = Object.create(null);
|
||||
this.fillContentModules();
|
||||
}
|
||||
|
||||
get parsedSize() {
|
||||
var _this$getParsedSize;
|
||||
|
||||
return (_this$getParsedSize = this.getParsedSize()) !== null && _this$getParsedSize !== void 0 ? _this$getParsedSize : this.getEstimatedSize('parsedSize');
|
||||
}
|
||||
|
||||
get gzipSize() {
|
||||
var _this$getGzipSize;
|
||||
|
||||
return (_this$getGzipSize = this.getGzipSize()) !== null && _this$getGzipSize !== void 0 ? _this$getGzipSize : this.getEstimatedSize('gzipSize');
|
||||
}
|
||||
|
||||
getEstimatedSize(sizeType) {
|
||||
const parentModuleSize = this.parent[sizeType];
|
||||
|
||||
if (parentModuleSize !== undefined) {
|
||||
return Math.floor(this.size / this.parent.size * parentModuleSize);
|
||||
}
|
||||
}
|
||||
|
||||
fillContentModules() {
|
||||
this.data.modules.forEach(moduleData => this.addContentModule(moduleData));
|
||||
}
|
||||
|
||||
addContentModule(moduleData) {
|
||||
const pathParts = (0, _utils.getModulePathParts)(moduleData);
|
||||
|
||||
if (!pathParts) {
|
||||
return;
|
||||
}
|
||||
|
||||
const [folders, fileName] = [pathParts.slice(0, -1), pathParts[pathParts.length - 1]];
|
||||
let currentFolder = this;
|
||||
folders.forEach(folderName => {
|
||||
let childFolder = currentFolder.getChild(folderName);
|
||||
|
||||
if (!childFolder) {
|
||||
childFolder = currentFolder.addChildFolder(new _ContentFolder.default(folderName, this));
|
||||
}
|
||||
|
||||
currentFolder = childFolder;
|
||||
});
|
||||
const ModuleConstructor = moduleData.modules ? ConcatenatedModule : _ContentModule.default;
|
||||
const module = new ModuleConstructor(fileName, moduleData, this);
|
||||
currentFolder.addChildModule(module);
|
||||
}
|
||||
|
||||
getChild(name) {
|
||||
return this.children[name];
|
||||
}
|
||||
|
||||
addChildModule(module) {
|
||||
module.parent = this;
|
||||
this.children[module.name] = module;
|
||||
}
|
||||
|
||||
addChildFolder(folder) {
|
||||
folder.parent = this;
|
||||
this.children[folder.name] = folder;
|
||||
return folder;
|
||||
}
|
||||
|
||||
mergeNestedFolders() {
|
||||
Object.values(this.children).forEach(child => {
|
||||
if (child.mergeNestedFolders) {
|
||||
child.mergeNestedFolders();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
toChartData() {
|
||||
return { ...super.toChartData(),
|
||||
concatenated: true,
|
||||
groups: Object.values(this.children).map(child => child.toChartData())
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = ConcatenatedModule;
|
||||
;
|
||||
45
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/ContentFolder.js
generated
vendored
Normal file
45
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/ContentFolder.js
generated
vendored
Normal file
@ -0,0 +1,45 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _BaseFolder = _interopRequireDefault(require("./BaseFolder"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
class ContentFolder extends _BaseFolder.default {
|
||||
constructor(name, ownerModule, parent) {
|
||||
super(name, parent);
|
||||
this.ownerModule = ownerModule;
|
||||
}
|
||||
|
||||
get parsedSize() {
|
||||
return this.getSize('parsedSize');
|
||||
}
|
||||
|
||||
get gzipSize() {
|
||||
return this.getSize('gzipSize');
|
||||
}
|
||||
|
||||
getSize(sizeType) {
|
||||
const ownerModuleSize = this.ownerModule[sizeType];
|
||||
|
||||
if (ownerModuleSize !== undefined) {
|
||||
return Math.floor(this.size / this.ownerModule.size * ownerModuleSize);
|
||||
}
|
||||
}
|
||||
|
||||
toChartData() {
|
||||
return { ...super.toChartData(),
|
||||
parsedSize: this.parsedSize,
|
||||
gzipSize: this.gzipSize,
|
||||
inaccurateSizes: true
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = ContentFolder;
|
||||
;
|
||||
43
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/ContentModule.js
generated
vendored
Normal file
43
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/ContentModule.js
generated
vendored
Normal file
@ -0,0 +1,43 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _Module = _interopRequireDefault(require("./Module"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
class ContentModule extends _Module.default {
|
||||
constructor(name, data, ownerModule, parent) {
|
||||
super(name, data, parent);
|
||||
this.ownerModule = ownerModule;
|
||||
}
|
||||
|
||||
get parsedSize() {
|
||||
return this.getSize('parsedSize');
|
||||
}
|
||||
|
||||
get gzipSize() {
|
||||
return this.getSize('gzipSize');
|
||||
}
|
||||
|
||||
getSize(sizeType) {
|
||||
const ownerModuleSize = this.ownerModule[sizeType];
|
||||
|
||||
if (ownerModuleSize !== undefined) {
|
||||
return Math.floor(this.size / this.ownerModule.size * ownerModuleSize);
|
||||
}
|
||||
}
|
||||
|
||||
toChartData() {
|
||||
return { ...super.toChartData(),
|
||||
inaccurateSizes: true
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = ContentModule;
|
||||
;
|
||||
71
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/Folder.js
generated
vendored
Normal file
71
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/Folder.js
generated
vendored
Normal file
@ -0,0 +1,71 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _gzipSize = _interopRequireDefault(require("gzip-size"));
|
||||
|
||||
var _Module = _interopRequireDefault(require("./Module"));
|
||||
|
||||
var _BaseFolder = _interopRequireDefault(require("./BaseFolder"));
|
||||
|
||||
var _ConcatenatedModule = _interopRequireDefault(require("./ConcatenatedModule"));
|
||||
|
||||
var _utils = require("./utils");
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
class Folder extends _BaseFolder.default {
|
||||
get parsedSize() {
|
||||
return this.src ? this.src.length : 0;
|
||||
}
|
||||
|
||||
get gzipSize() {
|
||||
if (!Object.prototype.hasOwnProperty.call(this, '_gzipSize')) {
|
||||
this._gzipSize = this.src ? _gzipSize.default.sync(this.src) : 0;
|
||||
}
|
||||
|
||||
return this._gzipSize;
|
||||
}
|
||||
|
||||
addModule(moduleData) {
|
||||
const pathParts = (0, _utils.getModulePathParts)(moduleData);
|
||||
|
||||
if (!pathParts) {
|
||||
return;
|
||||
}
|
||||
|
||||
const [folders, fileName] = [pathParts.slice(0, -1), pathParts[pathParts.length - 1]];
|
||||
let currentFolder = this;
|
||||
folders.forEach(folderName => {
|
||||
let childNode = currentFolder.getChild(folderName);
|
||||
|
||||
if ( // Folder is not created yet
|
||||
!childNode || // In some situations (invalid usage of dynamic `require()`) webpack generates a module with empty require
|
||||
// context, but it's moduleId points to a directory in filesystem.
|
||||
// In this case we replace this `File` node with `Folder`.
|
||||
// See `test/stats/with-invalid-dynamic-require.json` as an example.
|
||||
!(childNode instanceof Folder)) {
|
||||
childNode = currentFolder.addChildFolder(new Folder(folderName));
|
||||
}
|
||||
|
||||
currentFolder = childNode;
|
||||
});
|
||||
const ModuleConstructor = moduleData.modules ? _ConcatenatedModule.default : _Module.default;
|
||||
const module = new ModuleConstructor(fileName, moduleData, this);
|
||||
currentFolder.addChildModule(module);
|
||||
}
|
||||
|
||||
toChartData() {
|
||||
return { ...super.toChartData(),
|
||||
parsedSize: this.parsedSize,
|
||||
gzipSize: this.gzipSize
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = Folder;
|
||||
;
|
||||
81
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/Module.js
generated
vendored
Normal file
81
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/Module.js
generated
vendored
Normal file
@ -0,0 +1,81 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
var _gzipSize = _interopRequireDefault(require("gzip-size"));
|
||||
|
||||
var _Node = _interopRequireDefault(require("./Node"));
|
||||
|
||||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
||||
|
||||
class Module extends _Node.default {
|
||||
constructor(name, data, parent) {
|
||||
super(name, parent);
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
get src() {
|
||||
return this.data.parsedSrc;
|
||||
}
|
||||
|
||||
set src(value) {
|
||||
this.data.parsedSrc = value;
|
||||
delete this._gzipSize;
|
||||
}
|
||||
|
||||
get size() {
|
||||
return this.data.size;
|
||||
}
|
||||
|
||||
set size(value) {
|
||||
this.data.size = value;
|
||||
}
|
||||
|
||||
get parsedSize() {
|
||||
return this.getParsedSize();
|
||||
}
|
||||
|
||||
get gzipSize() {
|
||||
return this.getGzipSize();
|
||||
}
|
||||
|
||||
getParsedSize() {
|
||||
return this.src ? this.src.length : undefined;
|
||||
}
|
||||
|
||||
getGzipSize() {
|
||||
if (!('_gzipSize' in this)) {
|
||||
this._gzipSize = this.src ? _gzipSize.default.sync(this.src) : undefined;
|
||||
}
|
||||
|
||||
return this._gzipSize;
|
||||
}
|
||||
|
||||
mergeData(data) {
|
||||
if (data.size) {
|
||||
this.size += data.size;
|
||||
}
|
||||
|
||||
if (data.parsedSrc) {
|
||||
this.src = (this.src || '') + data.parsedSrc;
|
||||
}
|
||||
}
|
||||
|
||||
toChartData() {
|
||||
return {
|
||||
id: this.data.id,
|
||||
label: this.name,
|
||||
path: this.path,
|
||||
statSize: this.size,
|
||||
parsedSize: this.parsedSize,
|
||||
gzipSize: this.gzipSize
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = Module;
|
||||
;
|
||||
33
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/Node.js
generated
vendored
Normal file
33
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/Node.js
generated
vendored
Normal file
@ -0,0 +1,33 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.default = void 0;
|
||||
|
||||
class Node {
|
||||
constructor(name, parent) {
|
||||
this.name = name;
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
get path() {
|
||||
const path = [];
|
||||
let node = this;
|
||||
|
||||
while (node) {
|
||||
path.push(node.name);
|
||||
node = node.parent;
|
||||
}
|
||||
|
||||
return path.reverse().join('/');
|
||||
}
|
||||
|
||||
get isRoot() {
|
||||
return !this.parent;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
exports.default = Node;
|
||||
;
|
||||
21
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/utils.js
generated
vendored
Normal file
21
app_vue/node_modules/webpack-bundle-analyzer/lib/tree/utils.js
generated
vendored
Normal file
@ -0,0 +1,21 @@
|
||||
"use strict";
|
||||
|
||||
Object.defineProperty(exports, "__esModule", {
|
||||
value: true
|
||||
});
|
||||
exports.getModulePathParts = getModulePathParts;
|
||||
const MULTI_MODULE_REGEXP = /^multi /u;
|
||||
|
||||
function getModulePathParts(moduleData) {
|
||||
if (MULTI_MODULE_REGEXP.test(moduleData.identifier)) {
|
||||
return [moduleData.identifier];
|
||||
}
|
||||
|
||||
const loaders = moduleData.name.split('!'); // Removing loaders from module path: they're joined by `!` and the last part is a raw module path
|
||||
|
||||
const parsedPath = loaders[loaders.length - 1] // Splitting module path into parts
|
||||
.split('/') // Removing first `.`
|
||||
.slice(1) // Replacing `~` with `node_modules`
|
||||
.map(part => part === '~' ? 'node_modules' : part);
|
||||
return parsedPath.length ? parsedPath : null;
|
||||
}
|
||||
73
app_vue/node_modules/webpack-bundle-analyzer/lib/utils.js
generated
vendored
Normal file
73
app_vue/node_modules/webpack-bundle-analyzer/lib/utils.js
generated
vendored
Normal file
@ -0,0 +1,73 @@
|
||||
"use strict";
|
||||
|
||||
const {
|
||||
inspect,
|
||||
types
|
||||
} = require('util');
|
||||
|
||||
const opener = require('opener');
|
||||
|
||||
const MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
|
||||
exports.createAssetsFilter = createAssetsFilter;
|
||||
|
||||
function createAssetsFilter(excludePatterns) {
|
||||
const excludeFunctions = (Array.isArray(excludePatterns) ? excludePatterns : [excludePatterns]).filter(Boolean).map(pattern => {
|
||||
if (typeof pattern === 'string') {
|
||||
pattern = new RegExp(pattern, 'u');
|
||||
}
|
||||
|
||||
if (types.isRegExp(pattern)) {
|
||||
return asset => pattern.test(asset);
|
||||
}
|
||||
|
||||
if (typeof pattern !== 'function') {
|
||||
throw new TypeError(`Pattern should be either string, RegExp or a function, but "${inspect(pattern, {
|
||||
depth: 0
|
||||
})}" got.`);
|
||||
}
|
||||
|
||||
return pattern;
|
||||
});
|
||||
|
||||
if (excludeFunctions.length) {
|
||||
return asset => excludeFunctions.every(fn => fn(asset) !== true);
|
||||
} else {
|
||||
return () => true;
|
||||
}
|
||||
}
|
||||
/**
|
||||
* @desc get string of current time
|
||||
* format: dd/MMM HH:mm
|
||||
* */
|
||||
|
||||
|
||||
exports.defaultTitle = function () {
|
||||
const time = new Date();
|
||||
const year = time.getFullYear();
|
||||
const month = MONTHS[time.getMonth()];
|
||||
const day = time.getDate();
|
||||
const hour = `0${time.getHours()}`.slice(-2);
|
||||
const minute = `0${time.getMinutes()}`.slice(-2);
|
||||
const currentTime = `${day} ${month} ${year} at ${hour}:${minute}`;
|
||||
return `${process.env.npm_package_name || 'Webpack Bundle Analyzer'} [${currentTime}]`;
|
||||
};
|
||||
|
||||
exports.defaultAnalyzerUrl = function (options) {
|
||||
const {
|
||||
listenHost,
|
||||
boundAddress
|
||||
} = options;
|
||||
return `http://${listenHost}:${boundAddress.port}`;
|
||||
};
|
||||
/**
|
||||
* Calls opener on a URI, but silently try / catches it.
|
||||
*/
|
||||
|
||||
|
||||
exports.open = function (uri, logger) {
|
||||
try {
|
||||
opener(uri);
|
||||
} catch (err) {
|
||||
logger.debug(`Opener failed to open "${uri}":\n${err}`);
|
||||
}
|
||||
};
|
||||
220
app_vue/node_modules/webpack-bundle-analyzer/lib/viewer.js
generated
vendored
Normal file
220
app_vue/node_modules/webpack-bundle-analyzer/lib/viewer.js
generated
vendored
Normal file
@ -0,0 +1,220 @@
|
||||
"use strict";
|
||||
|
||||
const path = require('path');
|
||||
|
||||
const fs = require('fs');
|
||||
|
||||
const http = require('http');
|
||||
|
||||
const WebSocket = require('ws');
|
||||
|
||||
const sirv = require('sirv');
|
||||
|
||||
const {
|
||||
bold
|
||||
} = require('picocolors');
|
||||
|
||||
const Logger = require('./Logger');
|
||||
|
||||
const analyzer = require('./analyzer');
|
||||
|
||||
const {
|
||||
open
|
||||
} = require('./utils');
|
||||
|
||||
const {
|
||||
renderViewer
|
||||
} = require('./template');
|
||||
|
||||
const projectRoot = path.resolve(__dirname, '..');
|
||||
|
||||
function resolveTitle(reportTitle) {
|
||||
if (typeof reportTitle === 'function') {
|
||||
return reportTitle();
|
||||
} else {
|
||||
return reportTitle;
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
startServer,
|
||||
generateReport,
|
||||
generateJSONReport,
|
||||
getEntrypoints,
|
||||
// deprecated
|
||||
start: startServer
|
||||
};
|
||||
|
||||
async function startServer(bundleStats, opts) {
|
||||
const {
|
||||
port = 8888,
|
||||
host = '127.0.0.1',
|
||||
openBrowser = true,
|
||||
bundleDir = null,
|
||||
logger = new Logger(),
|
||||
defaultSizes = 'parsed',
|
||||
excludeAssets = null,
|
||||
reportTitle,
|
||||
analyzerUrl
|
||||
} = opts || {};
|
||||
const analyzerOpts = {
|
||||
logger,
|
||||
excludeAssets
|
||||
};
|
||||
let chartData = getChartData(analyzerOpts, bundleStats, bundleDir);
|
||||
const entrypoints = getEntrypoints(bundleStats);
|
||||
if (!chartData) return;
|
||||
const sirvMiddleware = sirv(`${projectRoot}/public`, {
|
||||
// disables caching and traverse the file system on every request
|
||||
dev: true
|
||||
});
|
||||
const server = http.createServer((req, res) => {
|
||||
if (req.method === 'GET' && req.url === '/') {
|
||||
const html = renderViewer({
|
||||
mode: 'server',
|
||||
title: resolveTitle(reportTitle),
|
||||
chartData,
|
||||
entrypoints,
|
||||
defaultSizes,
|
||||
enableWebSocket: true
|
||||
});
|
||||
res.writeHead(200, {
|
||||
'Content-Type': 'text/html'
|
||||
});
|
||||
res.end(html);
|
||||
} else {
|
||||
sirvMiddleware(req, res);
|
||||
}
|
||||
});
|
||||
await new Promise(resolve => {
|
||||
server.listen(port, host, () => {
|
||||
resolve();
|
||||
const url = analyzerUrl({
|
||||
listenPort: port,
|
||||
listenHost: host,
|
||||
boundAddress: server.address()
|
||||
});
|
||||
logger.info(`${bold('Webpack Bundle Analyzer')} is started at ${bold(url)}\n` + `Use ${bold('Ctrl+C')} to close it`);
|
||||
|
||||
if (openBrowser) {
|
||||
open(url, logger);
|
||||
}
|
||||
});
|
||||
});
|
||||
const wss = new WebSocket.Server({
|
||||
server
|
||||
});
|
||||
wss.on('connection', ws => {
|
||||
ws.on('error', err => {
|
||||
// Ignore network errors like `ECONNRESET`, `EPIPE`, etc.
|
||||
if (err.errno) return;
|
||||
logger.info(err.message);
|
||||
});
|
||||
});
|
||||
return {
|
||||
ws: wss,
|
||||
http: server,
|
||||
updateChartData
|
||||
};
|
||||
|
||||
function updateChartData(bundleStats) {
|
||||
const newChartData = getChartData(analyzerOpts, bundleStats, bundleDir);
|
||||
if (!newChartData) return;
|
||||
chartData = newChartData;
|
||||
wss.clients.forEach(client => {
|
||||
if (client.readyState === WebSocket.OPEN) {
|
||||
client.send(JSON.stringify({
|
||||
event: 'chartDataUpdated',
|
||||
data: newChartData
|
||||
}));
|
||||
}
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
async function generateReport(bundleStats, opts) {
|
||||
const {
|
||||
openBrowser = true,
|
||||
reportFilename,
|
||||
reportTitle,
|
||||
bundleDir = null,
|
||||
logger = new Logger(),
|
||||
defaultSizes = 'parsed',
|
||||
excludeAssets = null
|
||||
} = opts || {};
|
||||
const chartData = getChartData({
|
||||
logger,
|
||||
excludeAssets
|
||||
}, bundleStats, bundleDir);
|
||||
const entrypoints = getEntrypoints(bundleStats);
|
||||
if (!chartData) return;
|
||||
const reportHtml = renderViewer({
|
||||
mode: 'static',
|
||||
title: resolveTitle(reportTitle),
|
||||
chartData,
|
||||
entrypoints,
|
||||
defaultSizes,
|
||||
enableWebSocket: false
|
||||
});
|
||||
const reportFilepath = path.resolve(bundleDir || process.cwd(), reportFilename);
|
||||
fs.mkdirSync(path.dirname(reportFilepath), {
|
||||
recursive: true
|
||||
});
|
||||
fs.writeFileSync(reportFilepath, reportHtml);
|
||||
logger.info(`${bold('Webpack Bundle Analyzer')} saved report to ${bold(reportFilepath)}`);
|
||||
|
||||
if (openBrowser) {
|
||||
open(`file://${reportFilepath}`, logger);
|
||||
}
|
||||
}
|
||||
|
||||
async function generateJSONReport(bundleStats, opts) {
|
||||
const {
|
||||
reportFilename,
|
||||
bundleDir = null,
|
||||
logger = new Logger(),
|
||||
excludeAssets = null
|
||||
} = opts || {};
|
||||
const chartData = getChartData({
|
||||
logger,
|
||||
excludeAssets
|
||||
}, bundleStats, bundleDir);
|
||||
if (!chartData) return;
|
||||
await fs.promises.mkdir(path.dirname(reportFilename), {
|
||||
recursive: true
|
||||
});
|
||||
await fs.promises.writeFile(reportFilename, JSON.stringify(chartData));
|
||||
logger.info(`${bold('Webpack Bundle Analyzer')} saved JSON report to ${bold(reportFilename)}`);
|
||||
}
|
||||
|
||||
function getChartData(analyzerOpts, ...args) {
|
||||
let chartData;
|
||||
const {
|
||||
logger
|
||||
} = analyzerOpts;
|
||||
|
||||
try {
|
||||
chartData = analyzer.getViewerData(...args, analyzerOpts);
|
||||
} catch (err) {
|
||||
logger.error(`Could't analyze webpack bundle:\n${err}`);
|
||||
logger.debug(err.stack);
|
||||
chartData = null;
|
||||
} // chartData can either be an array (bundleInfo[]) or null. It can't be an plain object anyway
|
||||
|
||||
|
||||
if ( // analyzer.getViewerData() doesn't failed in the previous step
|
||||
chartData && !Array.isArray(chartData)) {
|
||||
logger.error("Could't find any javascript bundles in provided stats file");
|
||||
chartData = null;
|
||||
}
|
||||
|
||||
return chartData;
|
||||
}
|
||||
|
||||
function getEntrypoints(bundleStats) {
|
||||
if (bundleStats === null || bundleStats === undefined || !bundleStats.entrypoints) {
|
||||
return [];
|
||||
}
|
||||
|
||||
return Object.values(bundleStats.entrypoints).map(entrypoint => entrypoint.name);
|
||||
}
|
||||
440
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/CHANGELOG.md
generated
vendored
Normal file
440
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/CHANGELOG.md
generated
vendored
Normal file
@ -0,0 +1,440 @@
|
||||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file.
|
||||
|
||||
The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
|
||||
and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). (Format adopted after v3.0.0.)
|
||||
|
||||
<!-- markdownlint-disable MD024 -->
|
||||
<!-- markdownlint-disable MD004 -->
|
||||
|
||||
## [7.2.0] (2021-03-26)
|
||||
|
||||
### Added
|
||||
|
||||
- TypeScript typing for `parent` property on `Command` ([#1475])
|
||||
- TypeScript typing for `.attributeName()` on `Option` ([#1483])
|
||||
- support information in package ([#1477])
|
||||
|
||||
### Changed
|
||||
|
||||
- improvements to error messages, README, and tests
|
||||
- update dependencies
|
||||
|
||||
## [7.1.0] (2021-02-15)
|
||||
|
||||
### Added
|
||||
|
||||
- support for named imports from ECMAScript modules ([#1440])
|
||||
- add `.cjs` to list of expected script file extensions ([#1449])
|
||||
- allow using option choices and variadic together ([#1454])
|
||||
|
||||
### Fixed
|
||||
|
||||
- replace use of deprecated `process.mainModule` ([#1448])
|
||||
- regression for legacy `command('*')` and call when command line includes options ([#1464])
|
||||
- regression for `on('command:*', ...)` and call when command line includes unknown options ([#1464])
|
||||
- display best error for combination of unknown command and unknown option (i.e. unknown command) ([#1464])
|
||||
|
||||
### Changed
|
||||
|
||||
- make TypeScript typings tests stricter ([#1453])
|
||||
- improvements to README and tests
|
||||
|
||||
## [7.0.0] (2021-01-15)
|
||||
|
||||
### Added
|
||||
|
||||
- `.enablePositionalOptions()` to let program and subcommand reuse same option ([#1427])
|
||||
- `.passThroughOptions()` to pass options through to other programs without needing `--` ([#1427])
|
||||
- `.allowExcessArguments(false)` to show an error message if there are too many command-arguments on command line for the action handler ([#1409])
|
||||
- `.configureOutput()` to modify use of stdout and stderr or customise display of errors ([#1387])
|
||||
- use `.addHelpText()` to add text before or after the built-in help, for just current command or also for all subcommands ([#1296])
|
||||
- enhance Option class ([#1331])
|
||||
- allow hiding options from help
|
||||
- allow restricting option arguments to a list of choices
|
||||
- allow setting how default value is shown in help
|
||||
- `.createOption()` to support subclassing of automatically created options (like `.createCommand()`) ([#1380])
|
||||
- refactor the code generating the help into a separate public Help class ([#1365])
|
||||
- support sorting subcommands and options in help
|
||||
- support specifying wrap width (columns)
|
||||
- allow subclassing Help class
|
||||
- allow configuring Help class without subclassing
|
||||
|
||||
### Changed
|
||||
|
||||
- *Breaking:* options are stored safely by default, not as properties on the command ([#1409])
|
||||
- this especially affects accessing options on program, use `program.opts()`
|
||||
- revert behaviour with `.storeOptionsAsProperties()`
|
||||
- *Breaking:* action handlers are passed options and command separately ([#1409])
|
||||
- deprecated callback parameter to `.help()` and `.outputHelp()` (removed from README) ([#1296])
|
||||
- *Breaking:* errors now displayed using `process.stderr.write()` instead of `console.error()`
|
||||
- deprecate `.on('--help')` (removed from README) ([#1296])
|
||||
- initialise the command description to empty string (previously undefined) ([#1365])
|
||||
- document and annotate deprecated routines ([#1349])
|
||||
|
||||
### Fixed
|
||||
|
||||
- wrapping bugs in help ([#1365])
|
||||
- first line of command description was wrapping two characters early
|
||||
- pad width calculation was not including help option and help command
|
||||
- pad width calculation was including hidden options and commands
|
||||
- improve backwards compatibility for custom command event listeners ([#1403])
|
||||
|
||||
### Deleted
|
||||
|
||||
- *Breaking:* `.passCommandToAction()` ([#1409])
|
||||
- no longer needed as action handler is passed options and command
|
||||
- *Breaking:* "extra arguments" parameter to action handler ([#1409])
|
||||
- if being used to detect excess arguments, there is now an error available by setting `.allowExcessArguments(false)`
|
||||
|
||||
### Migration Tips
|
||||
|
||||
The biggest change is the parsed option values. Previously the options were stored by default as properties on the command object, and now the options are stored separately.
|
||||
|
||||
If you wish to restore the old behaviour and get running quickly you can call `.storeOptionsAsProperties()`.
|
||||
To allow you to move to the new code patterns incrementally, the action handler will be passed the command _twice_,
|
||||
to match the new "options" and "command" parameters (see below).
|
||||
|
||||
**program options**
|
||||
|
||||
Use the `.opts()` method to access the options. This is available on any command but is used most with the program.
|
||||
|
||||
```js
|
||||
program.option('-d, --debug');
|
||||
program.parse();
|
||||
// Old code before Commander 7
|
||||
if (program.debug) console.log(`Program name is ${program.name()}`);
|
||||
```
|
||||
|
||||
```js
|
||||
// New code
|
||||
const options = program.opts();
|
||||
if (options.debug) console.log(`Program name is ${program.name()}`);
|
||||
```
|
||||
|
||||
**action handler**
|
||||
|
||||
The action handler gets passed a parameter for each command-argument you declared. Previously by default the next parameter was the command object with the options as properties. Now the next two parameters are instead the options and the command. If you
|
||||
only accessed the options there may be no code changes required.
|
||||
|
||||
```js
|
||||
program
|
||||
.command('compress <filename>')
|
||||
.option('-t, --trace')
|
||||
// Old code before Commander 7
|
||||
.action((filename, cmd)) => {
|
||||
if (cmd.trace) console.log(`Command name is ${cmd.name()}`);
|
||||
});
|
||||
```
|
||||
|
||||
```js
|
||||
// New code
|
||||
.action((filename, options, command)) => {
|
||||
if (options.trace) console.log(`Command name is ${command.name()}`);
|
||||
});
|
||||
```
|
||||
|
||||
If you already set `.storeOptionsAsProperties(false)` you may still need to adjust your code.
|
||||
|
||||
```js
|
||||
program
|
||||
.command('compress <filename>')
|
||||
.storeOptionsAsProperties(false)
|
||||
.option('-t, --trace')
|
||||
// Old code before Commander 7
|
||||
.action((filename, command)) => {
|
||||
if (command.opts().trace) console.log(`Command name is ${command.name()}`);
|
||||
});
|
||||
```
|
||||
|
||||
```js
|
||||
// New code
|
||||
.action((filename, options, command)) => {
|
||||
if (command.opts().trace) console.log(`Command name is ${command.name()}`);
|
||||
});
|
||||
```
|
||||
|
||||
## [7.0.0-2] (2020-12-14)
|
||||
|
||||
(Released in 7.0.0)
|
||||
|
||||
## [7.0.0-1] (2020-11-21)
|
||||
|
||||
(Released in 7.0.0)
|
||||
|
||||
## [7.0.0-0] (2020-10-25)
|
||||
|
||||
(Released in 7.0.0)
|
||||
|
||||
## [6.2.1] (2020-12-13)
|
||||
|
||||
### Fixed
|
||||
|
||||
- some tests failed if directory path included a space ([1390])
|
||||
|
||||
## [6.2.0] (2020-10-25)
|
||||
|
||||
### Added
|
||||
|
||||
- added 'tsx' file extension for stand-alone executable subcommands ([#1368])
|
||||
- documented second parameter to `.description()` to describe command arguments ([#1353])
|
||||
- documentation of special cases with options taking varying numbers of option-arguments ([#1332])
|
||||
- documentation for terminology ([#1361])
|
||||
|
||||
### Fixed
|
||||
|
||||
- add missing TypeScript definition for `.addHelpCommand()' ([#1375])
|
||||
- removed blank line after "Arguments:" in help, to match "Options:" and "Commands:" ([#1360])
|
||||
|
||||
### Changed
|
||||
|
||||
- update dependencies
|
||||
|
||||
## [6.1.0] (2020-08-28)
|
||||
|
||||
### Added
|
||||
|
||||
- include URL to relevant section of README for error for potential conflict between Command properties and option values ([#1306])
|
||||
- `.combineFlagAndOptionalValue(false)` to ease upgrade path from older versions of Commander ([#1326])
|
||||
- allow disabling the built-in help option using `.helpOption(false)` ([#1325])
|
||||
- allow just some arguments in `argumentDescription` to `.description()` ([#1323])
|
||||
|
||||
### Changed
|
||||
|
||||
- tidy async test and remove lint override ([#1312])
|
||||
|
||||
### Fixed
|
||||
|
||||
- executable subcommand launching when script path not known ([#1322])
|
||||
|
||||
## [6.0.0] (2020-07-21)
|
||||
|
||||
### Added
|
||||
|
||||
- add support for variadic options ([#1250])
|
||||
- allow options to be added with just a short flag ([#1256])
|
||||
- *Breaking* the option property has same case as flag. e.g. flag `-n` accessed as `opts().n` (previously uppercase)
|
||||
- *Breaking* throw an error if there might be a clash between option name and a Command property, with advice on how to resolve ([#1275])
|
||||
|
||||
### Fixed
|
||||
|
||||
- Options which contain -no- in the middle of the option flag should not be treated as negatable. ([#1301])
|
||||
|
||||
## [6.0.0-0] (2020-06-20)
|
||||
|
||||
(Released in 6.0.0)
|
||||
|
||||
## [5.1.0] (2020-04-25)
|
||||
|
||||
### Added
|
||||
|
||||
- support for multiple command aliases, the first of which is shown in the auto-generated help ([#531], [#1236])
|
||||
- configuration support in `addCommand()` for `hidden` and `isDefault` ([#1232])
|
||||
|
||||
### Fixed
|
||||
|
||||
- omit masked help flags from the displayed help ([#645], [#1247])
|
||||
- remove old short help flag when change help flags using `helpOption` ([#1248])
|
||||
|
||||
### Changed
|
||||
|
||||
- remove use of `arguments` to improve auto-generated help in editors ([#1235])
|
||||
- rename `.command()` configuration `noHelp` to `hidden` (but not remove old support) ([#1232])
|
||||
- improvements to documentation
|
||||
- update dependencies
|
||||
- update tested versions of node
|
||||
- eliminate lint errors in TypeScript ([#1208])
|
||||
|
||||
## [5.0.0] (2020-03-14)
|
||||
|
||||
### Added
|
||||
|
||||
* support for nested commands with action-handlers ([#1] [#764] [#1149])
|
||||
* `.addCommand()` for adding a separately configured command ([#764] [#1149])
|
||||
* allow a non-executable to be set as the default command ([#742] [#1149])
|
||||
* implicit help command when there are subcommands (previously only if executables) ([#1149])
|
||||
* customise implicit help command with `.addHelpCommand()` ([#1149])
|
||||
* display error message for unknown subcommand, by default ([#432] [#1088] [#1149])
|
||||
* display help for missing subcommand, by default ([#1088] [#1149])
|
||||
* combined short options as single argument may include boolean flags and value flag and value (e.g. `-a -b -p 80` can be written as `-abp80`) ([#1145])
|
||||
* `.parseOption()` includes short flag and long flag expansions ([#1145])
|
||||
* `.helpInformation()` returns help text as a string, previously a private routine ([#1169])
|
||||
* `.parse()` implicitly uses `process.argv` if arguments not specified ([#1172])
|
||||
* optionally specify where `.parse()` arguments "from", if not following node conventions ([#512] [#1172])
|
||||
* suggest help option along with unknown command error ([#1179])
|
||||
* TypeScript definition for `commands` property of `Command` ([#1184])
|
||||
* export `program` property ([#1195])
|
||||
* `createCommand` factory method to simplify subclassing ([#1191])
|
||||
|
||||
### Fixed
|
||||
|
||||
* preserve argument order in subcommands ([#508] [#962] [#1138])
|
||||
* do not emit `command:*` for executable subcommands ([#809] [#1149])
|
||||
* action handler called whether or not there are non-option arguments ([#1062] [#1149])
|
||||
* combining option short flag and value in single argument now works for subcommands ([#1145])
|
||||
* only add implicit help command when it will not conflict with other uses of argument ([#1153] [#1149])
|
||||
* implicit help command works with command aliases ([#948] [#1149])
|
||||
* options are validated whether or not there is an action handler ([#1149])
|
||||
|
||||
### Changed
|
||||
|
||||
* *Breaking* `.args` contains command arguments with just recognised options removed ([#1032] [#1138])
|
||||
* *Breaking* display error if required argument for command is missing ([#995] [#1149])
|
||||
* tighten TypeScript definition of custom option processing function passed to `.option()` ([#1119])
|
||||
* *Breaking* `.allowUnknownOption()` ([#802] [#1138])
|
||||
* unknown options included in arguments passed to command action handler
|
||||
* unknown options included in `.args`
|
||||
* only recognised option short flags and long flags are expanded (e.g. `-ab` or `--foo=bar`) ([#1145])
|
||||
* *Breaking* `.parseOptions()` ([#1138])
|
||||
* `args` in returned result renamed `operands` and does not include anything after first unknown option
|
||||
* `unknown` in returned result has arguments after first unknown option including operands, not just options and values
|
||||
* *Breaking* `.on('command:*', callback)` and other command events passed (changed) results from `.parseOptions`, i.e. operands and unknown ([#1138])
|
||||
* refactor Option from prototype to class ([#1133])
|
||||
* refactor Command from prototype to class ([#1159])
|
||||
* changes to error handling ([#1165])
|
||||
* throw for author error, not just display message
|
||||
* preflight for variadic error
|
||||
* add tips to missing subcommand executable
|
||||
* TypeScript fluent return types changed to be more subclass friendly, return `this` rather than `Command` ([#1180])
|
||||
* `.parseAsync` returns `Promise<this>` to be consistent with `.parse()` ([#1180])
|
||||
* update dependencies
|
||||
|
||||
### Removed
|
||||
|
||||
* removed EventEmitter from TypeScript definition for Command, eliminating implicit peer dependency on `@types/node` ([#1146])
|
||||
* removed private function `normalize` (the functionality has been integrated into `parseOptions`) ([#1145])
|
||||
* `parseExpectedArgs` is now private ([#1149])
|
||||
|
||||
### Migration Tips
|
||||
|
||||
If you use `.on('command:*')` or more complicated tests to detect an unrecognised subcommand, you may be able to delete the code and rely on the default behaviour.
|
||||
|
||||
If you use `program.args` or more complicated tests to detect a missing subcommand, you may be able to delete the code and rely on the default behaviour.
|
||||
|
||||
If you use `.command('*')` to add a default command, you may be be able to switch to `isDefault:true` with a named command.
|
||||
|
||||
If you want to continue combining short options with optional values as though they were boolean flags, set `combineFlagAndOptionalValue(false)`
|
||||
to expand `-fb` to `-f -b` rather than `-f b`.
|
||||
|
||||
## [5.0.0-4] (2020-03-03)
|
||||
|
||||
(Released in 5.0.0)
|
||||
|
||||
## [5.0.0-3] (2020-02-20)
|
||||
|
||||
(Released in 5.0.0)
|
||||
|
||||
## [5.0.0-2] (2020-02-10)
|
||||
|
||||
(Released in 5.0.0)
|
||||
|
||||
## [5.0.0-1] (2020-02-08)
|
||||
|
||||
(Released in 5.0.0)
|
||||
|
||||
## [5.0.0-0] (2020-02-02)
|
||||
|
||||
(Released in 5.0.0)
|
||||
|
||||
## Older versions
|
||||
|
||||
* [4.x](./changelogs/CHANGELOG-4.md)
|
||||
* [3.x](./changelogs/CHANGELOG-3.md)
|
||||
* [2.x](./changelogs/CHANGELOG-2.md)
|
||||
* [1.x](./changelogs/CHANGELOG-1.md)
|
||||
* [0.x](./changelogs/CHANGELOG-0.md)
|
||||
|
||||
[#1]: https://github.com/tj/commander.js/issues/1
|
||||
[#432]: https://github.com/tj/commander.js/issues/432
|
||||
[#508]: https://github.com/tj/commander.js/issues/508
|
||||
[#512]: https://github.com/tj/commander.js/issues/512
|
||||
[#531]: https://github.com/tj/commander.js/issues/531
|
||||
[#645]: https://github.com/tj/commander.js/issues/645
|
||||
[#742]: https://github.com/tj/commander.js/issues/742
|
||||
[#764]: https://github.com/tj/commander.js/issues/764
|
||||
[#802]: https://github.com/tj/commander.js/issues/802
|
||||
[#809]: https://github.com/tj/commander.js/issues/809
|
||||
[#948]: https://github.com/tj/commander.js/issues/948
|
||||
[#962]: https://github.com/tj/commander.js/issues/962
|
||||
[#995]: https://github.com/tj/commander.js/issues/995
|
||||
[#1032]: https://github.com/tj/commander.js/issues/1032
|
||||
[#1062]: https://github.com/tj/commander.js/pull/1062
|
||||
[#1088]: https://github.com/tj/commander.js/issues/1088
|
||||
[#1119]: https://github.com/tj/commander.js/pull/1119
|
||||
[#1133]: https://github.com/tj/commander.js/pull/1133
|
||||
[#1138]: https://github.com/tj/commander.js/pull/1138
|
||||
[#1145]: https://github.com/tj/commander.js/pull/1145
|
||||
[#1146]: https://github.com/tj/commander.js/pull/1146
|
||||
[#1149]: https://github.com/tj/commander.js/pull/1149
|
||||
[#1153]: https://github.com/tj/commander.js/issues/1153
|
||||
[#1159]: https://github.com/tj/commander.js/pull/1159
|
||||
[#1165]: https://github.com/tj/commander.js/pull/1165
|
||||
[#1169]: https://github.com/tj/commander.js/pull/1169
|
||||
[#1172]: https://github.com/tj/commander.js/pull/1172
|
||||
[#1179]: https://github.com/tj/commander.js/pull/1179
|
||||
[#1180]: https://github.com/tj/commander.js/pull/1180
|
||||
[#1184]: https://github.com/tj/commander.js/pull/1184
|
||||
[#1191]: https://github.com/tj/commander.js/pull/1191
|
||||
[#1195]: https://github.com/tj/commander.js/pull/1195
|
||||
[#1208]: https://github.com/tj/commander.js/pull/1208
|
||||
[#1232]: https://github.com/tj/commander.js/pull/1232
|
||||
[#1235]: https://github.com/tj/commander.js/pull/1235
|
||||
[#1236]: https://github.com/tj/commander.js/pull/1236
|
||||
[#1247]: https://github.com/tj/commander.js/pull/1247
|
||||
[#1248]: https://github.com/tj/commander.js/pull/1248
|
||||
[#1250]: https://github.com/tj/commander.js/pull/1250
|
||||
[#1256]: https://github.com/tj/commander.js/pull/1256
|
||||
[#1275]: https://github.com/tj/commander.js/pull/1275
|
||||
[#1296]: https://github.com/tj/commander.js/pull/1296
|
||||
[#1301]: https://github.com/tj/commander.js/issues/1301
|
||||
[#1306]: https://github.com/tj/commander.js/pull/1306
|
||||
[#1312]: https://github.com/tj/commander.js/pull/1312
|
||||
[#1322]: https://github.com/tj/commander.js/pull/1322
|
||||
[#1323]: https://github.com/tj/commander.js/pull/1323
|
||||
[#1325]: https://github.com/tj/commander.js/pull/1325
|
||||
[#1326]: https://github.com/tj/commander.js/pull/1326
|
||||
[#1331]: https://github.com/tj/commander.js/pull/1331
|
||||
[#1332]: https://github.com/tj/commander.js/pull/1332
|
||||
[#1349]: https://github.com/tj/commander.js/pull/1349
|
||||
[#1353]: https://github.com/tj/commander.js/pull/1353
|
||||
[#1360]: https://github.com/tj/commander.js/pull/1360
|
||||
[#1361]: https://github.com/tj/commander.js/pull/1361
|
||||
[#1365]: https://github.com/tj/commander.js/pull/1365
|
||||
[#1368]: https://github.com/tj/commander.js/pull/1368
|
||||
[#1375]: https://github.com/tj/commander.js/pull/1375
|
||||
[#1380]: https://github.com/tj/commander.js/pull/1380
|
||||
[#1387]: https://github.com/tj/commander.js/pull/1387
|
||||
[#1390]: https://github.com/tj/commander.js/pull/1390
|
||||
[#1403]: https://github.com/tj/commander.js/pull/1403
|
||||
[#1409]: https://github.com/tj/commander.js/pull/1409
|
||||
[#1427]: https://github.com/tj/commander.js/pull/1427
|
||||
[#1440]: https://github.com/tj/commander.js/pull/1440
|
||||
[#1448]: https://github.com/tj/commander.js/pull/1448
|
||||
[#1449]: https://github.com/tj/commander.js/pull/1449
|
||||
[#1453]: https://github.com/tj/commander.js/pull/1453
|
||||
[#1454]: https://github.com/tj/commander.js/pull/1454
|
||||
[#1464]: https://github.com/tj/commander.js/pull/1464
|
||||
[#1475]: https://github.com/tj/commander.js/pull/1475
|
||||
[#1477]: https://github.com/tj/commander.js/pull/1477
|
||||
[#1483]: https://github.com/tj/commander.js/pull/1483
|
||||
|
||||
[Unreleased]: https://github.com/tj/commander.js/compare/master...develop
|
||||
[7.2.0]: https://github.com/tj/commander.js/compare/v7.1.0...v7.2.0
|
||||
[7.1.0]: https://github.com/tj/commander.js/compare/v7.0.0...v7.1.0
|
||||
[7.0.0]: https://github.com/tj/commander.js/compare/v6.2.1...v7.0.0
|
||||
[7.0.0-2]: https://github.com/tj/commander.js/compare/v7.0.0-1...v7.0.0-2
|
||||
[7.0.0-1]: https://github.com/tj/commander.js/compare/v7.0.0-0...v7.0.0-1
|
||||
[7.0.0-0]: https://github.com/tj/commander.js/compare/v6.2.0...v7.0.0-0
|
||||
[6.2.1]: https://github.com/tj/commander.js/compare/v6.2.0..v6.2.1
|
||||
[6.2.0]: https://github.com/tj/commander.js/compare/v6.1.0..v6.2.0
|
||||
[6.1.0]: https://github.com/tj/commander.js/compare/v6.0.0..v6.1.0
|
||||
[6.0.0]: https://github.com/tj/commander.js/compare/v5.1.0..v6.0.0
|
||||
[6.0.0-0]: https://github.com/tj/commander.js/compare/v5.1.0..v6.0.0-0
|
||||
[5.1.0]: https://github.com/tj/commander.js/compare/v5.0.0..v5.1.0
|
||||
[5.0.0]: https://github.com/tj/commander.js/compare/v4.1.1..v5.0.0
|
||||
[5.0.0-4]: https://github.com/tj/commander.js/compare/v5.0.0-3..v5.0.0-4
|
||||
[5.0.0-3]: https://github.com/tj/commander.js/compare/v5.0.0-2..v5.0.0-3
|
||||
[5.0.0-2]: https://github.com/tj/commander.js/compare/v5.0.0-1..v5.0.0-2
|
||||
[5.0.0-1]: https://github.com/tj/commander.js/compare/v5.0.0-0..v5.0.0-1
|
||||
[5.0.0-0]: https://github.com/tj/commander.js/compare/v4.1.1..v5.0.0-0
|
||||
22
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/LICENSE
generated
vendored
Normal file
22
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/LICENSE
generated
vendored
Normal file
@ -0,0 +1,22 @@
|
||||
(The MIT License)
|
||||
|
||||
Copyright (c) 2011 TJ Holowaychuk <tj@vision-media.ca>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of this software and associated documentation files (the
|
||||
'Software'), to deal in the Software without restriction, including
|
||||
without limitation the rights to use, copy, modify, merge, publish,
|
||||
distribute, sublicense, and/or sell copies of the Software, and to
|
||||
permit persons to whom the Software is furnished to do so, subject to
|
||||
the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be
|
||||
included in all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
||||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
|
||||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
|
||||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
917
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/Readme.md
generated
vendored
Normal file
917
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/Readme.md
generated
vendored
Normal file
@ -0,0 +1,917 @@
|
||||
# Commander.js
|
||||
|
||||
[](https://github.com/tj/commander.js/actions?query=workflow%3A%22build%22)
|
||||
[](https://www.npmjs.org/package/commander)
|
||||
[](https://npmcharts.com/compare/commander?minimal=true)
|
||||
[](https://packagephobia.now.sh/result?p=commander)
|
||||
|
||||
The complete solution for [node.js](http://nodejs.org) command-line interfaces.
|
||||
|
||||
Read this in other languages: English | [简体中文](./Readme_zh-CN.md)
|
||||
|
||||
- [Commander.js](#commanderjs)
|
||||
- [Installation](#installation)
|
||||
- [Declaring _program_ variable](#declaring-program-variable)
|
||||
- [Options](#options)
|
||||
- [Common option types, boolean and value](#common-option-types-boolean-and-value)
|
||||
- [Default option value](#default-option-value)
|
||||
- [Other option types, negatable boolean and boolean|value](#other-option-types-negatable-boolean-and-booleanvalue)
|
||||
- [Required option](#required-option)
|
||||
- [Variadic option](#variadic-option)
|
||||
- [Version option](#version-option)
|
||||
- [More configuration](#more-configuration)
|
||||
- [Custom option processing](#custom-option-processing)
|
||||
- [Commands](#commands)
|
||||
- [Specify the argument syntax](#specify-the-argument-syntax)
|
||||
- [Action handler](#action-handler)
|
||||
- [Stand-alone executable (sub)commands](#stand-alone-executable-subcommands)
|
||||
- [Automated help](#automated-help)
|
||||
- [Custom help](#custom-help)
|
||||
- [Display help from code](#display-help-from-code)
|
||||
- [.usage and .name](#usage-and-name)
|
||||
- [.helpOption(flags, description)](#helpoptionflags-description)
|
||||
- [.addHelpCommand()](#addhelpcommand)
|
||||
- [More configuration](#more-configuration-1)
|
||||
- [Custom event listeners](#custom-event-listeners)
|
||||
- [Bits and pieces](#bits-and-pieces)
|
||||
- [.parse() and .parseAsync()](#parse-and-parseasync)
|
||||
- [Parsing Configuration](#parsing-configuration)
|
||||
- [Legacy options as properties](#legacy-options-as-properties)
|
||||
- [TypeScript](#typescript)
|
||||
- [createCommand()](#createcommand)
|
||||
- [Node options such as `--harmony`](#node-options-such-as---harmony)
|
||||
- [Debugging stand-alone executable subcommands](#debugging-stand-alone-executable-subcommands)
|
||||
- [Override exit and output handling](#override-exit-and-output-handling)
|
||||
- [Additional documentation](#additional-documentation)
|
||||
- [Examples](#examples)
|
||||
- [Support](#support)
|
||||
- [Commander for enterprise](#commander-for-enterprise)
|
||||
|
||||
For information about terms used in this document see: [terminology](./docs/terminology.md)
|
||||
|
||||
## Installation
|
||||
|
||||
```bash
|
||||
npm install commander
|
||||
```
|
||||
|
||||
## Declaring _program_ variable
|
||||
|
||||
Commander exports a global object which is convenient for quick programs.
|
||||
This is used in the examples in this README for brevity.
|
||||
|
||||
```js
|
||||
const { program } = require('commander');
|
||||
program.version('0.0.1');
|
||||
```
|
||||
|
||||
For larger programs which may use commander in multiple ways, including unit testing, it is better to create a local Command object to use.
|
||||
|
||||
```js
|
||||
const { Command } = require('commander');
|
||||
const program = new Command();
|
||||
program.version('0.0.1');
|
||||
```
|
||||
|
||||
For named imports in ECMAScript modules, import from `commander/esm.mjs`.
|
||||
|
||||
```js
|
||||
// index.mjs
|
||||
import { Command } from 'commander/esm.mjs';
|
||||
const program = new Command();
|
||||
```
|
||||
|
||||
And in TypeScript:
|
||||
|
||||
```ts
|
||||
// index.ts
|
||||
import { Command } from 'commander';
|
||||
const program = new Command();
|
||||
```
|
||||
|
||||
|
||||
## Options
|
||||
|
||||
Options are defined with the `.option()` method, also serving as documentation for the options. Each option can have a short flag (single character) and a long name, separated by a comma or space or vertical bar ('|').
|
||||
|
||||
The parsed options can be accessed by calling `.opts()` on a `Command` object, and are passed to the action handler. Multi-word options such as "--template-engine" are camel-cased, becoming `program.opts().templateEngine` etc.
|
||||
|
||||
Multiple short flags may optionally be combined in a single argument following the dash: boolean flags, followed by a single option taking a value (possibly followed by the value).
|
||||
For example `-a -b -p 80` may be written as `-ab -p80` or even `-abp80`.
|
||||
|
||||
You can use `--` to indicate the end of the options, and any remaining arguments will be used without being interpreted.
|
||||
|
||||
By default options on the command line are not positional, and can be specified before or after other arguments.
|
||||
|
||||
### Common option types, boolean and value
|
||||
|
||||
The two most used option types are a boolean option, and an option which takes its value
|
||||
from the following argument (declared with angle brackets like `--expect <value>`). Both are `undefined` unless specified on command line.
|
||||
|
||||
Example file: [options-common.js](./examples/options-common.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.option('-d, --debug', 'output extra debugging')
|
||||
.option('-s, --small', 'small pizza size')
|
||||
.option('-p, --pizza-type <type>', 'flavour of pizza');
|
||||
|
||||
program.parse(process.argv);
|
||||
|
||||
const options = program.opts();
|
||||
if (options.debug) console.log(options);
|
||||
console.log('pizza details:');
|
||||
if (options.small) console.log('- small pizza size');
|
||||
if (options.pizzaType) console.log(`- ${options.pizzaType}`);
|
||||
```
|
||||
|
||||
```bash
|
||||
$ pizza-options -d
|
||||
{ debug: true, small: undefined, pizzaType: undefined }
|
||||
pizza details:
|
||||
$ pizza-options -p
|
||||
error: option '-p, --pizza-type <type>' argument missing
|
||||
$ pizza-options -ds -p vegetarian
|
||||
{ debug: true, small: true, pizzaType: 'vegetarian' }
|
||||
pizza details:
|
||||
- small pizza size
|
||||
- vegetarian
|
||||
$ pizza-options --pizza-type=cheese
|
||||
pizza details:
|
||||
- cheese
|
||||
```
|
||||
|
||||
`program.parse(arguments)` processes the arguments, leaving any args not consumed by the program options in the `program.args` array. The parameter is optional and defaults to `process.argv`.
|
||||
|
||||
### Default option value
|
||||
|
||||
You can specify a default value for an option which takes a value.
|
||||
|
||||
Example file: [options-defaults.js](./examples/options-defaults.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.option('-c, --cheese <type>', 'add the specified type of cheese', 'blue');
|
||||
|
||||
program.parse();
|
||||
|
||||
console.log(`cheese: ${program.opts().cheese}`);
|
||||
```
|
||||
|
||||
```bash
|
||||
$ pizza-options
|
||||
cheese: blue
|
||||
$ pizza-options --cheese stilton
|
||||
cheese: stilton
|
||||
```
|
||||
|
||||
### Other option types, negatable boolean and boolean|value
|
||||
|
||||
You can define a boolean option long name with a leading `no-` to set the option value to false when used.
|
||||
Defined alone this also makes the option true by default.
|
||||
|
||||
If you define `--foo` first, adding `--no-foo` does not change the default value from what it would
|
||||
otherwise be. You can specify a default boolean value for a boolean option and it can be overridden on command line.
|
||||
|
||||
Example file: [options-negatable.js](./examples/options-negatable.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.option('--no-sauce', 'Remove sauce')
|
||||
.option('--cheese <flavour>', 'cheese flavour', 'mozzarella')
|
||||
.option('--no-cheese', 'plain with no cheese')
|
||||
.parse();
|
||||
|
||||
const options = program.opts();
|
||||
const sauceStr = options.sauce ? 'sauce' : 'no sauce';
|
||||
const cheeseStr = (options.cheese === false) ? 'no cheese' : `${options.cheese} cheese`;
|
||||
console.log(`You ordered a pizza with ${sauceStr} and ${cheeseStr}`);
|
||||
```
|
||||
|
||||
```bash
|
||||
$ pizza-options
|
||||
You ordered a pizza with sauce and mozzarella cheese
|
||||
$ pizza-options --sauce
|
||||
error: unknown option '--sauce'
|
||||
$ pizza-options --cheese=blue
|
||||
You ordered a pizza with sauce and blue cheese
|
||||
$ pizza-options --no-sauce --no-cheese
|
||||
You ordered a pizza with no sauce and no cheese
|
||||
```
|
||||
|
||||
You can specify an option which may be used as a boolean option but may optionally take an option-argument
|
||||
(declared with square brackets like `--optional [value]`).
|
||||
|
||||
Example file: [options-boolean-or-value.js](./examples/options-boolean-or-value.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.option('-c, --cheese [type]', 'Add cheese with optional type');
|
||||
|
||||
program.parse(process.argv);
|
||||
|
||||
const options = program.opts();
|
||||
if (options.cheese === undefined) console.log('no cheese');
|
||||
else if (options.cheese === true) console.log('add cheese');
|
||||
else console.log(`add cheese type ${options.cheese}`);
|
||||
```
|
||||
|
||||
```bash
|
||||
$ pizza-options
|
||||
no cheese
|
||||
$ pizza-options --cheese
|
||||
add cheese
|
||||
$ pizza-options --cheese mozzarella
|
||||
add cheese type mozzarella
|
||||
```
|
||||
|
||||
For information about possible ambiguous cases, see [options taking varying arguments](./docs/options-taking-varying-arguments.md).
|
||||
|
||||
### Required option
|
||||
|
||||
You may specify a required (mandatory) option using `.requiredOption`. The option must have a value after parsing, usually specified on the command line, or perhaps from a default value (say from environment). The method is otherwise the same as `.option` in format, taking flags and description, and optional default value or custom processing.
|
||||
|
||||
Example file: [options-required.js](./examples/options-required.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.requiredOption('-c, --cheese <type>', 'pizza must have cheese');
|
||||
|
||||
program.parse();
|
||||
```
|
||||
|
||||
```bash
|
||||
$ pizza
|
||||
error: required option '-c, --cheese <type>' not specified
|
||||
```
|
||||
|
||||
### Variadic option
|
||||
|
||||
You may make an option variadic by appending `...` to the value placeholder when declaring the option. On the command line you
|
||||
can then specify multiple option-arguments, and the parsed option value will be an array. The extra arguments
|
||||
are read until the first argument starting with a dash. The special argument `--` stops option processing entirely. If a value
|
||||
is specified in the same argument as the option then no further values are read.
|
||||
|
||||
Example file: [options-variadic.js](./examples/options-variadic.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.option('-n, --number <numbers...>', 'specify numbers')
|
||||
.option('-l, --letter [letters...]', 'specify letters');
|
||||
|
||||
program.parse();
|
||||
|
||||
console.log('Options: ', program.opts());
|
||||
console.log('Remaining arguments: ', program.args);
|
||||
```
|
||||
|
||||
```bash
|
||||
$ collect -n 1 2 3 --letter a b c
|
||||
Options: { number: [ '1', '2', '3' ], letter: [ 'a', 'b', 'c' ] }
|
||||
Remaining arguments: []
|
||||
$ collect --letter=A -n80 operand
|
||||
Options: { number: [ '80' ], letter: [ 'A' ] }
|
||||
Remaining arguments: [ 'operand' ]
|
||||
$ collect --letter -n 1 -n 2 3 -- operand
|
||||
Options: { number: [ '1', '2', '3' ], letter: true }
|
||||
Remaining arguments: [ 'operand' ]
|
||||
```
|
||||
|
||||
For information about possible ambiguous cases, see [options taking varying arguments](./docs/options-taking-varying-arguments.md).
|
||||
|
||||
### Version option
|
||||
|
||||
The optional `version` method adds handling for displaying the command version. The default option flags are `-V` and `--version`, and when present the command prints the version number and exits.
|
||||
|
||||
```js
|
||||
program.version('0.0.1');
|
||||
```
|
||||
|
||||
```bash
|
||||
$ ./examples/pizza -V
|
||||
0.0.1
|
||||
```
|
||||
|
||||
You may change the flags and description by passing additional parameters to the `version` method, using
|
||||
the same syntax for flags as the `option` method.
|
||||
|
||||
```js
|
||||
program.version('0.0.1', '-v, --vers', 'output the current version');
|
||||
```
|
||||
|
||||
### More configuration
|
||||
|
||||
You can add most options using the `.option()` method, but there are some additional features available
|
||||
by constructing an `Option` explicitly for less common cases.
|
||||
|
||||
Example file: [options-extra.js](./examples/options-extra.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.addOption(new Option('-s, --secret').hideHelp())
|
||||
.addOption(new Option('-t, --timeout <delay>', 'timeout in seconds').default(60, 'one minute'))
|
||||
.addOption(new Option('-d, --drink <size>', 'drink size').choices(['small', 'medium', 'large']));
|
||||
```
|
||||
|
||||
```bash
|
||||
$ extra --help
|
||||
Usage: help [options]
|
||||
|
||||
Options:
|
||||
-t, --timeout <delay> timeout in seconds (default: one minute)
|
||||
-d, --drink <size> drink cup size (choices: "small", "medium", "large")
|
||||
-h, --help display help for command
|
||||
|
||||
$ extra --drink huge
|
||||
error: option '-d, --drink <size>' argument 'huge' is invalid. Allowed choices are small, medium, large.
|
||||
```
|
||||
|
||||
### Custom option processing
|
||||
|
||||
You may specify a function to do custom processing of option-arguments. The callback function receives two parameters,
|
||||
the user specified option-argument and the previous value for the option. It returns the new value for the option.
|
||||
|
||||
This allows you to coerce the option-argument to the desired type, or accumulate values, or do entirely custom processing.
|
||||
|
||||
You can optionally specify the default/starting value for the option after the function parameter.
|
||||
|
||||
Example file: [options-custom-processing.js](./examples/options-custom-processing.js)
|
||||
|
||||
```js
|
||||
function myParseInt(value, dummyPrevious) {
|
||||
// parseInt takes a string and a radix
|
||||
const parsedValue = parseInt(value, 10);
|
||||
if (isNaN(parsedValue)) {
|
||||
throw new commander.InvalidOptionArgumentError('Not a number.');
|
||||
}
|
||||
return parsedValue;
|
||||
}
|
||||
|
||||
function increaseVerbosity(dummyValue, previous) {
|
||||
return previous + 1;
|
||||
}
|
||||
|
||||
function collect(value, previous) {
|
||||
return previous.concat([value]);
|
||||
}
|
||||
|
||||
function commaSeparatedList(value, dummyPrevious) {
|
||||
return value.split(',');
|
||||
}
|
||||
|
||||
program
|
||||
.option('-f, --float <number>', 'float argument', parseFloat)
|
||||
.option('-i, --integer <number>', 'integer argument', myParseInt)
|
||||
.option('-v, --verbose', 'verbosity that can be increased', increaseVerbosity, 0)
|
||||
.option('-c, --collect <value>', 'repeatable value', collect, [])
|
||||
.option('-l, --list <items>', 'comma separated list', commaSeparatedList)
|
||||
;
|
||||
|
||||
program.parse();
|
||||
|
||||
const options = program.opts();
|
||||
if (options.float !== undefined) console.log(`float: ${options.float}`);
|
||||
if (options.integer !== undefined) console.log(`integer: ${options.integer}`);
|
||||
if (options.verbose > 0) console.log(`verbosity: ${options.verbose}`);
|
||||
if (options.collect.length > 0) console.log(options.collect);
|
||||
if (options.list !== undefined) console.log(options.list);
|
||||
```
|
||||
|
||||
```bash
|
||||
$ custom -f 1e2
|
||||
float: 100
|
||||
$ custom --integer 2
|
||||
integer: 2
|
||||
$ custom -v -v -v
|
||||
verbose: 3
|
||||
$ custom -c a -c b -c c
|
||||
[ 'a', 'b', 'c' ]
|
||||
$ custom --list x,y,z
|
||||
[ 'x', 'y', 'z' ]
|
||||
```
|
||||
|
||||
## Commands
|
||||
|
||||
You can specify (sub)commands using `.command()` or `.addCommand()`. There are two ways these can be implemented: using an action handler attached to the command, or as a stand-alone executable file (described in more detail later). The subcommands may be nested ([example](./examples/nestedCommands.js)).
|
||||
|
||||
In the first parameter to `.command()` you specify the command name and any command-arguments. The arguments may be `<required>` or `[optional]`, and the last argument may also be `variadic...`.
|
||||
|
||||
You can use `.addCommand()` to add an already configured subcommand to the program.
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
// Command implemented using action handler (description is supplied separately to `.command`)
|
||||
// Returns new command for configuring.
|
||||
program
|
||||
.command('clone <source> [destination]')
|
||||
.description('clone a repository into a newly created directory')
|
||||
.action((source, destination) => {
|
||||
console.log('clone command called');
|
||||
});
|
||||
|
||||
// Command implemented using stand-alone executable file (description is second parameter to `.command`)
|
||||
// Returns `this` for adding more commands.
|
||||
program
|
||||
.command('start <service>', 'start named service')
|
||||
.command('stop [service]', 'stop named service, or all if no name supplied');
|
||||
|
||||
// Command prepared separately.
|
||||
// Returns `this` for adding more commands.
|
||||
program
|
||||
.addCommand(build.makeBuildCommand());
|
||||
```
|
||||
|
||||
Configuration options can be passed with the call to `.command()` and `.addCommand()`. Specifying `hidden: true` will
|
||||
remove the command from the generated help output. Specifying `isDefault: true` will run the subcommand if no other
|
||||
subcommand is specified ([example](./examples/defaultCommand.js)).
|
||||
|
||||
### Specify the argument syntax
|
||||
|
||||
You use `.arguments` to specify the expected command-arguments for the top-level command, and for subcommands they are usually
|
||||
included in the `.command` call. Angled brackets (e.g. `<required>`) indicate required command-arguments.
|
||||
Square brackets (e.g. `[optional]`) indicate optional command-arguments.
|
||||
You can optionally describe the arguments in the help by supplying a hash as second parameter to `.description()`.
|
||||
|
||||
Example file: [arguments.js](./examples/arguments.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.version('0.1.0')
|
||||
.arguments('<username> [password]')
|
||||
.description('test command', {
|
||||
username: 'user to login',
|
||||
password: 'password for user, if required'
|
||||
})
|
||||
.action((username, password) => {
|
||||
console.log('username:', username);
|
||||
console.log('environment:', password || 'no password given');
|
||||
});
|
||||
```
|
||||
|
||||
The last argument of a command can be variadic, and only the last argument. To make an argument variadic you
|
||||
append `...` to the argument name. For example:
|
||||
|
||||
```js
|
||||
program
|
||||
.version('0.1.0')
|
||||
.command('rmdir <dirs...>')
|
||||
.action(function (dirs) {
|
||||
dirs.forEach((dir) => {
|
||||
console.log('rmdir %s', dir);
|
||||
});
|
||||
});
|
||||
```
|
||||
|
||||
The variadic argument is passed to the action handler as an array.
|
||||
|
||||
### Action handler
|
||||
|
||||
The action handler gets passed a parameter for each command-argument you declared, and two additional parameters
|
||||
which are the parsed options and the command object itself.
|
||||
|
||||
Example file: [thank.js](./examples/thank.js)
|
||||
|
||||
```js
|
||||
program
|
||||
.arguments('<name>')
|
||||
.option('-t, --title <honorific>', 'title to use before name')
|
||||
.option('-d, --debug', 'display some debugging')
|
||||
.action((name, options, command) => {
|
||||
if (options.debug) {
|
||||
console.error('Called %s with options %o', command.name(), options);
|
||||
}
|
||||
const title = options.title ? `${options.title} ` : '';
|
||||
console.log(`Thank-you ${title}${name}`);
|
||||
});
|
||||
```
|
||||
|
||||
You may supply an `async` action handler, in which case you call `.parseAsync` rather than `.parse`.
|
||||
|
||||
```js
|
||||
async function run() { /* code goes here */ }
|
||||
|
||||
async function main() {
|
||||
program
|
||||
.command('run')
|
||||
.action(run);
|
||||
await program.parseAsync(process.argv);
|
||||
}
|
||||
```
|
||||
|
||||
A command's options and arguments on the command line are validated when the command is used. Any unknown options or missing arguments will be reported as an error. You can suppress the unknown option checks with `.allowUnknownOption()`. By default it is not an error to
|
||||
pass more arguments than declared, but you can make this an error with `.allowExcessArguments(false)`.
|
||||
|
||||
### Stand-alone executable (sub)commands
|
||||
|
||||
When `.command()` is invoked with a description argument, this tells Commander that you're going to use stand-alone executables for subcommands.
|
||||
Commander will search the executables in the directory of the entry script (like `./examples/pm`) with the name `program-subcommand`, like `pm-install`, `pm-search`.
|
||||
You can specify a custom name with the `executableFile` configuration option.
|
||||
|
||||
You handle the options for an executable (sub)command in the executable, and don't declare them at the top-level.
|
||||
|
||||
Example file: [pm](./examples/pm)
|
||||
|
||||
```js
|
||||
program
|
||||
.version('0.1.0')
|
||||
.command('install [name]', 'install one or more packages')
|
||||
.command('search [query]', 'search with optional query')
|
||||
.command('update', 'update installed packages', { executableFile: 'myUpdateSubCommand' })
|
||||
.command('list', 'list packages installed', { isDefault: true });
|
||||
|
||||
program.parse(process.argv);
|
||||
```
|
||||
|
||||
If the program is designed to be installed globally, make sure the executables have proper modes, like `755`.
|
||||
|
||||
## Automated help
|
||||
|
||||
The help information is auto-generated based on the information commander already knows about your program. The default
|
||||
help option is `-h,--help`.
|
||||
|
||||
Example file: [pizza](./examples/pizza)
|
||||
|
||||
```bash
|
||||
$ node ./examples/pizza --help
|
||||
Usage: pizza [options]
|
||||
|
||||
An application for pizza ordering
|
||||
|
||||
Options:
|
||||
-p, --peppers Add peppers
|
||||
-c, --cheese <type> Add the specified type of cheese (default: "marble")
|
||||
-C, --no-cheese You do not want any cheese
|
||||
-h, --help display help for command
|
||||
```
|
||||
|
||||
A `help` command is added by default if your command has subcommands. It can be used alone, or with a subcommand name to show
|
||||
further help for the subcommand. These are effectively the same if the `shell` program has implicit help:
|
||||
|
||||
```bash
|
||||
shell help
|
||||
shell --help
|
||||
|
||||
shell help spawn
|
||||
shell spawn --help
|
||||
```
|
||||
|
||||
### Custom help
|
||||
|
||||
You can add extra text to be displayed along with the built-in help.
|
||||
|
||||
Example file: [custom-help](./examples/custom-help)
|
||||
|
||||
```js
|
||||
program
|
||||
.option('-f, --foo', 'enable some foo');
|
||||
|
||||
program.addHelpText('after', `
|
||||
|
||||
Example call:
|
||||
$ custom-help --help`);
|
||||
```
|
||||
|
||||
Yields the following help output:
|
||||
|
||||
```Text
|
||||
Usage: custom-help [options]
|
||||
|
||||
Options:
|
||||
-f, --foo enable some foo
|
||||
-h, --help display help for command
|
||||
|
||||
Example call:
|
||||
$ custom-help --help
|
||||
```
|
||||
|
||||
The positions in order displayed are:
|
||||
|
||||
- `beforeAll`: add to the program for a global banner or header
|
||||
- `before`: display extra information before built-in help
|
||||
- `after`: display extra information after built-in help
|
||||
- `afterAll`: add to the program for a global footer (epilog)
|
||||
|
||||
The positions "beforeAll" and "afterAll" apply to the command and all its subcommands.
|
||||
|
||||
The second parameter can be a string, or a function returning a string. The function is passed a context object for your convenience. The properties are:
|
||||
|
||||
- error: a boolean for whether the help is being displayed due to a usage error
|
||||
- command: the Command which is displaying the help
|
||||
|
||||
### Display help from code
|
||||
|
||||
`.help()`: display help information and exit immediately. You can optionally pass `{ error: true }` to display on stderr and exit with an error status.
|
||||
|
||||
`.outputHelp()`: output help information without exiting. You can optionally pass `{ error: true }` to display on stderr.
|
||||
|
||||
`.helpInformation()`: get the built-in command help information as a string for processing or displaying yourself.
|
||||
|
||||
### .usage and .name
|
||||
|
||||
These allow you to customise the usage description in the first line of the help. The name is otherwise
|
||||
deduced from the (full) program arguments. Given:
|
||||
|
||||
```js
|
||||
program
|
||||
.name("my-command")
|
||||
.usage("[global options] command")
|
||||
```
|
||||
|
||||
The help will start with:
|
||||
|
||||
```Text
|
||||
Usage: my-command [global options] command
|
||||
```
|
||||
|
||||
### .helpOption(flags, description)
|
||||
|
||||
By default every command has a help option. Override the default help flags and description. Pass false to disable the built-in help option.
|
||||
|
||||
```js
|
||||
program
|
||||
.helpOption('-e, --HELP', 'read more information');
|
||||
```
|
||||
|
||||
### .addHelpCommand()
|
||||
|
||||
A help command is added by default if your command has subcommands. You can explicitly turn on or off the implicit help command with `.addHelpCommand()` and `.addHelpCommand(false)`.
|
||||
|
||||
You can both turn on and customise the help command by supplying the name and description:
|
||||
|
||||
```js
|
||||
program.addHelpCommand('assist [command]', 'show assistance');
|
||||
```
|
||||
|
||||
### More configuration
|
||||
|
||||
The built-in help is formatted using the Help class.
|
||||
You can configure the Help behaviour by modifying data properties and methods using `.configureHelp()`, or by subclassing using `.createHelp()` if you prefer.
|
||||
|
||||
The data properties are:
|
||||
|
||||
- `helpWidth`: specify the wrap width, useful for unit tests
|
||||
- `sortSubcommands`: sort the subcommands alphabetically
|
||||
- `sortOptions`: sort the options alphabetically
|
||||
|
||||
There are methods getting the visible lists of arguments, options, and subcommands. There are methods for formatting the items in the lists, with each item having a _term_ and _description_. Take a look at `.formatHelp()` to see how they are used.
|
||||
|
||||
Example file: [configure-help.js](./examples/configure-help.js)
|
||||
|
||||
```
|
||||
program.configureHelp({
|
||||
sortSubcommands: true,
|
||||
subcommandTerm: (cmd) => cmd.name() // Just show the name, instead of short usage.
|
||||
});
|
||||
```
|
||||
|
||||
## Custom event listeners
|
||||
|
||||
You can execute custom actions by listening to command and option events.
|
||||
|
||||
```js
|
||||
program.on('option:verbose', function () {
|
||||
process.env.VERBOSE = this.opts().verbose;
|
||||
});
|
||||
|
||||
program.on('command:*', function (operands) {
|
||||
console.error(`error: unknown command '${operands[0]}'`);
|
||||
const availableCommands = program.commands.map(cmd => cmd.name());
|
||||
mySuggestBestMatch(operands[0], availableCommands);
|
||||
process.exitCode = 1;
|
||||
});
|
||||
```
|
||||
|
||||
## Bits and pieces
|
||||
|
||||
### .parse() and .parseAsync()
|
||||
|
||||
The first argument to `.parse` is the array of strings to parse. You may omit the parameter to implicitly use `process.argv`.
|
||||
|
||||
If the arguments follow different conventions than node you can pass a `from` option in the second parameter:
|
||||
|
||||
- 'node': default, `argv[0]` is the application and `argv[1]` is the script being run, with user parameters after that
|
||||
- 'electron': `argv[1]` varies depending on whether the electron application is packaged
|
||||
- 'user': all of the arguments from the user
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
program.parse(process.argv); // Explicit, node conventions
|
||||
program.parse(); // Implicit, and auto-detect electron
|
||||
program.parse(['-f', 'filename'], { from: 'user' });
|
||||
```
|
||||
|
||||
### Parsing Configuration
|
||||
|
||||
If the default parsing does not suit your needs, there are some behaviours to support other usage patterns.
|
||||
|
||||
By default program options are recognised before and after subcommands. To only look for program options before subcommands, use `.enablePositionalOptions()`. This lets you use
|
||||
an option for a different purpose in subcommands.
|
||||
|
||||
Example file: [positional-options.js](./examples/positional-options.js)
|
||||
|
||||
With positional options, the `-b` is a program option in the first line and a subcommand option in the second line:
|
||||
|
||||
```sh
|
||||
program -b subcommand
|
||||
program subcommand -b
|
||||
```
|
||||
|
||||
By default options are recognised before and after command-arguments. To only process options that come
|
||||
before the command-arguments, use `.passThroughOptions()`. This lets you pass the arguments and following options through to another program
|
||||
without needing to use `--` to end the option processing.
|
||||
To use pass through options in a subcommand, the program needs to enable positional options.
|
||||
|
||||
Example file: [pass-through-options.js](./examples/pass-through-options.js)
|
||||
|
||||
With pass through options, the `--port=80` is a program option in the first line and passed through as a command-argument in the second line:
|
||||
|
||||
```sh
|
||||
program --port=80 arg
|
||||
program arg --port=80
|
||||
```
|
||||
|
||||
By default the option processing shows an error for an unknown option. To have an unknown option treated as an ordinary command-argument and continue looking for options, use `.allowUnknownOption()`. This lets you mix known and unknown options.
|
||||
|
||||
By default the argument processing does not display an error for more command-arguments than expected.
|
||||
To display an error for excess arguments, use`.allowExcessArguments(false)`.
|
||||
|
||||
### Legacy options as properties
|
||||
|
||||
Before Commander 7, the option values were stored as properties on the command.
|
||||
This was convenient to code but the downside was possible clashes with
|
||||
existing properties of `Command`. You can revert to the old behaviour to run unmodified legacy code by using `.storeOptionsAsProperties()`.
|
||||
|
||||
```js
|
||||
program
|
||||
.storeOptionsAsProperties()
|
||||
.option('-d, --debug')
|
||||
.action((commandAndOptions) => {
|
||||
if (commandAndOptions.debug) {
|
||||
console.error(`Called ${commandAndOptions.name()}`);
|
||||
}
|
||||
});
|
||||
```
|
||||
|
||||
### TypeScript
|
||||
|
||||
If you use `ts-node` and stand-alone executable subcommands written as `.ts` files, you need to call your program through node to get the subcommands called correctly. e.g.
|
||||
|
||||
```bash
|
||||
node -r ts-node/register pm.ts
|
||||
```
|
||||
|
||||
### createCommand()
|
||||
|
||||
This factory function creates a new command. It is exported and may be used instead of using `new`, like:
|
||||
|
||||
```js
|
||||
const { createCommand } = require('commander');
|
||||
const program = createCommand();
|
||||
```
|
||||
|
||||
`createCommand` is also a method of the Command object, and creates a new command rather than a subcommand. This gets used internally
|
||||
when creating subcommands using `.command()`, and you may override it to
|
||||
customise the new subcommand (example file [custom-command-class.js](./examples/custom-command-class.js)).
|
||||
|
||||
### Node options such as `--harmony`
|
||||
|
||||
You can enable `--harmony` option in two ways:
|
||||
|
||||
- Use `#! /usr/bin/env node --harmony` in the subcommands scripts. (Note Windows does not support this pattern.)
|
||||
- Use the `--harmony` option when call the command, like `node --harmony examples/pm publish`. The `--harmony` option will be preserved when spawning subcommand process.
|
||||
|
||||
### Debugging stand-alone executable subcommands
|
||||
|
||||
An executable subcommand is launched as a separate child process.
|
||||
|
||||
If you are using the node inspector for [debugging](https://nodejs.org/en/docs/guides/debugging-getting-started/) executable subcommands using `node --inspect` et al,
|
||||
the inspector port is incremented by 1 for the spawned subcommand.
|
||||
|
||||
If you are using VSCode to debug executable subcommands you need to set the `"autoAttachChildProcesses": true` flag in your launch.json configuration.
|
||||
|
||||
### Override exit and output handling
|
||||
|
||||
By default Commander calls `process.exit` when it detects errors, or after displaying the help or version. You can override
|
||||
this behaviour and optionally supply a callback. The default override throws a `CommanderError`.
|
||||
|
||||
The override callback is passed a `CommanderError` with properties `exitCode` number, `code` string, and `message`. The default override behaviour is to throw the error, except for async handling of executable subcommand completion which carries on. The normal display of error messages or version or help
|
||||
is not affected by the override which is called after the display.
|
||||
|
||||
```js
|
||||
program.exitOverride();
|
||||
|
||||
try {
|
||||
program.parse(process.argv);
|
||||
} catch (err) {
|
||||
// custom processing...
|
||||
}
|
||||
```
|
||||
|
||||
By default Commander is configured for a command-line application and writes to stdout and stderr.
|
||||
You can modify this behaviour for custom applications. In addition, you can modify the display of error messages.
|
||||
|
||||
Example file: [configure-output.js](./examples/configure-output.js)
|
||||
|
||||
|
||||
```js
|
||||
function errorColor(str) {
|
||||
// Add ANSI escape codes to display text in red.
|
||||
return `\x1b[31m${str}\x1b[0m`;
|
||||
}
|
||||
|
||||
program
|
||||
.configureOutput({
|
||||
// Visibly override write routines as example!
|
||||
writeOut: (str) => process.stdout.write(`[OUT] ${str}`),
|
||||
writeErr: (str) => process.stdout.write(`[ERR] ${str}`),
|
||||
// Highlight errors in color.
|
||||
outputError: (str, write) => write(errorColor(str))
|
||||
});
|
||||
```
|
||||
|
||||
### Additional documentation
|
||||
|
||||
There is more information available about:
|
||||
|
||||
- [deprecated](./docs/deprecated.md) features still supported for backwards compatibility
|
||||
- [options taking varying arguments](./docs/options-taking-varying-arguments.md)
|
||||
|
||||
## Examples
|
||||
|
||||
In a single command program, you might not need an action handler.
|
||||
|
||||
Example file: [pizza](./examples/pizza)
|
||||
|
||||
```js
|
||||
const { program } = require('commander');
|
||||
|
||||
program
|
||||
.description('An application for pizza ordering')
|
||||
.option('-p, --peppers', 'Add peppers')
|
||||
.option('-c, --cheese <type>', 'Add the specified type of cheese', 'marble')
|
||||
.option('-C, --no-cheese', 'You do not want any cheese');
|
||||
|
||||
program.parse();
|
||||
|
||||
const options = program.opts();
|
||||
console.log('you ordered a pizza with:');
|
||||
if (options.peppers) console.log(' - peppers');
|
||||
const cheese = !options.cheese ? 'no' : options.cheese;
|
||||
console.log(' - %s cheese', cheese);
|
||||
```
|
||||
|
||||
In a multi-command program, you will have action handlers for each command (or stand-alone executables for the commands).
|
||||
|
||||
Example file: [deploy](./examples/deploy)
|
||||
|
||||
```js
|
||||
const { Command } = require('commander');
|
||||
const program = new Command();
|
||||
|
||||
program
|
||||
.version('0.0.1')
|
||||
.option('-c, --config <path>', 'set config path', './deploy.conf');
|
||||
|
||||
program
|
||||
.command('setup [env]')
|
||||
.description('run setup commands for all envs')
|
||||
.option('-s, --setup_mode <mode>', 'Which setup mode to use', 'normal')
|
||||
.action((env, options) => {
|
||||
env = env || 'all';
|
||||
console.log('read config from %s', program.opts().config);
|
||||
console.log('setup for %s env(s) with %s mode', env, options.setup_mode);
|
||||
});
|
||||
|
||||
program
|
||||
.command('exec <script>')
|
||||
.alias('ex')
|
||||
.description('execute the given remote cmd')
|
||||
.option('-e, --exec_mode <mode>', 'Which exec mode to use', 'fast')
|
||||
.action((script, options) => {
|
||||
console.log('read config from %s', program.opts().config);
|
||||
console.log('exec "%s" using %s mode and config %s', script, options.exec_mode, program.opts().config);
|
||||
}).addHelpText('after', `
|
||||
Examples:
|
||||
$ deploy exec sequential
|
||||
$ deploy exec async`
|
||||
);
|
||||
|
||||
program.parse(process.argv);
|
||||
```
|
||||
|
||||
More samples can be found in the [examples](https://github.com/tj/commander.js/tree/master/examples) directory.
|
||||
|
||||
## Support
|
||||
|
||||
The current version of Commander is fully supported on Long Term Support versions of node, and requires at least node v10.
|
||||
(For older versions of node, use an older version of Commander. Commander version 2.x has the widest support.)
|
||||
|
||||
The main forum for free and community support is the project [Issues](https://github.com/tj/commander.js/issues) on GitHub.
|
||||
|
||||
### Commander for enterprise
|
||||
|
||||
Available as part of the Tidelift Subscription
|
||||
|
||||
The maintainers of Commander and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-commander?utm_source=npm-commander&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
|
||||
4
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/esm.mjs
generated
vendored
Normal file
4
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/esm.mjs
generated
vendored
Normal file
@ -0,0 +1,4 @@
|
||||
import commander from './index.js';
|
||||
|
||||
// wrapper to provide named exports for ESM.
|
||||
export const { program, Option, Command, CommanderError, InvalidOptionArgumentError, Help, createCommand } = commander;
|
||||
2217
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/index.js
generated
vendored
Normal file
2217
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/index.js
generated
vendored
Normal file
File diff suppressed because it is too large
Load Diff
16
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/package-support.json
generated
vendored
Normal file
16
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/package-support.json
generated
vendored
Normal file
@ -0,0 +1,16 @@
|
||||
{
|
||||
"versions": [
|
||||
{
|
||||
"version": "*",
|
||||
"target": {
|
||||
"node": "supported"
|
||||
},
|
||||
"response": {
|
||||
"type": "time-permitting"
|
||||
},
|
||||
"backing": {
|
||||
"npm-funding": true
|
||||
}
|
||||
}
|
||||
]
|
||||
}
|
||||
68
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/package.json
generated
vendored
Normal file
68
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/package.json
generated
vendored
Normal file
@ -0,0 +1,68 @@
|
||||
{
|
||||
"name": "commander",
|
||||
"version": "7.2.0",
|
||||
"description": "the complete solution for node.js command-line programs",
|
||||
"keywords": [
|
||||
"commander",
|
||||
"command",
|
||||
"option",
|
||||
"parser",
|
||||
"cli",
|
||||
"argument",
|
||||
"args",
|
||||
"argv"
|
||||
],
|
||||
"author": "TJ Holowaychuk <tj@vision-media.ca>",
|
||||
"license": "MIT",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/tj/commander.js.git"
|
||||
},
|
||||
"scripts": {
|
||||
"lint": "eslint index.js esm.mjs \"tests/**/*.js\"",
|
||||
"typescript-lint": "eslint typings/*.ts tests/*.ts",
|
||||
"test": "jest && npm run test-typings",
|
||||
"test-esm": "node --experimental-modules ./tests/esm-imports-test.mjs",
|
||||
"test-typings": "tsd",
|
||||
"typescript-checkJS": "tsc --allowJS --checkJS index.js --noEmit",
|
||||
"test-all": "npm run test && npm run lint && npm run typescript-lint && npm run typescript-checkJS && npm run test-esm"
|
||||
},
|
||||
"main": "./index.js",
|
||||
"files": [
|
||||
"index.js",
|
||||
"esm.mjs",
|
||||
"typings/index.d.ts",
|
||||
"package-support.json"
|
||||
],
|
||||
"type": "commonjs",
|
||||
"dependencies": {},
|
||||
"devDependencies": {
|
||||
"@types/jest": "^26.0.20",
|
||||
"@types/node": "^14.14.20",
|
||||
"@typescript-eslint/eslint-plugin": "^4.12.0",
|
||||
"@typescript-eslint/parser": "^4.12.0",
|
||||
"eslint": "^7.17.0",
|
||||
"eslint-config-standard": "^16.0.2",
|
||||
"eslint-plugin-jest": "^24.1.3",
|
||||
"jest": "^26.6.3",
|
||||
"standard": "^16.0.3",
|
||||
"ts-jest": "^26.5.1",
|
||||
"tsd": "^0.14.0",
|
||||
"typescript": "^4.1.2"
|
||||
},
|
||||
"types": "typings/index.d.ts",
|
||||
"jest": {
|
||||
"testEnvironment": "node",
|
||||
"collectCoverage": true,
|
||||
"transform": {
|
||||
"^.+\\.tsx?$": "ts-jest"
|
||||
},
|
||||
"testPathIgnorePatterns": [
|
||||
"/node_modules/"
|
||||
]
|
||||
},
|
||||
"engines": {
|
||||
"node": ">= 10"
|
||||
},
|
||||
"support": true
|
||||
}
|
||||
627
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/typings/index.d.ts
generated
vendored
Normal file
627
app_vue/node_modules/webpack-bundle-analyzer/node_modules/commander/typings/index.d.ts
generated
vendored
Normal file
@ -0,0 +1,627 @@
|
||||
// Type definitions for commander
|
||||
// Original definitions by: Alan Agius <https://github.com/alan-agius4>, Marcelo Dezem <https://github.com/mdezem>, vvakame <https://github.com/vvakame>, Jules Randolph <https://github.com/sveinburne>
|
||||
|
||||
// Using method rather than property for method-signature-style, to document method overloads separately. Allow either.
|
||||
/* eslint-disable @typescript-eslint/method-signature-style */
|
||||
/* eslint-disable @typescript-eslint/no-explicit-any */
|
||||
|
||||
declare namespace commander {
|
||||
|
||||
interface CommanderError extends Error {
|
||||
code: string;
|
||||
exitCode: number;
|
||||
message: string;
|
||||
nestedError?: string;
|
||||
}
|
||||
type CommanderErrorConstructor = new (exitCode: number, code: string, message: string) => CommanderError;
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-empty-interface
|
||||
interface InvalidOptionArgumentError extends CommanderError {
|
||||
}
|
||||
type InvalidOptionArgumentErrorConstructor = new (message: string) => InvalidOptionArgumentError;
|
||||
|
||||
interface Option {
|
||||
flags: string;
|
||||
description: string;
|
||||
|
||||
required: boolean; // A value must be supplied when the option is specified.
|
||||
optional: boolean; // A value is optional when the option is specified.
|
||||
variadic: boolean;
|
||||
mandatory: boolean; // The option must have a value after parsing, which usually means it must be specified on command line.
|
||||
optionFlags: string;
|
||||
short?: string;
|
||||
long?: string;
|
||||
negate: boolean;
|
||||
defaultValue?: any;
|
||||
defaultValueDescription?: string;
|
||||
parseArg?: <T>(value: string, previous: T) => T;
|
||||
hidden: boolean;
|
||||
argChoices?: string[];
|
||||
|
||||
/**
|
||||
* Set the default value, and optionally supply the description to be displayed in the help.
|
||||
*/
|
||||
default(value: any, description?: string): this;
|
||||
|
||||
/**
|
||||
* Calculate the full description, including defaultValue etc.
|
||||
*/
|
||||
fullDescription(): string;
|
||||
|
||||
/**
|
||||
* Set the custom handler for processing CLI option arguments into option values.
|
||||
*/
|
||||
argParser<T>(fn: (value: string, previous: T) => T): this;
|
||||
|
||||
/**
|
||||
* Whether the option is mandatory and must have a value after parsing.
|
||||
*/
|
||||
makeOptionMandatory(mandatory?: boolean): this;
|
||||
|
||||
/**
|
||||
* Hide option in help.
|
||||
*/
|
||||
hideHelp(hide?: boolean): this;
|
||||
|
||||
/**
|
||||
* Validation of option argument failed.
|
||||
* Intended for use from custom argument processing functions.
|
||||
*/
|
||||
argumentRejected(messsage: string): never;
|
||||
|
||||
/**
|
||||
* Only allow option value to be one of choices.
|
||||
*/
|
||||
choices(values: string[]): this;
|
||||
|
||||
/**
|
||||
* Return option name.
|
||||
*/
|
||||
name(): string;
|
||||
|
||||
/**
|
||||
* Return option name, in a camelcase format that can be used
|
||||
* as a object attribute key.
|
||||
*/
|
||||
attributeName(): string;
|
||||
}
|
||||
type OptionConstructor = new (flags: string, description?: string) => Option;
|
||||
|
||||
interface Help {
|
||||
/** output helpWidth, long lines are wrapped to fit */
|
||||
helpWidth?: number;
|
||||
sortSubcommands: boolean;
|
||||
sortOptions: boolean;
|
||||
|
||||
/** Get the command term to show in the list of subcommands. */
|
||||
subcommandTerm(cmd: Command): string;
|
||||
/** Get the command description to show in the list of subcommands. */
|
||||
subcommandDescription(cmd: Command): string;
|
||||
/** Get the option term to show in the list of options. */
|
||||
optionTerm(option: Option): string;
|
||||
/** Get the option description to show in the list of options. */
|
||||
optionDescription(option: Option): string;
|
||||
|
||||
/** Get the command usage to be displayed at the top of the built-in help. */
|
||||
commandUsage(cmd: Command): string;
|
||||
/** Get the description for the command. */
|
||||
commandDescription(cmd: Command): string;
|
||||
|
||||
/** Get an array of the visible subcommands. Includes a placeholder for the implicit help command, if there is one. */
|
||||
visibleCommands(cmd: Command): Command[];
|
||||
/** Get an array of the visible options. Includes a placeholder for the implicit help option, if there is one. */
|
||||
visibleOptions(cmd: Command): Option[];
|
||||
/** Get an array of the arguments which have descriptions. */
|
||||
visibleArguments(cmd: Command): Array<{ term: string; description: string}>;
|
||||
|
||||
/** Get the longest command term length. */
|
||||
longestSubcommandTermLength(cmd: Command, helper: Help): number;
|
||||
/** Get the longest option term length. */
|
||||
longestOptionTermLength(cmd: Command, helper: Help): number;
|
||||
/** Get the longest argument term length. */
|
||||
longestArgumentTermLength(cmd: Command, helper: Help): number;
|
||||
/** Calculate the pad width from the maximum term length. */
|
||||
padWidth(cmd: Command, helper: Help): number;
|
||||
|
||||
/**
|
||||
* Wrap the given string to width characters per line, with lines after the first indented.
|
||||
* Do not wrap if insufficient room for wrapping (minColumnWidth), or string is manually formatted.
|
||||
*/
|
||||
wrap(str: string, width: number, indent: number, minColumnWidth?: number): string;
|
||||
|
||||
/** Generate the built-in help text. */
|
||||
formatHelp(cmd: Command, helper: Help): string;
|
||||
}
|
||||
type HelpConstructor = new () => Help;
|
||||
type HelpConfiguration = Partial<Help>;
|
||||
|
||||
interface ParseOptions {
|
||||
from: 'node' | 'electron' | 'user';
|
||||
}
|
||||
interface HelpContext { // optional parameter for .help() and .outputHelp()
|
||||
error: boolean;
|
||||
}
|
||||
interface AddHelpTextContext { // passed to text function used with .addHelpText()
|
||||
error: boolean;
|
||||
command: Command;
|
||||
}
|
||||
interface OutputConfiguration {
|
||||
writeOut?(str: string): void;
|
||||
writeErr?(str: string): void;
|
||||
getOutHelpWidth?(): number;
|
||||
getErrHelpWidth?(): number;
|
||||
outputError?(str: string, write: (str: string) => void): void;
|
||||
|
||||
}
|
||||
|
||||
type AddHelpTextPosition = 'beforeAll' | 'before' | 'after' | 'afterAll';
|
||||
|
||||
interface OptionValues {
|
||||
[key: string]: any;
|
||||
}
|
||||
|
||||
interface Command {
|
||||
args: string[];
|
||||
commands: Command[];
|
||||
parent: Command | null;
|
||||
|
||||
/**
|
||||
* Set the program version to `str`.
|
||||
*
|
||||
* This method auto-registers the "-V, --version" flag
|
||||
* which will print the version number when passed.
|
||||
*
|
||||
* You can optionally supply the flags and description to override the defaults.
|
||||
*/
|
||||
version(str: string, flags?: string, description?: string): this;
|
||||
|
||||
/**
|
||||
* Define a command, implemented using an action handler.
|
||||
*
|
||||
* @remarks
|
||||
* The command description is supplied using `.description`, not as a parameter to `.command`.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* program
|
||||
* .command('clone <source> [destination]')
|
||||
* .description('clone a repository into a newly created directory')
|
||||
* .action((source, destination) => {
|
||||
* console.log('clone command called');
|
||||
* });
|
||||
* ```
|
||||
*
|
||||
* @param nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
|
||||
* @param opts - configuration options
|
||||
* @returns new command
|
||||
*/
|
||||
command(nameAndArgs: string, opts?: CommandOptions): ReturnType<this['createCommand']>;
|
||||
/**
|
||||
* Define a command, implemented in a separate executable file.
|
||||
*
|
||||
* @remarks
|
||||
* The command description is supplied as the second parameter to `.command`.
|
||||
*
|
||||
* @example
|
||||
* ```ts
|
||||
* program
|
||||
* .command('start <service>', 'start named service')
|
||||
* .command('stop [service]', 'stop named service, or all if no name supplied');
|
||||
* ```
|
||||
*
|
||||
* @param nameAndArgs - command name and arguments, args are `<required>` or `[optional]` and last may also be `variadic...`
|
||||
* @param description - description of executable command
|
||||
* @param opts - configuration options
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
command(nameAndArgs: string, description: string, opts?: commander.ExecutableCommandOptions): this;
|
||||
|
||||
/**
|
||||
* Factory routine to create a new unattached command.
|
||||
*
|
||||
* See .command() for creating an attached subcommand, which uses this routine to
|
||||
* create the command. You can override createCommand to customise subcommands.
|
||||
*/
|
||||
createCommand(name?: string): Command;
|
||||
|
||||
/**
|
||||
* Add a prepared subcommand.
|
||||
*
|
||||
* See .command() for creating an attached subcommand which inherits settings from its parent.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
addCommand(cmd: Command, opts?: CommandOptions): this;
|
||||
|
||||
/**
|
||||
* Define argument syntax for command.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
arguments(desc: string): this;
|
||||
|
||||
/**
|
||||
* Override default decision whether to add implicit help command.
|
||||
*
|
||||
* addHelpCommand() // force on
|
||||
* addHelpCommand(false); // force off
|
||||
* addHelpCommand('help [cmd]', 'display help for [cmd]'); // force on with custom details
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
addHelpCommand(enableOrNameAndArgs?: string | boolean, description?: string): this;
|
||||
|
||||
/**
|
||||
* Register callback to use as replacement for calling process.exit.
|
||||
*/
|
||||
exitOverride(callback?: (err: CommanderError) => never|void): this;
|
||||
|
||||
/**
|
||||
* You can customise the help with a subclass of Help by overriding createHelp,
|
||||
* or by overriding Help properties using configureHelp().
|
||||
*/
|
||||
createHelp(): Help;
|
||||
|
||||
/**
|
||||
* You can customise the help by overriding Help properties using configureHelp(),
|
||||
* or with a subclass of Help by overriding createHelp().
|
||||
*/
|
||||
configureHelp(configuration: HelpConfiguration): this;
|
||||
/** Get configuration */
|
||||
configureHelp(): HelpConfiguration;
|
||||
|
||||
/**
|
||||
* The default output goes to stdout and stderr. You can customise this for special
|
||||
* applications. You can also customise the display of errors by overriding outputError.
|
||||
*
|
||||
* The configuration properties are all functions:
|
||||
*
|
||||
* // functions to change where being written, stdout and stderr
|
||||
* writeOut(str)
|
||||
* writeErr(str)
|
||||
* // matching functions to specify width for wrapping help
|
||||
* getOutHelpWidth()
|
||||
* getErrHelpWidth()
|
||||
* // functions based on what is being written out
|
||||
* outputError(str, write) // used for displaying errors, and not used for displaying help
|
||||
*/
|
||||
configureOutput(configuration: OutputConfiguration): this;
|
||||
/** Get configuration */
|
||||
configureOutput(): OutputConfiguration;
|
||||
|
||||
/**
|
||||
* Register callback `fn` for the command.
|
||||
*
|
||||
* @example
|
||||
* program
|
||||
* .command('help')
|
||||
* .description('display verbose help')
|
||||
* .action(function() {
|
||||
* // output help here
|
||||
* });
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
action(fn: (...args: any[]) => void | Promise<void>): this;
|
||||
|
||||
/**
|
||||
* Define option with `flags`, `description` and optional
|
||||
* coercion `fn`.
|
||||
*
|
||||
* The `flags` string contains the short and/or long flags,
|
||||
* separated by comma, a pipe or space. The following are all valid
|
||||
* all will output this way when `--help` is used.
|
||||
*
|
||||
* "-p, --pepper"
|
||||
* "-p|--pepper"
|
||||
* "-p --pepper"
|
||||
*
|
||||
* @example
|
||||
* // simple boolean defaulting to false
|
||||
* program.option('-p, --pepper', 'add pepper');
|
||||
*
|
||||
* --pepper
|
||||
* program.pepper
|
||||
* // => Boolean
|
||||
*
|
||||
* // simple boolean defaulting to true
|
||||
* program.option('-C, --no-cheese', 'remove cheese');
|
||||
*
|
||||
* program.cheese
|
||||
* // => true
|
||||
*
|
||||
* --no-cheese
|
||||
* program.cheese
|
||||
* // => false
|
||||
*
|
||||
* // required argument
|
||||
* program.option('-C, --chdir <path>', 'change the working directory');
|
||||
*
|
||||
* --chdir /tmp
|
||||
* program.chdir
|
||||
* // => "/tmp"
|
||||
*
|
||||
* // optional argument
|
||||
* program.option('-c, --cheese [type]', 'add cheese [marble]');
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
option(flags: string, description?: string, defaultValue?: string | boolean): this;
|
||||
option<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
|
||||
/** @deprecated since v7, instead use choices or a custom function */
|
||||
option(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean): this;
|
||||
|
||||
/**
|
||||
* Define a required option, which must have a value after parsing. This usually means
|
||||
* the option must be specified on the command line. (Otherwise the same as .option().)
|
||||
*
|
||||
* The `flags` string contains the short and/or long flags, separated by comma, a pipe or space.
|
||||
*/
|
||||
requiredOption(flags: string, description?: string, defaultValue?: string | boolean): this;
|
||||
requiredOption<T>(flags: string, description: string, fn: (value: string, previous: T) => T, defaultValue?: T): this;
|
||||
/** @deprecated since v7, instead use choices or a custom function */
|
||||
requiredOption(flags: string, description: string, regexp: RegExp, defaultValue?: string | boolean): this;
|
||||
|
||||
/**
|
||||
* Factory routine to create a new unattached option.
|
||||
*
|
||||
* See .option() for creating an attached option, which uses this routine to
|
||||
* create the option. You can override createOption to return a custom option.
|
||||
*/
|
||||
|
||||
createOption(flags: string, description?: string): Option;
|
||||
|
||||
/**
|
||||
* Add a prepared Option.
|
||||
*
|
||||
* See .option() and .requiredOption() for creating and attaching an option in a single call.
|
||||
*/
|
||||
addOption(option: Option): this;
|
||||
|
||||
/**
|
||||
* Whether to store option values as properties on command object,
|
||||
* or store separately (specify false). In both cases the option values can be accessed using .opts().
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
storeOptionsAsProperties(): this & OptionValues;
|
||||
storeOptionsAsProperties(storeAsProperties: true): this & OptionValues;
|
||||
storeOptionsAsProperties(storeAsProperties?: boolean): this;
|
||||
|
||||
/**
|
||||
* Alter parsing of short flags with optional values.
|
||||
*
|
||||
* @example
|
||||
* // for `.option('-f,--flag [value]'):
|
||||
* .combineFlagAndOptionalValue(true) // `-f80` is treated like `--flag=80`, this is the default behaviour
|
||||
* .combineFlagAndOptionalValue(false) // `-fb` is treated like `-f -b`
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
combineFlagAndOptionalValue(combine?: boolean): this;
|
||||
|
||||
/**
|
||||
* Allow unknown options on the command line.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
allowUnknownOption(allowUnknown?: boolean): this;
|
||||
|
||||
/**
|
||||
* Allow excess command-arguments on the command line. Pass false to make excess arguments an error.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
allowExcessArguments(allowExcess?: boolean): this;
|
||||
|
||||
/**
|
||||
* Enable positional options. Positional means global options are specified before subcommands which lets
|
||||
* subcommands reuse the same option names, and also enables subcommands to turn on passThroughOptions.
|
||||
*
|
||||
* The default behaviour is non-positional and global options may appear anywhere on the command line.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
enablePositionalOptions(positional?: boolean): this;
|
||||
|
||||
/**
|
||||
* Pass through options that come after command-arguments rather than treat them as command-options,
|
||||
* so actual command-options come before command-arguments. Turning this on for a subcommand requires
|
||||
* positional options to have been enabled on the program (parent commands).
|
||||
*
|
||||
* The default behaviour is non-positional and options may appear before or after command-arguments.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
passThroughOptions(passThrough?: boolean): this;
|
||||
|
||||
/**
|
||||
* Parse `argv`, setting options and invoking commands when defined.
|
||||
*
|
||||
* The default expectation is that the arguments are from node and have the application as argv[0]
|
||||
* and the script being run in argv[1], with user parameters after that.
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* program.parse(process.argv);
|
||||
* program.parse(); // implicitly use process.argv and auto-detect node vs electron conventions
|
||||
* program.parse(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
parse(argv?: string[], options?: ParseOptions): this;
|
||||
|
||||
/**
|
||||
* Parse `argv`, setting options and invoking commands when defined.
|
||||
*
|
||||
* Use parseAsync instead of parse if any of your action handlers are async. Returns a Promise.
|
||||
*
|
||||
* The default expectation is that the arguments are from node and have the application as argv[0]
|
||||
* and the script being run in argv[1], with user parameters after that.
|
||||
*
|
||||
* Examples:
|
||||
*
|
||||
* program.parseAsync(process.argv);
|
||||
* program.parseAsync(); // implicitly use process.argv and auto-detect node vs electron conventions
|
||||
* program.parseAsync(my-args, { from: 'user' }); // just user supplied arguments, nothing special about argv[0]
|
||||
*
|
||||
* @returns Promise
|
||||
*/
|
||||
parseAsync(argv?: string[], options?: ParseOptions): Promise<this>;
|
||||
|
||||
/**
|
||||
* Parse options from `argv` removing known options,
|
||||
* and return argv split into operands and unknown arguments.
|
||||
*
|
||||
* @example
|
||||
* argv => operands, unknown
|
||||
* --known kkk op => [op], []
|
||||
* op --known kkk => [op], []
|
||||
* sub --unknown uuu op => [sub], [--unknown uuu op]
|
||||
* sub -- --unknown uuu op => [sub --unknown uuu op], []
|
||||
*/
|
||||
parseOptions(argv: string[]): commander.ParseOptionsResult;
|
||||
|
||||
/**
|
||||
* Return an object containing options as key-value pairs
|
||||
*/
|
||||
opts(): OptionValues;
|
||||
|
||||
/**
|
||||
* Set the description.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
description(str: string, argsDescription?: {[argName: string]: string}): this;
|
||||
/**
|
||||
* Get the description.
|
||||
*/
|
||||
description(): string;
|
||||
|
||||
/**
|
||||
* Set an alias for the command.
|
||||
*
|
||||
* You may call more than once to add multiple aliases. Only the first alias is shown in the auto-generated help.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
alias(alias: string): this;
|
||||
/**
|
||||
* Get alias for the command.
|
||||
*/
|
||||
alias(): string;
|
||||
|
||||
/**
|
||||
* Set aliases for the command.
|
||||
*
|
||||
* Only the first alias is shown in the auto-generated help.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
aliases(aliases: string[]): this;
|
||||
/**
|
||||
* Get aliases for the command.
|
||||
*/
|
||||
aliases(): string[];
|
||||
|
||||
/**
|
||||
* Set the command usage.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
usage(str: string): this;
|
||||
/**
|
||||
* Get the command usage.
|
||||
*/
|
||||
usage(): string;
|
||||
|
||||
/**
|
||||
* Set the name of the command.
|
||||
*
|
||||
* @returns `this` command for chaining
|
||||
*/
|
||||
name(str: string): this;
|
||||
/**
|
||||
* Get the name of the command.
|
||||
*/
|
||||
name(): string;
|
||||
|
||||
/**
|
||||
* Output help information for this command.
|
||||
*
|
||||
* Outputs built-in help, and custom text added using `.addHelpText()`.
|
||||
*
|
||||
*/
|
||||
outputHelp(context?: HelpContext): void;
|
||||
/** @deprecated since v7 */
|
||||
outputHelp(cb?: (str: string) => string): void;
|
||||
|
||||
/**
|
||||
* Return command help documentation.
|
||||
*/
|
||||
helpInformation(context?: HelpContext): string;
|
||||
|
||||
/**
|
||||
* You can pass in flags and a description to override the help
|
||||
* flags and help description for your command. Pass in false
|
||||
* to disable the built-in help option.
|
||||
*/
|
||||
helpOption(flags?: string | boolean, description?: string): this;
|
||||
|
||||
/**
|
||||
* Output help information and exit.
|
||||
*
|
||||
* Outputs built-in help, and custom text added using `.addHelpText()`.
|
||||
*/
|
||||
help(context?: HelpContext): never;
|
||||
/** @deprecated since v7 */
|
||||
help(cb?: (str: string) => string): never;
|
||||
|
||||
/**
|
||||
* Add additional text to be displayed with the built-in help.
|
||||
*
|
||||
* Position is 'before' or 'after' to affect just this command,
|
||||
* and 'beforeAll' or 'afterAll' to affect this command and all its subcommands.
|
||||
*/
|
||||
addHelpText(position: AddHelpTextPosition, text: string): this;
|
||||
addHelpText(position: AddHelpTextPosition, text: (context: AddHelpTextContext) => string | undefined): this;
|
||||
|
||||
/**
|
||||
* Add a listener (callback) for when events occur. (Implemented using EventEmitter.)
|
||||
*/
|
||||
on(event: string | symbol, listener: (...args: any[]) => void): this;
|
||||
}
|
||||
type CommandConstructor = new (name?: string) => Command;
|
||||
|
||||
interface CommandOptions {
|
||||
hidden?: boolean;
|
||||
isDefault?: boolean;
|
||||
/** @deprecated since v7, replaced by hidden */
|
||||
noHelp?: boolean;
|
||||
}
|
||||
interface ExecutableCommandOptions extends CommandOptions {
|
||||
executableFile?: string;
|
||||
}
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
interface ParseOptionsResult {
|
||||
operands: string[];
|
||||
unknown: string[];
|
||||
}
|
||||
|
||||
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
||||
interface CommanderStatic extends Command {
|
||||
program: Command;
|
||||
Command: CommandConstructor;
|
||||
Option: OptionConstructor;
|
||||
CommanderError: CommanderErrorConstructor;
|
||||
InvalidOptionArgumentError: InvalidOptionArgumentErrorConstructor;
|
||||
Help: HelpConstructor;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Declaring namespace AND global
|
||||
// eslint-disable-next-line @typescript-eslint/no-redeclare
|
||||
declare const commander: commander.CommanderStatic;
|
||||
export = commander;
|
||||
108
app_vue/node_modules/webpack-bundle-analyzer/package.json
generated
vendored
Normal file
108
app_vue/node_modules/webpack-bundle-analyzer/package.json
generated
vendored
Normal file
@ -0,0 +1,108 @@
|
||||
{
|
||||
"name": "webpack-bundle-analyzer",
|
||||
"version": "4.10.2",
|
||||
"description": "Webpack plugin and CLI utility that represents bundle content as convenient interactive zoomable treemap",
|
||||
"author": "Yury Grunin <grunin.ya@ya.ru>",
|
||||
"license": "MIT",
|
||||
"homepage": "https://github.com/webpack-contrib/webpack-bundle-analyzer",
|
||||
"changelog": "https://github.com/webpack-contrib/webpack-bundle-analyzer/blob/master/CHANGELOG.md",
|
||||
"bugs": {
|
||||
"url": "https://github.com/webpack-contrib/webpack-bundle-analyzer/issues"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/webpack-contrib/webpack-bundle-analyzer.git"
|
||||
},
|
||||
"main": "lib/index.js",
|
||||
"bin": "lib/bin/analyzer.js",
|
||||
"engines": {
|
||||
"node": ">= 10.13.0"
|
||||
},
|
||||
"packageManager": "npm@6.14.8",
|
||||
"scripts": {
|
||||
"start": "gulp watch",
|
||||
"build": "gulp build",
|
||||
"npm-publish": "npm run lint && npm run build && npm test && npm publish",
|
||||
"lint": "eslint --ext js,jsx .",
|
||||
"install-test-webpack-versions": "./bin/install-test-webpack-versions.sh",
|
||||
"test": "npm run install-test-webpack-versions && jest --runInBand",
|
||||
"test-dev": "npm run install-test-webpack-versions && jest --watch --runInBand"
|
||||
},
|
||||
"files": [
|
||||
"public",
|
||||
"lib"
|
||||
],
|
||||
"dependencies": {
|
||||
"@discoveryjs/json-ext": "0.5.7",
|
||||
"acorn": "^8.0.4",
|
||||
"acorn-walk": "^8.0.0",
|
||||
"commander": "^7.2.0",
|
||||
"debounce": "^1.2.1",
|
||||
"escape-string-regexp": "^4.0.0",
|
||||
"gzip-size": "^6.0.0",
|
||||
"html-escaper": "^2.0.2",
|
||||
"opener": "^1.5.2",
|
||||
"picocolors": "^1.0.0",
|
||||
"sirv": "^2.0.3",
|
||||
"ws": "^7.3.1"
|
||||
},
|
||||
"devDependencies": {
|
||||
"@babel/core": "7.14.3",
|
||||
"@babel/plugin-proposal-class-properties": "7.13.0",
|
||||
"@babel/plugin-proposal-decorators": "7.14.2",
|
||||
"@babel/plugin-transform-runtime": "7.14.3",
|
||||
"@babel/preset-env": "7.14.2",
|
||||
"@babel/preset-react": "7.13.13",
|
||||
"@babel/runtime": "7.14.0",
|
||||
"@carrotsearch/foamtree": "3.5.0",
|
||||
"autoprefixer": "10.2.5",
|
||||
"babel-eslint": "10.1.0",
|
||||
"babel-loader": "8.2.2",
|
||||
"babel-plugin-lodash": "3.3.4",
|
||||
"chai": "4.3.4",
|
||||
"chai-subset": "1.6.0",
|
||||
"classnames": "2.3.1",
|
||||
"core-js": "3.12.1",
|
||||
"css-loader": "5.2.5",
|
||||
"cssnano": "5.0.4",
|
||||
"del": "6.0.0",
|
||||
"eslint": "5.16.0",
|
||||
"eslint-config-th0r": "2.0.0",
|
||||
"eslint-config-th0r-react": "2.0.1",
|
||||
"eslint-plugin-react": "7.23.2",
|
||||
"filesize": "^6.3.0",
|
||||
"globby": "11.0.3",
|
||||
"gulp": "4.0.2",
|
||||
"gulp-babel": "8.0.0",
|
||||
"jest": "27.2.2",
|
||||
"lodash.memoize": "^4.1.2",
|
||||
"lodash.merge": "^4.6.2",
|
||||
"lodash.partial": "^4.2.1",
|
||||
"mobx": "5.15.7",
|
||||
"mobx-react": "6.3.1",
|
||||
"postcss": "8.3.0",
|
||||
"postcss-icss-values": "2.0.2",
|
||||
"postcss-loader": "5.3.0",
|
||||
"preact": "10.5.13",
|
||||
"puppeteer": "10.4.0",
|
||||
"stream-combiner2": "1.1.1",
|
||||
"style-loader": "2.0.0",
|
||||
"terser-webpack-plugin": "5.1.2",
|
||||
"url-loader": "4.1.1",
|
||||
"webpack": "5.76.0",
|
||||
"webpack-cli": "3.3.12",
|
||||
"webpack-dev-server": "3.11.3"
|
||||
},
|
||||
"keywords": [
|
||||
"webpack",
|
||||
"bundle",
|
||||
"analyzer",
|
||||
"modules",
|
||||
"size",
|
||||
"interactive",
|
||||
"chart",
|
||||
"treemap",
|
||||
"zoomable",
|
||||
"zoom"
|
||||
]
|
||||
}
|
||||
16
app_vue/node_modules/webpack-bundle-analyzer/public/viewer.js
generated
vendored
Normal file
16
app_vue/node_modules/webpack-bundle-analyzer/public/viewer.js
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
10
app_vue/node_modules/webpack-bundle-analyzer/public/viewer.js.LICENSE.txt
generated
vendored
Normal file
10
app_vue/node_modules/webpack-bundle-analyzer/public/viewer.js.LICENSE.txt
generated
vendored
Normal file
@ -0,0 +1,10 @@
|
||||
/*!
|
||||
Copyright (c) 2018 Jed Watson.
|
||||
Licensed under the MIT License (MIT), see
|
||||
http://jedwatson.github.io/classnames
|
||||
*/
|
||||
|
||||
/*!
|
||||
2020 Jason Mulligan <jason.mulligan@avoidwork.com>
|
||||
@version 6.3.0
|
||||
*/
|
||||
1
app_vue/node_modules/webpack-bundle-analyzer/public/viewer.js.map
generated
vendored
Normal file
1
app_vue/node_modules/webpack-bundle-analyzer/public/viewer.js.map
generated
vendored
Normal file
File diff suppressed because one or more lines are too long
Reference in New Issue
Block a user