xhs-mp-pack 1.1.0-beta.0

package/dist/base/identifier.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUndoPath = exports.parseResourceWithoutFragment = exports.parseResource = exports.absolutify = exports.contextify = exports.makePathsAbsolute = exports.makePathsRelative = void 0;
+const path_1 = __importDefault(require("path"));
+const WINDOWS_ABS_PATH_REGEXP = /^[a-zA-Z]:[\\/]/;
+const SEGMENTS_SPLIT_REGEXP = /([|!])/;
+const WINDOWS_PATH_SEPARATOR_REGEXP = /\\/g;
+const relativePathToRequest = (relativePath) => {
+    if (relativePath === '')
+        return './.';
+    if (relativePath === '..')
+        return '../.';
+    if (relativePath.startsWith('../'))
+        return relativePath;
+    return `./${relativePath}`;
+};
+const absoluteToRequest = (context, maybeAbsolutePath) => {
+    if (maybeAbsolutePath[0] === '/') {
+        if (maybeAbsolutePath.length > 1 && maybeAbsolutePath[maybeAbsolutePath.length - 1] === '/') {
+            // this 'path' is actually a regexp generated by dynamic requires.
+            // Don't treat it as an absolute path.
+            return maybeAbsolutePath;
+        }
+        const querySplitPos = maybeAbsolutePath.indexOf('?');
+        let resource = querySplitPos === -1 ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
+        resource = relativePathToRequest(path_1.default.posix.relative(context, resource));
+        return querySplitPos === -1 ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
+    }
+    if (WINDOWS_ABS_PATH_REGEXP.test(maybeAbsolutePath)) {
+        const querySplitPos = maybeAbsolutePath.indexOf('?');
+        let resource = querySplitPos === -1 ? maybeAbsolutePath : maybeAbsolutePath.slice(0, querySplitPos);
+        resource = path_1.default.win32.relative(context, resource);
+        if (!WINDOWS_ABS_PATH_REGEXP.test(resource)) {
+            resource = relativePathToRequest(resource.replace(WINDOWS_PATH_SEPARATOR_REGEXP, '/'));
+        }
+        return querySplitPos === -1 ? resource : resource + maybeAbsolutePath.slice(querySplitPos);
+    }
+    // not an absolute path
+    return maybeAbsolutePath;
+};
+const requestToAbsolute = (context, relativePath) => {
+    if (relativePath.startsWith('./') || relativePath.startsWith('../'))
+        return path_1.default.join(context, relativePath);
+    return relativePath;
+};
+const makeCacheable = realFn => {
+    const cache = new WeakMap();
+    const getCache = associatedObjectForCache => {
+        const entry = cache.get(associatedObjectForCache);
+        if (entry !== undefined)
+            return entry;
+        const map = new Map();
+        cache.set(associatedObjectForCache, map);
+        return map;
+    };
+    const fn = (str, associatedObjectForCache) => {
+        if (!associatedObjectForCache)
+            return realFn(str);
+        const cache = getCache(associatedObjectForCache);
+        const entry = cache.get(str);
+        if (entry !== undefined)
+            return entry;
+        const result = realFn(str);
+        cache.set(str, result);
+        return result;
+    };
+    fn.bindCache = associatedObjectForCache => {
+        const cache = getCache(associatedObjectForCache);
+        return str => {
+            const entry = cache.get(str);
+            if (entry !== undefined)
+                return entry;
+            const result = realFn(str);
+            cache.set(str, result);
+            return result;
+        };
+    };
+    return fn;
+};
+const makeCacheableWithContext = fn => {
+    const cache = new WeakMap();
+    const cachedFn = (context, identifier, associatedObjectForCache) => {
+        if (!associatedObjectForCache)
+            return fn(context, identifier);
+        let innerCache = cache.get(associatedObjectForCache);
+        if (innerCache === undefined) {
+            innerCache = new Map();
+            cache.set(associatedObjectForCache, innerCache);
+        }
+        let cachedResult;
+        let innerSubCache = innerCache.get(context);
+        if (innerSubCache === undefined) {
+            innerCache.set(context, (innerSubCache = new Map()));
+        }
+        else {
+            cachedResult = innerSubCache.get(identifier);
+        }
+        if (cachedResult !== undefined) {
+            return cachedResult;
+        }
+        const result = fn(context, identifier);
+        innerSubCache.set(identifier, result);
+        return result;
+    };
+    cachedFn.bindCache = (associatedObjectForCache) => {
+        let innerCache;
+        if (associatedObjectForCache) {
+            innerCache = cache.get(associatedObjectForCache);
+            if (innerCache === undefined) {
+                innerCache = new Map();
+                cache.set(associatedObjectForCache, innerCache);
+            }
+        }
+        else {
+            innerCache = new Map();
+        }
+        const boundFn = (context, identifier) => {
+            let cachedResult;
+            let innerSubCache = innerCache.get(context);
+            if (innerSubCache === undefined) {
+                innerCache.set(context, (innerSubCache = new Map()));
+            }
+            else {
+                cachedResult = innerSubCache.get(identifier);
+            }
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const result = fn(context, identifier);
+            innerSubCache.set(identifier, result);
+            return result;
+        };
+        return boundFn;
+    };
+    cachedFn.bindContextCache = (context, associatedObjectForCache) => {
+        let innerSubCache;
+        if (associatedObjectForCache) {
+            let innerCache = cache.get(associatedObjectForCache);
+            if (innerCache === undefined) {
+                innerCache = new Map();
+                cache.set(associatedObjectForCache, innerCache);
+            }
+            innerSubCache = innerCache.get(context);
+            if (innerSubCache === undefined) {
+                innerCache.set(context, (innerSubCache = new Map()));
+            }
+        }
+        else {
+            innerSubCache = new Map();
+        }
+        const boundFn = identifier => {
+            const cachedResult = innerSubCache.get(identifier);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const result = fn(context, identifier);
+            innerSubCache.set(identifier, result);
+            return result;
+        };
+        return boundFn;
+    };
+    return cachedFn;
+};
+const _makePathsRelative = (context, identifier) => identifier
+    .split(SEGMENTS_SPLIT_REGEXP)
+    .map(str => absoluteToRequest(context, str))
+    .join('');
+const makePathsRelative = makeCacheableWithContext(_makePathsRelative);
+exports.makePathsRelative = makePathsRelative;
+const _makePathsAbsolute = (context, identifier) => identifier
+    .split(SEGMENTS_SPLIT_REGEXP)
+    .map(str => requestToAbsolute(context, str))
+    .join('');
+const makePathsAbsolute = makeCacheableWithContext(_makePathsAbsolute);
+exports.makePathsAbsolute = makePathsAbsolute;
+const contextify = makeCacheableWithContext((context, request) => request
+    .split('!')
+    .map(r => absoluteToRequest(context, r))
+    .join('!'));
+exports.contextify = contextify;
+const absolutify = makeCacheableWithContext((context, request) => request
+    .split('!')
+    .map(r => requestToAbsolute(context, r))
+    .join('!'));
+exports.absolutify = absolutify;
+const PATH_QUERY_FRAGMENT_REGEXP = /^((?:\0.|[^?#\0])*)(\?(?:\0.|[^#\0])*)?(#.*)?$/;
+const PATH_QUERY_REGEXP = /^((?:\0.|[^?\0])*)(\?.*)?$/;
+const _parseResource = (str) => {
+    const match = PATH_QUERY_FRAGMENT_REGEXP.exec(str);
+    return {
+        resource: str,
+        path: match[1].replace(/\0(.)/g, '$1'),
+        query: match[2] ? match[2].replace(/\0(.)/g, '$1') : '',
+        fragment: match[3] || '',
+    };
+};
+const parseResource = makeCacheable(_parseResource);
+exports.parseResource = parseResource;
+const _parseResourceWithoutFragment = (str) => {
+    const match = PATH_QUERY_REGEXP.exec(str);
+    return {
+        resource: str,
+        path: match[1].replace(/\0(.)/g, '$1'),
+        query: match[2] ? match[2].replace(/\0(.)/g, '$1') : '',
+    };
+};
+const parseResourceWithoutFragment = makeCacheable(_parseResourceWithoutFragment);
+exports.parseResourceWithoutFragment = parseResourceWithoutFragment;
+const getUndoPath = (filename, outputPath, enforceRelative) => {
+    let depth = -1;
+    let append = '';
+    outputPath = outputPath.replace(/[\\/]$/, '');
+    for (const part of filename.split(/[/\\]+/)) {
+        if (part === '..') {
+            if (depth > -1) {
+                depth--;
+            }
+            else {
+                const i = outputPath.lastIndexOf('/');
+                const j = outputPath.lastIndexOf('\\');
+                const pos = i < 0 ? j : j < 0 ? i : Math.max(i, j);
+                if (pos < 0)
+                    return `${outputPath}/`;
+                append = `${outputPath.slice(pos + 1)}/${append}`;
+                outputPath = outputPath.slice(0, pos);
+            }
+        }
+        else if (part !== '.') {
+            depth++;
+        }
+    }
+    return depth > 0 ? `${'../'.repeat(depth)}${append}` : enforceRelative ? `./${append}` : append;
+};
+exports.getUndoPath = getUndoPath;

package/dist/base/logging/Logger.d.ts

@@ -0,0 +1,40 @@
+declare const LogType: Readonly<{
+    error: "error";
+    warn: "warn";
+    info: "info";
+    log: "log";
+    debug: "debug";
+    trace: "trace";
+    group: "group";
+    groupCollapsed: "groupCollapsed";
+    groupEnd: "groupEnd";
+    profile: "profile";
+    profileEnd: "profileEnd";
+    time: "time";
+    clear: "clear";
+    status: "status";
+}>;
+declare class Logger {
+    getChildLogger: any;
+    constructor(log: any, getChildLogger?: any);
+    error(...args: any[]): void;
+    warn(...args: any[]): void;
+    info(...args: any[]): void;
+    log(...args: any[]): void;
+    debug(...args: any[]): void;
+    assert(assertion: any, ...args: any[]): void;
+    trace(): void;
+    clear(): void;
+    status(...args: any[]): void;
+    group(...args: any[]): void;
+    groupCollapsed(...args: any[]): void;
+    groupEnd(...args: any[]): void;
+    profile(label: any): void;
+    profileEnd(label: any): void;
+    time(label: any): void;
+    timeLog(label: any): void;
+    timeEnd(label: any): void;
+    timeAggregate(label: any): void;
+    timeAggregateEnd(label: any): void;
+}
+export { LogType, Logger };

package/dist/base/logging/Logger.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = exports.LogType = void 0;
+const LogType = Object.freeze({
+    error: 'error',
+    warn: 'warn',
+    info: 'info',
+    log: 'log',
+    debug: 'debug',
+    trace: 'trace',
+    group: 'group',
+    groupCollapsed: 'groupCollapsed',
+    groupEnd: 'groupEnd',
+    profile: 'profile',
+    profileEnd: 'profileEnd',
+    time: 'time',
+    clear: 'clear',
+    status: 'status', // message, arguments
+});
+exports.LogType = LogType;
+const LOG_SYMBOL = Symbol('webpack logger raw log method');
+const TIMERS_SYMBOL = Symbol('webpack logger times');
+const TIMERS_AGGREGATES_SYMBOL = Symbol('webpack logger aggregated times');
+class Logger {
+    constructor(log, getChildLogger) {
+        this[LOG_SYMBOL] = log;
+        this.getChildLogger = getChildLogger;
+    }
+    error(...args) {
+        this[LOG_SYMBOL](LogType.error, args);
+    }
+    warn(...args) {
+        this[LOG_SYMBOL](LogType.warn, args);
+    }
+    info(...args) {
+        this[LOG_SYMBOL](LogType.info, args);
+    }
+    log(...args) {
+        this[LOG_SYMBOL](LogType.log, args);
+    }
+    debug(...args) {
+        this[LOG_SYMBOL](LogType.debug, args);
+    }
+    assert(assertion, ...args) {
+        if (!assertion) {
+            this[LOG_SYMBOL](LogType.error, args);
+        }
+    }
+    trace() {
+        this[LOG_SYMBOL](LogType.trace, ['Trace']);
+    }
+    clear() {
+        this[LOG_SYMBOL](LogType.clear);
+    }
+    status(...args) {
+        this[LOG_SYMBOL](LogType.status, args);
+    }
+    group(...args) {
+        this[LOG_SYMBOL](LogType.group, args);
+    }
+    groupCollapsed(...args) {
+        this[LOG_SYMBOL](LogType.groupCollapsed, args);
+    }
+    groupEnd(...args) {
+        this[LOG_SYMBOL](LogType.groupEnd, args);
+    }
+    profile(label) {
+        this[LOG_SYMBOL](LogType.profile, [label]);
+    }
+    profileEnd(label) {
+        this[LOG_SYMBOL](LogType.profileEnd, [label]);
+    }
+    time(label) {
+        this[TIMERS_SYMBOL] = this[TIMERS_SYMBOL] || new Map();
+        this[TIMERS_SYMBOL].set(label, process.hrtime());
+    }
+    timeLog(label) {
+        var _a;
+        const prev = (_a = this[TIMERS_SYMBOL]) === null || _a === void 0 ? void 0 : _a.get(label);
+        if (!prev) {
+            throw new Error(`No such label '${label}' for WebpackLogger.timeLog()`);
+        }
+        const time = process.hrtime(prev);
+        this[LOG_SYMBOL](LogType.time, [label, ...time]);
+    }
+    timeEnd(label) {
+        var _a;
+        const prev = (_a = this[TIMERS_SYMBOL]) === null || _a === void 0 ? void 0 : _a.get(label);
+        if (!prev) {
+            throw new Error(`No such label '${label}' for WebpackLogger.timeEnd()`);
+        }
+        const time = process.hrtime(prev);
+        this[TIMERS_SYMBOL].delete(label);
+        this[LOG_SYMBOL](LogType.time, [label, ...time]);
+    }
+    timeAggregate(label) {
+        var _a;
+        const prev = (_a = this[TIMERS_SYMBOL]) === null || _a === void 0 ? void 0 : _a.get(label);
+        if (!prev) {
+            throw new Error(`No such label '${label}' for WebpackLogger.timeAggregate()`);
+        }
+        const time = process.hrtime(prev);
+        this[TIMERS_SYMBOL].delete(label);
+        this[TIMERS_AGGREGATES_SYMBOL] = this[TIMERS_AGGREGATES_SYMBOL] || new Map();
+        const current = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+        if (current !== undefined) {
+            if (time[1] + current[1] > 1e9) {
+                time[0] += current[0] + 1;
+                time[1] = time[1] - 1e9 + current[1];
+            }
+            else {
+                time[0] += current[0];
+                time[1] += current[1];
+            }
+        }
+        this[TIMERS_AGGREGATES_SYMBOL].set(label, time);
+    }
+    timeAggregateEnd(label) {
+        if (this[TIMERS_AGGREGATES_SYMBOL] === undefined)
+            return;
+        const time = this[TIMERS_AGGREGATES_SYMBOL].get(label);
+        if (time === undefined)
+            return;
+        this[TIMERS_AGGREGATES_SYMBOL].delete(label);
+        this[LOG_SYMBOL](LogType.time, [label, ...time]);
+    }
+}
+exports.Logger = Logger;

package/dist/base/logging/createConsoleLogger.d.ts

@@ -0,0 +1,6 @@
+declare const _default: ({ level, debug, console }: {
+    level?: string | undefined;
+    debug?: boolean | undefined;
+    console: any;
+}) => (name: any, type: any, args: any) => void;
+export default _default;

package/dist/base/logging/createConsoleLogger.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Logger_1 = require("./Logger");
+const filterToFunction = item => {
+    if (typeof item === 'string') {
+        const regExp = new RegExp(`[\\\\/]${item.replace(
+        // eslint-disable-next-line no-useless-escape
+        /[-[\]{}()*+?.\\^$|]/g, '\\$&')}([\\\\/]|$|!|\\?)`);
+        return ident => regExp.test(ident);
+    }
+    if (item && typeof item === 'object' && typeof item.test === 'function') {
+        return ident => item.test(ident);
+    }
+    if (typeof item === 'function') {
+        return item;
+    }
+    if (typeof item === 'boolean') {
+        return () => item;
+    }
+};
+const LogLevel = {
+    none: 6,
+    false: 6,
+    error: 5,
+    warn: 4,
+    info: 3,
+    log: 2,
+    true: 2,
+    verbose: 1,
+};
+exports.default = ({ level = 'info', debug = false, console }) => {
+    const debugFilters = typeof debug === 'boolean' ? [() => debug] : [].concat(debug).map(filterToFunction);
+    const loglevel = LogLevel[`${level}`] || 0;
+    const logger = (name, type, args) => {
+        const labeledArgs = () => {
+            if (Array.isArray(args)) {
+                if (args.length > 0 && typeof args[0] === 'string') {
+                    return [`[${name}] ${args[0]}`, ...args.slice(1)];
+                }
+                return [`[${name}]`, ...args];
+            }
+            return [];
+        };
+        const debug = debugFilters.some(f => f(name));
+        switch (type) {
+            case Logger_1.LogType.debug:
+                if (!debug)
+                    return;
+                if (typeof console.debug === 'function') {
+                    console.debug(...labeledArgs());
+                }
+                else {
+                    console.log(...labeledArgs());
+                }
+                break;
+            case Logger_1.LogType.log:
+                if (!debug && loglevel > LogLevel.log)
+                    return;
+                console.log(...labeledArgs());
+                break;
+            case Logger_1.LogType.info:
+                if (!debug && loglevel > LogLevel.info)
+                    return;
+                console.info(...labeledArgs());
+                break;
+            case Logger_1.LogType.warn:
+                if (!debug && loglevel > LogLevel.warn)
+                    return;
+                console.warn(...labeledArgs());
+                break;
+            case Logger_1.LogType.error:
+                if (!debug && loglevel > LogLevel.error)
+                    return;
+                console.error(...labeledArgs());
+                break;
+            case Logger_1.LogType.trace:
+                if (!debug)
+                    return;
+                console.trace();
+                break;
+            case Logger_1.LogType.groupCollapsed:
+                if (!debug && loglevel > LogLevel.log)
+                    return;
+                if (!debug && loglevel > LogLevel.verbose) {
+                    if (typeof console.groupCollapsed === 'function') {
+                        console.groupCollapsed(...labeledArgs());
+                    }
+                    else {
+                        console.log(...labeledArgs());
+                    }
+                    break;
+                }
+            // falls through
+            case Logger_1.LogType.group:
+                if (!debug && loglevel > LogLevel.log)
+                    return;
+                if (typeof console.group === 'function') {
+                    console.group(...labeledArgs());
+                }
+                else {
+                    console.log(...labeledArgs());
+                }
+                break;
+            case Logger_1.LogType.groupEnd:
+                if (!debug && loglevel > LogLevel.log)
+                    return;
+                if (typeof console.groupEnd === 'function') {
+                    console.groupEnd();
+                }
+                break;
+            case Logger_1.LogType.time: {
+                if (!debug && loglevel > LogLevel.log)
+                    return;
+                const ms = args[1] * 1000 + args[2] / 1000000;
+                const msg = `[${name}] ${args[0]}: ${ms} ms`;
+                if (typeof console.logTime === 'function') {
+                    console.logTime(msg);
+                }
+                else {
+                    console.log(msg);
+                }
+                break;
+            }
+            case Logger_1.LogType.profile:
+                if (typeof console.profile === 'function') {
+                    console.profile(...labeledArgs());
+                }
+                break;
+            case Logger_1.LogType.profileEnd:
+                if (typeof console.profileEnd === 'function') {
+                    console.profileEnd(...labeledArgs());
+                }
+                break;
+            case Logger_1.LogType.clear:
+                if (!debug && loglevel > LogLevel.log)
+                    return;
+                if (typeof console.clear === 'function') {
+                    console.clear();
+                }
+                break;
+            case Logger_1.LogType.status:
+                if (!debug && loglevel > LogLevel.info)
+                    return;
+                if (typeof console.status === 'function') {
+                    if (args.length === 0) {
+                        console.status();
+                    }
+                    else {
+                        console.status(...labeledArgs());
+                    }
+                }
+                else if (args.length !== 0) {
+                    console.info(...labeledArgs());
+                }
+                break;
+            default:
+                throw new Error(`Unexpected LogType ${type}`);
+        }
+    };
+    return logger;
+};

package/dist/base/logging/nodeConsole.d.ts

@@ -0,0 +1,21 @@
+declare const _default: ({ colors, appendOnly, stream }: {
+    colors: any;
+    appendOnly: any;
+    stream: any;
+}) => {
+    log: (...args: any[]) => void;
+    debug: (...args: any[]) => void;
+    trace: (...args: any[]) => void;
+    info: (...args: any[]) => void;
+    warn: (...args: any[]) => void;
+    error: (...args: any[]) => void;
+    logTime: (...args: any[]) => void;
+    group: (...args: any[]) => void;
+    groupCollapsed: (...args: any[]) => void;
+    groupEnd: () => void;
+    profile: (name: any) => void;
+    profileEnd: (name: any) => void;
+    clear: false | (() => void);
+    status: (...args: any[]) => void;
+};
+export default _default;