webpack.web.JsonpChunkLoadingRuntimeModule

• {RuntimeModule}

new JsonpChunkLoadingRuntimeModule(runtimeRequirements): void

• runtimeRequirements {ReadonlySet} runtime requirements
• Returns: {JsonpChunkLoadingRuntimeModule}

• blocks {AsyncDependenciesBlock[]}
• buildInfo {BuildInfo}
• buildMeta {BuildMeta}
• chunk {Chunk}
• chunkGraph {ChunkGraph}
• chunksIterable {Iterable}
• codeGenerationDependencies {Dependency[]}
• compilation {Compilation}
• context <string>
• debugId <number>
• dependencies {Dependency[]}
• dependentHash <boolean>
• depth <number>
• errors <any>
• exportsArgument <string>
• factoryMeta {FactoryMeta}
• fullHash <boolean>
• hasEqualsChunks <any>
• hash <string>
• hot <boolean>
• id <string> | <number>
• index <number>
• index2 <number>
• issuer {Module}
• isUsed <any>
• layer <string>
• moduleArgument <string>
• name <string>
• needId <boolean>
• optimizationBailout <string> | <object[]>
• optional <boolean>
• parent {DependenciesBlock}
• presentationalDependencies {Dependency[]}
• profile {ModuleProfile}
• renderedHash <string>
• resolveOptions {ResolveOptions}
• stage <number>
• type <string>
• used <any>
• usedExports {boolean|SortableSet}
• useSimpleSourceMap <boolean>
• useSourceMap <boolean>
• warnings <any>
• STAGE_ATTACH <number> Runtime modules which attach to handlers of other runtime modules
• STAGE_BASIC <number> Runtime modules with simple dependencies on other runtime modules
• STAGE_NORMAL <number> Runtime modules without any dependencies to other runtime modules
• STAGE_TRIGGER <number> Runtime modules which trigger actions on bootstrap

webpack.web.JsonpChunkLoadingRuntimeModule.addBlock(block): void

• block {AsyncDependenciesBlock}
• Returns: {void}

Adds a DependencyBlock to DependencyBlock relationship. This is used for when a Module has a AsyncDependencyBlock tie (for code-splitting)

webpack.web.JsonpChunkLoadingRuntimeModule.addCacheDependencies(fileDependencies, contextDependencies, missingDependencies, buildDependencies): void

• fileDependencies {LazySet} set where file dependencies are added to
• contextDependencies {LazySet} set where context dependencies are added to
• missingDependencies {LazySet} set where missing dependencies are added to
• buildDependencies {LazySet} set where build dependencies are added to
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.addChunk(chunk): void

• chunk {Chunk} the chunk
• Returns: <boolean> true, when the module was added

webpack.web.JsonpChunkLoadingRuntimeModule.addCodeGenerationDependency(codeGenerationDependency): void

• codeGenerationDependency {Dependency} dependency being tied to module. This is a Dependency where the code generation result of the referenced module is needed during code generation. The Dependency should also be added to normal dependencies via addDependency.
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.addDependency(dependency): void

• dependency {Dependency}
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.addError(error): void

• error {WebpackError} the error
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.addPresentationalDependency(presentationalDependency): void

• presentationalDependency {Dependency} dependency being tied to module. This is a Dependency without edge in the module graph. It's only for presentation.
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.addWarning(warning): void

• warning {WebpackError} the warning
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.attach(compilation, chunk, chunkGraph?): void

• compilation {Compilation} the compilation
• chunk {Chunk} the chunk
• chunkGraph {ChunkGraph} the chunk graph
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.build(options, compilation, resolver, fs, callback): void

• options {WebpackOptionsNormalizedWithDefaults} webpack options
• compilation {Compilation} the compilation
• resolver {ResolverWithOptions} the resolver
• fs {InputFileSystem} the file system
• callback <object> callback function
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.chunkCondition(chunk, compilation): void

• chunk {Chunk} the chunk which condition should be checked
• compilation {Compilation} the compilation
• Returns: <boolean> true if the module can be placed in the chunk

webpack.web.JsonpChunkLoadingRuntimeModule.cleanupForCache(): void

