xhs-mp-pack 1.1.0-beta.0

package/dist/base/semver.js

@@ -0,0 +1,425 @@
+"use strict";
+/** @typedef {(string|number|undefined|[])[]} SemVerRange */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.satisfyRuntimeCode = exports.rangeToStringRuntimeCode = exports.versionLtRuntimeCode = exports.parseVersionRuntimeCode = exports.stringifyHoley = exports.satisfy = exports.rangeToString = exports.parseRange = exports.versionLt = exports.parseVersion = void 0;
+/**
+ * @param {string} str version string
+ * @returns {(string|number|undefined|[])[]} parsed version
+ */
+const parseVersion = str => {
+    const splitAndConvert = function (str) {
+        return str.split('.').map((item) => 
+        // eslint-disable-next-line eqeqeq
+        +item == item ? +item : item);
+    };
+    const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
+    const ver = match[1] ? splitAndConvert(match[1]) : [];
+    if (match[2]) {
+        ver.length++;
+        ver.push.apply(ver, splitAndConvert(match[2]));
+    }
+    if (match[3]) {
+        ver.push([]);
+        ver.push.apply(ver, splitAndConvert(match[3]));
+    }
+    return ver;
+};
+exports.parseVersion = parseVersion;
+/* eslint-disable eqeqeq */
+/**
+ * @param {string} a version
+ * @param {string} b version
+ * @returns {boolean} true, iff a < b
+ */
+const versionLt = (a, b) => {
+    a = parseVersion(a);
+    b = parseVersion(b);
+    let i = 0;
+    for (;;) {
+        // a       b  EOA     object  undefined  number  string
+        // EOA        a == b  a < b   b < a      a < b   a < b
+        // object     b < a   (0)     b < a      a < b   a < b
+        // undefined  a < b   a < b   (0)        a < b   a < b
+        // number     b < a   b < a   b < a      (1)     a < b
+        // string     b < a   b < a   b < a      b < a   (1)
+        // EOA end of array
+        // (0) continue on
+        // (1) compare them via "<"
+        // Handles first row in table
+        if (i >= a.length)
+            return i < b.length && (typeof b[i])[0] != 'u';
+        const aValue = a[i];
+        const aType = (typeof aValue)[0];
+        // Handles first column in table
+        if (i >= b.length)
+            return aType == 'u';
+        const bValue = b[i];
+        const bType = (typeof bValue)[0];
+        if (aType == bType) {
+            if (aType != 'o' && aType != 'u' && aValue != bValue) {
+                return aValue < bValue;
+            }
+            i++;
+        }
+        else {
+            // Handles remaining cases
+            if (aType == 'o' && bType == 'n')
+                return true;
+            return bType == 's' || aType == 'u';
+        }
+    }
+};
+exports.versionLt = versionLt;
+/**
+ * @param {string} str range string
+ * @returns {SemVerRange} parsed range
+ */
+const parseRange = str => {
+    const splitAndConvert = str => str.split('.').map(item => (item !== 'NaN' && `${+item}` === item ? +item : item));
+    const parsePartial = str => {
+        const match = /^([^-+]+)?(?:-([^+]+))?(?:\+(.+))?$/.exec(str);
+        const ver = match[1] ? [0, ...splitAndConvert(match[1])] : [0];
+        if (match[2]) {
+            ver.length++;
+            ver.push.apply(ver, splitAndConvert(match[2]));
+        }
+        // remove trailing any matchers
+        let last = ver[ver.length - 1];
+        while (ver.length && (last === undefined || /^[*xX]$/.test(last))) {
+            ver.pop();
+            last = ver[ver.length - 1];
+        }
+        return ver;
+    };
+    const toFixed = range => {
+        if (range.length === 1) {
+            // Special case for "*" is "x.x.x" instead of "="
+            return [0];
+        }
+        if (range.length === 2) {
+            // Special case for "1" is "1.x.x" instead of "=1"
+            return [1, ...range.slice(1)];
+        }
+        if (range.length === 3) {
+            // Special case for "1.2" is "1.2.x" instead of "=1.2"
+            return [2, ...range.slice(1)];
+        }
+        return [range.length, ...range.slice(1)];
+    };
+    const negate = range => [-range[0] - 1, ...range.slice(1)];
+    const parseSimple = str => {
+        // simple       ::= primitive | partial | tilde | caret
+        // primitive    ::= ( '<' | '>' | '>=' | '<=' | '=' | '!' ) ( ' ' ) * partial
+        // tilde        ::= '~' ( ' ' ) * partial
+        // caret        ::= '^' ( ' ' ) * partial
+        const match = /^(\^|~|<=|<|>=|>|=|v|!)/.exec(str);
+        const start = match ? match[0] : '';
+        const remainder = parsePartial(start.length ? str.slice(start.length).trim() : str.trim());
+        switch (start) {
+            case '^':
+                if (remainder.length > 1 && remainder[1] === 0) {
+                    if (remainder.length > 2 && remainder[2] === 0) {
+                        return [3, ...remainder.slice(1)];
+                    }
+                    return [2, ...remainder.slice(1)];
+                }
+                return [1, ...remainder.slice(1)];
+            case '~':
+                return [2, ...remainder.slice(1)];
+            case '>=':
+                return remainder;
+            case '=':
+            case 'v':
+            case '':
+                return toFixed(remainder);
+            case '<':
+                return negate(remainder);
+            case '>': {
+                // and( >=, not( = ) ) => >=, =, not, and
+                const fixed = toFixed(remainder);
+                // eslint-disable-next-line no-sparse-arrays
+                return [, fixed, 0, remainder, 2];
+            }
+            case '<=':
+                // or( <, = ) => <, =, or
+                // eslint-disable-next-line no-sparse-arrays
+                return [, toFixed(remainder), negate(remainder), 1];
+            case '!': {
+                // not =
+                const fixed = toFixed(remainder);
+                // eslint-disable-next-line no-sparse-arrays
+                return [, fixed, 0];
+            }
+            default:
+                throw new Error('Unexpected start value');
+        }
+    };
+    const combine = (items, fn) => {
+        if (items.length === 1)
+            return items[0];
+        const arr = [];
+        for (const item of items.slice().reverse()) {
+            if (0 in item) {
+                arr.push(item);
+            }
+            else {
+                arr.push(...item.slice(1));
+            }
+        }
+        // eslint-disable-next-line no-sparse-arrays
+        return [, ...arr, ...items.slice(1).map(() => fn)];
+    };
+    const parseRange = str => {
+        // range      ::= hyphen | simple ( ' ' ( ' ' ) * simple ) * | ''
+        // hyphen     ::= partial ( ' ' ) * ' - ' ( ' ' ) * partial
+        const items = str.split(/\s+-\s+/);
+        if (items.length === 1) {
+            const items = str
+                .trim()
+                .split(/(?<=[-0-9A-Za-z])\s+/g)
+                .map(parseSimple);
+            return combine(items, 2);
+        }
+        const a = parsePartial(items[0]);
+        const b = parsePartial(items[1]);
+        // >=a <=b => and( >=a, or( <b, =b ) ) => >=a, <b, =b, or, and
+        // eslint-disable-next-line no-sparse-arrays
+        return [, toFixed(b), negate(b), 1, a, 2];
+    };
+    const parseLogicalOr = str => {
+        // range-set  ::= range ( logical-or range ) *
+        // logical-or ::= ( ' ' ) * '||' ( ' ' ) *
+        const items = str.split(/\s*\|\|\s*/).map(parseRange);
+        return combine(items, 1);
+    };
+    return parseLogicalOr(str);
+};
+exports.parseRange = parseRange;
+/* eslint-disable eqeqeq */
+const rangeToString = range => {
+    const fixCount = range[0];
+    let str = '';
+    if (range.length === 1) {
+        return '*';
+    }
+    if (fixCount + 0.5) {
+        str +=
+            fixCount == 0
+                ? '>='
+                : fixCount == -1
+                    ? '<'
+                    : fixCount == 1
+                        ? '^'
+                        : fixCount == 2
+                            ? '~'
+                            : fixCount > 0
+                                ? '='
+                                : '!=';
+        let needDot = 1;
+        // eslint-disable-next-line no-redeclare
+        for (let i = 1; i < range.length; i++) {
+            const item = range[i];
+            const t = (typeof item)[0];
+            needDot--;
+            str +=
+                t == 'u'
+                    ? // undefined: prerelease marker, add an "-"
+                        '-'
+                    : // number or string: add the item, set flag to add an "." between two of them
+                        (needDot > 0 ? '.' : '') + ((needDot = 2), item);
+        }
+        return str;
+    }
+    const stack = [];
+    // eslint-disable-next-line no-redeclare
+    for (let i = 1; i < range.length; i++) {
+        // eslint-disable-next-line no-redeclare
+        const item = range[i];
+        stack.push(item === 0
+            ? `not(${pop()})`
+            : item === 1
+                ? `(${pop()} || ${pop()})`
+                : item === 2
+                    ? `${stack.pop()} ${stack.pop()}`
+                    : rangeToString(item));
+    }
+    return pop();
+    function pop() {
+        // @ts-ignore
+        return stack.pop().replace(/^\((.+)\)$/, '$1');
+    }
+};
+exports.rangeToString = rangeToString;
+const satisfy = (range, version) => {
+    if (0 in range) {
+        version = parseVersion(version);
+        let fixCount = range[0];
+        // when negated is set it swill set for < instead of >=
+        const negated = fixCount < 0;
+        if (negated)
+            fixCount = -fixCount - 1;
+        for (let i = 0, j = 1, isEqual = true;; j++, i++) {
+            // cspell:word nequal nequ
+            // when isEqual = true:
+            // range         version: EOA/object  undefined  number    string
+            // EOA                    equal       block      big-ver   big-ver
+            // undefined              bigger      next       big-ver   big-ver
+            // number                 smaller     block      cmp       big-cmp
+            // fixed number           smaller     block      cmp-fix   differ
+            // string                 smaller     block      differ    cmp
+            // fixed string           smaller     block      small-cmp cmp-fix
+            // when isEqual = false:
+            // range         version: EOA/object  undefined  number    string
+            // EOA                    nequal      block      next-ver  next-ver
+            // undefined              nequal      block      next-ver  next-ver
+            // number                 nequal      block      next      next
+            // fixed number           nequal      block      next      next   (this never happens)
+            // string                 nequal      block      next      next
+            // fixed string           nequal      block      next      next   (this never happens)
+            // EOA end of array
+            // equal (version is equal range):
+            //   when !negated: return true,
+            //   when negated: return false
+            // bigger (version is bigger as range):
+            //   when fixed: return false,
+            //   when !negated: return true,
+            //   when negated: return false,
+            // smaller (version is smaller as range):
+            //   when !negated: return false,
+            //   when negated: return true
+            // nequal (version is not equal range (> resp <)): return true
+            // block (version is in different prerelease area): return false
+            // differ (version is different from fixed range (string vs. number)): return false
+            // next: continues to the next items
+            // next-ver: when fixed: return false, continues to the next item only for the version, sets isEqual=false
+            // big-ver: when fixed || negated: return false, continues to the next item only for the version, sets isEqual=false
+            // next-nequ: continues to the next items, sets isEqual=false
+            // cmp (negated === false): version < range => return false, version > range => next-nequ, else => next
+            // cmp (negated === true): version > range => return false, version < range => next-nequ, else => next
+            // cmp-fix: version == range => next, else => return false
+            // big-cmp: when negated => return false, else => next-nequ
+            // small-cmp: when negated => next-nequ, else => return false
+            const rangeType = j < range.length ? (typeof range[j])[0] : '';
+            let versionValue;
+            let versionType;
+            // Handles first column in both tables (end of version or object)
+            if (i >= version.length ||
+                ((versionValue = version[i]), (versionType = (typeof versionValue)[0]) == 'o')) {
+                // Handles nequal
+                if (!isEqual)
+                    return true;
+                // Handles bigger
+                if (rangeType == 'u')
+                    return j > fixCount && !negated;
+                // Handles equal and smaller: (range === EOA) XOR negated
+                return (rangeType == '') != negated; // equal + smaller
+            }
+            // Handles second column in both tables (version = undefined)
+            if (versionType == 'u') {
+                if (!isEqual || rangeType != 'u') {
+                    return false;
+                }
+            }
+            // switch between first and second table
+            else if (isEqual) {
+                // Handle diagonal
+                if (rangeType == versionType) {
+                    if (j <= fixCount) {
+                        // Handles "cmp-fix" cases
+                        if (versionValue != range[j]) {
+                            return false;
+                        }
+                    }
+                    else {
+                        // Handles "cmp" cases
+                        if (negated ? versionValue > range[j] : versionValue < range[j]) {
+                            return false;
+                        }
+                        if (versionValue != range[j])
+                            isEqual = false;
+                    }
+                }
+                // Handle big-ver
+                else if (rangeType != 's' && rangeType != 'n') {
+                    if (negated || j <= fixCount)
+                        return false;
+                    isEqual = false;
+                    j--;
+                }
+                // Handle differ, big-cmp and small-cmp
+                else if (j <= fixCount || versionType < rangeType != negated) {
+                    return false;
+                }
+                else {
+                    isEqual = false;
+                }
+            }
+            else {
+                // Handles all "next-ver" cases in the second table
+                // eslint-disable-next-line no-lonely-if
+                if (rangeType != 's' && rangeType != 'n') {
+                    isEqual = false;
+                    j--;
+                }
+                // next is applied by default
+            }
+        }
+    }
+    const stack = [];
+    const p = stack.pop.bind(stack);
+    // eslint-disable-next-line no-redeclare, block-scoped-var
+    for (let i = 1; i < range.length; i++) {
+        const item = range[i];
+        stack.push(item == 1 ? p() | p() : item == 2 ? p() & p() : item ? satisfy(item, version) : !p());
+    }
+    return !!p();
+};
+exports.satisfy = satisfy;
+const stringifyHoley = json => {
+    switch (typeof json) {
+        case 'undefined':
+            return '';
+        case 'object':
+            if (Array.isArray(json)) {
+                let str = '[';
+                for (let i = 0; i < json.length; i++) {
+                    if (i !== 0)
+                        str += ',';
+                    str += stringifyHoley(json[i]);
+                }
+                str += ']';
+                return str;
+            }
+            return JSON.stringify(json);
+        default:
+            return JSON.stringify(json);
+    }
+};
+exports.stringifyHoley = stringifyHoley;
+// #region runtime code: parseVersion
+const parseVersionRuntimeCode = runtimeTemplate => `var parseVersion = ${runtimeTemplate.basicFunction('str', [
+    '@/base/semver.js for original code',
+    `var p=${runtimeTemplate.supportsArrowFunction() ? 'p=>' : 'function(p)'}{return p.split(".").map((${runtimeTemplate.supportsArrowFunction() ? 'p=>' : 'function(p)'}{return+p==p?+p:p}))},n=/^([^-+]+)?(?:-([^+]+))?(?:\\+(.+))?$/.exec(str),r=n[1]?p(n[1]):[];return n[2]&&(r.length++,r.push.apply(r,p(n[2]))),n[3]&&(r.push([]),r.push.apply(r,p(n[3]))),r;`,
+])}`;
+exports.parseVersionRuntimeCode = parseVersionRuntimeCode;
+// #endregion
+// #region runtime code: versionLt
+const versionLtRuntimeCode = runtimeTemplate => `var versionLt = ${runtimeTemplate.basicFunction('a, b', [
+    '@/base/semver.js for original code',
+    'a=parseVersion(a),b=parseVersion(b);for(var r=0;;){if(r>=a.length)return r<b.length&&"u"!=(typeof b[r])[0];var e=a[r],n=(typeof e)[0];if(r>=b.length)return"u"==n;var t=b[r],f=(typeof t)[0];if(n!=f)return"o"==n&&"n"==f||("s"==f||"u"==n);if("o"!=n&&"u"!=n&&e!=t)return e<t;r++}',
+])}`;
+exports.versionLtRuntimeCode = versionLtRuntimeCode;
+// #endregion
+// #region runtime code: rangeToString
+const rangeToStringRuntimeCode = runtimeTemplate => `var rangeToString = ${runtimeTemplate.basicFunction('range', [
+    '@/base/semver.js for original code',
+    'var r=range[0],n="";if(1===range.length)return"*";if(r+.5){n+=0==r?">=":-1==r?"<":1==r?"^":2==r?"~":r>0?"=":"!=";for(var e=1,a=1;a<range.length;a++){e--,n+="u"==(typeof(t=range[a]))[0]?"-":(e>0?".":"")+(e=2,t)}return n}var g=[];for(a=1;a<range.length;a++){var t=range[a];g.push(0===t?"not("+o()+")":1===t?"("+o()+" || "+o()+")":2===t?g.pop()+" "+g.pop():rangeToString(t))}return o();function o(){return g.pop().replace(/^\\((.+)\\)$/,"$1")}',
+])}`;
+exports.rangeToStringRuntimeCode = rangeToStringRuntimeCode;
+// #endregion
+// #region runtime code: satisfy
+const satisfyRuntimeCode = runtimeTemplate => `var satisfy = ${runtimeTemplate.basicFunction('range, version', [
+    '@/base/semver.js for original code',
+    'if(0 in range){version=parseVersion(version);var e=range[0],r=e<0;r&&(e=-e-1);for(var n=0,i=1,a=!0;;i++,n++){var f,s,g=i<range.length?(typeof range[i])[0]:"";if(n>=version.length||"o"==(s=(typeof(f=version[n]))[0]))return!a||("u"==g?i>e&&!r:""==g!=r);if("u"==s){if(!a||"u"!=g)return!1}else if(a)if(g==s)if(i<=e){if(f!=range[i])return!1}else{if(r?f>range[i]:f<range[i])return!1;f!=range[i]&&(a=!1)}else if("s"!=g&&"n"!=g){if(r||i<=e)return!1;a=!1,i--}else{if(i<=e||s<g!=r)return!1;a=!1}else"s"!=g&&"n"!=g&&(a=!1,i--)}}var t=[],o=t.pop.bind(t);for(n=1;n<range.length;n++){var u=range[n];t.push(1==u?o()|o():2==u?o()&o():u?satisfy(u,version):!o())}return!!o();',
+])}`;
+exports.satisfyRuntimeCode = satisfyRuntimeCode;

