99 lines
2.5 KiB
TypeScript
99 lines
2.5 KiB
TypeScript
// TODO: Check of dit bestand weg kan — uitsluitend gebruikt door eigen test
|
|
import { access, readdir, readFile } from "node:fs/promises";
|
|
import { dirname, extname, join, relative, resolve, sep } from "node:path";
|
|
|
|
export interface MissingLocalImport {
|
|
importer: string;
|
|
specifier: string;
|
|
}
|
|
|
|
const sourceExtensions = new Set([
|
|
".ts",
|
|
".tsx",
|
|
".js",
|
|
".jsx",
|
|
".mjs",
|
|
".cjs",
|
|
]);
|
|
const resolutionSuffixes = [
|
|
".ts",
|
|
".tsx",
|
|
".js",
|
|
".jsx",
|
|
".mjs",
|
|
".cjs",
|
|
".css",
|
|
"/index.ts",
|
|
"/index.tsx",
|
|
"/index.js",
|
|
"/index.jsx",
|
|
];
|
|
const importPattern =
|
|
/(?:import|export)\s+(?:[^"']*?\s+from\s+)?["']([^"']+)["']|import\(\s*["']([^"']+)["']\s*\)|require\(\s*["']([^"']+)["']\s*\)/g;
|
|
|
|
async function collectSourceFiles(directory: string): Promise<string[]> {
|
|
const entries = await readdir(directory, { withFileTypes: true });
|
|
const files = await Promise.all(
|
|
entries.map(async (entry) => {
|
|
const path = join(directory, entry.name);
|
|
if (entry.isDirectory()) return collectSourceFiles(path);
|
|
if (/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(entry.name)) return [];
|
|
return sourceExtensions.has(extname(entry.name)) ? [path] : [];
|
|
}),
|
|
);
|
|
return files.flat();
|
|
}
|
|
|
|
async function exists(path: string): Promise<boolean> {
|
|
try {
|
|
await access(path);
|
|
return true;
|
|
} catch {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
async function resolvesToLocalFile(base: string): Promise<boolean> {
|
|
if (extname(base) && (await exists(base))) return true;
|
|
for (const suffix of resolutionSuffixes) {
|
|
if (await exists(`${base}${suffix}`)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
export async function findMissingLocalImports(
|
|
root: string,
|
|
): Promise<MissingLocalImport[]> {
|
|
const src = resolve(root, "src");
|
|
const files = await collectSourceFiles(src);
|
|
const missing: MissingLocalImport[] = [];
|
|
|
|
for (const importer of files) {
|
|
const source = await readFile(importer, "utf8");
|
|
for (const match of source.matchAll(importPattern)) {
|
|
const specifier = match[1] ?? match[2] ?? match[3];
|
|
if (
|
|
!specifier?.startsWith("@/") &&
|
|
!specifier?.startsWith("./") &&
|
|
!specifier?.startsWith("../")
|
|
)
|
|
continue;
|
|
const base = specifier.startsWith("@/")
|
|
? resolve(src, specifier.slice(2))
|
|
: resolve(dirname(importer), specifier);
|
|
if (!(await resolvesToLocalFile(base))) {
|
|
missing.push({
|
|
importer: relative(root, importer).split(sep).join("/"),
|
|
specifier,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
return missing.sort(
|
|
(a, b) =>
|
|
a.importer.localeCompare(b.importer) ||
|
|
a.specifier.localeCompare(b.specifier),
|
|
);
|
|
}
|