Assuming this module is in the cache. Remove internal references to allow freeing some memory.

webpack.web.JsonpChunkLoadingRuntimeModule.clearDependenciesAndBlocks(): void

Removes all dependencies and blocks

webpack.web.JsonpChunkLoadingRuntimeModule.clearWarningsAndErrors(): void

removes all warnings and errors

webpack.web.JsonpChunkLoadingRuntimeModule.codeGeneration(context): void

• context {CodeGenerationContext} context for code generation
• Returns: {CodeGenerationResult} result

webpack.web.JsonpChunkLoadingRuntimeModule.deserialize(__namedParameters): void

• __namedParameters {ObjectDeserializerContext} context
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.generate(): string

webpack.web.JsonpChunkLoadingRuntimeModule.getChunks(): Chunk[]

webpack.web.JsonpChunkLoadingRuntimeModule.getConcatenationBailoutReason(context): void

• context {ConcatenationBailoutReasonContext} context
• Returns: <string> reason why this module can't be concatenated, undefined when it can be concatenated

webpack.web.JsonpChunkLoadingRuntimeModule.getErrors(): Iterable<WebpackError, any, any>

webpack.web.JsonpChunkLoadingRuntimeModule.getExportsType(moduleGraph, strict?): void

• moduleGraph {ModuleGraph} the module graph
• strict <boolean> the importing module is strict
• Returns: {ExportsType} export type "namespace": Exports is already a namespace object. namespace = exports. "dynamic": Check at runtime if __esModule is set. When set: namespace = { ...exports, default: exports }. When not set: namespace = { default: exports }. "default-only": Provide a namespace object with only default export. namespace = { default: exports } "default-with-named": Provide a namespace object with named and default export. namespace = { ...exports, default: exports }

webpack.web.JsonpChunkLoadingRuntimeModule.getGeneratedCode(): string

webpack.web.JsonpChunkLoadingRuntimeModule.getNumberOfChunks(): number

webpack.web.JsonpChunkLoadingRuntimeModule.getNumberOfErrors(): number

webpack.web.JsonpChunkLoadingRuntimeModule.getNumberOfWarnings(): number

webpack.web.JsonpChunkLoadingRuntimeModule.getRootBlock(): DependenciesBlock

webpack.web.JsonpChunkLoadingRuntimeModule.getSideEffectsConnectionState(moduleGraph): void

• moduleGraph {ModuleGraph} the module graph
• Returns: {ConnectionState} how this module should be connected to referencing modules when consumed for side-effects only

webpack.web.JsonpChunkLoadingRuntimeModule.getSourceBasicTypes(): ReadonlySet<string>

Basic source types are high-level categories like javascript, css, webassembly, etc. We only have built-in knowledge about the javascript basic type here; other basic types may be added or changed over time by generators and do not need to be handled or detected here. Some modules, e.g. RemoteModule, may return non-basic source types like "remote" and "share-init" from getSourceTypes(), but their generated output is still JavaScript, i.e. their basic type is JS.

webpack.web.JsonpChunkLoadingRuntimeModule.getSourceTypes(): ReadonlySet<string>

webpack.web.JsonpChunkLoadingRuntimeModule.getUnsafeCacheData(): UnsafeCacheData

Module should be unsafe cached. Get data that's needed for that. This data will be passed to restoreFromUnsafeCache later.

webpack.web.JsonpChunkLoadingRuntimeModule.getWarnings(): Iterable<WebpackError, any, any>

webpack.web.JsonpChunkLoadingRuntimeModule.hasChunkCondition(): boolean

webpack.web.JsonpChunkLoadingRuntimeModule.hasReasonForChunk(chunk, moduleGraph, chunkGraph): void

• chunk {Chunk} a chunk
• moduleGraph {ModuleGraph} the module graph
• chunkGraph {ChunkGraph} the chunk graph
• Returns: <boolean> true, if the module has any reason why "chunk" should be included

webpack.web.JsonpChunkLoadingRuntimeModule.hasReasons(moduleGraph, runtime): void

• moduleGraph {ModuleGraph} the module graph
• runtime {RuntimeSpec} the runtime
• Returns: <boolean> true if at least one other module depends on this module

