xhs-mp-pack 1.1.0-beta.0

package/dist/module/ContextModuleFactory.d.ts

@@ -0,0 +1,8 @@
+import ModuleFactory from './ModuleFactory';
+export default class ContextModuleFactory extends ModuleFactory {
+    hooks: any;
+    resolverFactory: any;
+    constructor(resolverFactory: any);
+    create(data: any, callback: any): void;
+    resolveDependencies(fs: any, options: any, callback: any): any;
+}

package/dist/module/ContextModuleFactory.js

@@ -0,0 +1,292 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const neo_async_1 = __importDefault(require("neo-async"));
+const tapable_1 = require("tapable");
+const ContextElementDependency_1 = __importDefault(require("@/dependencies/context/ContextElementDependency"));
+const LazySet_1 = __importDefault(require("@/base/LazySet"));
+const cleverMerge_1 = require("@/base/cleverMerge");
+const deprecation_1 = require("@/base/deprecation");
+const fs_1 = require("@/base/fs");
+const ModuleFactory_1 = __importDefault(require("./ModuleFactory"));
+const ContextModule_1 = __importDefault(require("./ContextModule"));
+const EMPTY_RESOLVE_OPTIONS = {};
+class ContextModuleFactory extends ModuleFactory_1.default {
+    constructor(resolverFactory) {
+        super();
+        const alternativeRequests = new tapable_1.AsyncSeriesWaterfallHook([
+            'modules',
+            'options',
+        ]);
+        this.hooks = Object.freeze({
+            beforeResolve: new tapable_1.AsyncSeriesWaterfallHook(['data']),
+            afterResolve: new tapable_1.AsyncSeriesWaterfallHook(['data']),
+            contextModuleFiles: new tapable_1.SyncWaterfallHook(['files']),
+            alternatives: (0, deprecation_1.createFakeHook)({
+                name: 'alternatives',
+                intercept: interceptor => {
+                    throw new Error('Intercepting fake hook ContextModuleFactory.hooks.alternatives is not possible, use ContextModuleFactory.hooks.alternativeRequests instead');
+                },
+                tap: (options, fn) => {
+                    alternativeRequests.tap(options, fn);
+                },
+                tapAsync: (options, fn) => {
+                    alternativeRequests.tapAsync(options, (items, _options, callback) => fn(items, callback));
+                },
+                tapPromise: (options, fn) => {
+                    alternativeRequests.tapPromise(options, fn);
+                },
+            }, 'ContextModuleFactory.hooks.alternatives has deprecated in favor of ContextModuleFactory.hooks.alternativeRequests with an additional options argument.', 'DEP_WEBPACK_CONTEXT_MODULE_FACTORY_ALTERNATIVES'),
+            alternativeRequests,
+        });
+        this.resolverFactory = resolverFactory;
+    }
+    create(data, callback) {
+        const context = data.context;
+        const dependencies = data.dependencies;
+        const resolveOptions = data.resolveOptions;
+        const dependency = dependencies[0];
+        const fileDependencies = new LazySet_1.default();
+        const missingDependencies = new LazySet_1.default();
+        const contextDependencies = new LazySet_1.default();
+        this.hooks.beforeResolve.callAsync(Object.assign({ context,
+            dependencies, layer: data.contextInfo.issuerLayer, resolveOptions,
+            fileDependencies,
+            missingDependencies,
+            contextDependencies }, dependency.options), (err, beforeResolveResult) => {
+            if (err) {
+                return callback(err, {
+                    fileDependencies,
+                    missingDependencies,
+                    contextDependencies,
+                });
+            }
+            // Ignored
+            if (!beforeResolveResult) {
+                return callback(null, {
+                    fileDependencies,
+                    missingDependencies,
+                    contextDependencies,
+                });
+            }
+            const context = beforeResolveResult.context;
+            const request = beforeResolveResult.request;
+            const resolveOptions = beforeResolveResult.resolveOptions;
+            let loaders;
+            let resource;
+            let loadersPrefix = '';
+            const idx = request.lastIndexOf('!');
+            if (idx >= 0) {
+                let loadersRequest = request.slice(0, idx + 1);
+                let i;
+                for (i = 0; i < loadersRequest.length && loadersRequest[i] === '!'; i++) {
+                    loadersPrefix += '!';
+                }
+                loadersRequest = loadersRequest.slice(i).replace(/!+$/, '').replace(/!!+/g, '!');
+                if (loadersRequest === '') {
+                    loaders = [];
+                }
+                else {
+                    loaders = loadersRequest.split('!');
+                }
+                resource = request.slice(idx + 1);
+            }
+            else {
+                loaders = [];
+                resource = request;
+            }
+            const contextResolver = this.resolverFactory.get('context', dependencies.length > 0
+                ? (0, cleverMerge_1.cachedSetProperty)(resolveOptions || EMPTY_RESOLVE_OPTIONS, 'dependencyType', dependencies[0].category)
+                : resolveOptions);
+            const loaderResolver = this.resolverFactory.get('loader');
+            neo_async_1.default.parallel([
+                callback => {
+                    const results = [];
+                    const yield_ = obj => results.push(obj);
+                    contextResolver.resolve({}, context, resource, {
+                        fileDependencies,
+                        missingDependencies,
+                        contextDependencies,
+                        yield: yield_,
+                    }, err => {
+                        if (err)
+                            return callback(err);
+                        callback(null, results);
+                    });
+                },
+                callback => {
+                    neo_async_1.default.map(loaders, (loader, callback) => {
+                        loaderResolver.resolve({}, context, loader, {
+                            fileDependencies,
+                            missingDependencies,
+                            contextDependencies,
+                        }, (err, result) => {
+                            if (err)
+                                return callback(err);
+                            callback(null, result);
+                        });
+                    }, callback);
+                },
+            ], (err, result) => {
+                if (err) {
+                    return callback(err, {
+                        fileDependencies,
+                        missingDependencies,
+                        contextDependencies,
+                    });
+                }
+                let [contextResult, loaderResult] = result;
+                if (contextResult.length > 1) {
+                    const first = contextResult[0];
+                    contextResult = contextResult.filter(r => r.path);
+                    if (contextResult.length === 0)
+                        contextResult.push(first);
+                }
+                this.hooks.afterResolve.callAsync(Object.assign({ addon: loadersPrefix + loaderResult.join('!') + (loaderResult.length > 0 ? '!' : ''), resource: contextResult.length > 1 ? contextResult.map(r => r.path) : contextResult[0].path, resolveDependencies: this.resolveDependencies.bind(this), resourceQuery: contextResult[0].query, resourceFragment: contextResult[0].fragment }, beforeResolveResult), (err, result) => {
+                    if (err) {
+                        return callback(err, {
+                            fileDependencies,
+                            missingDependencies,
+                            contextDependencies,
+                        });
+                    }
+                    // Ignored
+                    if (!result) {
+                        return callback(null, {
+                            fileDependencies,
+                            missingDependencies,
+                            contextDependencies,
+                        });
+                    }
+                    return callback(null, {
+                        module: new ContextModule_1.default(result.resolveDependencies, result),
+                        fileDependencies,
+                        missingDependencies,
+                        contextDependencies,
+                    });
+                });
+            });
+        });
+    }
+    resolveDependencies(fs, options, callback) {
+        const cmf = this;
+        const { resource, resourceQuery, resourceFragment, recursive, regExp, include, exclude, referencedExports, category, typePrefix, } = options;
+        if (!regExp || !resource)
+            return callback(null, []);
+        const addDirectoryChecked = (ctx, directory, visited, callback) => {
+            fs.realpath(directory, (err, realPath) => {
+                if (err)
+                    return callback(err);
+                if (visited.has(realPath))
+                    return callback(null, []);
+                let recursionStack;
+                addDirectory(ctx, directory, (_, dir, callback) => {
+                    if (recursionStack === undefined) {
+                        recursionStack = new Set(visited);
+                        recursionStack.add(realPath);
+                    }
+                    addDirectoryChecked(ctx, dir, recursionStack, callback);
+                }, callback);
+            });
+        };
+        const addDirectory = (ctx, directory, addSubDirectory, callback) => {
+            fs.readdir(directory, (err, files) => {
+                if (err)
+                    return callback(err);
+                const processedFiles = cmf.hooks.contextModuleFiles.call(files.map(file => file.normalize('NFC')));
+                if (!processedFiles || processedFiles.length === 0)
+                    return callback(null, []);
+                neo_async_1.default.map(processedFiles.filter(p => p.indexOf('.') !== 0), (segment, callback) => {
+                    const subResource = (0, fs_1.join)(fs, directory, segment);
+                    if (!exclude || !subResource.match(exclude)) {
+                        fs.stat(subResource, (err, stat) => {
+                            if (err) {
+                                if (err.code === 'ENOENT') {
+                                    // ENOENT is ok here because the file may have been deleted between
+                                    // the readdir and stat calls.
+                                    return callback();
+                                }
+                                return callback(err);
+                            }
+                            if (stat.isDirectory()) {
+                                if (!recursive)
+                                    return callback();
+                                addSubDirectory(ctx, subResource, callback);
+                            }
+                            else if (stat.isFile() && (!include || subResource.match(include))) {
+                                const obj = {
+                                    context: ctx,
+                                    request: `.${subResource.slice(ctx.length).replace(/\\/g, '/')}`,
+                                };
+                                this.hooks.alternativeRequests.callAsync([obj], options, (err, alternatives) => {
+                                    if (err)
+                                        return callback(err);
+                                    alternatives = alternatives
+                                        .filter(obj => regExp.test(obj.request))
+                                        .map(obj => {
+                                        const dep = new ContextElementDependency_1.default(`${obj.request}${resourceQuery}${resourceFragment}`, obj.request, typePrefix, category, referencedExports, obj.context);
+                                        dep.optional = true;
+                                        return dep;
+                                    });
+                                    callback(null, alternatives);
+                                });
+                            }
+                            else {
+                                callback();
+                            }
+                        });
+                    }
+                    else {
+                        callback();
+                    }
+                }, (err, result) => {
+                    if (err)
+                        return callback(err);
+                    if (!result)
+                        return callback(null, []);
+                    const flattenedResult = [];
+                    for (const item of result) {
+                        if (item)
+                            flattenedResult.push(...item);
+                    }
+                    callback(null, flattenedResult);
+                });
+            });
+        };
+        const addSubDirectory = (ctx, dir, callback) => addDirectory(ctx, dir, addSubDirectory, callback);
+        const visitResource = (resource, callback) => {
+            if (typeof fs.realpath === 'function') {
+                addDirectoryChecked(resource, resource, new Set(), callback);
+            }
+            else {
+                addDirectory(resource, resource, addSubDirectory, callback);
+            }
+        };
+        if (typeof resource === 'string') {
+            visitResource(resource, callback);
+        }
+        else {
+            neo_async_1.default.map(resource, visitResource, (err, result) => {
+                if (err)
+                    return callback(err);
+                // result dependencies should have unique userRequest
+                // ordered by resolve result
+                const temp = new Set();
+                const res = [];
+                for (let i = 0; i < result.length; i++) {
+                    const inner = result[i];
+                    for (const el of inner) {
+                        if (temp.has(el.userRequest))
+                            continue;
+                        res.push(el);
+                        temp.add(el.userRequest);
+                    }
+                }
+                callback(null, res);
+            });
+        }
+    }
+}
+exports.default = ContextModuleFactory;

