xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/miniCssExtractPlugin/MiniCssExtractLoader.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugins/miniCssExtractPlugin/MiniCssExtractLoader.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const MiniCssUtils_1 = require("./MiniCssUtils");
+const MiniCssExtractPlugin_1 = __importDefault(require("./MiniCssExtractPlugin"));
+function hotLoader(content, context) {
+    const accept = context.locals ? '' : 'module.hot.accept(undefined, cssReload);';
+    return `${content}
+    if(module.hot) {
+      // ${Date.now()}
+      var cssReload = require(${(0, MiniCssUtils_1.stringifyRequest)(context.loaderContext, path_1.default.join(__dirname, 'hmr/hotModuleReplacement.js'))})(module.id, ${JSON.stringify(Object.assign(Object.assign({}, context.options), { locals: !!context.locals }))});
+      module.hot.dispose(cssReload);
+      ${accept}
+    }
+  `;
+}
+function pitch(request) {
+    var _a, _b, _c;
+    try {
+        if (((_c = (_b = (_a = this._compiler) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.experiments) === null || _c === void 0 ? void 0 : _c.css) && this._module && this._module.type === 'css') {
+            this.emitWarning(new Error('You can\'t use `experiments.css` (`experiments.futureDefaults` enable built-in CSS support by default) and `mini-css-extract-plugin` together, please set `experiments.css` to `false` or set `{ type: "javascript/auto" }` for rules with `mini-css-extract-plugin` in your webpack config (now `mini-css-extract-plugin` does nothing).'));
+            return;
+        }
+        const options = this.getOptions();
+        const emit = typeof options.emit !== 'undefined' ? options.emit : true;
+        const callback = this.async();
+        const optionsFromPlugin = this[MiniCssExtractPlugin_1.default.pluginSymbol];
+        if (!optionsFromPlugin) {
+            callback(new Error("You forgot to add 'mini-css-extract-plugin' plugin (i.e. `{ plugins: [new MiniCssExtractPlugin()] }`), please read https://github.com/webpack-contrib/mini-css-extract-plugin#getting-started"));
+            return;
+        }
+        const handleExports = (originalExports, compilation, assets, assetsInfo) => {
+            let locals;
+            let namedExport;
+            const esModule = typeof options.esModule !== 'undefined' ? options.esModule : true;
+            const addDependencies = dependencies => {
+                if (!Array.isArray(dependencies) && dependencies != null) {
+                    throw new Error(`Exported value was not extracted as an array: ${JSON.stringify(dependencies)}`);
+                }
+                const identifierCountMap = new Map();
+                let lastDep;
+                for (const dependency of dependencies) {
+                    if (!dependency.identifier || !emit) {
+                        // eslint-disable-next-line no-continue
+                        continue;
+                    }
+                    const count = identifierCountMap.get(dependency.identifier) || 0;
+                    const CssDependency = MiniCssExtractPlugin_1.default.getCssDependency(this._compiler.MPPack);
+                    this._module.addDependency((lastDep = new CssDependency(dependency, dependency.context, count)));
+                    identifierCountMap.set(dependency.identifier, count + 1);
+                }
+                if (lastDep && assets) {
+                    lastDep.assets = assets;
+                    lastDep.assetsInfo = assetsInfo;
+                }
+            };
+            try {
+                const exports = originalExports.__esModule ? originalExports.default : originalExports;
+                namedExport =
+                    originalExports.__esModule &&
+                        (!originalExports.default || !('locals' in originalExports.default));
+                if (namedExport) {
+                    Object.keys(originalExports).forEach(key => {
+                        if (key !== 'default') {
+                            if (!locals) {
+                                locals = {};
+                            }
+                            locals[key] = originalExports[key];
+                        }
+                    });
+                }
+                else {
+                    locals = exports === null || exports === void 0 ? void 0 : exports.locals;
+                }
+                let dependencies;
+                if (!Array.isArray(exports)) {
+                    dependencies = [[null, exports]];
+                }
+                else {
+                    dependencies = exports.map(([id, content, media, sourceMap, supports, layer]) => {
+                        let identifier = id;
+                        let context;
+                        if (compilation) {
+                            const module = (0, MiniCssUtils_1.findModuleById)(compilation, id);
+                            identifier = module.identifier();
+                            ({ context } = module);
+                        }
+                        else {
+                            // TODO check if this context is used somewhere
+                            context = this.rootContext;
+                        }
+                        return {
+                            identifier,
+                            context,
+                            content: Buffer.from(content),
+                            media,
+                            supports,
+                            layer,
+                            sourceMap: sourceMap
+                                ? Buffer.from(JSON.stringify(sourceMap))
+                                : // eslint-disable-next-line no-undefined
+                                    undefined,
+                        };
+                    });
+                }
+                addDependencies(dependencies);
+            }
+            catch (e) {
+                callback(e);
+                return;
+            }
+            const result = locals
+                ? namedExport
+                    ? Object.keys(locals)
+                        .map(key => `\nexport var ${key} = ${(0, MiniCssUtils_1.stringifyLocal)(locals[key])};`)
+                        .join('')
+                    : `\n${esModule ? 'export default' : 'module.exports ='} ${JSON.stringify(locals)};`
+                : esModule
+                    ? `\nexport {};`
+                    : '';
+            let resultSource = `// extracted by ${MiniCssExtractPlugin_1.default.pluginName}`;
+            // only attempt hotreloading if the css is actually used for something other than hash values
+            resultSource +=
+                this.hot && emit ? hotLoader(result, { loaderContext: this, options, locals }) : result;
+            callback(null, resultSource);
+        };
+        let { publicPath } = this._compilation.outputOptions;
+        if (typeof options.publicPath === 'string') {
+            publicPath = options.publicPath;
+        }
+        else if (typeof options.publicPath === 'function') {
+            publicPath = options.publicPath(this.resourcePath, this.rootContext);
+        }
+        if (publicPath === 'auto') {
+            publicPath = MiniCssUtils_1.AUTO_PUBLIC_PATH;
+        }
+        if (!this.importModule) {
+            callback(new Error("You are using 'experimentalUseImportModule' but 'this.importModule' is not available in loader context. You need to have at least webpack 5.33.2."));
+            return;
+        }
+        let publicPathForExtract;
+        if (typeof publicPath === 'string') {
+            const isAbsolutePublicPath = /^[a-zA-Z][a-zA-Z\d+\-.]*?:/.test(publicPath);
+            publicPathForExtract = isAbsolutePublicPath
+                ? publicPath
+                : `${MiniCssUtils_1.ABSOLUTE_PUBLIC_PATH}${publicPath.replace(/\./g, MiniCssUtils_1.SINGLE_DOT_PATH_SEGMENT)}`;
+        }
+        else {
+            publicPathForExtract = publicPath;
+        }
+        this.importModule(`${this.resourcePath}.webpack[javascript/auto]!=!!!${request}`, {
+            layer: options.layer,
+            publicPath: publicPathForExtract,
+            baseUri: `${MiniCssUtils_1.BASE_URI}/`,
+        }, (error, exports) => {
+            if (error) {
+                callback(error);
+                return;
+            }
+            handleExports(exports);
+        });
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
+function loader(content) {
+    var _a, _b, _c;
+    if (((_c = (_b = (_a = this._compiler) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.experiments) === null || _c === void 0 ? void 0 : _c.css) && this._module && this._module.type === 'css') {
+        return content;
+    }
+}
+module.exports = loader;
+module.exports.pitch = pitch;

package/dist/plugins/miniCssExtractPlugin/MiniCssExtractPlugin.d.ts

@@ -0,0 +1,22 @@
+import { ConcatSource } from 'webpack-sources';
+declare const pluginSymbol: unique symbol;
+declare class MiniCssExtractPlugin {
+    _sortedModulesCache: WeakMap<any, any>;
+    options: any;
+    runtimeOptions: {
+        insert: any;
+        linkType: any;
+        attributes: any;
+    };
+    static pluginName: string;
+    static pluginSymbol: typeof pluginSymbol;
+    static loader: string;
+    static getCssModule(indentifier: any): any;
+    static getCssDependency(indentifier: any): any;
+    constructor(options?: any);
+    apply(compiler: any): void;
+    getChunkModules(chunk: any, chunkGraph: any): any;
+    sortModules(compilation: any, chunk: any, modules: any, requestShortener: any): any;
+    renderContentAsset(compiler: any, compilation: any, chunk: any, modules: any, requestShortener: any, filenameTemplate: any, pathData: any): ConcatSource;
+}
+export default MiniCssExtractPlugin;