@graphql-codegen/visitor-plugin-common/esm/imports.js

import { dirname, isAbsolute, join, relative, resolve } from 'path';
import parse from 'parse-filepath';
import { normalizeImportExtension } from '@graphql-codegen/plugin-helpers';
export function generateFragmentImportStatement(statement, kind) {
    const { importSource: fragmentImportSource, ...rest } = statement;
    const { identifiers, path, namespace } = fragmentImportSource;
    const importSource = {
        identifiers: identifiers
            .filter(fragmentImport => kind === 'both' || kind === fragmentImport.kind)
            .map(({ name }) => name),
        path,
        namespace,
    };
    return generateImportStatement({
        importSource,
        ...rest,
        typesImport: kind === 'type' ? statement.typesImport : false,
    });
}
export function generateImportStatement(statement) {
    const { baseDir, importSource, outputPath, typesImport } = statement;
    const importPath = resolveImportPath(baseDir, outputPath, importSource.path);
    const importNames = importSource.identifiers?.length
        ? `{ ${Array.from(new Set(importSource.identifiers)).join(', ')} }`
        : '*';
    const importExtension = importPath.startsWith('/') || importPath.startsWith('.')
        ? normalizeImportExtension({
            emitLegacyCommonJSImports: statement.emitLegacyCommonJSImports,
            importExtension: statement.importExtension,
        })
        : '';
    const importAlias = importSource.namespace ? ` as ${importSource.namespace}` : '';
    const importStatement = typesImport ? 'import type' : 'import';
    return `${importStatement} ${importNames}${importAlias} from '${importPath}${importExtension}';${importAlias ? '\n' : ''}`;
    // return `${importStatement} ${importNames}${importAlias} from '${importPath}';${importAlias ? '\n' : ''}`;
}
function resolveImportPath(baseDir, outputPath, sourcePath) {
    const shouldAbsolute = !sourcePath.startsWith('~');
    if (shouldAbsolute) {
        const absGeneratedFilePath = resolve(baseDir, outputPath);
        const absImportFilePath = resolve(baseDir, sourcePath);
        return resolveRelativeImport(absGeneratedFilePath, absImportFilePath);
    }
    return sourcePath.replace(`~`, '');
}
export function resolveRelativeImport(from, to) {
    if (!isAbsolute(from)) {
        throw new Error(`Argument 'from' must be an absolute path, '${from}' given.`);
    }
    if (!isAbsolute(to)) {
        throw new Error(`Argument 'to' must be an absolute path, '${to}' given.`);
    }
    return fixLocalFilePath(clearExtension(relative(dirname(from), to)));
}
export function resolveImportSource(source) {
    return typeof source === 'string' ? { path: source } : source;
}
export function clearExtension(path) {
    const parsedPath = parse(path);
    return join(parsedPath.dir, parsedPath.name).replace(/\\/g, '/');
}
export function fixLocalFilePath(path) {
    return path.startsWith('..') ? path : `./${path}`;
}
export function getEnumsImports({ enumValues, useTypeImports, }) {
    function handleEnumValueMapper({ typeIdentifierConverted, importIdentifier, sourceIdentifier, sourceFile, useTypeImports, }) {
        if (importIdentifier !== sourceIdentifier) {
            // use namespace import to dereference nested enum
            // { enumValues: { MyEnum: './my-file#NS.NestedEnum' } }
            return [
                buildTypeImport({
                    identifier: importIdentifier || sourceIdentifier,
                    source: sourceFile,
                    useTypeImports,
                }),
                `import ${typeIdentifierConverted} = ${sourceIdentifier};`,
            ];
        }
        if (sourceIdentifier !== typeIdentifierConverted) {
            return [
                buildTypeImport({
                    identifier: `${sourceIdentifier} as ${typeIdentifierConverted}`,
                    source: sourceFile,
                    useTypeImports,
                }),
            ];
        }
        return [
            buildTypeImport({
                identifier: importIdentifier || sourceIdentifier,
                source: sourceFile,
                useTypeImports,
            }),
        ];
    }
    return Object.keys(enumValues)
        .flatMap(enumName => {
        const mappedValue = enumValues[enumName];
        if (mappedValue.sourceFile) {
            if (mappedValue.isDefault) {
                return [
                    buildTypeImport({
                        identifier: mappedValue.typeIdentifierConverted,
                        source: mappedValue.sourceFile,
                        asDefault: true,
                        useTypeImports,
                    }),
                ];
            }
            return handleEnumValueMapper({
                typeIdentifierConverted: mappedValue.typeIdentifierConverted,
                importIdentifier: mappedValue.importIdentifier,
                sourceIdentifier: mappedValue.sourceIdentifier,
                sourceFile: mappedValue.sourceFile,
                useTypeImports,
            });
        }
        return [];
    })
        .filter(Boolean);
}
export function buildTypeImport({ identifier, source, useTypeImports, asDefault = false, }) {
    if (asDefault) {
        if (useTypeImports) {
            return `import type { default as ${identifier} } from '${source}';`;
        }
        return `import ${identifier} from '${source}';`;
    }
    return `import${useTypeImports ? ' type' : ''} { ${identifier} } from '${source}';`;
}