120 lines
No EOL
3.6 KiB
JavaScript
120 lines
No EOL
3.6 KiB
JavaScript
import { resolve } from "node:path";
|
|
import picomatch from "picomatch";
|
|
import { Parser } from "acorn";
|
|
|
|
//#region src/utils/general.ts
|
|
function toArray(array) {
|
|
array = array || [];
|
|
if (Array.isArray(array)) return array;
|
|
return [array];
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/filter.ts
|
|
const BACKSLASH_REGEX = /\\/g;
|
|
function normalize$1(path$1) {
|
|
return path$1.replace(BACKSLASH_REGEX, "/");
|
|
}
|
|
const ABSOLUTE_PATH_REGEX = /^(?:\/|(?:[A-Z]:)?[/\\|])/i;
|
|
function isAbsolute$1(path$1) {
|
|
return ABSOLUTE_PATH_REGEX.test(path$1);
|
|
}
|
|
function getMatcherString(glob, cwd) {
|
|
if (glob.startsWith("**") || isAbsolute$1(glob)) return normalize$1(glob);
|
|
return normalize$1(resolve(cwd, glob));
|
|
}
|
|
function patternToIdFilter(pattern) {
|
|
if (pattern instanceof RegExp) return (id) => {
|
|
const normalizedId = normalize$1(id);
|
|
const result = pattern.test(normalizedId);
|
|
pattern.lastIndex = 0;
|
|
return result;
|
|
};
|
|
const matcher = picomatch(getMatcherString(pattern, process.cwd()), { dot: true });
|
|
return (id) => {
|
|
return matcher(normalize$1(id));
|
|
};
|
|
}
|
|
function patternToCodeFilter(pattern) {
|
|
if (pattern instanceof RegExp) return (code) => {
|
|
const result = pattern.test(code);
|
|
pattern.lastIndex = 0;
|
|
return result;
|
|
};
|
|
return (code) => code.includes(pattern);
|
|
}
|
|
function createFilter(exclude, include) {
|
|
if (!exclude && !include) return;
|
|
return (input) => {
|
|
if (exclude?.some((filter) => filter(input))) return false;
|
|
if (include?.some((filter) => filter(input))) return true;
|
|
return !(include && include.length > 0);
|
|
};
|
|
}
|
|
function normalizeFilter(filter) {
|
|
if (typeof filter === "string" || filter instanceof RegExp) return { include: [filter] };
|
|
if (Array.isArray(filter)) return { include: filter };
|
|
return {
|
|
exclude: filter.exclude ? toArray(filter.exclude) : void 0,
|
|
include: filter.include ? toArray(filter.include) : void 0
|
|
};
|
|
}
|
|
function createIdFilter(filter) {
|
|
if (!filter) return;
|
|
const { exclude, include } = normalizeFilter(filter);
|
|
const excludeFilter = exclude?.map(patternToIdFilter);
|
|
const includeFilter = include?.map(patternToIdFilter);
|
|
return createFilter(excludeFilter, includeFilter);
|
|
}
|
|
function createCodeFilter(filter) {
|
|
if (!filter) return;
|
|
const { exclude, include } = normalizeFilter(filter);
|
|
const excludeFilter = exclude?.map(patternToCodeFilter);
|
|
const includeFilter = include?.map(patternToCodeFilter);
|
|
return createFilter(excludeFilter, includeFilter);
|
|
}
|
|
function createFilterForId(filter) {
|
|
const filterFunction = createIdFilter(filter);
|
|
return filterFunction ? (id) => !!filterFunction(id) : void 0;
|
|
}
|
|
function createFilterForTransform(idFilter, codeFilter) {
|
|
if (!idFilter && !codeFilter) return;
|
|
const idFilterFunction = createIdFilter(idFilter);
|
|
const codeFilterFunction = createCodeFilter(codeFilter);
|
|
return (id, code) => {
|
|
let fallback = true;
|
|
if (idFilterFunction) fallback &&= idFilterFunction(id);
|
|
if (!fallback) return false;
|
|
if (codeFilterFunction) fallback &&= codeFilterFunction(code);
|
|
return fallback;
|
|
};
|
|
}
|
|
function normalizeObjectHook(name, hook) {
|
|
let handler;
|
|
let filter;
|
|
if (typeof hook === "function") handler = hook;
|
|
else {
|
|
handler = hook.handler;
|
|
const hookFilter = hook.filter;
|
|
if (name === "resolveId" || name === "load") filter = createFilterForId(hookFilter?.id);
|
|
else filter = createFilterForTransform(hookFilter?.id, hookFilter?.code);
|
|
}
|
|
return {
|
|
handler,
|
|
filter: filter || (() => true)
|
|
};
|
|
}
|
|
|
|
//#endregion
|
|
//#region src/utils/context.ts
|
|
function parse(code, opts = {}) {
|
|
return Parser.parse(code, {
|
|
sourceType: "module",
|
|
ecmaVersion: "latest",
|
|
locations: true,
|
|
...opts
|
|
});
|
|
}
|
|
|
|
//#endregion
|
|
export { normalizeObjectHook as n, toArray as r, parse as t }; |