xhs-mp-pack 1.1.0-beta.0

package/dist/base/comparators.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareLocations = exports.compareChunksNatural = exports.keepOriginalOrder = exports.compareIterables = exports.compareSelect = exports.concatComparators = exports.compareChunkGroupsByIndex = exports.compareStrings = exports.compareChunks = exports.compareModulesByIdOrIdentifier = exports.compareModulesByPreOrderIndexOrIdentifier = exports.compareModulesByPostOrderIndexOrIdentifier = exports.compareStringsNumeric = exports.compareNumbers = exports.compareModulesById = exports.compareModulesByIdentifier = exports.compareChunksById = exports.compareIds = void 0;
+const RuntimeHelpers_1 = require("../module/RuntimeHelpers");
+const createCachedParameterizedComparator = fn => {
+    const map = new WeakMap();
+    return arg => {
+        const cachedResult = map.get(arg);
+        if (cachedResult !== undefined)
+            return cachedResult;
+        const result = fn.bind(null, arg);
+        map.set(arg, result);
+        return result;
+    };
+};
+const compareChunksById = (a, b) => compareIds(a.id, b.id);
+exports.compareChunksById = compareChunksById;
+const compareModulesByIdentifier = (a, b) => compareIds(a.identifier(), b.identifier());
+exports.compareModulesByIdentifier = compareModulesByIdentifier;
+const compareModulesById = createCachedParameterizedComparator((chunkGraph, a, b) => compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b)));
+exports.compareModulesById = compareModulesById;
+const compareNumbers = (a, b) => {
+    if (typeof a !== typeof b) {
+        return typeof a < typeof b ? -1 : 1;
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+exports.compareNumbers = compareNumbers;
+const compareStringsNumeric = (a, b) => {
+    const partsA = a.split(/(\d+)/);
+    const partsB = b.split(/(\d+)/);
+    const len = Math.min(partsA.length, partsB.length);
+    for (let i = 0; i < len; i++) {
+        const pA = partsA[i];
+        const pB = partsB[i];
+        if (i % 2 === 0) {
+            if (pA.length > pB.length) {
+                if (pA.slice(0, pB.length) > pB)
+                    return 1;
+                return -1;
+            }
+            if (pB.length > pA.length) {
+                if (pB.slice(0, pA.length) > pA)
+                    return -1;
+                return 1;
+            }
+            if (pA < pB)
+                return -1;
+            if (pA > pB)
+                return 1;
+        }
+        else {
+            const nA = +pA;
+            const nB = +pB;
+            if (nA < nB)
+                return -1;
+            if (nA > nB)
+                return 1;
+        }
+    }
+    if (partsB.length < partsA.length)
+        return 1;
+    if (partsB.length > partsA.length)
+        return -1;
+    return 0;
+};
+exports.compareStringsNumeric = compareStringsNumeric;
+const compareModulesByPostOrderIndexOrIdentifier = createCachedParameterizedComparator((moduleGraph, a, b) => {
+    const cmp = compareNumbers(moduleGraph.getPostOrderIndex(a), moduleGraph.getPostOrderIndex(b));
+    if (cmp !== 0)
+        return cmp;
+    return compareIds(a.identifier(), b.identifier());
+});
+exports.compareModulesByPostOrderIndexOrIdentifier = compareModulesByPostOrderIndexOrIdentifier;
+const compareModulesByPreOrderIndexOrIdentifier = createCachedParameterizedComparator((moduleGraph, a, b) => {
+    const cmp = compareNumbers(moduleGraph.getPreOrderIndex(a), moduleGraph.getPreOrderIndex(b));
+    if (cmp !== 0)
+        return cmp;
+    return compareIds(a.identifier(), b.identifier());
+});
+exports.compareModulesByPreOrderIndexOrIdentifier = compareModulesByPreOrderIndexOrIdentifier;
+const compareModulesByIdOrIdentifier = createCachedParameterizedComparator((chunkGraph, a, b) => {
+    const cmp = compareIds(chunkGraph.getModuleId(a), chunkGraph.getModuleId(b));
+    if (cmp !== 0)
+        return cmp;
+    return compareIds(a.identifier(), b.identifier());
+});
+exports.compareModulesByIdOrIdentifier = compareModulesByIdOrIdentifier;
+const compareChunks = createCachedParameterizedComparator((chunkGraph, a, b) => chunkGraph.compareChunks(a, b));
+exports.compareChunks = compareChunks;
+const compareIds = (a, b) => {
+    if (typeof a !== typeof b) {
+        return typeof a < typeof b ? -1 : 1;
+    }
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+exports.compareIds = compareIds;
+const compareStrings = (a, b) => {
+    if (a < b)
+        return -1;
+    if (a > b)
+        return 1;
+    return 0;
+};
+exports.compareStrings = compareStrings;
+const compareChunkGroupsByIndex = (a, b) => a.index < b.index ? -1 : 1;
+exports.compareChunkGroupsByIndex = compareChunkGroupsByIndex;
+class TwoKeyWeakMap {
+    constructor() {
+        this._map = new WeakMap();
+    }
+    get(key1, key2) {
+        const childMap = this._map.get(key1);
+        if (childMap === undefined) {
+            return undefined;
+        }
+        return childMap.get(key2);
+    }
+    set(key1, key2, value) {
+        let childMap = this._map.get(key1);
+        if (childMap === undefined) {
+            childMap = new WeakMap();
+            this._map.set(key1, childMap);
+        }
+        childMap.set(key2, value);
+    }
+}
+const concatComparatorsCache = new TwoKeyWeakMap();
+const concatComparators = (c1, c2, ...cRest) => {
+    if (cRest.length > 0) {
+        const [c3, ...cRest2] = cRest;
+        return concatComparators(c1, concatComparators(c2, c3, ...cRest2));
+    }
+    const cacheEntry = concatComparatorsCache.get(c1, c2);
+    if (cacheEntry !== undefined)
+        return cacheEntry;
+    const result = (a, b) => {
+        const res = c1(a, b);
+        if (res !== 0)
+            return res;
+        return c2(a, b);
+    };
+    concatComparatorsCache.set(c1, c2, result);
+    return result;
+};
+exports.concatComparators = concatComparators;
+const compareSelectCache = new TwoKeyWeakMap();
+const compareSelect = (getter, comparator) => {
+    const cacheEntry = compareSelectCache.get(getter, comparator);
+    if (cacheEntry !== undefined)
+        return cacheEntry;
+    const result = (a, b) => {
+        const aValue = getter(a);
+        const bValue = getter(b);
+        if (aValue !== undefined && aValue !== null) {
+            if (bValue !== undefined && bValue !== null) {
+                return comparator(aValue, bValue);
+            }
+            return -1;
+        }
+        if (bValue !== undefined && bValue !== null) {
+            return 1;
+        }
+        return 0;
+    };
+    compareSelectCache.set(getter, comparator, result);
+    return result;
+};
+exports.compareSelect = compareSelect;
+const compareIteratorsCache = new WeakMap();
+const compareIterables = elementComparator => {
+    const cacheEntry = compareIteratorsCache.get(elementComparator);
+    if (cacheEntry !== undefined)
+        return cacheEntry;
+    const result = (a, b) => {
+        const aI = a[Symbol.iterator]();
+        const bI = b[Symbol.iterator]();
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            const aItem = aI.next();
+            const bItem = bI.next();
+            if (aItem.done) {
+                return bItem.done ? 0 : -1;
+            }
+            if (bItem.done) {
+                return 1;
+            }
+            const res = elementComparator(aItem.value, bItem.value);
+            if (res !== 0)
+                return res;
+        }
+    };
+    compareIteratorsCache.set(elementComparator, result);
+    return result;
+};
+exports.compareIterables = compareIterables;
+// TODO this is no longer needed when minimum node.js version is >= 12
+// since these versions ship with a stable sort function
+const keepOriginalOrder = iterable => {
+    const map = new Map();
+    let i = 0;
+    for (const item of iterable) {
+        map.set(item, i++);
+    }
+    return (a, b) => compareNumbers(map.get(a), map.get(b));
+};
+exports.keepOriginalOrder = keepOriginalOrder;
+const compareChunksNatural = chunkGraph => {
+    const cmpFn = compareModulesById(chunkGraph);
+    const cmpIterableFn = compareIterables(cmpFn);
+    return concatComparators(compareSelect(chunk => chunk.name, compareIds), compareSelect(chunk => chunk.runtime, RuntimeHelpers_1.compareRuntime), compareSelect(chunk => chunkGraph.getOrderedChunkModulesIterable(chunk, cmpFn), cmpIterableFn));
+};
+exports.compareChunksNatural = compareChunksNatural;
+/**
+ * Compare two locations
+ */
+const compareLocations = (a, b) => {
+    const isObjectA = typeof a === 'object' && a !== null;
+    const isObjectB = typeof b === 'object' && b !== null;
+    if (!isObjectA || !isObjectB) {
+        if (isObjectA)
+            return 1;
+        if (isObjectB)
+            return -1;
+        return 0;
+    }
+    if ('start' in a) {
+        if ('start' in b) {
+            const ap = a.start;
+            const bp = b.start;
+            if (ap.line < bp.line)
+                return -1;
+            if (ap.line > bp.line)
+                return 1;
+            if (ap.column < bp.column)
+                return -1;
+            if (ap.column > bp.column)
+                return 1;
+        }
+        else
+            return -1;
+    }
+    else if ('start' in b)
+        return 1;
+    if ('name' in a) {
+        if ('name' in b) {
+            if (a.name < b.name)
+                return -1;
+            if (a.name > b.name)
+                return 1;
+        }
+        else
+            return -1;
+    }
+    else if ('name' in b)
+        return 1;
+    if ('index' in a) {
+        if ('index' in b) {
+            if (a.index < b.index)
+                return -1;
+            if (a.index > b.index)
+                return 1;
+        }
+        else
+            return -1;
+    }
+    else if ('index' in b)
+        return 1;
+    return 0;
+};
+exports.compareLocations = compareLocations;

package/dist/base/compileBooleanMatcher.d.ts

@@ -0,0 +1,6 @@
+declare const compileBooleanMatcher: {
+    (map: any): boolean | ((value: any) => string);
+    fromLists: (positiveItems: string[], negativeItems: string[]) => (value: any) => string;
+    itemsToRegexp: (itemsArr: string[]) => any;
+};
+export default compileBooleanMatcher;

package/dist/base/compileBooleanMatcher.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const quoteMeta = str => str.replace(/[-[\]\\/{}()*+?.^$|]/g, '\\$&');
+const toSimpleString = str => {
+    if (`${+str}` === str) {
+        return str;
+    }
+    return JSON.stringify(str);
+};
+const compileBooleanMatcher = map => {
+    const positiveItems = Object.keys(map).filter(i => map[i]);
+    const negativeItems = Object.keys(map).filter(i => !map[i]);
+    if (positiveItems.length === 0)
+        return false;
+    if (negativeItems.length === 0)
+        return true;
+    return compileBooleanMatcherFromLists(positiveItems, negativeItems);
+};
+const compileBooleanMatcherFromLists = (positiveItems, negativeItems) => {
+    if (positiveItems.length === 0)
+        return () => 'false';
+    if (negativeItems.length === 0)
+        return () => 'true';
+    if (positiveItems.length === 1)
+        return value => `${toSimpleString(positiveItems[0])} == ${value}`;
+    if (negativeItems.length === 1)
+        return value => `${toSimpleString(negativeItems[0])} != ${value}`;
+    const positiveRegexp = itemsToRegexp(positiveItems);
+    const negativeRegexp = itemsToRegexp(negativeItems);
+    if (positiveRegexp.length <= negativeRegexp.length) {
+        return value => `/^${positiveRegexp}$/.test(${value})`;
+    }
+    return value => `!/^${negativeRegexp}$/.test(${value})`;
+};
+const popCommonItems = (itemsSet, getKey, condition) => {
+    const map = new Map();
+    for (const item of itemsSet) {
+        const key = getKey(item);
+        if (key) {
+            let list = map.get(key);
+            if (list === undefined) {
+                list = [];
+                map.set(key, list);
+            }
+            list.push(item);
+        }
+    }
+    const result = [];
+    for (const list of map.values()) {
+        if (condition(list)) {
+            for (const item of list) {
+                itemsSet.delete(item);
+            }
+            result.push(list);
+        }
+    }
+    return result;
+};
+const getCommonPrefix = (items) => {
+    let prefix = items[0];
+    for (let i = 1; i < items.length; i++) {
+        const item = items[i];
+        for (let p = 0; p < prefix.length; p++) {
+            if (item[p] !== prefix[p]) {
+                prefix = prefix.slice(0, p);
+                break;
+            }
+        }
+    }
+    return prefix;
+};
+const getCommonSuffix = (items) => {
+    let suffix = items[0];
+    for (let i = 1; i < items.length; i++) {
+        const item = items[i];
+        for (let p = item.length - 1, s = suffix.length - 1; s >= 0; p--, s--) {
+            if (item[p] !== suffix[s]) {
+                suffix = suffix.slice(s + 1);
+                break;
+            }
+        }
+    }
+    return suffix;
+};
+const itemsToRegexp = (itemsArr) => {
+    if (itemsArr.length === 1) {
+        return quoteMeta(itemsArr[0]);
+    }
+    const finishedItems = [];
+    // merge single char items: (a|b|c|d|ef) => ([abcd]|ef)
+    let countOfSingleCharItems = 0;
+    for (const item of itemsArr) {
+        if (item.length === 1) {
+            countOfSingleCharItems++;
+        }
+    }
+    // special case for only single char items
+    if (countOfSingleCharItems === itemsArr.length) {
+        return `[${quoteMeta(itemsArr.sort().join(''))}]`;
+    }
+    const items = new Set(itemsArr.sort());
+    if (countOfSingleCharItems > 2) {
+        let singleCharItems = '';
+        for (const item of items) {
+            if (item.length === 1) {
+                singleCharItems += item;
+                items.delete(item);
+            }
+        }
+        finishedItems.push(`[${quoteMeta(singleCharItems)}]`);
+    }
+    // special case for 2 items with common prefix/suffix
+    if (finishedItems.length === 0 && items.size === 2) {
+        const prefix = getCommonPrefix(itemsArr);
+        const suffix = getCommonSuffix(itemsArr.map(item => item.slice(prefix.length)));
+        if (prefix.length > 0 || suffix.length > 0) {
+            return `${quoteMeta(prefix)}${itemsToRegexp(itemsArr.map(i => i.slice(prefix.length, -suffix.length || undefined)))}${quoteMeta(suffix)}`;
+        }
+    }
+    // special case for 2 items with common suffix
+    if (finishedItems.length === 0 && items.size === 2) {
+        const it = items[Symbol.iterator]();
+        const a = it.next().value;
+        const b = it.next().value;
+        if (a.length > 0 && b.length > 0 && a.slice(-1) === b.slice(-1)) {
+            return `${itemsToRegexp([a.slice(0, -1), b.slice(0, -1)])}${quoteMeta(a.slice(-1))}`;
+        }
+    }
+    // find common prefix: (a1|a2|a3|a4|b5) => (a(1|2|3|4)|b5)
+    const prefixed = popCommonItems(items, item => (item.length >= 1 ? item[0] : false), list => {
+        if (list.length >= 3)
+            return true;
+        if (list.length <= 1)
+            return false;
+        return list[0][1] === list[1][1];
+    });
+    for (const prefixedItems of prefixed) {
+        const prefix = getCommonPrefix(prefixedItems);
+        finishedItems.push(`${quoteMeta(prefix)}${itemsToRegexp(prefixedItems.map(i => i.slice(prefix.length)))}`);
+    }
+    // find common suffix: (a1|b1|c1|d1|e2) => ((a|b|c|d)1|e2)
+    const suffixed = popCommonItems(items, item => (item.length >= 1 ? item.slice(-1) : false), list => {
+        if (list.length >= 3)
+            return true;
+        if (list.length <= 1)
+            return false;
+        return list[0].slice(-2) === list[1].slice(-2);
+    });
+    for (const suffixedItems of suffixed) {
+        const suffix = getCommonSuffix(suffixedItems);
+        finishedItems.push(`${itemsToRegexp(suffixedItems.map(i => i.slice(0, -suffix.length)))}${quoteMeta(suffix)}`);
+    }
+    // TODO further optimize regexp, i. e.
+    // use ranges: (1|2|3|4|a) => [1-4a]
+    const conditional = finishedItems.concat(Array.from(items, quoteMeta));
+    if (conditional.length === 1)
+        return conditional[0];
+    return `(${conditional.join('|')})`;
+};
+compileBooleanMatcher.fromLists = compileBooleanMatcherFromLists;
+compileBooleanMatcher.itemsToRegexp = itemsToRegexp;
+exports.default = compileBooleanMatcher;

package/dist/base/const.d.ts

@@ -0,0 +1,29 @@
+declare const CONSTANTS: {
+    PROD_BROWSERSLIST: string[];
+    DEV_BROWSERSLIST: string[];
+    DEV_TARGETS: {
+        chrome: string;
+    };
+    PROD_TARGETS: {
+        chrome: string;
+        ios: string;
+    };
+    ENTRY_CSS_NAME: string;
+    FULL_PKG: string;
+    MAIN_PKG: string;
+    SUB_PKG: string;
+    COMPILE_TYPE: {
+        mp: string;
+        component: string;
+        render: string;
+        service: string;
+    };
+    ASSETS_EXTS: string[];
+    BUILD_REASON: {
+        INIT: string;
+        FILE_CHANGE: string;
+        ACTIVATE_PKG: string;
+        RECOMPILE: string;
+    };
+};
+export default CONSTANTS;

package/dist/base/const.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CONSTANTS = {
+    PROD_BROWSERSLIST: ['ios_saf >= 10', 'chrome >= 83'],
+    DEV_BROWSERSLIST: ['last 2 chrome version'],
+    DEV_TARGETS: {
+        chrome: '90',
+    },
+    PROD_TARGETS: {
+        chrome: '83',
+        ios: '10',
+    },
+    ENTRY_CSS_NAME: 'app',
+    FULL_PKG: 'xhs-full',
+    MAIN_PKG: 'xhs-main',
+    SUB_PKG: 'xhs-sub',
+    COMPILE_TYPE: {
+        mp: 'mp',
+        component: 'component',
+        render: 'render',
+        service: 'service',
+    },
+    ASSETS_EXTS: [
+        'png',
+        'jpg',
+        'jpeg',
+        'gif',
+        'svg',
+        'webp',
+        'cer',
+        'mp3',
+        'aac',
+        'm4a',
+        'mp4',
+        'wav',
+        'ogg',
+        'silk',
+        'wasm',
+        'br',
+        'plist',
+    ],
+    BUILD_REASON: {
+        INIT: 'INIT',
+        FILE_CHANGE: 'FILE_CHANGE',
+        ACTIVATE_PKG: 'ACTIVATE_PKG',
+        RECOMPILE: 'RECOMPILE',
+    },
+};
+exports.default = CONSTANTS;

package/dist/base/copyPatterns.d.ts

@@ -0,0 +1,14 @@
+declare class CopyPatterns {
+    static createSnapshot(compilation: any, startTime: any, dependency: any): Promise<unknown>;
+    static checkSnapshotValid(compilation: any, snapshot: any): Promise<unknown>;
+    static getContentHash(compiler: any, compilation: any, source: any): any;
+    static runPattern(globby: any, compiler: any, compilation: any, logger: any, cache: any, inputPattern: any, index: any): Promise<any>;
+    copy({ compiler, compilation, logger, cache, patterns }: {
+        compiler: any;
+        compilation: any;
+        logger: any;
+        cache: any;
+        patterns: any;
+    }): Promise<void>;
+}
+export default CopyPatterns;