dependency-owners/dist/utils/loader.js

Determine ownership of dependencies in a project

var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
    if (typeof path === "string" && /^\.\.?\//.test(path)) {
        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
        });
    }
    return path;
};
import * as path from 'node:path';
/**
 * Import a dependency loader by name.
 * @param {string} loaderName The name of the loader to import.
 * @returns {Promise<DependencyLoader>} The imported dependency loader.
 */
async function importDependencyLoader(loaderName) {
    let loaderModule;
    // Try importing from an installed dependency/absolute path
    try {
        loaderModule = await import(__rewriteRelativeImportExtension(loaderName));
    }
    catch {
        // no-op
    }
    // Try import from relative path
    try {
        loaderModule = await import(__rewriteRelativeImportExtension(path.join(process.cwd(), loaderName)));
    }
    catch {
        // no-op
    }
    // If we couldn't find the module, throw an error
    if (!loaderModule) {
        throw new Error(`Failed to import loader: ${loaderName}`);
    }
    // Check if the loader has the required functions
    const loader = loaderModule.default || loaderModule;
    if (loader &&
        typeof loader.canLoad === 'function' &&
        typeof loader.load === 'function') {
        return loader;
    }
    else {
        throw new Error(`Invalid loader: ${loaderName}. The module does not export an object with 'canLoad' and 'load' functions.`);
    }
}
/**
 * Resolve a dependency loader for a specific file.
 * @param {DependencyLoader | string} loader The loader to use.
 * @param {string} depFilePath The path to the dependency file.
 * @returns {Promise<DependencyLoader | undefined>} The resolved dependency loader or undefined if not found.
 */
export async function resolveDependencyLoader(loader, depFilePath) {
    const resolvedLoader = typeof loader === 'string' ? await importDependencyLoader(loader) : loader;
    const canLoad = await resolvedLoader.canLoad(depFilePath);
    return canLoad ? resolvedLoader : undefined;
}