surgio/build/filters/utils.js

Generating rules for Surge, Clash, Quantumult like a PRO

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.mergeReversedFilters = exports.reverseFilter = exports.mergeSortedFilters = exports.useSortedKeywords = exports.discardProviders = exports.useProviders = exports.discardGlob = exports.useGlob = exports.matchGlob = exports.useRegexp = exports.discardKeywords = exports.useKeywords = exports.mergeFilters = exports.applyFilter = exports.validateFilter = void 0;
const lodash_1 = __importDefault(require("lodash"));
const micromatch_1 = __importDefault(require("micromatch"));
const classes_1 = require("./classes");
const validateFilter = (filter) => {
    if (filter === null || filter === undefined) {
        return false;
    }
    if (typeof filter === 'function') {
        return true;
    }
    return (typeof filter === 'object' &&
        'supportSort' in filter &&
        'filter' in filter &&
        typeof filter.supportSort === 'boolean' &&
        typeof filter.filter === 'function');
};
exports.validateFilter = validateFilter;
const applyFilter = (nodeList, filter) => {
    // istanbul ignore next
    if (filter && !(0, exports.validateFilter)(filter)) {
        throw new Error(`使用了无效的过滤器 ${filter}`);
    }
    let newNodeList = nodeList.filter((item) => {
        // Only checks the enable property when it's present, default to true
        const isEnabled = item.enable !== false;
        if (filter && typeof filter === 'function') {
            return filter(item) && isEnabled;
        }
        return isEnabled;
    });
    if (filter &&
        typeof filter === 'object' &&
        typeof filter.filter === 'function') {
        newNodeList = filter.filter(newNodeList);
    }
    return newNodeList;
};
exports.applyFilter = applyFilter;
const mergeFilters = (filters, isStrict) => {
    filters.forEach((filter) => {
        if ('supportSort' in filter && filter.supportSort) {
            throw new Error('mergeFilters 不支持包含排序功能的过滤器');
        }
        // istanbul ignore next
        if (typeof filter !== 'function') {
            throw new Error('mergeFilters 传入了无效的过滤器');
        }
    });
    return (item) => {
        return filters[isStrict ? 'every' : 'some']((filter) => filter(item));
    };
};
exports.mergeFilters = mergeFilters;
const useKeywords = (keywords, isStrict) => {
    // istanbul ignore next
    if (!Array.isArray(keywords)) {
        throw new Error('keywords 请使用数组');
    }
    return (item) => keywords[isStrict ? 'every' : 'some']((keyword) => item.nodeName.includes(keyword));
};
exports.useKeywords = useKeywords;
const discardKeywords = (keywords, isStrict) => {
    // istanbul ignore next
    if (!Array.isArray(keywords)) {
        throw new Error('keywords 请使用数组');
    }
    return (item) => !keywords[isStrict ? 'every' : 'some']((keyword) => item.nodeName.includes(keyword));
};
exports.discardKeywords = discardKeywords;
const useRegexp = (regexp) => {
    // istanbul ignore next
    if (!lodash_1.default.isRegExp(regexp)) {
        throw new Error('入参不是一个合法的正则表达式');
    }
    return (item) => regexp.test(item.nodeName);
};
exports.useRegexp = useRegexp;
const matchGlob = (str, glob) => {
    return micromatch_1.default.contains(str, glob);
};
exports.matchGlob = matchGlob;
const useGlob = (glob) => {
    return (item) => (0, exports.matchGlob)(item.nodeName, glob);
};
exports.useGlob = useGlob;
const discardGlob = (glob) => {
    return (item) => !(0, exports.matchGlob)(item.nodeName, glob);
};
exports.discardGlob = discardGlob;
const useProviders = (keywords, isStrict = true) => {
    // istanbul ignore next
    if (!Array.isArray(keywords)) {
        throw new Error('keywords 请使用数组');
    }
    return (item) => keywords.some((keyword) => isStrict
        ? item?.provider?.name === keyword
        : item?.provider?.name.includes(keyword));
};
exports.useProviders = useProviders;
const discardProviders = (keywords, isStrict = true) => {
    // istanbul ignore next
    if (!Array.isArray(keywords)) {
        throw new Error('keywords 请使用数组');
    }
    return (item) => !keywords.some((keyword) => isStrict
        ? item?.provider?.name === keyword
        : item?.provider?.name.includes(keyword));
};
exports.discardProviders = discardProviders;
const useSortedKeywords = (keywords) => {
    // istanbul ignore next
    if (!Array.isArray(keywords)) {
        throw new Error('keywords 请使用数组');
    }
    return new classes_1.SortFilterWithSortedKeywords(keywords);
};
exports.useSortedKeywords = useSortedKeywords;
const mergeSortedFilters = (filters) => {
    filters.forEach((filter) => {
        if ('supportSort' in filter && filter.supportSort) {
            throw new Error('mergeSortedFilters 不支持包含排序功能的过滤器');
        }
        // istanbul ignore next
        if (typeof filter !== 'function') {
            throw new Error('mergeSortedFilters 传入了无效的过滤器');
        }
    });
    return new classes_1.SortFilterWithSortedFilters(filters);
};
exports.mergeSortedFilters = mergeSortedFilters;
const reverseFilter = (filter) => {
    if ('supportSort' in filter && filter.supportSort) {
        throw new Error('reverseFilter 不支持包含排序功能的过滤器');
    }
    return (item) => !filter(item);
};
exports.reverseFilter = reverseFilter;
const mergeReversedFilters = (filters, isStrict) => {
    filters.forEach((filter) => {
        if ('supportSort' in filter && filter.supportSort) {
            throw new Error('mergeReversedFilters 不支持包含排序功能的过滤器');
        }
        // istanbul ignore next
        if (typeof filter !== 'function') {
            throw new Error('mergeReversedFilters 传入了无效的过滤器');
        }
    });
    return (item) => {
        return filters[isStrict ? 'some' : 'every']((filter) => filter(item));
    };
};
exports.mergeReversedFilters = mergeReversedFilters;
//# sourceMappingURL=utils.js.map