xhs-mp-pack 1.1.0-beta.0

package/dist/plugins/CleanPlugin.js

@@ -0,0 +1,295 @@
+"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 Compilation_1 = __importDefault(require("@/Compilation"));
+const fs_1 = require("@/base/fs");
+const processAsyncTree_1 = __importDefault(require("@/base/processAsyncTree"));
+const _10sec = 10 * 1000;
+const mergeAssets = (as1, as2) => {
+    for (const [key, value1] of as2) {
+        const value2 = as1.get(key);
+        if (!value2 || value1 > value2)
+            as1.set(key, value1);
+    }
+};
+const getDiffToFs = (fs, outputPath, currentAssets, callback) => {
+    const directories = new Set();
+    // get directories of assets
+    for (const [asset] of currentAssets) {
+        directories.add(asset.replace(/(^|\/)[^/]*$/, ''));
+    }
+    // and all parent directories
+    for (const directory of directories) {
+        directories.add(directory.replace(/(^|\/)[^/]*$/, ''));
+    }
+    const diff = new Set();
+    neo_async_1.default.forEachLimit(directories, 10, (directory, callback) => {
+        fs.readdir((0, fs_1.join)(fs, outputPath, directory), (err, entries) => {
+            if (err) {
+                if (err.code === 'ENOENT')
+                    return callback();
+                if (err.code === 'ENOTDIR') {
+                    diff.add(directory);
+                    return callback();
+                }
+                return callback(err);
+            }
+            for (const entry of entries) {
+                const file = entry;
+                const filename = directory ? `${directory}/${file}` : file;
+                if (!directories.has(filename) && !currentAssets.has(filename)) {
+                    diff.add(filename);
+                }
+            }
+            callback();
+        });
+    }, err => {
+        if (err)
+            return callback(err);
+        callback(null, diff);
+    });
+};
+const getDiffToOldAssets = (currentAssets, oldAssets) => {
+    const diff = new Set();
+    const now = Date.now();
+    for (const [asset, ts] of oldAssets) {
+        if (ts >= now)
+            continue;
+        if (!currentAssets.has(asset))
+            diff.add(asset);
+    }
+    return diff;
+};
+const doStat = (fs, filename, callback) => {
+    if ('lstat' in fs) {
+        fs.lstat(filename, callback);
+    }
+    else {
+        fs.stat(filename, callback);
+    }
+};
+const applyDiff = (fs, outputPath, dry, logger, diff, isKept, callback) => {
+    const log = msg => {
+        if (dry) {
+            logger.info(msg);
+        }
+        else {
+            logger.log(msg);
+        }
+    };
+    const jobs = Array.from(diff.keys(), filename => ({
+        type: 'check',
+        filename,
+        parent: undefined,
+    }));
+    const keptAssets = new Map();
+    (0, processAsyncTree_1.default)(jobs, 10, ({ type, filename, parent }, push, callback) => {
+        const handleError = err => {
+            if (err.code === 'ENOENT') {
+                log(`${filename} was removed during cleaning by something else`);
+                handleParent();
+                return callback();
+            }
+            return callback(err);
+        };
+        const handleParent = () => {
+            if (parent && --parent.remaining === 0)
+                push(parent.job);
+        };
+        const path = (0, fs_1.join)(fs, outputPath, filename);
+        switch (type) {
+            case 'check':
+                if (isKept(filename)) {
+                    keptAssets.set(filename, 0);
+                    // do not decrement parent entry as we don't want to delete the parent
+                    log(`${filename} will be kept`);
+                    return process.nextTick(callback);
+                }
+                doStat(fs, path, (err, stats) => {
+                    if (err)
+                        return handleError(err);
+                    if (!stats.isDirectory()) {
+                        push({
+                            type: 'unlink',
+                            filename,
+                            parent,
+                        });
+                        return callback();
+                    }
+                    fs.readdir(path, (err, entries) => {
+                        if (err)
+                            return handleError(err);
+                        const deleteJob = {
+                            type: 'rmdir',
+                            filename,
+                            parent,
+                        };
+                        if (entries.length === 0) {
+                            push(deleteJob);
+                        }
+                        else {
+                            const parentToken = {
+                                remaining: entries.length,
+                                job: deleteJob,
+                            };
+                            for (const entry of entries) {
+                                const file = entry;
+                                if (file.startsWith('.')) {
+                                    log(`${filename} will be kept (dot-files will never be removed)`);
+                                    continue;
+                                }
+                                push({
+                                    type: 'check',
+                                    filename: `${filename}/${file}`,
+                                    parent: parentToken,
+                                });
+                            }
+                        }
+                        return callback();
+                    });
+                });
+                break;
+            case 'rmdir':
+                log(`${filename} will be removed`);
+                if (dry) {
+                    handleParent();
+                    return process.nextTick(callback);
+                }
+                if (!fs.rmdir) {
+                    logger.warn(`${filename} can't be removed because output file system doesn't support removing directories (rmdir)`);
+                    return process.nextTick(callback);
+                }
+                fs.rmdir(path, err => {
+                    if (err)
+                        return handleError(err);
+                    handleParent();
+                    callback();
+                });
+                break;
+            case 'unlink':
+                log(`${filename} will be removed`);
+                if (dry) {
+                    handleParent();
+                    return process.nextTick(callback);
+                }
+                if (!fs.unlink) {
+                    logger.warn(`${filename} can't be removed because output file system doesn't support removing files (rmdir)`);
+                    return process.nextTick(callback);
+                }
+                fs.unlink(path, err => {
+                    if (err)
+                        return handleError(err);
+                    handleParent();
+                    callback();
+                });
+                break;
+        }
+    }, err => {
+        if (err)
+            return callback(err);
+        callback(undefined, keptAssets);
+    });
+};
+const compilationHooksMap = new WeakMap();
+class CleanPlugin {
+    static getCompilationHooks(compilation) {
+        if (!(compilation instanceof Compilation_1.default)) {
+            throw new TypeError("The 'compilation' argument must be an instance of Compilation");
+        }
+        let hooks = compilationHooksMap.get(compilation);
+        if (hooks === undefined) {
+            hooks = {
+                keep: new tapable_1.SyncBailHook(['ignore']),
+            };
+            compilationHooksMap.set(compilation, hooks);
+        }
+        return hooks;
+    }
+    constructor(options = {}) {
+        this.options = Object.assign({ dry: false }, options);
+    }
+    apply(compiler) {
+        const { dry, keep } = this.options;
+        const keepFn = typeof keep === 'function'
+            ? keep
+            : typeof keep === 'string'
+                ? path => path.startsWith(keep)
+                : typeof keep === 'object' && keep.test
+                    ? path => keep.test(path)
+                    : () => false;
+        // We assume that no external modification happens while the compiler is active
+        // So we can store the old assets and only diff to them to avoid fs access on
+        // incremental builds
+        let oldAssets;
+        compiler.hooks.emit.tapAsync({
+            name: 'CleanPlugin',
+            stage: 100,
+        }, (compilation, callback) => {
+            const hooks = CleanPlugin.getCompilationHooks(compilation);
+            const logger = compilation.getLogger('webpack.CleanPlugin');
+            const fs = compiler.outputFileSystem;
+            if (!fs.readdir) {
+                return callback(new Error("CleanPlugin: Output filesystem doesn't support listing directories (readdir)"));
+            }
+            const currentAssets = new Map();
+            const now = Date.now();
+            for (const asset of Object.keys(compilation.assets)) {
+                if (/^[A-Za-z]:\\|^\/|^\\\\/.test(asset))
+                    continue;
+                let normalizedAsset;
+                let newNormalizedAsset = asset.replace(/\\/g, '/');
+                do {
+                    normalizedAsset = newNormalizedAsset;
+                    newNormalizedAsset = normalizedAsset.replace(/(^|\/)(?!\.\.)[^/]+\/\.\.\//g, '$1');
+                } while (newNormalizedAsset !== normalizedAsset);
+                if (normalizedAsset.startsWith('../'))
+                    continue;
+                const assetInfo = compilation.assetsInfo.get(asset);
+                if (assetInfo === null || assetInfo === void 0 ? void 0 : assetInfo.hotModuleReplacement) {
+                    currentAssets.set(normalizedAsset, now + _10sec);
+                }
+                else {
+                    currentAssets.set(normalizedAsset, 0);
+                }
+            }
+            const outputPath = compilation.getPath(compiler.outputPath, {});
+            const isKept = path => {
+                const result = hooks.keep.call(path);
+                if (result !== undefined)
+                    return result;
+                return keepFn(path);
+            };
+            const diffCallback = (err, diff) => {
+                if (err) {
+                    oldAssets = undefined;
+                    callback(err);
+                    return;
+                }
+                applyDiff(fs, outputPath, dry, logger, diff, isKept, (err, keptAssets) => {
+                    if (err) {
+                        oldAssets = undefined;
+                    }
+                    else {
+                        if (oldAssets)
+                            mergeAssets(currentAssets, oldAssets);
+                        oldAssets = currentAssets;
+                        if (keptAssets)
+                            mergeAssets(oldAssets, keptAssets);
+                    }
+                    callback(err);
+                });
+            };
+            if (oldAssets) {
+                diffCallback(null, getDiffToOldAssets(currentAssets, oldAssets));
+            }
+            else {
+                getDiffToFs(fs, outputPath, currentAssets, diffCallback);
+            }
+        });
+    }
+}
+exports.default = CleanPlugin;

package/dist/plugins/CompatibilityPlugin.d.ts

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

package/dist/plugins/CompatibilityPlugin.js

@@ -0,0 +1,142 @@
+"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 ModuleTypeConstants_1 = require("@/module/ModuleTypeConstants");
+const RuntimeGlobals = __importStar(require("@/module/RuntimeGlobals"));
+const ConstDependency_1 = __importDefault(require("@/dependencies/const/ConstDependency"));
+const nestedWebpackIdentifierTag = Symbol('nested webpack identifier');
+const PLUGIN_NAME = 'CompatibilityPlugin';
+class CompatibilityPlugin {
+    apply(compiler) {
+        compiler.hooks.compilation.tap(PLUGIN_NAME, (compilation, { normalModuleFactory }) => {
+            compilation.dependencyTemplates.set(ConstDependency_1.default, new ConstDependency_1.default.Template());
+            normalModuleFactory.hooks.parser
+                .for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO)
+                .tap(PLUGIN_NAME, (parser, parserOptions) => {
+                if (parserOptions.browserify !== undefined && !parserOptions.browserify)
+                    return;
+                parser.hooks.call.for('require').tap(PLUGIN_NAME, expr => {
+                    // support for browserify style require delegator: "require(o, !0)"
+                    if (expr.arguments.length !== 2)
+                        return;
+                    const second = parser.evaluateExpression(expr.arguments[1]);
+                    if (!second.isBoolean())
+                        return;
+                    if (second.asBool() !== true)
+                        return;
+                    const dep = new ConstDependency_1.default('require', expr.callee.range);
+                    dep.loc = expr.loc;
+                    if (parser.state.current.dependencies.length > 0) {
+                        const last = parser.state.current.dependencies[parser.state.current.dependencies.length - 1];
+                        if (last.critical &&
+                            last.options &&
+                            last.options.request === '.' &&
+                            last.userRequest === '.' &&
+                            last.options.recursive)
+                            parser.state.current.dependencies.pop();
+                    }
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+            });
+            const handler = parser => {
+                // Handle nested requires
+                parser.hooks.preStatement.tap(PLUGIN_NAME, statement => {
+                    if (statement.type === 'FunctionDeclaration' &&
+                        statement.id &&
+                        statement.id.name === RuntimeGlobals.require) {
+                        const newName = `__nested_webpack_require_${statement.range[0]}__`;
+                        parser.tagVariable(statement.id.name, nestedWebpackIdentifierTag, {
+                            name: newName,
+                            declaration: {
+                                updated: false,
+                                loc: statement.id.loc,
+                                range: statement.id.range,
+                            },
+                        });
+                        return true;
+                    }
+                });
+                parser.hooks.pattern.for(RuntimeGlobals.require).tap(PLUGIN_NAME, pattern => {
+                    const newName = `__nested_webpack_require_${pattern.range[0]}__`;
+                    parser.tagVariable(pattern.name, nestedWebpackIdentifierTag, {
+                        name: newName,
+                        declaration: {
+                            updated: false,
+                            loc: pattern.loc,
+                            range: pattern.range,
+                        },
+                    });
+                    return true;
+                });
+                parser.hooks.pattern.for(RuntimeGlobals.exports).tap(PLUGIN_NAME, pattern => {
+                    parser.tagVariable(pattern.name, nestedWebpackIdentifierTag, {
+                        name: '__nested_webpack_exports__',
+                        declaration: {
+                            updated: false,
+                            loc: pattern.loc,
+                            range: pattern.range,
+                        },
+                    });
+                    return true;
+                });
+                parser.hooks.expression.for(nestedWebpackIdentifierTag).tap(PLUGIN_NAME, expr => {
+                    const { name, declaration } = parser.currentTagData;
+                    if (!declaration.updated) {
+                        const dep = new ConstDependency_1.default(name, declaration.range);
+                        dep.loc = declaration.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                        declaration.updated = true;
+                    }
+                    const dep = new ConstDependency_1.default(name, expr.range);
+                    dep.loc = expr.loc;
+                    parser.state.module.addPresentationalDependency(dep);
+                    return true;
+                });
+                // Handle hashbang
+                parser.hooks.program.tap(PLUGIN_NAME, (program, comments) => {
+                    if (comments.length === 0)
+                        return;
+                    const c = comments[0];
+                    if (c.type === 'Line' && c.range[0] === 0) {
+                        if (parser.state.source.slice(0, 2).toString() !== '#!')
+                            return;
+                        // this is a hashbang comment
+                        const dep = new ConstDependency_1.default('//', 0);
+                        dep.loc = c.loc;
+                        parser.state.module.addPresentationalDependency(dep);
+                    }
+                });
+            };
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_AUTO).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_DYNAMIC).tap(PLUGIN_NAME, handler);
+            normalModuleFactory.hooks.parser.for(ModuleTypeConstants_1.JAVASCRIPT_MODULE_TYPE_ESM).tap(PLUGIN_NAME, handler);
+        });
+    }
+}
+exports.default = CompatibilityPlugin;

package/dist/plugins/ConstPlugin.d.ts

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