xhs-mp-pack 1.1.0-beta.0

package/dist/ids/NaturalChunkIdsPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparators_1 = require("@/base/comparators");
+const IdHelpers_1 = require("./IdHelpers");
+class NaturalChunkIdsPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('NaturalChunkIdsPlugin', compilation => {
+            compilation.hooks.chunkIds.tap('NaturalChunkIdsPlugin', chunks => {
+                const chunkGraph = compilation.chunkGraph;
+                const compareNatural = (0, comparators_1.compareChunksNatural)(chunkGraph);
+                const chunksInNaturalOrder = Array.from(chunks).sort(compareNatural);
+                (0, IdHelpers_1.assignAscendingChunkIds)(chunksInNaturalOrder, compilation);
+            });
+        });
+    }
+}
+exports.default = NaturalChunkIdsPlugin;

package/dist/ids/NaturalModuleIdsPlugin.d.ts

@@ -0,0 +1,4 @@
+declare class NaturalModuleIdsPlugin {
+    apply(compiler: any): void;
+}
+export default NaturalModuleIdsPlugin;

package/dist/ids/NaturalModuleIdsPlugin.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const comparators_1 = require("@/base/comparators");
+const IdHelpers_1 = require("./IdHelpers");
+class NaturalModuleIdsPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap('NaturalModuleIdsPlugin', compilation => {
+            compilation.hooks.moduleIds.tap('NaturalModuleIdsPlugin', modules => {
+                const [usedIds, modulesInNaturalOrder] = (0, IdHelpers_1.getUsedModuleIdsAndModules)(compilation);
+                modulesInNaturalOrder.sort((0, comparators_1.compareModulesByPreOrderIndexOrIdentifier)(compilation.moduleGraph));
+                (0, IdHelpers_1.assignAscendingModuleIds)(usedIds, modulesInNaturalOrder, compilation);
+            });
+        });
+    }
+}
+exports.default = NaturalModuleIdsPlugin;

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import './base/moduleAlias';
+import Config from 'webpack-chain';
+import { Resolver } from 'enhanced-resolve';
+import BaseError from './base/errors/BaseError';
+import { readFile, stat, throttleAll } from '@/base/fs';
+import CopyPatterns from '@/base/copyPatterns';
+import Compilation from '@/Compilation';
+import CssMinimizerPlugin from '@/plugins/cssMinimizer/CssMinimizerPlugin';
+import MiniCssExtractPlugin from '@/plugins/miniCssExtractPlugin/MiniCssExtractPlugin';
+export * from '@/plugins/miniCssExtractPlugin/MiniCssExtractLoader';
+import DefinePlugin from '@/plugins/DefinePlugin';
+import CONSTANTS from './base/const';
+export * from './types';
+export { RawSource, ConcatSource } from 'webpack-sources';
+import { AbstractMPPack, MPPack } from './MPPack';
+import MPPackSetting from './MPPackSetting';
+declare const utils: {
+    createHash: (algorithm: string | typeof import("./base/Hash").default | undefined) => any;
+    readFile: typeof readFile;
+    stat: typeof stat;
+    throttleAll: typeof throttleAll;
+};
+export { Config, Resolver, CONSTANTS, BaseError, utils, CopyPatterns, Compilation, DefinePlugin, CssMinimizerPlugin, MiniCssExtractPlugin, AbstractMPPack, MPPack, MPPackSetting };