package/dist/module/ContextReplacementPlugin.d.ts

@@ -0,0 +1,11 @@
+declare class ContextReplacementPlugin {
+    resourceRegExp: any;
+    newContentCallback: any;
+    newContentRecursive: any;
+    newContentRegExp: any;
+    newContentCreateContextMap: any;
+    newContentResource: any;
+    constructor(resourceRegExp: any, newContentResource: any, newContentRecursive: any, newContentRegExp: any);
+    apply(compiler: any): void;
+}
+export default ContextReplacementPlugin;

package/dist/module/ContextReplacementPlugin.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ContextElementDependency_1 = __importDefault(require("@/dependencies/context/ContextElementDependency"));
+const fs_1 = require("@/base/fs");
+class ContextReplacementPlugin {
+    constructor(resourceRegExp, newContentResource, newContentRecursive, newContentRegExp) {
+        this.resourceRegExp = resourceRegExp;
+        if (typeof newContentResource === 'function') {
+            this.newContentCallback = newContentResource;
+        }
+        else if (typeof newContentResource === 'string' && typeof newContentRecursive === 'object') {
+            this.newContentResource = newContentResource;
+            this.newContentCreateContextMap = (fs, callback) => {
+                callback(null, newContentRecursive);
+            };
+        }
+        else if (typeof newContentResource === 'string' &&
+            typeof newContentRecursive === 'function') {
+            this.newContentResource = newContentResource;
+            this.newContentCreateContextMap = newContentRecursive;
+        }
+        else {
+            if (typeof newContentResource !== 'string') {
+                newContentRegExp = newContentRecursive;
+                newContentRecursive = newContentResource;
+                newContentResource = undefined;
+            }
+            if (typeof newContentRecursive !== 'boolean') {
+                newContentRegExp = newContentRecursive;
+                newContentRecursive = undefined;
+            }
+            this.newContentResource = newContentResource;
+            this.newContentRecursive = newContentRecursive;
+            this.newContentRegExp = newContentRegExp;
+        }
+    }
+    apply(compiler) {
+        const resourceRegExp = this.resourceRegExp;
+        const newContentCallback = this.newContentCallback;
+        const newContentResource = this.newContentResource;
+        const newContentRecursive = this.newContentRecursive;
+        const newContentRegExp = this.newContentRegExp;
+        const newContentCreateContextMap = this.newContentCreateContextMap;
+        compiler.hooks.contextModuleFactory.tap('ContextReplacementPlugin', cmf => {
+            cmf.hooks.beforeResolve.tap('ContextReplacementPlugin', result => {
+                if (!result)
+                    return;
+                if (resourceRegExp.test(result.request)) {
+                    if (newContentResource !== undefined) {
+                        result.request = newContentResource;
+                    }
+                    if (newContentRecursive !== undefined) {
+                        result.recursive = newContentRecursive;
+                    }
+                    if (newContentRegExp !== undefined) {
+                        result.regExp = newContentRegExp;
+                    }
+                    if (typeof newContentCallback === 'function') {
+                        newContentCallback(result);
+                    }
+                    else {
+                        for (const d of result.dependencies) {
+                            if (d.critical)
+                                d.critical = false;
+                        }
+                    }
+                }
+                return result;
+            });
+            cmf.hooks.afterResolve.tap('ContextReplacementPlugin', result => {
+                if (!result)
+                    return;
+                if (resourceRegExp.test(result.resource)) {
+                    if (newContentResource !== undefined) {
+                        if (newContentResource.startsWith('/') ||
+                            (newContentResource.length > 1 && newContentResource[1] === ':')) {
+                            result.resource = newContentResource;
+                        }
+                        else {
+                            result.resource = (0, fs_1.join)(compiler.inputFileSystem, result.resource, newContentResource);
+                        }
+                    }
+                    if (newContentRecursive !== undefined) {
+                        result.recursive = newContentRecursive;
+                    }
+                    if (newContentRegExp !== undefined) {
+                        result.regExp = newContentRegExp;
+                    }
+                    if (typeof newContentCreateContextMap === 'function') {
+                        result.resolveDependencies = createResolveDependenciesFromContextMap(newContentCreateContextMap);
+                    }
+                    if (typeof newContentCallback === 'function') {
+                        const origResource = result.resource;
+                        newContentCallback(result);
+                        if (result.resource !== origResource &&
+                            !result.resource.startsWith('/') &&
+                            (result.resource.length <= 1 || result.resource[1] !== ':')) {
+                            // When the function changed it to an relative path
+                            result.resource = (0, fs_1.join)(compiler.inputFileSystem, origResource, result.resource);
+                        }
+                    }
+                    else {
+                        for (const d of result.dependencies) {
+                            if (d.critical)
+                                d.critical = false;
+                        }
+                    }
+                }
+                return result;
+            });
+        });
+    }
+}
+const createResolveDependenciesFromContextMap = createContextMap => {
+    const resolveDependenciesFromContextMap = (fs, options, callback) => {
+        createContextMap(fs, (err, map) => {
+            if (err)
+                return callback(err);
+            const dependencies = Object.keys(map).map(key => new ContextElementDependency_1.default(map[key] + options.resourceQuery + options.resourceFragment, key, options.category, options.referencedExports));
+            callback(null, dependencies);
+        });
+    };
+    return resolveDependenciesFromContextMap;
+};
+exports.default = ContextReplacementPlugin;