package/dist/base/singletontask.d.ts

@@ -0,0 +1,27 @@
+/**
+ * 单例任务
+ * 如果有需要缓存、截流的请求，可以使用这个管理任务
+ */
+type FN<T> = (...args: any[]) => {};
+interface ISingletonTask {
+    getResult: () => Promise<any>;
+    getResultCache: () => any;
+}
+declare class SingletonTask implements ISingletonTask {
+    private readonly executor;
+    private readonly timeout;
+    private status;
+    private result;
+    private rejectedReason;
+    private queue;
+    private timer;
+    constructor(executor: FN<Promise<any>>, timeout?: number);
+    private _run;
+    private _emit;
+    private _resolve;
+    private _reject;
+    getResult(retryWhenRejected?: boolean, retryWhenResolved?: boolean): Promise<any>;
+    getResultCache(): any;
+}
+declare function createSingletonTask(key: any, fn: any, timeout?: any): Promise<any>;
+export { SingletonTask, createSingletonTask };

package/dist/base/singletontask.js

@@ -0,0 +1,124 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSingletonTask = exports.SingletonTask = void 0;
+var SingletonTaskStatus;
+(function (SingletonTaskStatus) {
+    SingletonTaskStatus[SingletonTaskStatus["WAITING"] = 0] = "WAITING";
+    SingletonTaskStatus[SingletonTaskStatus["PENDING"] = 1] = "PENDING";
+    SingletonTaskStatus[SingletonTaskStatus["RESOLVED"] = 2] = "RESOLVED";
+    SingletonTaskStatus[SingletonTaskStatus["REJECTED"] = 3] = "REJECTED";
+})(SingletonTaskStatus || (SingletonTaskStatus = {}));
+class SingletonTask {
+    constructor(executor, timeout = 60000) {
+        this.executor = executor;
+        this.timeout = timeout;
+        this.status = SingletonTaskStatus.WAITING;
+        this.queue = [];
+    }
+    _run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.status = SingletonTaskStatus.PENDING;
+            this.timer = setTimeout(() => {
+                this._reject('timeout');
+            }, this.timeout);
+            try {
+                const result = yield this.executor();
+                this._resolve(result);
+                return result;
+            }
+            catch (e) {
+                this._reject(e);
+                throw e;
+            }
+        });
+    }
+    _emit() {
+        const queue = this.queue;
+        this.queue = [];
+        for (const item of queue) {
+            if (this.status === SingletonTaskStatus.REJECTED) {
+                item.reject(this.rejectedReason);
+            }
+            else {
+                item.resolve(this.result);
+            }
+        }
+    }
+    _resolve(result) {
+        this.status = SingletonTaskStatus.RESOLVED;
+        this.result = result;
+        clearTimeout(this.timer);
+        this._emit();
+    }
+    _reject(reason) {
+        this.status = SingletonTaskStatus.REJECTED;
+        this.rejectedReason = reason;
+        clearTimeout(this.timer);
+        this._emit();
+    }
+    getResult(retryWhenRejected = false, retryWhenResolved = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.status === SingletonTaskStatus.WAITING ||
+                (this.status === SingletonTaskStatus.REJECTED && retryWhenRejected) ||
+                (this.status === SingletonTaskStatus.RESOLVED && retryWhenResolved)) {
+                return this._run();
+            }
+            if (this.status === SingletonTaskStatus.PENDING) {
+                return new Promise((resolve, reject) => {
+                    this.queue.push({
+                        // @ts-ignore
+                        resolve,
+                        // @ts-ignore
+                        reject,
+                    });
+                });
+            }
+            if (this.status === SingletonTaskStatus.REJECTED) {
+                throw this.rejectedReason;
+            }
+            return this.result;
+        });
+    }
+    getResultCache() {
+        return this.result;
+    }
+}
+exports.SingletonTask = SingletonTask;
+const taskMap = {};
+function createSingletonTask(key, fn, timeout) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        let taskInfo = taskMap[key];
+        if (!taskInfo) {
+            const task = new SingletonTask(fn, timeout);
+            taskInfo = taskMap[key] = {
+                task,
+                isDownloading: false,
+                manuelCancel: false,
+                contentLength: 0,
+                chunkTotle: 0,
+            };
+        }
+        try {
+            const result = yield ((_a = taskInfo.task) === null || _a === void 0 ? void 0 : _a.getResult());
+            taskInfo = null;
+            delete taskMap[key];
+            return result;
+        }
+        catch (error) {
+            taskInfo = null;
+            delete taskMap[key];
+            throw error;
+        }
+    });
+}
+exports.createSingletonTask = createSingletonTask;

package/dist/base/smartGrouping.d.ts

@@ -0,0 +1,2 @@
+declare const smartGrouping: (items: any, groupConfigs: any) => any[];
+export default smartGrouping;