package/dist/index.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MPPackSetting = exports.MPPack = exports.AbstractMPPack = exports.MiniCssExtractPlugin = exports.CssMinimizerPlugin = exports.DefinePlugin = exports.Compilation = exports.CopyPatterns = exports.utils = exports.BaseError = exports.CONSTANTS = exports.Resolver = exports.Config = exports.ConcatSource = exports.RawSource = void 0;
+require("./base/moduleAlias");
+const webpack_chain_1 = __importDefault(require("webpack-chain"));
+exports.Config = webpack_chain_1.default;
+const enhanced_resolve_1 = require("enhanced-resolve");
+Object.defineProperty(exports, "Resolver", { enumerable: true, get: function () { return enhanced_resolve_1.Resolver; } });
+const BaseError_1 = __importDefault(require("./base/errors/BaseError"));
+exports.BaseError = BaseError_1.default;
+const createHash_1 = __importDefault(require("@/base/createHash"));
+const fs_1 = require("@/base/fs");
+const copyPatterns_1 = __importDefault(require("@/base/copyPatterns"));
+exports.CopyPatterns = copyPatterns_1.default;
+const Compilation_1 = __importDefault(require("@/Compilation"));
+exports.Compilation = Compilation_1.default;
+const CssMinimizerPlugin_1 = __importDefault(require("@/plugins/cssMinimizer/CssMinimizerPlugin"));
+exports.CssMinimizerPlugin = CssMinimizerPlugin_1.default;
+const MiniCssExtractPlugin_1 = __importDefault(require("@/plugins/miniCssExtractPlugin/MiniCssExtractPlugin"));
+exports.MiniCssExtractPlugin = MiniCssExtractPlugin_1.default;
+__exportStar(require("@/plugins/miniCssExtractPlugin/MiniCssExtractLoader"), exports);
+const DefinePlugin_1 = __importDefault(require("@/plugins/DefinePlugin"));
+exports.DefinePlugin = DefinePlugin_1.default;
+const const_1 = __importDefault(require("./base/const"));
+exports.CONSTANTS = const_1.default;
+__exportStar(require("./types"), exports);
+var webpack_sources_1 = require("webpack-sources");
+Object.defineProperty(exports, "RawSource", { enumerable: true, get: function () { return webpack_sources_1.RawSource; } });
+Object.defineProperty(exports, "ConcatSource", { enumerable: true, get: function () { return webpack_sources_1.ConcatSource; } });
+const MPPack_1 = require("./MPPack");
+Object.defineProperty(exports, "AbstractMPPack", { enumerable: true, get: function () { return MPPack_1.AbstractMPPack; } });
+Object.defineProperty(exports, "MPPack", { enumerable: true, get: function () { return MPPack_1.MPPack; } });
+const MPPackSetting_1 = __importDefault(require("./MPPackSetting"));
+exports.MPPackSetting = MPPackSetting_1.default;
+const utils = {
+    createHash: createHash_1.default,
+    readFile: fs_1.readFile,
+    stat: fs_1.stat,
+    throttleAll: fs_1.throttleAll
+};
+exports.utils = utils;

package/dist/library/AbstractLibraryPlugin.d.ts

@@ -0,0 +1,21 @@
+declare class AbstractLibraryPlugin {
+    _pluginName: any;
+    _type: any;
+    _parseCache: WeakMap<any, any>;
+    static COMMON_LIBRARY_NAME_MESSAGE: string;
+    constructor({ pluginName, type }: {
+        pluginName: any;
+        type: any;
+    });
+    apply(compiler: any): void;
+    _parseOptionsCached(library?: any): any;
+    parseOptions(library: any): void;
+    finishEntryModule(module: any, entryName: any, libraryContext: any): void;
+    embedInRuntimeBailout(module: any, renderContext: any, libraryContext: any): any;
+    strictRuntimeBailout(renderContext: any, libraryContext: any): any;
+    runtimeRequirements(chunk: any, set: any, libraryContext: any): void;
+    render(source: any, renderContext: any, libraryContext: any): any;
+    renderStartup(source: any, module: any, renderContext: any, libraryContext: any): any;
+    chunkHash(chunk: any, hash: any, chunkHashContext: any, libraryContext: any): void;
+}
+export default AbstractLibraryPlugin;

package/dist/library/AbstractLibraryPlugin.js

