knip/dist/util/module-graph.js

Find and fix unused dependencies, exports and files in your TypeScript and JavaScript projects

const updateImportMaps = (fromImportMaps, toImportMaps) => {
    for (const id of fromImportMaps.refs)
        toImportMaps.refs.add(id);
    for (const [id, v] of fromImportMaps.imported)
        addValues(toImportMaps.imported, id, v);
    for (const [id, v] of fromImportMaps.importedAs)
        addNsValues(toImportMaps.importedAs, id, v);
    for (const [id, v] of fromImportMaps.importedNs)
        addValues(toImportMaps.importedNs, id, v);
    for (const [id, v] of fromImportMaps.reExported)
        addValues(toImportMaps.reExported, id, v);
    for (const [id, v] of fromImportMaps.reExportedAs)
        addNsValues(toImportMaps.reExportedAs, id, v);
    for (const [id, v] of fromImportMaps.reExportedNs)
        addValues(toImportMaps.reExportedNs, id, v);
};
export const updateImportMap = (file, importMap, graph) => {
    for (const [importedFilePath, fileImportMaps] of importMap) {
        const importMaps = file.imports.internal.get(importedFilePath);
        if (!importMaps)
            file.imports.internal.set(importedFilePath, fileImportMaps);
        else
            updateImportMaps(fileImportMaps, importMaps);
        const importedFile = graph.get(importedFilePath) ?? createFileNode();
        if (!importedFile.imported)
            importedFile.imported = createImports();
        updateImportMaps(fileImportMaps, importedFile.imported);
        graph.set(importedFilePath, importedFile);
    }
};
export const createFileNode = () => ({
    imports: {
        internal: new Map(),
        external: new Set(),
        externalRefs: new Set(),
        unresolved: new Set(),
        programFiles: new Set(),
        entryFiles: new Set(),
        imports: new Set(),
    },
    exports: new Map(),
    duplicates: new Set(),
    scripts: new Set(),
    imported: undefined,
    internalImportCache: undefined,
});
export const createImports = () => ({
    refs: new Set(),
    imported: new Map(),
    importedAs: new Map(),
    importedNs: new Map(),
    reExported: new Map(),
    reExportedAs: new Map(),
    reExportedNs: new Map(),
});
export const addValue = (map, id, value) => {
    if (map.has(id))
        map.get(id)?.add(value);
    else
        map.set(id, new Set([value]));
};
export const addNsValue = (map, id, ns, value) => {
    if (map.has(id)) {
        if (map.get(id)?.has(ns))
            map.get(id)?.get(ns)?.add(value);
        else
            map.get(id)?.set(ns, new Set([value]));
    }
    else {
        map.set(id, new Map([[ns, new Set([value])]]));
    }
};
const addValues = (map, id, values) => {
    if (map.has(id))
        for (const v of values)
            map.get(id)?.add(v);
    else
        map.set(id, values);
};
const addNsValues = (map, id, value) => {
    if (map.has(id))
        for (const [ns, v] of value)
            addValues(map.get(id), ns, v);
    else
        map.set(id, value);
};