[Pkg-javascript-devel] Bug#1011868: node-core-js: FTBFS: ValidationError: Invalid configuration object. Webpack has been initialized using a configuration object that does not match the API schema.
Lucas Nussbaum
lucas at debian.org
Thu May 26 20:10:00 BST 2022
Source: node-core-js
Version: 3.22.5-1
Severity: serious
Justification: FTBFS
Tags: bookworm sid ftbfs
User: lucas at debian.org
Usertags: ftbfs-20220525 ftbfs-bookworm
Hi,
During a rebuild of all packages in sid, your package failed to build
on amd64.
Relevant part (hopefully):
> make[1]: Entering directory '/<<PKGBUILDDIR>>'
> zx scripts/generate-indexes.mjs
> indexes generated
> zx scripts/clean-and-copy.mjs
> old copies removed
> created /features/ entries
> copied 3109 files
> zx scripts/build-compat-data.mjs
> compat data rebuilt
> zx scripts/build-compat-entries.mjs
> entries data rebuilt
> zx scripts/build-compat-modules-by-versions.mjs
> modules-by-versions data rebuilt
> ln -s ../packages/core-js node_modules/core-js || true
> zx scripts/bundle.mjs
> /usr/share/nodejs/schema-utils/dist/validate.js:105
> throw new _ValidationError.default(errors, schema, configuration);
> ^
>
> ValidationError: Invalid configuration object. Webpack has been initialized using a configuration object that does not match the API schema.
> - configuration.node should be one of these:
> false | object { __dirname?, __filename?, global? }
> -> Include polyfills or mocks for various node stuff.
> Details:
> * configuration.node has an unknown property 'process'. These properties are valid:
> object { __dirname?, __filename?, global? }
> -> Options object for node compatibility features.
> * configuration.node has an unknown property 'setImmediate'. These properties are valid:
> object { __dirname?, __filename?, global? }
> -> Options object for node compatibility features.
> at validate (/usr/share/nodejs/schema-utils/dist/validate.js:105:11)
> at validateSchema (/usr/share/nodejs/webpack/lib/validateSchema.js:78:2)
> at create (/usr/share/nodejs/webpack/lib/webpack.js:111:24)
> at webpack (/usr/share/nodejs/webpack/lib/webpack.js:142:47)
> at f (/usr/share/nodejs/webpack/lib/index.js:58:16)
> at node:internal/util:360:7
> at new Promise (<anonymous>)
> at f (node:internal/util:346:12)
> at module.exports (/<<PKGBUILDDIR>>/packages/core-js-builder/index.js:47:11)
> at bundle (file:///<<PKGBUILDDIR>>/scripts/bundle.mjs:13:24) {
> errors: [
> {
> keyword: 'anyOf',
> dataPath: '.node',
> schemaPath: '#/anyOf',
> params: {},
> message: 'should match some schema in anyOf',
> schema: [ { enum: [ false ] }, { '$ref': '#/definitions/NodeOptions' } ],
> parentSchema: {
> description: 'Include polyfills or mocks for various node stuff.',
> anyOf: [ { enum: [Array] }, { '$ref': '#/definitions/NodeOptions' } ]
> },
> data: { global: false, process: false, setImmediate: false },
> children: [
> {
> keyword: 'enum',
> dataPath: '.node',
> schemaPath: '#/anyOf/0/enum',
> params: { allowedValues: [Array] },
> message: 'should be equal to one of the allowed values',
> schema: [ false ],
> parentSchema: { enum: [Array] },
> data: { global: false, process: false, setImmediate: false },
> children: undefined
> },
> {
> keyword: 'additionalProperties',
> dataPath: '.node',
> schemaPath: '#/definitions/NodeOptions/additionalProperties',
> params: { additionalProperty: 'process' },
> message: 'should NOT have additional properties',
> schema: false,
> parentSchema: {
> description: 'Options object for node compatibility features.',
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> },
> data: { global: false, process: false, setImmediate: false },
> children: undefined
> },
> {
> keyword: 'additionalProperties',
> dataPath: '.node',
> schemaPath: '#/definitions/NodeOptions/additionalProperties',
> params: { additionalProperty: 'setImmediate' },
> message: 'should NOT have additional properties',
> schema: false,
> parentSchema: {
> description: 'Options object for node compatibility features.',
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> },
> data: { global: false, process: false, setImmediate: false },
> children: undefined
> }
> ]
> }
> ],
> schema: {
> definitions: {
> Amd: {
> description: 'Set the value of `require.amd` and `define.amd`. Or disable AMD support.',
> anyOf: [
> {
> description: 'You can pass `false` to disable AMD support.',
> enum: [Array]
> },
> {
> description: 'You can pass an object to set the value of `require.amd` and `define.amd`.',
> type: 'object'
> }
> ]
> },
> AssetFilterItemTypes: {
> description: 'Filtering value, regexp or function.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: "((name: string, asset: import('../lib/stats/DefaultStatsFactoryPlugin').StatsAsset) => boolean)"
> }
> ]
> },
> AssetFilterTypes: {
> description: 'Filtering modules.',
> cli: { helper: true },
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/AssetFilterItemTypes' }
> ]
> },
> AssetGeneratorDataUrl: {
> description: 'The options for data url generator.',
> anyOf: [
> { '$ref': '#/definitions/AssetGeneratorDataUrlOptions' },
> { '$ref': '#/definitions/AssetGeneratorDataUrlFunction' }
> ]
> },
> AssetGeneratorDataUrlFunction: {
> description: 'Function that executes for module and should return an DataUrl string.',
> instanceof: 'Function',
> tsType: "((source: string | Buffer, context: { filename: string, module: import('../lib/Module') }) => string)"
> },
> AssetGeneratorDataUrlOptions: {
> description: 'Options object for data url generation.',
> type: 'object',
> additionalProperties: false,
> properties: {
> encoding: {
> description: 'Asset encoding (defaults to base64).',
> enum: [Array]
> },
> mimetype: {
> description: 'Asset mimetype (getting from file extension by default).',
> type: 'string'
> }
> }
> },
> AssetGeneratorOptions: {
> description: 'Generator options for asset modules.',
> type: 'object',
> implements: [
> '#/definitions/AssetInlineGeneratorOptions',
> '#/definitions/AssetResourceGeneratorOptions'
> ],
> additionalProperties: false,
> properties: {
> dataUrl: { '$ref': '#/definitions/AssetGeneratorDataUrl' },
> emit: {
> description: "Emit an output asset from this asset module. This can be set to 'false' to omit emitting e. g. for SSR.",
> type: 'boolean'
> },
> filename: { '$ref': '#/definitions/FilenameTemplate' },
> publicPath: { '$ref': '#/definitions/RawPublicPath' }
> }
> },
> AssetInlineGeneratorOptions: {
> description: 'Generator options for asset/inline modules.',
> type: 'object',
> additionalProperties: false,
> properties: { dataUrl: { '$ref': '#/definitions/AssetGeneratorDataUrl' } }
> },
> AssetModuleFilename: {
> description: "The filename of asset modules as relative path inside the 'output.path' directory.",
> anyOf: [
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: '((pathData: import("../lib/Compilation").PathData, assetInfo?: import("../lib/Compilation").AssetInfo) => string)'
> }
> ]
> },
> AssetParserDataUrlFunction: {
> description: 'Function that executes for module and should return whenever asset should be inlined as DataUrl.',
> instanceof: 'Function',
> tsType: "((source: string | Buffer, context: { filename: string, module: import('../lib/Module') }) => boolean)"
> },
> AssetParserDataUrlOptions: {
> description: 'Options object for DataUrl condition.',
> type: 'object',
> additionalProperties: false,
> properties: {
> maxSize: {
> description: 'Maximum size of asset that should be inline as modules. Default: 8kb.',
> type: 'number'
> }
> }
> },
> AssetParserOptions: {
> description: 'Parser options for asset modules.',
> type: 'object',
> additionalProperties: false,
> properties: {
> dataUrlCondition: {
> description: 'The condition for inlining the asset as DataUrl.',
> anyOf: [Array]
> }
> }
> },
> AssetResourceGeneratorOptions: {
> description: 'Generator options for asset/resource modules.',
> type: 'object',
> additionalProperties: false,
> properties: {
> emit: {
> description: "Emit an output asset from this asset module. This can be set to 'false' to omit emitting e. g. for SSR.",
> type: 'boolean'
> },
> filename: { '$ref': '#/definitions/FilenameTemplate' },
> publicPath: { '$ref': '#/definitions/RawPublicPath' }
> }
> },
> AuxiliaryComment: {
> description: 'Add a comment in the UMD wrapper.',
> anyOf: [
> {
> description: 'Append the same comment above each import style.',
> type: 'string'
> },
> { '$ref': '#/definitions/LibraryCustomUmdCommentObject' }
> ]
> },
> Bail: {
> description: 'Report the first error as a hard error instead of tolerating it.',
> type: 'boolean'
> },
> CacheOptions: {
> description: 'Cache generated modules and chunks to improve performance for multiple incremental builds.',
> anyOf: [
> { description: 'Enable in memory caching.', enum: [Array] },
> { '$ref': '#/definitions/CacheOptionsNormalized' }
> ]
> },
> CacheOptionsNormalized: {
> description: 'Cache generated modules and chunks to improve performance for multiple incremental builds.',
> anyOf: [
> { description: 'Disable caching.', enum: [Array] },
> { '$ref': '#/definitions/MemoryCacheOptions' },
> { '$ref': '#/definitions/FileCacheOptions' }
> ]
> },
> Charset: {
> description: 'Add charset attribute for script tag.',
> type: 'boolean'
> },
> ChunkFilename: {
> description: "Specifies the filename template of output files of non-initial chunks on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.",
> oneOf: [ { '$ref': '#/definitions/FilenameTemplate' } ]
> },
> ChunkFormat: {
> description: "The format of chunks (formats included by default are 'array-push' (web/WebWorker), 'commonjs' (node.js), 'module' (ESM), but others might be added by plugins).",
> anyOf: [ { enum: [Array] }, { type: 'string' } ]
> },
> ChunkLoadTimeout: {
> description: 'Number of milliseconds before chunk request expires.',
> type: 'number'
> },
> ChunkLoading: {
> description: "The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).",
> anyOf: [
> { enum: [Array] },
> { '$ref': '#/definitions/ChunkLoadingType' }
> ]
> },
> ChunkLoadingGlobal: {
> description: 'The global variable used by webpack for loading of chunks.',
> type: 'string'
> },
> ChunkLoadingType: {
> description: "The method of loading chunks (methods included by default are 'jsonp' (web), 'import' (ESM), 'importScripts' (WebWorker), 'require' (sync node.js), 'async-node' (async node.js), but others might be added by plugins).",
> anyOf: [ { enum: [Array] }, { type: 'string' } ]
> },
> Clean: {
> description: 'Clean the output directory before emit.',
> anyOf: [
> { type: 'boolean' },
> { '$ref': '#/definitions/CleanOptions' }
> ]
> },
> CleanOptions: {
> description: 'Advanced options for cleaning assets.',
> type: 'object',
> additionalProperties: false,
> properties: {
> dry: {
> description: 'Log the assets that should be removed instead of deleting them.',
> type: 'boolean'
> },
> keep: { description: 'Keep these assets.', anyOf: [Array] }
> }
> },
> CompareBeforeEmit: {
> description: 'Check if to be emitted file already exists and have the same content before writing to output filesystem.',
> type: 'boolean'
> },
> Context: {
> description: 'The base directory (absolute path!) for resolving the `entry` option. If `output.pathinfo` is set, the included pathinfo is shortened to this directory.',
> type: 'string',
> absolutePath: true
> },
> CrossOriginLoading: {
> description: 'This option enables cross-origin loading of chunks.',
> enum: [ false, 'anonymous', 'use-credentials' ]
> },
> Dependencies: {
> description: 'References to other configurations to depend on.',
> type: 'array',
> items: {
> description: 'References to another configuration to depend on.',
> type: 'string'
> }
> },
> DevServer: {
> description: 'Options for the webpack-dev-server.',
> type: 'object'
> },
> DevTool: {
> description: 'A developer tool to enhance debugging (false | eval | [inline-|hidden-|eval-][nosources-][cheap-[module-]]source-map).',
> anyOf: [
> { enum: [Array] },
> {
> type: 'string',
> pattern: '^(inline-|hidden-|eval-)?(nosources-)?(cheap-(module-)?)?source-map$'
> }
> ]
> },
> DevtoolFallbackModuleFilenameTemplate: {
> description: 'Similar to `output.devtoolModuleFilenameTemplate`, but used in the case of duplicate module identifiers.',
> anyOf: [
> { type: 'string' },
> { instanceof: 'Function', tsType: 'Function' }
> ]
> },
> DevtoolModuleFilenameTemplate: {
> description: 'Filename template string of function for the sources array in a generated SourceMap.',
> anyOf: [
> { type: 'string' },
> { instanceof: 'Function', tsType: 'Function' }
> ]
> },
> DevtoolNamespace: {
> description: "Module namespace to use when interpolating filename template string for the sources array in a generated SourceMap. Defaults to `output.library` if not set. It's useful for avoiding runtime collisions in sourcemaps from multiple webpack projects built as libraries.",
> type: 'string'
> },
> EmptyGeneratorOptions: {
> description: 'No generator options are supported for this module type.',
> type: 'object',
> additionalProperties: false
> },
> EmptyParserOptions: {
> description: 'No parser options are supported for this module type.',
> type: 'object',
> additionalProperties: false
> },
> EnabledChunkLoadingTypes: {
> description: 'List of chunk loading types enabled for use by entry points.',
> type: 'array',
> items: { '$ref': '#/definitions/ChunkLoadingType' }
> },
> EnabledLibraryTypes: {
> description: 'List of library types enabled for use by entry points.',
> type: 'array',
> items: { '$ref': '#/definitions/LibraryType' }
> },
> EnabledWasmLoadingTypes: {
> description: 'List of wasm loading types enabled for use by entry points.',
> type: 'array',
> items: { '$ref': '#/definitions/WasmLoadingType' }
> },
> Entry: {
> description: 'The entry point(s) of the compilation.',
> anyOf: [
> { '$ref': '#/definitions/EntryDynamic' },
> { '$ref': '#/definitions/EntryStatic' }
> ]
> },
> EntryDescription: {
> description: 'An object with entry point description.',
> type: 'object',
> additionalProperties: false,
> properties: {
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are loaded on demand.',
> type: 'boolean'
> },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> dependOn: {
> description: 'The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.',
> anyOf: [Array]
> },
> filename: { '$ref': '#/definitions/EntryFilename' },
> import: { '$ref': '#/definitions/EntryItem' },
> layer: { '$ref': '#/definitions/Layer' },
> library: { '$ref': '#/definitions/LibraryOptions' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> runtime: { '$ref': '#/definitions/EntryRuntime' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' }
> },
> required: [ 'import' ]
> },
> EntryDescriptionNormalized: {
> description: 'An object with entry point description.',
> type: 'object',
> additionalProperties: false,
> properties: {
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are loaded on demand.',
> type: 'boolean'
> },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> dependOn: {
> description: 'The entrypoints that the current entrypoint depend on. They must be loaded when this entrypoint is loaded.',
> type: 'array',
> items: [Object],
> minItems: 1,
> uniqueItems: true
> },
> filename: { '$ref': '#/definitions/Filename' },
> import: {
> description: 'Module(s) that are loaded upon startup. The last one is exported.',
> type: 'array',
> items: [Object],
> minItems: 1,
> uniqueItems: true
> },
> layer: { '$ref': '#/definitions/Layer' },
> library: { '$ref': '#/definitions/LibraryOptions' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> runtime: { '$ref': '#/definitions/EntryRuntime' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' }
> }
> },
> EntryDynamic: {
> description: 'A Function returning an entry object, an entry string, an entry array or a promise to these things.',
> instanceof: 'Function',
> tsType: '(() => EntryStatic | Promise<EntryStatic>)'
> },
> EntryDynamicNormalized: {
> description: 'A Function returning a Promise resolving to a normalized entry.',
> instanceof: 'Function',
> tsType: '(() => Promise<EntryStaticNormalized>)'
> },
> EntryFilename: {
> description: "Specifies the filename of the output file on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.",
> oneOf: [ { '$ref': '#/definitions/FilenameTemplate' } ]
> },
> EntryItem: {
> description: 'Module(s) that are loaded upon startup.',
> anyOf: [
> {
> description: 'All modules are loaded upon startup. The last one is exported.',
> type: 'array',
> items: [Object],
> minItems: 1,
> uniqueItems: true
> },
> {
> description: 'The string is resolved to a module which is loaded upon startup.',
> type: 'string',
> minLength: 1
> }
> ]
> },
> EntryNormalized: {
> description: 'The entry point(s) of the compilation.',
> anyOf: [
> { '$ref': '#/definitions/EntryDynamicNormalized' },
> { '$ref': '#/definitions/EntryStaticNormalized' }
> ]
> },
> EntryObject: {
> description: 'Multiple entry bundles are created. The key is the entry name. The value can be a string, an array or an entry description object.',
> type: 'object',
> additionalProperties: {
> description: 'An entry point with name.',
> anyOf: [ [Object], [Object] ]
> }
> },
> EntryRuntime: {
> description: 'The name of the runtime chunk. If set a runtime chunk with this name is created or an existing entrypoint is used as runtime.',
> anyOf: [ { enum: [Array] }, { type: 'string', minLength: 1 } ]
> },
> EntryStatic: {
> description: 'A static entry description.',
> anyOf: [
> { '$ref': '#/definitions/EntryObject' },
> { '$ref': '#/definitions/EntryUnnamed' }
> ]
> },
> EntryStaticNormalized: {
> description: 'Multiple entry bundles are created. The key is the entry name. The value is an entry description object.',
> type: 'object',
> additionalProperties: {
> description: 'An object with entry point description.',
> oneOf: [ [Object] ]
> }
> },
> EntryUnnamed: {
> description: 'An entry point without name.',
> oneOf: [ { '$ref': '#/definitions/EntryItem' } ]
> },
> Environment: {
> description: 'The abilities of the environment where the webpack generated code should run.',
> type: 'object',
> additionalProperties: false,
> properties: {
> arrowFunction: {
> description: "The environment supports arrow functions ('() => { ... }').",
> type: 'boolean'
> },
> bigIntLiteral: {
> description: 'The environment supports BigInt as literal (123n).',
> type: 'boolean'
> },
> const: {
> description: 'The environment supports const and let for variable declarations.',
> type: 'boolean'
> },
> destructuring: {
> description: "The environment supports destructuring ('{ a, b } = obj').",
> type: 'boolean'
> },
> dynamicImport: {
> description: 'The environment supports an async import() function to import EcmaScript modules.',
> type: 'boolean'
> },
> forOf: {
> description: "The environment supports 'for of' iteration ('for (const x of array) { ... }').",
> type: 'boolean'
> },
> module: {
> description: "The environment supports EcmaScript Module syntax to import EcmaScript modules (import ... from '...').",
> type: 'boolean'
> },
> optionalChaining: {
> description: "The environment supports optional chaining ('obj?.a' or 'obj?.()').",
> type: 'boolean'
> },
> templateLiteral: {
> description: 'The environment supports template literals.',
> type: 'boolean'
> }
> }
> },
> Experiments: {
> description: 'Enables/Disables experiments (experimental features with relax SemVer compatibility).',
> type: 'object',
> implements: [ '#/definitions/ExperimentsCommon' ],
> additionalProperties: false,
> properties: {
> asyncWebAssembly: {
> description: 'Support WebAssembly as asynchronous EcmaScript Module.',
> type: 'boolean'
> },
> backCompat: {
> description: 'Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.',
> type: 'boolean'
> },
> buildHttp: {
> description: 'Build http(s): urls using a lockfile and resource content cache.',
> anyOf: [Array]
> },
> cacheUnaffected: {
> description: 'Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> futureDefaults: {
> description: 'Apply defaults of next major version.',
> type: 'boolean'
> },
> layers: { description: 'Enable module layers.', type: 'boolean' },
> lazyCompilation: {
> description: 'Compile entrypoints and import()s only when they are accessed.',
> anyOf: [Array]
> },
> outputModule: {
> description: 'Allow output javascript files as module source type.',
> type: 'boolean'
> },
> syncWebAssembly: {
> description: 'Support WebAssembly as synchronous EcmaScript Module (outdated).',
> type: 'boolean'
> },
> topLevelAwait: {
> description: 'Allow using top-level-await in EcmaScript Modules.',
> type: 'boolean'
> }
> }
> },
> ExperimentsCommon: {
> description: 'Enables/Disables experiments (experimental features with relax SemVer compatibility).',
> type: 'object',
> additionalProperties: false,
> properties: {
> asyncWebAssembly: {
> description: 'Support WebAssembly as asynchronous EcmaScript Module.',
> type: 'boolean'
> },
> backCompat: {
> description: 'Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.',
> type: 'boolean'
> },
> cacheUnaffected: {
> description: 'Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> futureDefaults: {
> description: 'Apply defaults of next major version.',
> type: 'boolean'
> },
> layers: { description: 'Enable module layers.', type: 'boolean' },
> outputModule: {
> description: 'Allow output javascript files as module source type.',
> type: 'boolean'
> },
> syncWebAssembly: {
> description: 'Support WebAssembly as synchronous EcmaScript Module (outdated).',
> type: 'boolean'
> },
> topLevelAwait: {
> description: 'Allow using top-level-await in EcmaScript Modules.',
> type: 'boolean'
> }
> }
> },
> ExperimentsNormalized: {
> description: 'Enables/Disables experiments (experimental features with relax SemVer compatibility).',
> type: 'object',
> implements: [ '#/definitions/ExperimentsCommon' ],
> additionalProperties: false,
> properties: {
> asyncWebAssembly: {
> description: 'Support WebAssembly as asynchronous EcmaScript Module.',
> type: 'boolean'
> },
> backCompat: {
> description: 'Enable backward-compat layer with deprecation warnings for many webpack 4 APIs.',
> type: 'boolean'
> },
> buildHttp: {
> description: 'Build http(s): urls using a lockfile and resource content cache.',
> oneOf: [Array]
> },
> cacheUnaffected: {
> description: 'Enable additional in memory caching of modules that are unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> futureDefaults: {
> description: 'Apply defaults of next major version.',
> type: 'boolean'
> },
> layers: { description: 'Enable module layers.', type: 'boolean' },
> lazyCompilation: {
> description: 'Compile entrypoints and import()s only when they are accessed.',
> oneOf: [Array]
> },
> outputModule: {
> description: 'Allow output javascript files as module source type.',
> type: 'boolean'
> },
> syncWebAssembly: {
> description: 'Support WebAssembly as synchronous EcmaScript Module (outdated).',
> type: 'boolean'
> },
> topLevelAwait: {
> description: 'Allow using top-level-await in EcmaScript Modules.',
> type: 'boolean'
> }
> }
> },
> ExternalItem: {
> description: "Specify dependency that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.",
> anyOf: [
> {
> description: 'Every matched dependency becomes external.',
> instanceof: 'RegExp',
> tsType: 'RegExp'
> },
> {
> description: 'An exact matched dependency becomes external. The same string is used as external dependency.',
> type: 'string'
> },
> {
> description: 'If an dependency matches exactly a property of the object, the property value is used as dependency.',
> type: 'object',
> additionalProperties: [Object],
> properties: [Object]
> },
> {
> description: 'The function is called on each dependency (`function(context, request, callback(err, result))`).',
> instanceof: 'Function',
> tsType: '(((data: ExternalItemFunctionData, callback: (err?: Error, result?: ExternalItemValue) => void) => void) | ((data: ExternalItemFunctionData) => Promise<ExternalItemValue>))'
> }
> ]
> },
> ExternalItemFunctionData: {
> description: "Data object passed as argument when a function is set for 'externals'.",
> type: 'object',
> additionalProperties: false,
> properties: {
> context: {
> description: 'The directory in which the request is placed.',
> type: 'string'
> },
> contextInfo: {
> description: 'Contextual information.',
> type: 'object',
> tsType: "import('../lib/ModuleFactory').ModuleFactoryCreateDataContextInfo"
> },
> dependencyType: {
> description: 'The category of the referencing dependencies.',
> type: 'string'
> },
> getResolve: {
> description: 'Get a resolve function with the current resolver options.',
> instanceof: 'Function',
> tsType: '((options?: ResolveOptions) => ((context: string, request: string, callback: (err?: Error, result?: string) => void) => void) | ((context: string, request: string) => Promise<string>))'
> },
> request: {
> description: 'The request as written by the user in the require/import expression/statement.',
> type: 'string'
> }
> }
> },
> ExternalItemValue: {
> description: 'The dependency used for the external.',
> anyOf: [
> { type: 'array', items: [Object] },
> {
> description: '`true`: The dependency name is used as target of the external.',
> type: 'boolean'
> },
> {
> description: 'The target of the external.',
> type: 'string'
> },
> { type: 'object' }
> ]
> },
> Externals: {
> description: "Specify dependencies that shouldn't be resolved by webpack, but should become dependencies of the resulting bundle. The kind of the dependency depends on `output.libraryTarget`.",
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/ExternalItem' }
> ]
> },
> ExternalsPresets: {
> description: 'Enable presets of externals for specific targets.',
> type: 'object',
> additionalProperties: false,
> properties: {
> electron: {
> description: "Treat common electron built-in modules in main and preload context like 'electron', 'ipc' or 'shell' as external and load them via require() when used.",
> type: 'boolean'
> },
> electronMain: {
> description: "Treat electron built-in modules in the main context like 'app', 'ipc-main' or 'shell' as external and load them via require() when used.",
> type: 'boolean'
> },
> electronPreload: {
> description: "Treat electron built-in modules in the preload context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.",
> type: 'boolean'
> },
> electronRenderer: {
> description: "Treat electron built-in modules in the renderer context like 'web-frame', 'ipc-renderer' or 'shell' as external and load them via require() when used.",
> type: 'boolean'
> },
> node: {
> description: 'Treat node.js built-in modules like fs, path or vm as external and load them via require() when used.',
> type: 'boolean'
> },
> nwjs: {
> description: 'Treat NW.js legacy nw.gui module as external and load it via require() when used.',
> type: 'boolean'
> },
> web: {
> description: "Treat references to 'http(s)://...' and 'std:...' as external and load them via import when used (Note that this changes execution order as externals are executed before any other code in the chunk).",
> type: 'boolean'
> },
> webAsync: {
> description: "Treat references to 'http(s)://...' and 'std:...' as external and load them via async import() when used (Note that this external type is an async module, which has various effects on the execution).",
> type: 'boolean'
> }
> }
> },
> ExternalsType: {
> description: "Specifies the default type of externals ('amd*', 'umd*', 'system' and 'jsonp' depend on output.libraryTarget set to the same value).",
> enum: [
> 'var', 'module',
> 'assign', 'this',
> 'window', 'self',
> 'global', 'commonjs',
> 'commonjs2', 'commonjs-module',
> 'amd', 'amd-require',
> 'umd', 'umd2',
> 'jsonp', 'system',
> 'promise', 'import',
> 'script', 'node-commonjs'
> ]
> },
> FileCacheOptions: {
> description: 'Options object for persistent file-based caching.',
> type: 'object',
> additionalProperties: false,
> properties: {
> allowCollectingMemory: {
> description: 'Allows to collect unused memory allocated during deserialization. This requires copying data into smaller buffers and has a performance cost.',
> type: 'boolean'
> },
> buildDependencies: {
> description: "Dependencies the build depends on (in multiple categories, default categories: 'defaultWebpack').",
> type: 'object',
> additionalProperties: [Object]
> },
> cacheDirectory: {
> description: 'Base directory for the cache (defaults to node_modules/.cache/webpack).',
> type: 'string',
> absolutePath: true
> },
> cacheLocation: {
> description: 'Locations for the cache (defaults to cacheDirectory / name).',
> type: 'string',
> absolutePath: true
> },
> compression: {
> description: 'Compression type used for the cache files.',
> enum: [Array]
> },
> hashAlgorithm: {
> description: 'Algorithm used for generation the hash (see node.js crypto package).',
> type: 'string'
> },
> idleTimeout: {
> description: 'Time in ms after which idle period the cache storing should happen.',
> type: 'number',
> minimum: 0
> },
> idleTimeoutAfterLargeChanges: {
> description: 'Time in ms after which idle period the cache storing should happen when larger changes has been detected (cumulative build time > 2 x avg cache store time).',
> type: 'number',
> minimum: 0
> },
> idleTimeoutForInitialStore: {
> description: 'Time in ms after which idle period the initial cache storing should happen.',
> type: 'number',
> minimum: 0
> },
> immutablePaths: {
> description: 'List of paths that are managed by a package manager and contain a version or hash in its path so all files are immutable.',
> type: 'array',
> items: [Object]
> },
> managedPaths: {
> description: 'List of paths that are managed by a package manager and can be trusted to not be modified otherwise.',
> type: 'array',
> items: [Object]
> },
> maxAge: {
> description: 'Time for which unused cache entries stay in the filesystem cache at minimum (in milliseconds).',
> type: 'number',
> minimum: 0
> },
> maxMemoryGenerations: {
> description: 'Number of generations unused cache entries stay in memory cache at minimum (0 = no memory cache used, 1 = may be removed after unused for a single compilation, ..., Infinity: kept forever). Cache entries will be deserialized from disk when removed from memory cache.',
> type: 'number',
> minimum: 0
> },
> memoryCacheUnaffected: {
> description: 'Additionally cache computation of modules that are unchanged and reference only unchanged modules in memory.',
> type: 'boolean'
> },
> name: {
> description: 'Name for the cache. Different names will lead to different coexisting caches.',
> type: 'string'
> },
> profile: {
> description: 'Track and log detailed timing information for individual cache items.',
> type: 'boolean'
> },
> store: {
> description: 'When to store data to the filesystem. (pack: Store data when compiler is idle in a single file).',
> enum: [Array]
> },
> type: { description: 'Filesystem caching.', enum: [Array] },
> version: {
> description: "Version of the cache data. Different versions won't allow to reuse the cache and override existing content. Update the version when config changed in a way which doesn't allow to reuse cache. This will invalidate the cache.",
> type: 'string'
> }
> },
> required: [ 'type' ]
> },
> Filename: {
> description: "Specifies the filename of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.",
> oneOf: [ { '$ref': '#/definitions/FilenameTemplate' } ]
> },
> FilenameTemplate: {
> description: "Specifies the filename template of output files on disk. You must **not** specify an absolute path here, but the path may contain folders separated by '/'! The specified path is joined with the value of the 'output.path' option to determine the location on disk.",
> anyOf: [
> { type: 'string', absolutePath: false, minLength: 1 },
> {
> instanceof: 'Function',
> tsType: '((pathData: import("../lib/Compilation").PathData, assetInfo?: import("../lib/Compilation").AssetInfo) => string)'
> }
> ]
> },
> FilterItemTypes: {
> description: 'Filtering value, regexp or function.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: '((value: string) => boolean)'
> }
> ]
> },
> FilterTypes: {
> description: 'Filtering values.',
> cli: { helper: true },
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/FilterItemTypes' }
> ]
> },
> GeneratorOptionsByModuleType: {
> description: 'Specify options for each generator.',
> type: 'object',
> additionalProperties: {
> description: 'Options for generating.',
> type: 'object',
> additionalProperties: true
> },
> properties: {
> asset: { '$ref': '#/definitions/AssetGeneratorOptions' },
> 'asset/inline': { '$ref': '#/definitions/AssetInlineGeneratorOptions' },
> 'asset/resource': { '$ref': '#/definitions/AssetResourceGeneratorOptions' },
> javascript: { '$ref': '#/definitions/EmptyGeneratorOptions' },
> 'javascript/auto': { '$ref': '#/definitions/EmptyGeneratorOptions' },
> 'javascript/dynamic': { '$ref': '#/definitions/EmptyGeneratorOptions' },
> 'javascript/esm': { '$ref': '#/definitions/EmptyGeneratorOptions' }
> }
> },
> GlobalObject: {
> description: 'An expression which is used to address the global object/scope in runtime code.',
> type: 'string',
> minLength: 1
> },
> HashDigest: { description: 'Digest type used for the hash.', type: 'string' },
> HashDigestLength: {
> description: 'Number of chars which are used for the hash.',
> type: 'number',
> minimum: 1
> },
> HashFunction: {
> description: 'Algorithm used for generation the hash (see node.js crypto package).',
> anyOf: [
> { type: 'string', minLength: 1 },
> {
> instanceof: 'Function',
> tsType: "typeof import('../lib/util/Hash')"
> }
> ]
> },
> HashSalt: {
> description: 'Any string which is added to the hash to salt it.',
> type: 'string',
> minLength: 1
> },
> HotUpdateChunkFilename: {
> description: 'The filename of the Hot Update Chunks. They are inside the output.path directory.',
> type: 'string',
> absolutePath: false
> },
> HotUpdateGlobal: {
> description: 'The global variable used by webpack for loading of hot update chunks.',
> type: 'string'
> },
> HotUpdateMainFilename: {
> description: "The filename of the Hot Update Main File. It is inside the 'output.path' directory.",
> type: 'string',
> absolutePath: false
> },
> HttpUriAllowedUris: {
> description: 'List of allowed URIs for building http resources.',
> cli: { exclude: true },
> oneOf: [ { '$ref': '#/definitions/HttpUriOptionsAllowedUris' } ]
> },
> HttpUriOptions: {
> description: 'Options for building http resources.',
> type: 'object',
> additionalProperties: false,
> properties: {
> allowedUris: { '$ref': '#/definitions/HttpUriOptionsAllowedUris' },
> cacheLocation: {
> description: "Location where resource content is stored for lockfile entries. It's also possible to disable storing by passing false.",
> anyOf: [Array]
> },
> frozen: {
> description: 'When set, anything that would lead to a modification of the lockfile or any resource content, will result in an error.',
> type: 'boolean'
> },
> lockfileLocation: {
> description: 'Location of the lockfile.',
> type: 'string',
> absolutePath: true
> },
> upgrade: {
> description: 'When set, resources of existing lockfile entries will be fetched and entries will be upgraded when resource content has changed.',
> type: 'boolean'
> }
> },
> required: [ 'allowedUris' ]
> },
> HttpUriOptionsAllowedUris: {
> description: 'List of allowed URIs (resp. the beginning of them).',
> type: 'array',
> items: {
> description: 'List of allowed URIs (resp. the beginning of them).',
> anyOf: [ [Object], [Object], [Object] ]
> }
> },
> IgnoreWarnings: {
> description: 'Ignore specific warnings.',
> type: 'array',
> items: {
> description: 'Ignore specific warnings.',
> anyOf: [ [Object], [Object], [Object] ]
> }
> },
> IgnoreWarningsNormalized: {
> description: 'Ignore specific warnings.',
> type: 'array',
> items: {
> description: 'A function to select warnings based on the raw warning instance.',
> instanceof: 'Function',
> tsType: "((warning: import('../lib/WebpackError'), compilation: import('../lib/Compilation')) => boolean)"
> }
> },
> Iife: {
> description: "Wrap javascript code into IIFE's to avoid leaking into global scope.",
> type: 'boolean'
> },
> ImportFunctionName: {
> description: 'The name of the native import() function (can be exchanged for a polyfill).',
> type: 'string'
> },
> ImportMetaName: {
> description: 'The name of the native import.meta object (can be exchanged for a polyfill).',
> type: 'string'
> },
> InfrastructureLogging: {
> description: 'Options for infrastructure level logging.',
> type: 'object',
> additionalProperties: false,
> properties: {
> appendOnly: {
> description: 'Only appends lines to the output. Avoids updating existing output e. g. for status messages. This option is only used when no custom console is provided.',
> type: 'boolean'
> },
> colors: {
> description: 'Enables/Disables colorful output. This option is only used when no custom console is provided.',
> type: 'boolean'
> },
> console: {
> description: 'Custom console used for logging.',
> tsType: 'Console'
> },
> debug: {
> description: 'Enable debug logging for specific loggers.',
> anyOf: [Array]
> },
> level: { description: 'Log level.', enum: [Array] },
> stream: {
> description: 'Stream used for logging output. Defaults to process.stderr. This option is only used when no custom console is provided.',
> tsType: 'NodeJS.WritableStream'
> }
> }
> },
> JavascriptParserOptions: {
> description: 'Parser options for javascript modules.',
> type: 'object',
> additionalProperties: true,
> properties: {
> amd: { '$ref': '#/definitions/Amd' },
> browserify: {
> description: 'Enable/disable special handling for browserify bundles.',
> type: 'boolean'
> },
> commonjs: {
> description: 'Enable/disable parsing of CommonJs syntax.',
> type: 'boolean'
> },
> commonjsMagicComments: {
> description: 'Enable/disable parsing of magic comments in CommonJs syntax.',
> type: 'boolean'
> },
> exportsPresence: {
> description: 'Specifies the behavior of invalid export names in "import ... from ..." and "export ... from ...".',
> enum: [Array]
> },
> exprContextCritical: {
> description: 'Enable warnings for full dynamic dependencies.',
> type: 'boolean'
> },
> exprContextRecursive: {
> description: 'Enable recursive directory lookup for full dynamic dependencies.',
> type: 'boolean'
> },
> exprContextRegExp: {
> description: 'Sets the default regular expression for full dynamic dependencies.',
> anyOf: [Array]
> },
> exprContextRequest: {
> description: 'Set the default request for full dynamic dependencies.',
> type: 'string'
> },
> harmony: {
> description: 'Enable/disable parsing of EcmaScript Modules syntax.',
> type: 'boolean'
> },
> import: {
> description: 'Enable/disable parsing of import() syntax.',
> type: 'boolean'
> },
> importExportsPresence: {
> description: 'Specifies the behavior of invalid export names in "import ... from ...".',
> enum: [Array]
> },
> node: { '$ref': '#/definitions/Node' },
> reexportExportsPresence: {
> description: 'Specifies the behavior of invalid export names in "export ... from ...". This might be useful to disable during the migration from "export ... from ..." to "export type ... from ..." when reexporting types in TypeScript.',
> enum: [Array]
> },
> requireContext: {
> description: 'Enable/disable parsing of require.context syntax.',
> type: 'boolean'
> },
> requireEnsure: {
> description: 'Enable/disable parsing of require.ensure syntax.',
> type: 'boolean'
> },
> requireInclude: {
> description: 'Enable/disable parsing of require.include syntax.',
> type: 'boolean'
> },
> requireJs: {
> description: 'Enable/disable parsing of require.js special syntax like require.config, requirejs.config, require.version and requirejs.onError.',
> type: 'boolean'
> },
> strictExportPresence: {
> description: `Deprecated in favor of "exportsPresence". Emit errors instead of warnings when imported names don't exist in imported module.`,
> type: 'boolean'
> },
> strictThisContextOnImports: {
> description: 'Handle the this context correctly according to the spec for namespace objects.',
> type: 'boolean'
> },
> system: {
> description: 'Enable/disable parsing of System.js special syntax like System.import, System.get, System.set and System.register.',
> type: 'boolean'
> },
> unknownContextCritical: {
> description: 'Enable warnings when using the require function in a not statically analyse-able way.',
> type: 'boolean'
> },
> unknownContextRecursive: {
> description: 'Enable recursive directory lookup when using the require function in a not statically analyse-able way.',
> type: 'boolean'
> },
> unknownContextRegExp: {
> description: 'Sets the regular expression when using the require function in a not statically analyse-able way.',
> anyOf: [Array]
> },
> unknownContextRequest: {
> description: 'Sets the request when using the require function in a not statically analyse-able way.',
> type: 'string'
> },
> url: {
> description: 'Enable/disable parsing of new URL() syntax.',
> anyOf: [Array]
> },
> worker: {
> description: 'Disable or configure parsing of WebWorker syntax like new Worker() or navigator.serviceWorker.register().',
> anyOf: [Array]
> },
> wrappedContextCritical: {
> description: 'Enable warnings for partial dynamic dependencies.',
> type: 'boolean'
> },
> wrappedContextRecursive: {
> description: 'Enable recursive directory lookup for partial dynamic dependencies.',
> type: 'boolean'
> },
> wrappedContextRegExp: {
> description: 'Set the inner regular expression for partial dynamic dependencies.',
> instanceof: 'RegExp',
> tsType: 'RegExp'
> }
> }
> },
> Layer: {
> description: 'Specifies the layer in which modules of this entrypoint are placed.',
> anyOf: [ { enum: [Array] }, { type: 'string', minLength: 1 } ]
> },
> LazyCompilationDefaultBackendOptions: {
> description: 'Options for the default backend.',
> type: 'object',
> additionalProperties: false,
> properties: {
> client: { description: 'A custom client.', type: 'string' },
> listen: {
> description: 'Specifies where to listen to from the server.',
> anyOf: [Array]
> },
> protocol: {
> description: 'Specifies the protocol the client should use to connect to the server.',
> enum: [Array]
> },
> server: {
> description: 'Specifies how to create the server handling the EventSource requests.',
> anyOf: [Array]
> }
> }
> },
> LazyCompilationOptions: {
> description: 'Options for compiling entrypoints and import()s only when they are accessed.',
> type: 'object',
> additionalProperties: false,
> properties: {
> backend: {
> description: 'Specifies the backend that should be used for handling client keep alive.',
> anyOf: [Array]
> },
> entries: {
> description: 'Enable/disable lazy compilation for entries.',
> type: 'boolean'
> },
> imports: {
> description: 'Enable/disable lazy compilation for import() modules.',
> type: 'boolean'
> },
> test: {
> description: 'Specify which entrypoints or import()ed modules should be lazily compiled. This is matched with the imported module and not the entrypoint name.',
> anyOf: [Array]
> }
> }
> },
> Library: {
> description: 'Make the output files a library, exporting the exports of the entry point.',
> anyOf: [
> { '$ref': '#/definitions/LibraryName' },
> { '$ref': '#/definitions/LibraryOptions' }
> ]
> },
> LibraryCustomUmdCommentObject: {
> description: 'Set explicit comments for `commonjs`, `commonjs2`, `amd`, and `root`.',
> type: 'object',
> additionalProperties: false,
> properties: {
> amd: {
> description: 'Set comment for `amd` section in UMD.',
> type: 'string'
> },
> commonjs: {
> description: 'Set comment for `commonjs` (exports) section in UMD.',
> type: 'string'
> },
> commonjs2: {
> description: 'Set comment for `commonjs2` (module.exports) section in UMD.',
> type: 'string'
> },
> root: {
> description: 'Set comment for `root` (global variable) section in UMD.',
> type: 'string'
> }
> }
> },
> LibraryCustomUmdObject: {
> description: 'Description object for all UMD variants of the library name.',
> type: 'object',
> additionalProperties: false,
> properties: {
> amd: {
> description: 'Name of the exposed AMD library in the UMD.',
> type: 'string',
> minLength: 1
> },
> commonjs: {
> description: 'Name of the exposed commonjs export in the UMD.',
> type: 'string',
> minLength: 1
> },
> root: {
> description: 'Name of the property exposed globally by a UMD library.',
> anyOf: [Array]
> }
> }
> },
> LibraryExport: {
> description: 'Specify which export should be exposed as library.',
> anyOf: [
> { type: 'array', items: [Object] },
> { type: 'string', minLength: 1 }
> ]
> },
> LibraryName: {
> description: 'The name of the library (some types allow unnamed libraries too).',
> anyOf: [
> { type: 'array', items: [Object], minItems: 1 },
> { type: 'string', minLength: 1 },
> { '$ref': '#/definitions/LibraryCustomUmdObject' }
> ]
> },
> LibraryOptions: {
> description: 'Options for library.',
> type: 'object',
> additionalProperties: false,
> properties: {
> auxiliaryComment: { '$ref': '#/definitions/AuxiliaryComment' },
> export: { '$ref': '#/definitions/LibraryExport' },
> name: { '$ref': '#/definitions/LibraryName' },
> type: { '$ref': '#/definitions/LibraryType' },
> umdNamedDefine: { '$ref': '#/definitions/UmdNamedDefine' }
> },
> required: [ 'type' ]
> },
> LibraryType: {
> description: "Type of library (types included by default are 'var', 'module', 'assign', 'assign-properties', 'this', 'window', 'self', 'global', 'commonjs', 'commonjs2', 'commonjs-module', 'amd', 'amd-require', 'umd', 'umd2', 'jsonp', 'system', but others might be added by plugins).",
> anyOf: [ { enum: [Array] }, { type: 'string' } ]
> },
> Loader: {
> description: 'Custom values available in the loader context.',
> type: 'object'
> },
> MemoryCacheOptions: {
> description: 'Options object for in-memory caching.',
> type: 'object',
> additionalProperties: false,
> properties: {
> cacheUnaffected: {
> description: 'Additionally cache computation of modules that are unchanged and reference only unchanged modules.',
> type: 'boolean'
> },
> maxGenerations: {
> description: 'Number of generations unused cache entries stay in memory cache at minimum (1 = may be removed after unused for a single compilation, ..., Infinity: kept forever).',
> type: 'number',
> minimum: 1
> },
> type: { description: 'In memory caching.', enum: [Array] }
> },
> required: [ 'type' ]
> },
> Mode: {
> description: 'Enable production optimizations or development hints.',
> enum: [ 'development', 'production', 'none' ]
> },
> ModuleFilterItemTypes: {
> description: 'Filtering value, regexp or function.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: false },
> {
> instanceof: 'Function',
> tsType: "((name: string, module: import('../lib/stats/DefaultStatsFactoryPlugin').StatsModule, type: 'module' | 'chunk' | 'root-of-chunk' | 'nested') => boolean)"
> }
> ]
> },
> ModuleFilterTypes: {
> description: 'Filtering modules.',
> cli: { helper: true },
> anyOf: [
> { type: 'array', items: [Object] },
> { '$ref': '#/definitions/ModuleFilterItemTypes' }
> ]
> },
> ModuleOptions: {
> description: 'Options affecting the normal modules (`NormalModuleFactory`).',
> type: 'object',
> additionalProperties: false,
> properties: {
> defaultRules: {
> description: 'An array of rules applied by default for modules.',
> cli: [Object],
> oneOf: [Array]
> },
> exprContextCritical: {
> description: 'Enable warnings for full dynamic dependencies.',
> type: 'boolean'
> },
> exprContextRecursive: {
> description: "Enable recursive directory lookup for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRecursive'.",
> type: 'boolean'
> },
> exprContextRegExp: {
> description: "Sets the default regular expression for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRegExp'.",
> anyOf: [Array]
> },
> exprContextRequest: {
> description: "Set the default request for full dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.exprContextRequest'.",
> type: 'string'
> },
> generator: { '$ref': '#/definitions/GeneratorOptionsByModuleType' },
> noParse: { '$ref': '#/definitions/NoParse' },
> parser: { '$ref': '#/definitions/ParserOptionsByModuleType' },
> rules: {
> description: 'An array of rules applied for modules.',
> oneOf: [Array]
> },
> strictExportPresence: {
> description: "Emit errors instead of warnings when imported names don't exist in imported module. Deprecated: This option has moved to 'module.parser.javascript.strictExportPresence'.",
> type: 'boolean'
> },
> strictThisContextOnImports: {
> description: "Handle the this context correctly according to the spec for namespace objects. Deprecated: This option has moved to 'module.parser.javascript.strictThisContextOnImports'.",
> type: 'boolean'
> },
> unknownContextCritical: {
> description: "Enable warnings when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextCritical'.",
> type: 'boolean'
> },
> unknownContextRecursive: {
> description: "Enable recursive directory lookup when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRecursive'.",
> type: 'boolean'
> },
> unknownContextRegExp: {
> description: "Sets the regular expression when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRegExp'.",
> anyOf: [Array]
> },
> unknownContextRequest: {
> description: "Sets the request when using the require function in a not statically analyse-able way. Deprecated: This option has moved to 'module.parser.javascript.unknownContextRequest'.",
> type: 'string'
> },
> unsafeCache: {
> description: 'Cache the resolving of module requests.',
> anyOf: [Array]
> },
> wrappedContextCritical: {
> description: "Enable warnings for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextCritical'.",
> type: 'boolean'
> },
> wrappedContextRecursive: {
> description: "Enable recursive directory lookup for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRecursive'.",
> type: 'boolean'
> },
> wrappedContextRegExp: {
> description: "Set the inner regular expression for partial dynamic dependencies. Deprecated: This option has moved to 'module.parser.javascript.wrappedContextRegExp'.",
> instanceof: 'RegExp',
> tsType: 'RegExp'
> }
> }
> },
> ModuleOptionsNormalized: {
> description: 'Options affecting the normal modules (`NormalModuleFactory`).',
> type: 'object',
> additionalProperties: false,
> properties: {
> defaultRules: {
> description: 'An array of rules applied by default for modules.',
> cli: [Object],
> oneOf: [Array]
> },
> generator: { '$ref': '#/definitions/GeneratorOptionsByModuleType' },
> noParse: { '$ref': '#/definitions/NoParse' },
> parser: { '$ref': '#/definitions/ParserOptionsByModuleType' },
> rules: {
> description: 'An array of rules applied for modules.',
> oneOf: [Array]
> },
> unsafeCache: {
> description: 'Cache the resolving of module requests.',
> anyOf: [Array]
> }
> },
> required: [ 'defaultRules', 'generator', 'parser', 'rules' ]
> },
> Name: {
> description: 'Name of the configuration. Used when loading multiple configurations.',
> type: 'string'
> },
> NoParse: {
> description: "Don't parse files matching. It's matched against the full resolved request.",
> anyOf: [
> { type: 'array', items: [Object], minItems: 1 },
> {
> description: 'A regular expression, when matched the module is not parsed.',
> instanceof: 'RegExp',
> tsType: 'RegExp'
> },
> {
> description: 'An absolute path, when the module starts with this path it is not parsed.',
> type: 'string',
> absolutePath: true
> },
> { instanceof: 'Function', tsType: 'Function' }
> ]
> },
> Node: {
> description: 'Include polyfills or mocks for various node stuff.',
> anyOf: [ { enum: [Array] }, { '$ref': '#/definitions/NodeOptions' } ]
> },
> NodeOptions: {
> description: 'Options object for node compatibility features.',
> type: 'object',
> additionalProperties: false,
> properties: {
> __dirname: {
> description: "Include a polyfill for the '__dirname' variable.",
> enum: [Array]
> },
> __filename: {
> description: "Include a polyfill for the '__filename' variable.",
> enum: [Array]
> },
> global: {
> description: "Include a polyfill for the 'global' variable.",
> enum: [Array]
> }
> }
> },
> Optimization: {
> description: 'Enables/Disables integrated optimizations.',
> type: 'object',
> additionalProperties: false,
> properties: {
> checkWasmTypes: {
> description: 'Check for incompatible wasm types when importing/exporting from/to ESM.',
> type: 'boolean'
> },
> chunkIds: {
> description: 'Define the algorithm to choose chunk ids (named: readable ids for better debugging, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, total-size: numeric ids focused on minimal total download size, false: no algorithm used, as custom one can be provided via plugin).',
> enum: [Array]
> },
> concatenateModules: {
> description: 'Concatenate modules when possible to generate less modules, more efficient code and enable more optimizations by the minimizer.',
> type: 'boolean'
> },
> emitOnErrors: {
> description: 'Emit assets even when errors occur. Critical errors are emitted into the generated code and will cause errors at runtime.',
> type: 'boolean'
> },
> flagIncludedChunks: {
> description: 'Also flag chunks as loaded which contain a subset of the modules.',
> type: 'boolean'
> },
> innerGraph: {
> description: 'Creates a module-internal dependency graph for top level symbols, exports and imports, to improve unused exports detection.',
> type: 'boolean'
> },
> mangleExports: {
> description: 'Rename exports when possible to generate shorter code (depends on optimization.usedExports and optimization.providedExports, true/"deterministic": generate short deterministic names optimized for caching, "size": generate the shortest possible names).',
> anyOf: [Array]
> },
> mangleWasmImports: {
> description: 'Reduce size of WASM by changing imports to shorter strings.',
> type: 'boolean'
> },
> mergeDuplicateChunks: {
> description: 'Merge chunks which contain the same modules.',
> type: 'boolean'
> },
> minimize: {
> description: 'Enable minimizing the output. Uses optimization.minimizer.',
> type: 'boolean'
> },
> minimizer: {
> description: 'Minimizer(s) to use for minimizing the output.',
> type: 'array',
> cli: [Object],
> items: [Object]
> },
> moduleIds: {
> description: 'Define the algorithm to choose module ids (natural: numeric ids in order of usage, named: readable ids for better debugging, hashed: (deprecated) short hashes as ids for better long term caching, deterministic: numeric hash ids for better long term caching, size: numeric ids focused on minimal initial download size, false: no algorithm used, as custom one can be provided via plugin).',
> enum: [Array]
> },
> noEmitOnErrors: {
> description: "Avoid emitting assets when errors occur (deprecated: use 'emitOnErrors' instead).",
> type: 'boolean',
> cli: [Object]
> },
> nodeEnv: {
> description: 'Set process.env.NODE_ENV to a specific value.',
> anyOf: [Array]
> },
> portableRecords: {
> description: 'Generate records with relative paths to be able to move the context folder.',
> type: 'boolean'
> },
> providedExports: {
> description: 'Figure out which exports are provided by modules to generate more efficient code.',
> type: 'boolean'
> },
> realContentHash: {
> description: 'Use real [contenthash] based on final content of the assets.',
> type: 'boolean'
> },
> removeAvailableModules: {
> description: 'Removes modules from chunks when these modules are already included in all parents.',
> type: 'boolean'
> },
> removeEmptyChunks: {
> description: 'Remove chunks which are empty.',
> type: 'boolean'
> },
> runtimeChunk: { '$ref': '#/definitions/OptimizationRuntimeChunk' },
> sideEffects: {
> description: "Skip over modules which contain no side effects when exports are not used (false: disabled, 'flag': only use manually placed side effects flag, true: also analyse source code for side effects).",
> anyOf: [Array]
> },
> splitChunks: {
> description: 'Optimize duplication and caching by splitting chunks by shared modules and cache group.',
> anyOf: [Array]
> },
> usedExports: {
> description: 'Figure out which exports are used by modules to mangle export names, omit unused exports and generate more efficient code (true: analyse used exports for each runtime, "global": analyse exports globally for all runtimes combined).',
> anyOf: [Array]
> }
> }
> },
> OptimizationRuntimeChunk: {
> description: 'Create an additional chunk which contains only the webpack runtime and chunk hash maps.',
> anyOf: [
> { enum: [Array] },
> { type: 'boolean' },
> {
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> }
> ]
> },
> OptimizationRuntimeChunkNormalized: {
> description: 'Create an additional chunk which contains only the webpack runtime and chunk hash maps.',
> anyOf: [
> { enum: [Array] },
> {
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> }
> ]
> },
> OptimizationSplitChunksCacheGroup: {
> description: 'Options object for describing behavior of a cache group selecting modules that should be cached together.',
> type: 'object',
> additionalProperties: false,
> properties: {
> automaticNameDelimiter: {
> description: 'Sets the name delimiter for created chunks.',
> type: 'string',
> minLength: 1
> },
> chunks: {
> description: 'Select chunks for determining cache group content (defaults to "initial", "initial" and "all" requires adding these chunks to the HTML).',
> anyOf: [Array]
> },
> enforce: {
> description: 'Ignore minimum size, minimum chunks and maximum requests and always create chunks for this cache group.',
> type: 'boolean'
> },
> enforceSizeThreshold: {
> description: 'Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.',
> oneOf: [Array]
> },
> filename: {
> description: 'Sets the template for the filename for created chunks.',
> anyOf: [Array]
> },
> idHint: {
> description: 'Sets the hint for chunk id.',
> type: 'string'
> },
> layer: {
> description: 'Assign modules to a cache group by module layer.',
> anyOf: [Array]
> },
> maxAsyncRequests: {
> description: 'Maximum number of requests which are accepted for on-demand loading.',
> type: 'number',
> minimum: 1
> },
> maxAsyncSize: {
> description: 'Maximal size hint for the on-demand chunks.',
> oneOf: [Array]
> },
> maxInitialRequests: {
> description: 'Maximum number of initial chunks which are accepted for an entry point.',
> type: 'number',
> minimum: 1
> },
> maxInitialSize: {
> description: 'Maximal size hint for the initial chunks.',
> oneOf: [Array]
> },
> maxSize: {
> description: 'Maximal size hint for the created chunks.',
> oneOf: [Array]
> },
> minChunks: {
> description: "Minimum number of times a module has to be duplicated until it's considered for splitting.",
> type: 'number',
> minimum: 1
> },
> minRemainingSize: {
> description: 'Minimal size for the chunks the stay after moving the modules to a new chunk.',
> oneOf: [Array]
> },
> minSize: {
> description: 'Minimal size for the created chunk.',
> oneOf: [Array]
> },
> minSizeReduction: {
> description: 'Minimum size reduction due to the created chunk.',
> oneOf: [Array]
> },
> name: {
> description: 'Give chunks for this cache group a name (chunks with equal name are merged).',
> anyOf: [Array]
> },
> priority: {
> description: 'Priority of this cache group.',
> type: 'number'
> },
> reuseExistingChunk: {
> description: 'Try to reuse existing chunk (with name) when it has matching modules.',
> type: 'boolean'
> },
> test: {
> description: 'Assign modules to a cache group by module name.',
> anyOf: [Array]
> },
> type: {
> description: 'Assign modules to a cache group by module type.',
> anyOf: [Array]
> },
> usedExports: {
> description: 'Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.',
> type: 'boolean'
> }
> }
> },
> OptimizationSplitChunksGetCacheGroups: {
> description: 'A function returning cache groups.',
> instanceof: 'Function',
> tsType: "((module: import('../lib/Module')) => OptimizationSplitChunksCacheGroup | OptimizationSplitChunksCacheGroup[] | void)"
> },
> OptimizationSplitChunksOptions: {
> description: 'Options object for splitting chunks into smaller chunks.',
> type: 'object',
> additionalProperties: false,
> properties: {
> automaticNameDelimiter: {
> description: 'Sets the name delimiter for created chunks.',
> type: 'string',
> minLength: 1
> },
> cacheGroups: {
> description: "Assign modules to a cache group (modules from different cache groups are tried to keep in separate chunks, default categories: 'default', 'defaultVendors').",
> type: 'object',
> additionalProperties: [Object],
> not: [Object]
> },
> chunks: {
> description: 'Select chunks for determining shared modules (defaults to "async", "initial" and "all" requires adding these chunks to the HTML).',
> anyOf: [Array]
> },
> defaultSizeTypes: {
> description: 'Sets the size types which are used when a number is used for sizes.',
> type: 'array',
> items: [Object],
> minItems: 1
> },
> enforceSizeThreshold: {
> description: 'Size threshold at which splitting is enforced and other restrictions (minRemainingSize, maxAsyncRequests, maxInitialRequests) are ignored.',
> oneOf: [Array]
> },
> fallbackCacheGroup: {
> description: 'Options for modules not selected by any other cache group.',
> type: 'object',
> additionalProperties: false,
> properties: [Object]
> },
> filename: {
> description: 'Sets the template for the filename for created chunks.',
> anyOf: [Array]
> },
> hidePathInfo: {
> description: 'Prevents exposing path info when creating names for parts splitted by maxSize.',
> type: 'boolean'
> },
> maxAsyncRequests: {
> description: 'Maximum number of requests which are accepted for on-demand loading.',
> type: 'number',
> minimum: 1
> },
> maxAsyncSize: {
> description: 'Maximal size hint for the on-demand chunks.',
> oneOf: [Array]
> },
> maxInitialRequests: {
> description: 'Maximum number of initial chunks which are accepted for an entry point.',
> type: 'number',
> minimum: 1
> },
> maxInitialSize: {
> description: 'Maximal size hint for the initial chunks.',
> oneOf: [Array]
> },
> maxSize: {
> description: 'Maximal size hint for the created chunks.',
> oneOf: [Array]
> },
> minChunks: {
> description: "Minimum number of times a module has to be duplicated until it's considered for splitting.",
> type: 'number',
> minimum: 1
> },
> minRemainingSize: {
> description: 'Minimal size for the chunks the stay after moving the modules to a new chunk.',
> oneOf: [Array]
> },
> minSize: {
> description: 'Minimal size for the created chunks.',
> oneOf: [Array]
> },
> minSizeReduction: {
> description: 'Minimum size reduction due to the created chunk.',
> oneOf: [Array]
> },
> name: {
> description: 'Give chunks created a name (chunks with equal name are merged).',
> anyOf: [Array]
> },
> usedExports: {
> description: 'Compare used exports when checking common modules. Modules will only be put in the same chunk when exports are equal.',
> type: 'boolean'
> }
> }
> },
> OptimizationSplitChunksSizes: {
> description: 'Size description for limits.',
> anyOf: [
> {
> description: 'Size of the javascript part of the chunk.',
> type: 'number',
> minimum: 0
> },
> {
> description: 'Specify size limits per size type.',
> type: 'object',
> additionalProperties: [Object]
> }
> ]
> },
> Output: {
> description: 'Options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.',
> type: 'object',
> additionalProperties: false,
> properties: {
> assetModuleFilename: { '$ref': '#/definitions/AssetModuleFilename' },
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are loaded on demand.',
> type: 'boolean'
> },
> auxiliaryComment: { cli: [Object], oneOf: [Array] },
> charset: { '$ref': '#/definitions/Charset' },
> chunkFilename: { '$ref': '#/definitions/ChunkFilename' },
> chunkFormat: { '$ref': '#/definitions/ChunkFormat' },
> chunkLoadTimeout: { '$ref': '#/definitions/ChunkLoadTimeout' },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> chunkLoadingGlobal: { '$ref': '#/definitions/ChunkLoadingGlobal' },
> clean: { '$ref': '#/definitions/Clean' },
> compareBeforeEmit: { '$ref': '#/definitions/CompareBeforeEmit' },
> crossOriginLoading: { '$ref': '#/definitions/CrossOriginLoading' },
> devtoolFallbackModuleFilenameTemplate: {
> '$ref': '#/definitions/DevtoolFallbackModuleFilenameTemplate'
> },
> devtoolModuleFilenameTemplate: { '$ref': '#/definitions/DevtoolModuleFilenameTemplate' },
> devtoolNamespace: { '$ref': '#/definitions/DevtoolNamespace' },
> enabledChunkLoadingTypes: { '$ref': '#/definitions/EnabledChunkLoadingTypes' },
> enabledLibraryTypes: { '$ref': '#/definitions/EnabledLibraryTypes' },
> enabledWasmLoadingTypes: { '$ref': '#/definitions/EnabledWasmLoadingTypes' },
> environment: { '$ref': '#/definitions/Environment' },
> filename: { '$ref': '#/definitions/Filename' },
> globalObject: { '$ref': '#/definitions/GlobalObject' },
> hashDigest: { '$ref': '#/definitions/HashDigest' },
> hashDigestLength: { '$ref': '#/definitions/HashDigestLength' },
> hashFunction: { '$ref': '#/definitions/HashFunction' },
> hashSalt: { '$ref': '#/definitions/HashSalt' },
> hotUpdateChunkFilename: { '$ref': '#/definitions/HotUpdateChunkFilename' },
> hotUpdateGlobal: { '$ref': '#/definitions/HotUpdateGlobal' },
> hotUpdateMainFilename: { '$ref': '#/definitions/HotUpdateMainFilename' },
> iife: { '$ref': '#/definitions/Iife' },
> importFunctionName: { '$ref': '#/definitions/ImportFunctionName' },
> importMetaName: { '$ref': '#/definitions/ImportMetaName' },
> library: { '$ref': '#/definitions/Library' },
> libraryExport: { cli: [Object], oneOf: [Array] },
> libraryTarget: { cli: [Object], oneOf: [Array] },
> module: { '$ref': '#/definitions/OutputModule' },
> path: { '$ref': '#/definitions/Path' },
> pathinfo: { '$ref': '#/definitions/Pathinfo' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> scriptType: { '$ref': '#/definitions/ScriptType' },
> sourceMapFilename: { '$ref': '#/definitions/SourceMapFilename' },
> sourcePrefix: { '$ref': '#/definitions/SourcePrefix' },
> strictModuleErrorHandling: { '$ref': '#/definitions/StrictModuleErrorHandling' },
> strictModuleExceptionHandling: { '$ref': '#/definitions/StrictModuleExceptionHandling' },
> trustedTypes: {
> description: "Use a Trusted Types policy to create urls for chunks. 'output.uniqueName' is used a default policy name. Passing a string sets a custom policy name.",
> anyOf: [Array]
> },
> umdNamedDefine: { cli: [Object], oneOf: [Array] },
> uniqueName: { '$ref': '#/definitions/UniqueName' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' },
> webassemblyModuleFilename: { '$ref': '#/definitions/WebassemblyModuleFilename' },
> workerChunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> workerWasmLoading: { '$ref': '#/definitions/WasmLoading' }
> }
> },
> OutputModule: {
> description: 'Output javascript files as module source type.',
> type: 'boolean'
> },
> OutputNormalized: {
> description: 'Normalized options affecting the output of the compilation. `output` options tell webpack how to write the compiled files to disk.',
> type: 'object',
> additionalProperties: false,
> properties: {
> assetModuleFilename: { '$ref': '#/definitions/AssetModuleFilename' },
> asyncChunks: {
> description: 'Enable/disable creating async chunks that are loaded on demand.',
> type: 'boolean'
> },
> charset: { '$ref': '#/definitions/Charset' },
> chunkFilename: { '$ref': '#/definitions/ChunkFilename' },
> chunkFormat: { '$ref': '#/definitions/ChunkFormat' },
> chunkLoadTimeout: { '$ref': '#/definitions/ChunkLoadTimeout' },
> chunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> chunkLoadingGlobal: { '$ref': '#/definitions/ChunkLoadingGlobal' },
> clean: { '$ref': '#/definitions/Clean' },
> compareBeforeEmit: { '$ref': '#/definitions/CompareBeforeEmit' },
> crossOriginLoading: { '$ref': '#/definitions/CrossOriginLoading' },
> devtoolFallbackModuleFilenameTemplate: {
> '$ref': '#/definitions/DevtoolFallbackModuleFilenameTemplate'
> },
> devtoolModuleFilenameTemplate: { '$ref': '#/definitions/DevtoolModuleFilenameTemplate' },
> devtoolNamespace: { '$ref': '#/definitions/DevtoolNamespace' },
> enabledChunkLoadingTypes: { '$ref': '#/definitions/EnabledChunkLoadingTypes' },
> enabledLibraryTypes: { '$ref': '#/definitions/EnabledLibraryTypes' },
> enabledWasmLoadingTypes: { '$ref': '#/definitions/EnabledWasmLoadingTypes' },
> environment: { '$ref': '#/definitions/Environment' },
> filename: { '$ref': '#/definitions/Filename' },
> globalObject: { '$ref': '#/definitions/GlobalObject' },
> hashDigest: { '$ref': '#/definitions/HashDigest' },
> hashDigestLength: { '$ref': '#/definitions/HashDigestLength' },
> hashFunction: { '$ref': '#/definitions/HashFunction' },
> hashSalt: { '$ref': '#/definitions/HashSalt' },
> hotUpdateChunkFilename: { '$ref': '#/definitions/HotUpdateChunkFilename' },
> hotUpdateGlobal: { '$ref': '#/definitions/HotUpdateGlobal' },
> hotUpdateMainFilename: { '$ref': '#/definitions/HotUpdateMainFilename' },
> iife: { '$ref': '#/definitions/Iife' },
> importFunctionName: { '$ref': '#/definitions/ImportFunctionName' },
> importMetaName: { '$ref': '#/definitions/ImportMetaName' },
> library: { '$ref': '#/definitions/LibraryOptions' },
> module: { '$ref': '#/definitions/OutputModule' },
> path: { '$ref': '#/definitions/Path' },
> pathinfo: { '$ref': '#/definitions/Pathinfo' },
> publicPath: { '$ref': '#/definitions/PublicPath' },
> scriptType: { '$ref': '#/definitions/ScriptType' },
> sourceMapFilename: { '$ref': '#/definitions/SourceMapFilename' },
> sourcePrefix: { '$ref': '#/definitions/SourcePrefix' },
> strictModuleErrorHandling: { '$ref': '#/definitions/StrictModuleErrorHandling' },
> strictModuleExceptionHandling: { '$ref': '#/definitions/StrictModuleExceptionHandling' },
> trustedTypes: { '$ref': '#/definitions/TrustedTypes' },
> uniqueName: { '$ref': '#/definitions/UniqueName' },
> wasmLoading: { '$ref': '#/definitions/WasmLoading' },
> webassemblyModuleFilename: { '$ref': '#/definitions/WebassemblyModuleFilename' },
> workerChunkLoading: { '$ref': '#/definitions/ChunkLoading' },
> workerWasmLoading: { '$ref': '#/definitions/WasmLoading' }
> }
> },
> Parallelism: {
> description: 'The number of parallel processed modules in the compilation.',
> type: 'number',
> minimum: 1
> },
> ParserOptionsByModuleType: {
> description: 'Specify options for each parser.',
> type: 'object',
> additionalProperties: {
> description: 'Options for parsing.',
> type: 'object',
> additionalProperties: true
> },
> properties: {
> asset: { '$ref': '#/definitions/AssetParserOptions' },
> 'asset/inline': { '$ref': '#/definitions/EmptyParserOptions' },
> 'asset/resource': { '$ref': '#/definitions/EmptyParserOptions' },
> 'asset/source': { '$ref': '#/definitions/EmptyParserOptions' },
> javascript: { '$ref': '#/definitions/JavascriptParserOptions' },
> 'javascript/auto': { '$ref': '#/definitions/JavascriptParserOptions' },
> 'javascript/dynamic': { '$ref': '#/definitions/JavascriptParserOptions' },
> 'javascript/esm': { '$ref': '#/definitions/JavascriptParserOptions' }
> }
> },
> Path: {
> description: 'The output directory as **absolute path** (required).',
> type: 'string',
> absolutePath: true
> },
> Pathinfo: {
> description: 'Include comments with information about the modules.',
> anyOf: [ { enum: [Array] }, { type: 'boolean' } ]
> },
> Performance: {
> description: 'Configuration for web performance recommendations.',
> anyOf: [
> { enum: [Array] },
> { '$ref': '#/definitions/PerformanceOptions' }
> ]
> },
> PerformanceOptions: {
> description: 'Configuration object for web performance recommendations.',
> type: 'object',
> additionalProperties: false,
> properties: {
> assetFilter: {
> description: 'Filter function to select assets that are checked.',
> instanceof: 'Function',
> tsType: 'Function'
> },
> hints: {
> description: 'Sets the format of the hints: warnings, errors or nothing at all.',
> enum: [Array]
> },
> maxAssetSize: {
> description: 'File size limit (in bytes) when exceeded, that webpack will provide performance hints.',
> type: 'number'
> },
> maxEntrypointSize: {
> description: 'Total size of an entry point (in bytes).',
> type: 'number'
> }
> }
> },
> Plugins: {
> description: 'Add additional plugins to the compiler.',
> type: 'array',
> items: {
> description: 'Plugin of type object or instanceof Function.',
> anyOf: [ [Object], [Object] ]
> }
> },
> Profile: {
> description: 'Capture timing information for each module.',
> type: 'boolean'
> },
> PublicPath: {
> description: "The 'publicPath' specifies the public URL address of the output files when referenced in a browser.",
> anyOf: [
> { enum: [Array] },
> { '$ref': '#/definitions/RawPublicPath' }
> ]
> },
> RawPublicPath: {
> description: "The 'publicPath' specifies the public URL address of the output files when referenced in a browser.",
> anyOf: [
> { type: 'string' },
> {
> instanceof: 'Function',
> tsType: '((pathData: import("../lib/Compilation").PathData, assetInfo?: import("../lib/Compilation").AssetInfo) => string)'
> }
> ]
> },
> RecordsInputPath: {
> description: 'Store compiler state to a json file.',
> anyOf: [ { enum: [Array] }, { type: 'string', absolutePath: true } ]
> },
> RecordsOutputPath: {
> description: 'Load compiler state from a json file.',
> anyOf: [ { enum: [Array] }, { type: 'string', absolutePath: true } ]
> },
> RecordsPath: {
> description: 'Store/Load compiler state from/to a json file. This will result in persistent ids of modules and chunks. An absolute path is expected. `recordsPath` is used for `recordsInputPath` and `recordsOutputPath` if they left undefined.',
> anyOf: [ { enum: [Array] }, { type: 'string', absolutePath: true } ]
> },
> Resolve: {
> description: 'Options for the resolver.',
> oneOf: [ { '$ref': '#/definitions/ResolveOptions' } ]
> },
> ResolveAlias: {
> description: 'Redirect module requests.',
> anyOf: [
> { type: 'array', items: [Object] },
> { type: 'object', additionalProperties: [Object] }
> ]
> },
> ResolveLoader: {
> description: 'Options for the resolver when resolving loaders.',
> oneOf: [ { '$ref': '#/definitions/ResolveOptions' } ]
> },
> ResolveOptions: {
> description: 'Options object for resolving requests.',
> type: 'object',
> additionalProperties: false,
> properties: {
> alias: { '$ref': '#/definitions/ResolveAlias' },
> aliasFields: {
> description: 'Fields in the description file (usually package.json) which are used to redirect requests inside the module.',
> type: 'array',
> items: [Object]
> },
> byDependency: {
> description: 'Extra resolve options per dependency category. Typical categories are "commonjs", "amd", "esm".',
> type: 'object',
> additionalProperties: [Object]
> },
> cache: {
> description: 'Enable caching of successfully resolved requests (cache entries are revalidated).',
> type: 'boolean'
> },
> cachePredicate: {
> description: 'Predicate function to decide which requests should be cached.',
> instanceof: 'Function',
> tsType: "((request: import('enhanced-resolve').ResolveRequest) => boolean)"
> },
> cacheWithContext: {
> description: 'Include the context information in the cache identifier when caching.',
> type: 'boolean'
> },
> conditionNames: {
> description: 'Condition names for exports field entry point.',
> type: 'array',
> items: [Object]
> },
> descriptionFiles: {
> description: 'Filenames used to find a description file (like a package.json).',
> type: 'array',
> items: [Object]
> },
> enforceExtension: {
> description: 'Enforce the resolver to use one of the extensions from the extensions option (User must specify requests without extension).',
> type: 'boolean'
> },
> exportsFields: {
> description: 'Field names from the description file (usually package.json) which are used to provide entry points of a package.',
> type: 'array',
> items: [Object]
> },
> extensions: {
> description: 'Extensions added to the request when trying to find the file.',
> type: 'array',
> items: [Object]
> },
> fallback: {
> description: 'Redirect module requests when normal resolving fails.',
> oneOf: [Array]
> },
> fileSystem: {
> description: 'Filesystem for the resolver.',
> tsType: "(import('../lib/util/fs').InputFileSystem)"
> },
> fullySpecified: {
> description: "Treats the request specified by the user as fully specified, meaning no extensions are added and the mainFiles in directories are not resolved (This doesn't affect requests from mainFields, aliasFields or aliases).",
> type: 'boolean'
> },
> importsFields: {
> description: 'Field names from the description file (usually package.json) which are used to provide internal request of a package (requests starting with # are considered as internal).',
> type: 'array',
> items: [Object]
> },
> mainFields: {
> description: 'Field names from the description file (package.json) which are used to find the default entry point.',
> type: 'array',
> items: [Object]
> },
> mainFiles: {
> description: 'Filenames used to find the default entry point if there is no description file or main field.',
> type: 'array',
> items: [Object]
> },
> modules: {
> description: 'Folder names or directory paths where to find modules.',
> type: 'array',
> items: [Object]
> },
> plugins: {
> description: 'Plugins for the resolver.',
> type: 'array',
> cli: [Object],
> items: [Object]
> },
> preferAbsolute: {
> description: "Prefer to resolve server-relative URLs (starting with '/') as absolute paths before falling back to resolve in 'resolve.roots'.",
> type: 'boolean'
> },
> preferRelative: {
> description: 'Prefer to resolve module requests as relative request and fallback to resolving as module.',
> type: 'boolean'
> },
> resolver: {
> description: 'Custom resolver.',
> tsType: "(import('enhanced-resolve').Resolver)"
> },
> restrictions: {
> description: 'A list of resolve restrictions. Resolve results must fulfill all of these restrictions to resolve successfully. Other resolve paths are taken when restrictions are not met.',
> type: 'array',
> items: [Object]
> },
> roots: {
> description: "A list of directories in which requests that are server-relative URLs (starting with '/') are resolved.",
> type: 'array',
> items: [Object]
> },
> symlinks: {
> description: 'Enable resolving symlinks to the original location.',
> type: 'boolean'
> },
> unsafeCache: {
> description: 'Enable caching of successfully resolved requests (cache entries are not revalidated).',
> anyOf: [Array]
> },
> useSyncFileSystemCalls: {
> description: 'Use synchronous filesystem calls for the resolver.',
> type: 'boolean'
> }
> }
> },
> ResolvePluginInstance: {
> description: 'Plugin instance.',
> type: 'object',
> additionalProperties: true,
> properties: {
> apply: {
> description: 'The run point of the plugin, required method.',
> instanceof: 'Function',
> tsType: "(resolver: import('enhanced-resolve').Resolver) => void"
> }
> },
> required: [ 'apply' ]
> },
> RuleSetCondition: {
> description: 'A condition matcher.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string' },
> {
> instanceof: 'Function',
> tsType: '((value: string) => boolean)'
> },
> { '$ref': '#/definitions/RuleSetLogicalConditions' },
> { '$ref': '#/definitions/RuleSetConditions' }
> ]
> },
> RuleSetConditionAbsolute: {
> description: 'A condition matcher matching an absolute path.',
> cli: { helper: true },
> anyOf: [
> { instanceof: 'RegExp', tsType: 'RegExp' },
> { type: 'string', absolutePath: true },
> {
> instanceof: 'Function',
> tsType: '((value: string) => boolean)'
> },
> { '$ref': '#/definitions/RuleSetLogicalConditionsAbsolute' },
> { '$ref': '#/definitions/RuleSetConditionsAbsolute' }
> ]
> },
> RuleSetConditiomake[1]: *** [debian/rules:14: override_dh_auto_build] Error 1
> make[1]: Leaving directory '/<<PKGBUILDDIR>>'
> make: *** [debian/rules:5: binary] Error 2
The full build log is available from:
http://qa-logs.debian.net/2022/05/25/node-core-js_3.22.5-1_unstable.log
All bugs filed during this archive rebuild are listed at:
https://bugs.debian.org/cgi-bin/pkgreport.cgi?tag=ftbfs-20220525;users=lucas@debian.org
or:
https://udd.debian.org/bugs/?release=na&merged=ign&fnewerval=7&flastmodval=7&fusertag=only&fusertagtag=ftbfs-20220525&fusertaguser=lucas@debian.org&allbugs=1&cseverity=1&ctags=1&caffected=1#results
A list of current common problems and possible solutions is available at
http://wiki.debian.org/qa.debian.org/FTBFS . You're welcome to contribute!
If you reassign this bug to another package, please marking it as 'affects'-ing
this package. See https://www.debian.org/Bugs/server-control#affects
If you fail to reproduce this, please provide a build log and diff it with mine
so that we can identify if something relevant changed in the meantime.
More information about the Pkg-javascript-devel
mailing list