@@ -0,0 +1,177 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const JavascriptModulesPlugin_1 = require("@/module/javascript/JavascriptModulesPlugin");
+const COMMON_LIBRARY_NAME_MESSAGE = "Common configuration options that specific library names are 'output.library[.name]', 'entry.xyz.library[.name]', 'ModuleFederationPlugin.name' and 'ModuleFederationPlugin.library[.name]'.";
+class AbstractLibraryPlugin {
+    constructor({ pluginName, type }) {
+        this._pluginName = pluginName;
+        this._type = type;
+        this._parseCache = new WeakMap();
+    }
+    apply(compiler) {
+        const { _pluginName } = this;
+        compiler.hooks.thisCompilation.tap(_pluginName, compilation => {
+            compilation.hooks.finishModules.tap({ name: _pluginName, stage: 10 }, () => {
+                for (const [name, { dependencies: deps, options: { library }, },] of compilation.entries) {
+                    const options = this._parseOptionsCached(library !== undefined ? library : compilation.outputOptions.library);
+                    if (options !== false) {
+                        const dep = deps[deps.length - 1];
+                        if (dep) {
+                            const module = compilation.moduleGraph.getModule(dep);
+                            if (module) {
+                                this.finishEntryModule(module, name, {
+                                    options,
+                                    compilation,
+                                    chunkGraph: compilation.chunkGraph,
+                                });
+                            }
+                        }
+                    }
+                }
+            });
+            const getOptionsForChunk = chunk => {
+                if (compilation.chunkGraph.getNumberOfEntryModules(chunk) === 0)
+                    return false;
+                const options = chunk.getEntryOptions();
+                const library = options === null || options === void 0 ? void 0 : options.library;
+                return this._parseOptionsCached(library !== undefined ? library : compilation.outputOptions.library);
+            };
+            if (this.render !== AbstractLibraryPlugin.prototype.render ||
+                this.runtimeRequirements !== AbstractLibraryPlugin.prototype.runtimeRequirements) {
+                compilation.hooks.additionalChunkRuntimeRequirements.tap(_pluginName, (chunk, set, { chunkGraph }) => {
+                    const options = getOptionsForChunk(chunk);
+                    if (options !== false) {
+                        this.runtimeRequirements(chunk, set, {
+                            options,
+                            compilation,
+                            chunkGraph,
+                        });
+                    }
+                });
+            }
+            const hooks = JavascriptModulesPlugin_1.JavascriptModulesPlugin.getCompilationHooks(compilation);
+            if (this.render !== AbstractLibraryPlugin.prototype.render) {
+                hooks.render.tap(_pluginName, (source, renderContext) => {
+                    const options = getOptionsForChunk(renderContext.chunk);
+                    if (options === false)
+                        return source;
+                    return this.render(source, renderContext, {
+                        options,
+                        compilation,
+                        chunkGraph: compilation.chunkGraph,
+                    });
+                });
+            }
+            if (this.embedInRuntimeBailout !== AbstractLibraryPlugin.prototype.embedInRuntimeBailout) {
+                hooks.embedInRuntimeBailout.tap(_pluginName, (module, renderContext) => {
+                    const options = getOptionsForChunk(renderContext.chunk);
+                    if (options === false)
+                        return;
+                    return this.embedInRuntimeBailout(module, renderContext, {
+                        options,
+                        compilation,
+                        chunkGraph: compilation.chunkGraph,
+                    });
+                });
+            }
+            if (this.strictRuntimeBailout !== AbstractLibraryPlugin.prototype.strictRuntimeBailout) {
+                hooks.strictRuntimeBailout.tap(_pluginName, renderContext => {
+                    const options = getOptionsForChunk(renderContext.chunk);
+                    if (options === false)
+                        return;
+                    return this.strictRuntimeBailout(renderContext, {
+                        options,
+                        compilation,
+                        chunkGraph: compilation.chunkGraph,
+                    });
+                });
+            }
+            if (this.renderStartup !== AbstractLibraryPlugin.prototype.renderStartup) {
+                hooks.renderStartup.tap(_pluginName, (source, module, renderContext) => {
+                    const options = getOptionsForChunk(renderContext.chunk);
+                    if (options === false)
+                        return source;
+                    return this.renderStartup(source, module, renderContext, {
+                        options,
+                        compilation,
+                        chunkGraph: compilation.chunkGraph,
+                    });
+                });
+            }
+            hooks.chunkHash.tap(_pluginName, (chunk, hash, context) => {
+                const options = getOptionsForChunk(chunk);
+                if (options === false)
+                    return;
+                this.chunkHash(chunk, hash, context, {
+                    options,
+                    compilation,
+                    chunkGraph: compilation.chunkGraph,
+                });
+            });
+        });
+    }
+    _parseOptionsCached(library) {
+        if (!library)
+            return false;
+        if (library.type !== this._type)
+            return false;
+        const cacheEntry = this._parseCache.get(library);
+        if (cacheEntry !== undefined)
+            return cacheEntry;
+        const result = this.parseOptions(library);
+        this._parseCache.set(library, result);
+        return result;
+    }
+    parseOptions(library) {
+        const AbstractMethodError = require('@/base/errors/AbstractMethodError').default;
+        throw new AbstractMethodError();
+    }
+    finishEntryModule(module, entryName, libraryContext) { }
+    embedInRuntimeBailout(module, renderContext, libraryContext) {
+        return undefined;
+    }
+    strictRuntimeBailout(renderContext, libraryContext) {
+        return undefined;
+    }
+    runtimeRequirements(chunk, set, libraryContext) {
+        if (this.render !== AbstractLibraryPlugin.prototype.render)
+            set.add(RuntimeGlobals.returnExportsFromRuntime);
+    }
+    render(source, renderContext, libraryContext) {
+        return source;
+    }
+    renderStartup(source, module, renderContext, libraryContext) {
+        return source;
+    }
+    chunkHash(chunk, hash, chunkHashContext, libraryContext) {
+        const options = this._parseOptionsCached(libraryContext.compilation.outputOptions.library);
+        hash.update(this._pluginName);
+        hash.update(JSON.stringify(options));
+    }
+}
+AbstractLibraryPlugin.COMMON_LIBRARY_NAME_MESSAGE = COMMON_LIBRARY_NAME_MESSAGE;
+exports.default = AbstractLibraryPlugin;