webpack.web.JsonpChunkLoadingRuntimeModule.identifier(): string

webpack.web.JsonpChunkLoadingRuntimeModule.invalidateBuild(): void

webpack.web.JsonpChunkLoadingRuntimeModule.isAccessibleInChunk(chunkGraph, chunk, ignoreChunk?): void

• chunkGraph {ChunkGraph} the chunk graph
• chunk {Chunk} a chunk
• ignoreChunk {Chunk} chunk to be ignored
• Returns: <boolean> true, if the module is accessible from "chunk" when ignoring "ignoreChunk"

webpack.web.JsonpChunkLoadingRuntimeModule.isAccessibleInChunkGroup(chunkGraph, chunkGroup, ignoreChunk?): void

• chunkGraph {ChunkGraph} the chunk graph
• chunkGroup {ChunkGroup} a chunk group
• ignoreChunk {Chunk} chunk to be ignored
• Returns: <boolean> true, if the module is accessible from "chunkGroup" when ignoring "ignoreChunk"

webpack.web.JsonpChunkLoadingRuntimeModule.isEntryModule(): boolean

webpack.web.JsonpChunkLoadingRuntimeModule.isInChunk(chunk): void

• chunk {Chunk} the chunk
• Returns: <boolean> true, when the module is in the chunk

webpack.web.JsonpChunkLoadingRuntimeModule.isOptional(moduleGraph): void

• moduleGraph {ModuleGraph} the module graph
• Returns: <boolean> true, if the module is optional

webpack.web.JsonpChunkLoadingRuntimeModule.isProvided(exportName): boolean

webpack.web.JsonpChunkLoadingRuntimeModule.libIdent(options): void

• options {LibIdentOptions} options
• Returns: <string> an identifier for library inclusion

webpack.web.JsonpChunkLoadingRuntimeModule.nameForCondition(): string

webpack.web.JsonpChunkLoadingRuntimeModule.needBuild(context, callback): void

• context {NeedBuildContext} context info
• callback <object> callback function, returns true, if the module needs a rebuild
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.needRebuild(fileTimestamps, contextTimestamps): void

• fileTimestamps {Map<string, number>}
• contextTimestamps {Map<string, number>}
• Returns: <boolean>

Use needBuild instead

webpack.web.JsonpChunkLoadingRuntimeModule.originalSource(): Source

webpack.web.JsonpChunkLoadingRuntimeModule.readableIdentifier(requestShortener): void

• requestShortener {RequestShortener} the request shortener
• Returns: <string> a user readable identifier of the module

webpack.web.JsonpChunkLoadingRuntimeModule.removeChunk(chunk): void

• chunk {Chunk} the chunk
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.removeDependency(dependency): void

• dependency {Dependency}
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.serialize(__namedParameters): void

• __namedParameters {ObjectSerializerContext} context
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.shouldIsolate(): boolean

webpack.web.JsonpChunkLoadingRuntimeModule.size(type?): number

webpack.web.JsonpChunkLoadingRuntimeModule.source(dependencyTemplates, runtimeTemplate, type?): void

• dependencyTemplates {DependencyTemplates}
• runtimeTemplate {RuntimeTemplate}
• type <string>
• Returns: {Source}

Use codeGeneration() instead

webpack.web.JsonpChunkLoadingRuntimeModule.updateCacheModule(module): void

• module {Module}
• Returns: {void}

Assuming this module is in the cache. Update the (cached) module with the fresh module from the factory. Usually updates internal references and properties.

webpack.web.JsonpChunkLoadingRuntimeModule.updateHash(hash, context): void

• hash {Hash} the hash used to track dependencies
• context {UpdateHashContextDependency} context
• Returns: {void}

webpack.web.JsonpChunkLoadingRuntimeModule.getCompilationHooks(compilation): void

• compilation {Compilation} the compilation
• Returns: {JsonpCompilationPluginHooks} hooks

webpack.web.JsonpChunkLoadingRuntimeModule.getSourceBasicTypes(module): void

• module {Module}
• Returns: {ReadonlySet}

In webpack 6, call getSourceBasicTypes() directly on the module instance instead of using this static method.