package/dist/module/CssModule.d.ts

@@ -0,0 +1,20 @@
+import NormalModule from '@/module/NormalModule';
+declare class CssModule extends NormalModule {
+    cssLayer: any;
+    supports: any;
+    media: any;
+    inheritance: any;
+    constructor(options: any);
+    identifier(): any;
+    readableIdentifier(requestShortener: any): string;
+    /**
+     * Assuming this module is in the cache. Update the (cached) module with
+     * the fresh module from the factory. Usually updates internal references
+     * and properties.
+     */
+    updateCacheModule(module: any): void;
+    serialize(context: any): void;
+    static deserialize(context: any): CssModule;
+    deserialize(context: any): void;
+}
+export default CssModule;

package/dist/module/CssModule.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NormalModule_1 = __importDefault(require("@/module/NormalModule"));
+const makeSerializable_1 = __importDefault(require("@/serialization/makeSerializable"));
+class CssModule extends NormalModule_1.default {
+    constructor(options) {
+        super(options);
+        // Avoid override `layer` for `Module` class, because it is a feature to run module in specific layer
+        this.cssLayer = options.cssLayer;
+        this.supports = options.supports;
+        this.media = options.media;
+        this.inheritance = options.inheritance;
+    }
+    identifier() {
+        let identifier = super.identifier();
+        if (this.cssLayer) {
+            identifier += `|${this.cssLayer}`;
+        }
+        if (this.supports) {
+            identifier += `|${this.supports}`;
+        }
+        if (this.media) {
+            identifier += `|${this.media}`;
+        }
+        if (this.inheritance) {
+            const inheritance = this.inheritance.map((item, index) => `inheritance_${index}|${item[0] || ''}|${item[1] || ''}|${item[2] || ''}`);
+            identifier += `|${inheritance.join('|')}`;
+        }
+        return identifier;
+    }
+    readableIdentifier(requestShortener) {
+        const readableIdentifier = super.readableIdentifier(requestShortener);
+        let identifier = `css ${readableIdentifier}`;
+        if (this.cssLayer) {
+            identifier += ` (layer: ${this.cssLayer})`;
+        }
+        if (this.supports) {
+            identifier += ` (supports: ${this.supports})`;
+        }
+        if (this.media) {
+            identifier += ` (media: ${this.media})`;
+        }
+        return identifier;
+    }
+    /**
+     * Assuming this module is in the cache. Update the (cached) module with
+     * the fresh module from the factory. Usually updates internal references
+     * and properties.
+     */
+    updateCacheModule(module) {
+        super.updateCacheModule(module);
+        const m = module;
+        this.cssLayer = m.cssLayer;
+        this.supports = m.supports;
+        this.media = m.media;
+        this.inheritance = m.inheritance;
+    }
+    serialize(context) {
+        const { write } = context;
+        write(this.cssLayer);
+        write(this.supports);
+        write(this.media);
+        write(this.inheritance);
+        super.serialize(context);
+    }
+    static deserialize(context) {
+        const obj = new CssModule({
+            // will be deserialized by Module
+            layer: null,
+            type: '',
+            // will be filled by updateCacheModule
+            resource: '',
+            context: '',
+            request: null,
+            userRequest: null,
+            rawRequest: null,
+            loaders: null,
+            matchResource: null,
+            parser: null,
+            parserOptions: null,
+            generator: null,
+            generatorOptions: null,
+            resolveOptions: null,
+            cssLayer: null,
+            supports: null,
+            media: null,
+            inheritance: null,
+        });
+        obj.deserialize(context);
+        return obj;
+    }
+    deserialize(context) {
+        const { read } = context;
+        this.cssLayer = read();
+        this.supports = read();
+        this.media = read();
+        this.inheritance = read();
+        super.deserialize(context);
+    }
+}
+(0, makeSerializable_1.default)(CssModule, 'mp-compiler/core/module/CssModule');
+exports.default = CssModule;