package/dist/library/AssignLibraryPlugin.d.ts

@@ -0,0 +1,53 @@
+import { ConcatSource } from 'webpack-sources';
+import AbstractLibraryPlugin from './AbstractLibraryPlugin';
+declare class AssignLibraryPlugin extends AbstractLibraryPlugin {
+    prefix: any;
+    declare: any;
+    unnamed: any;
+    named: any;
+    constructor(options: any);
+    parseOptions(library: any): {
+        name: any;
+        export: any;
+    };
+    finishEntryModule(module: any, entryName: any, { options, compilation, compilation: { moduleGraph } }: {
+        options: any;
+        compilation: {
+            moduleGraph: any;
+        };
+    }): void;
+    _getPrefix(compilation: any): any;
+    _getResolvedFullName(options: any, chunk: any, compilation: any): any;
+    render(source: any, { chunk }: {
+        chunk: any;
+    }, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): any;
+    embedInRuntimeBailout(module: any, { chunk, codeGenerationResults }: {
+        chunk: any;
+        codeGenerationResults: any;
+    }, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): string | undefined;
+    strictRuntimeBailout({ chunk }: {
+        chunk: any;
+    }, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): "a global variable is assign and maybe created" | undefined;
+    renderStartup(source: any, module: any, { moduleGraph, chunk }: {
+        moduleGraph: any;
+        chunk: any;
+    }, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): ConcatSource;
+    runtimeRequirements(chunk: any, set: any, libraryContext: any): void;
+    chunkHash(chunk: any, hash: any, chunkHashContext: any, { options, compilation }: {
+        options: any;
+        compilation: any;
+    }): void;
+}
+export default AssignLibraryPlugin;

package/dist/library/AssignLibraryPlugin.js

@@ -0,0 +1,201 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webpack_sources_1 = require("webpack-sources");
+const ExportsInfo_1 = require("@/module/ExportsInfo");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const Template_1 = require("@/template/Template");
+const propertyAccess_1 = __importDefault(require("@/base/propertyAccess"));
+const RuntimeHelpers_1 = require("@/module/RuntimeHelpers");
+const AbstractLibraryPlugin_1 = __importDefault(require("./AbstractLibraryPlugin"));
+const KEYWORD_REGEX = /^(await|break|case|catch|class|const|continue|debugger|default|delete|do|else|enum|export|extends|false|finally|for|function|if|implements|import|in|instanceof|interface|let|new|null|package|private|protected|public|return|super|switch|static|this|throw|try|true|typeof|var|void|while|with|yield)$/;
+const IDENTIFIER_REGEX = /^[\p{L}\p{Nl}$_][\p{L}\p{Nl}$\p{Mn}\p{Mc}\p{Nd}\p{Pc}]*$/iu;
+const isNameValid = name => !KEYWORD_REGEX.test(name) && IDENTIFIER_REGEX.test(name);
+const accessWithInit = (accessor, existingLength, initLast = false) => {
+    // This generates for [a, b, c, d]:
+    // (((a = typeof a === "undefined" ? {} : a).b = a.b || {}).c = a.b.c || {}).d
+    const base = accessor[0];
+    if (accessor.length === 1 && !initLast)
+        return base;
+    let current = existingLength > 0 ? base : `(${base} = typeof ${base} === "undefined" ? {} : ${base})`;
+    // i is the current position in accessor that has been printed
+    let i = 1;
+    // all properties printed so far (excluding base)
+    let propsSoFar;
+    // if there is existingLength, print all properties until this position as property access
+    if (existingLength > i) {
+        propsSoFar = accessor.slice(1, existingLength);
+        i = existingLength;
+        current += (0, propertyAccess_1.default)(propsSoFar);
+    }
+    else {
+        propsSoFar = [];
+    }
+    // all remaining properties (except the last one when initLast is not set)
+    // should be printed as initializer
+    const initUntil = initLast ? accessor.length : accessor.length - 1;
+    for (; i < initUntil; i++) {
+        const prop = accessor[i];
+        propsSoFar.push(prop);
+        current = `(${current}${(0, propertyAccess_1.default)([prop])} = ${base}${(0, propertyAccess_1.default)(propsSoFar)} || {})`;
+    }
+    // print the last property as property access if not yet printed
+    if (i < accessor.length)
+        current = `${current}${(0, propertyAccess_1.default)([accessor[accessor.length - 1]])}`;
+    return current;
+};
+class AssignLibraryPlugin extends AbstractLibraryPlugin_1.default {
+    constructor(options) {
+        super({
+            pluginName: 'AssignLibraryPlugin',
+            type: options.type,
+        });
+        this.prefix = options.prefix;
+        this.declare = options.declare;
+        this.unnamed = options.unnamed;
+        this.named = options.named || 'assign';
+    }
+    parseOptions(library) {
+        const { name } = library;
+        if (this.unnamed === 'error') {
+            if (typeof name !== 'string' && !Array.isArray(name)) {
+                throw new Error(`Library name must be a string or string array. ${AbstractLibraryPlugin_1.default.COMMON_LIBRARY_NAME_MESSAGE}`);
+            }
+        }
+        else if (name && typeof name !== 'string' && !Array.isArray(name)) {
+            throw new Error(`Library name must be a string, string array or unset. ${AbstractLibraryPlugin_1.default.COMMON_LIBRARY_NAME_MESSAGE}`);
+        }
+        return {
+            name,
+            export: library.export,
+        };
+    }
+    finishEntryModule(module, entryName, { options, compilation, compilation: { moduleGraph } }) {
+        const runtime = (0, RuntimeHelpers_1.getEntryRuntime)(compilation, entryName);
+        if (options.export) {
+            const exportsInfo = moduleGraph.getExportInfo(module, Array.isArray(options.export) ? options.export[0] : options.export);
+            exportsInfo.setUsed(ExportsInfo_1.UsageState.Used, runtime);
+            exportsInfo.canMangleUse = false;
+        }
+        else {
+            const exportsInfo = moduleGraph.getExportsInfo(module);
+            exportsInfo.setUsedInUnknownWay(runtime);
+        }
+        moduleGraph.addExtraReason(module, 'used as library export');
+    }
+    _getPrefix(compilation) {
+        return this.prefix === 'global' ? [compilation.runtimeTemplate.globalObject] : this.prefix;
+    }
+    _getResolvedFullName(options, chunk, compilation) {
+        const prefix = this._getPrefix(compilation);
+        const fullName = options.name ? prefix.concat(options.name) : prefix;
+        return fullName.map(n => compilation.getPath(n, {
+            chunk,
+        }));
+    }
+    render(source, { chunk }, { options, compilation }) {
+        const fullNameResolved = this._getResolvedFullName(options, chunk, compilation);
+        if (this.declare) {
+            const base = fullNameResolved[0];
+            if (!isNameValid(base)) {
+                throw new Error(`Library name base (${base}) must be a valid identifier when using a var declaring library type. Either use a valid identifier (e. g. ${Template_1.Template.toIdentifier(base)}) or use a different library type (e. g. 'type: "global"', which assign a property on the global scope instead of declaring a variable). ${AbstractLibraryPlugin_1.default.COMMON_LIBRARY_NAME_MESSAGE}`);
+            }
+            source = new webpack_sources_1.ConcatSource(`${this.declare} ${base};\n`, source);
+        }
+        return source;
+    }
+    embedInRuntimeBailout(module, { chunk, codeGenerationResults }, { options, compilation }) {
+        var _a;
+        const { data } = codeGenerationResults.get(module, chunk.runtime);
+        const topLevelDeclarations = (data === null || data === void 0 ? void 0 : data.get('topLevelDeclarations')) ||
+            ((_a = module.buildInfo) === null || _a === void 0 ? void 0 : _a.topLevelDeclarations);
+        if (!topLevelDeclarations)
+            return "it doesn't tell about top level declarations.";
+        const fullNameResolved = this._getResolvedFullName(options, chunk, compilation);
+        const base = fullNameResolved[0];
+        if (topLevelDeclarations.has(base))
+            return `it declares '${base}' on top-level, which conflicts with the current library output.`;
+    }
+    strictRuntimeBailout({ chunk }, { options, compilation }) {
+        if (this.declare || this.prefix === 'global' || this.prefix.length > 0 || !options.name) {
+            return;
+        }
+        return 'a global variable is assign and maybe created';
+    }
+    renderStartup(source, module, { moduleGraph, chunk }, { options, compilation }) {
+        const fullNameResolved = this._getResolvedFullName(options, chunk, compilation);
+        const staticExports = this.unnamed === 'static';
+        const exportAccess = options.export
+            ? (0, propertyAccess_1.default)(Array.isArray(options.export) ? options.export : [options.export])
+            : '';
+        const result = new webpack_sources_1.ConcatSource(source);
+        if (staticExports) {
+            const exportsInfo = moduleGraph.getExportsInfo(module);
+            const exportTarget = accessWithInit(fullNameResolved, this._getPrefix(compilation).length, true);
+            for (const exportInfo of exportsInfo.orderedExports) {
+                if (!exportInfo.provided)
+                    continue;
+                const nameAccess = (0, propertyAccess_1.default)([exportInfo.name]);
+                result.add(`${exportTarget}${nameAccess} = ${RuntimeGlobals.exports}${exportAccess}${nameAccess};\n`);
+            }
+            result.add(`Object.defineProperty(${exportTarget}, "__esModule", { value: true });\n`);
+        }
+        else if (options.name ? this.named === 'copy' : this.unnamed === 'copy') {
+            result.add(`var __webpack_export_target__ = ${accessWithInit(fullNameResolved, this._getPrefix(compilation).length, true)};\n`);
+            let exports = RuntimeGlobals.exports;
+            if (exportAccess) {
+                result.add(`var __webpack_exports_export__ = ${RuntimeGlobals.exports}${exportAccess};\n`);
+                exports = '__webpack_exports_export__';
+            }
+            result.add(`for(var i in ${exports}) __webpack_export_target__[i] = ${exports}[i];\n`);
+            result.add(`if(${exports}.__esModule) Object.defineProperty(__webpack_export_target__, "__esModule", { value: true });\n`);
+        }
+        else {
+            result.add(`${accessWithInit(fullNameResolved, this._getPrefix(compilation).length, false)} = ${RuntimeGlobals.exports}${exportAccess};\n`);
+        }
+        return result;
+    }
+    runtimeRequirements(chunk, set, libraryContext) {
+        // we don't need to return exports from runtime
+    }
+    chunkHash(chunk, hash, chunkHashContext, { options, compilation }) {
+        hash.update('AssignLibraryPlugin');
+        const fullNameResolved = this._getResolvedFullName(options, chunk, compilation);
+        if (options.name ? this.named === 'copy' : this.unnamed === 'copy') {
+            hash.update('copy');
+        }
+        if (this.declare) {
+            hash.update(this.declare);
+        }
+        hash.update(fullNameResolved.join('.'));
+        if (options.export) {
+            hash.update(`${options.export}`);
+        }
+    }
+}
+exports.default = AssignLibraryPlugin;

package/dist/library/EnableLibraryPlugin.d.ts

@@ -0,0 +1,8 @@
+declare class EnableLibraryPlugin {
+    type: string;
+    constructor(type: any);
+    static setEnabled(compiler: any, type: any): void;
+    static checkEnabled(compiler: any, type: any): void;
+    apply(compiler: any): void;
+}
+export default EnableLibraryPlugin;