@graphql-codegen/cli 2.8.0-alpha-2ada7b533.0 → 2.9.0-alpha-33d33bf6b.0

package/cjs/codegen.js

@@ -5,7 +5,6 @@ const tslib_1 = require("tslib");
 const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
 const core_1 = require("@graphql-codegen/core");
 const utils_1 = require("@graphql-tools/utils");
-const listr_renderer_js_1 = require("./utils/listr-renderer.js");
 const graphql_1 = require("graphql");
 const plugins_js_1 = require("./plugins.js");
 const presets_js_1 = require("./presets.js");
@@ -15,8 +14,7 @@ const fs_1 = tslib_1.__importDefault(require("fs"));
 const path_1 = tslib_1.__importDefault(require("path"));
 const os_1 = require("os");
 const module_1 = require("module");
-const listr_1 = tslib_1.__importDefault(require("listr"));
-const cli_error_js_1 = require("./utils/cli-error.js");
+const listr2_1 = require("listr2");
 /**
  * Poor mans ESM detection.
  * Looking at this and you have a better method?
@@ -57,39 +55,12 @@ async function executeCodegen(input) {
     const config = context.getConfig();
     const pluginContext = context.getPluginContext();
     const result = [];
-    const commonListrOptions = {
-        exitOnError: true,
-    };
-    let listr;
-    if (process.env.VERBOSE) {
-        listr = new listr_1.default({
-            ...commonListrOptions,
-            renderer: 'verbose',
-            nonTTYRenderer: 'verbose',
-        });
-    }
-    else if (process.env.NODE_ENV === 'test') {
-        listr = new listr_1.default({
-            ...commonListrOptions,
-            renderer: 'silent',
-            nonTTYRenderer: 'silent',
-        });
-    }
-    else {
-        listr = new listr_1.default({
-            ...commonListrOptions,
-            renderer: config.silent ? 'silent' : config.errorsOnly ? listr_renderer_js_1.ErrorRenderer : listr_renderer_js_1.Renderer,
-            nonTTYRenderer: config.silent ? 'silent' : 'default',
-            collapse: true,
-            clearOutput: false,
-        });
-    }
     let rootConfig = {};
     let rootSchemas;
     let rootDocuments;
     const generates = {};
     const cache = createCache();
-    function wrapTask(task, source, taskName) {
+    function wrapTask(task, source, taskName, ctx) {
         return () => {
             return context.profiler.run(async () => {
                 try {
@@ -99,6 +70,7 @@ async function executeCodegen(input) {
                     if (source && !(error instanceof graphql_1.GraphQLError)) {
                         error.source = source;
                     }
+                    ctx.errors.push(error);
                     throw error;
                 }
             }, taskName);
@@ -169,123 +141,109 @@ async function executeCodegen(input) {
       `);
         }
     }
-    listr.add({
-        title: 'Parse configuration',
-        task: () => normalize(),
-    });
-    listr.add({
-        title: 'Generate outputs',
-        task: () => {
-            return new listr_1.default(Object.keys(generates).map(filename => {
-                const outputConfig = generates[filename];
-                const hasPreset = !!outputConfig.preset;
-                return {
-                    title: hasPreset
+    const isTest = process.env.NODE_ENV === 'test';
+    const tasks = new listr2_1.Listr([
+        {
+            title: 'Parse Configuration',
+            task: () => normalize(),
+        },
+        {
+            title: 'Generate outputs',
+            task: (ctx, task) => {
+                const generateTasks = Object.keys(generates).map(filename => {
+                    const outputConfig = generates[filename];
+                    const hasPreset = !!outputConfig.preset;
+                    const title = hasPreset
                         ? `Generate to ${filename} (using EXPERIMENTAL preset "${outputConfig.preset}")`
-                        : `Generate ${filename}`,
-                    task: () => {
-                        let outputSchemaAst;
-                        let outputSchema;
-                        const outputFileTemplateConfig = outputConfig.config || {};
-                        let outputDocuments = [];
-                        const outputSpecificSchemas = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.schema);
-                        const outputSpecificDocuments = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.documents);
-                        return new listr_1.default([
-                            {
-                                title: 'Load GraphQL schemas',
-                                task: wrapTask(async () => {
-                                    (0, debugging_js_1.debugLog)(`[CLI] Loading Schemas`);
-                                    const schemaPointerMap = {};
-                                    const allSchemaUnnormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
-                                    for (const unnormalizedPtr of allSchemaUnnormalizedPointers) {
-                                        if (typeof unnormalizedPtr === 'string') {
-                                            schemaPointerMap[unnormalizedPtr] = {};
-                                        }
-                                        else if (typeof unnormalizedPtr === 'object') {
-                                            Object.assign(schemaPointerMap, unnormalizedPtr);
-                                        }
-                                    }
-                                    const hash = JSON.stringify(schemaPointerMap);
-                                    const result = await cache('schema', hash, async () => {
-                                        const outputSchemaAst = await context.loadSchema(schemaPointerMap);
-                                        const outputSchema = (0, plugin_helpers_1.getCachedDocumentNodeFromSchema)(outputSchemaAst);
-                                        return {
-                                            outputSchemaAst,
-                                            outputSchema,
-                                        };
-                                    });
-                                    outputSchemaAst = await result.outputSchemaAst;
-                                    outputSchema = result.outputSchema;
-                                }, filename, `Load GraphQL schemas: ${filename}`),
-                            },
-                            {
-                                title: 'Load GraphQL documents',
-                                task: wrapTask(async () => {
-                                    (0, debugging_js_1.debugLog)(`[CLI] Loading Documents`);
-                                    // get different cache for shared docs and output specific docs
-                                    const documentPointerMap = {};
-                                    const allDocumentsUnnormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
-                                    for (const unnormalizedPtr of allDocumentsUnnormalizedPointers) {
-                                        if (typeof unnormalizedPtr === 'string') {
-                                            documentPointerMap[unnormalizedPtr] = {};
+                        : `Generate ${filename}`;
+                    return {
+                        title,
+                        task: (_, subTask) => {
+                            let outputSchemaAst;
+                            let outputSchema;
+                            const outputFileTemplateConfig = outputConfig.config || {};
+                            let outputDocuments = [];
+                            const outputSpecificSchemas = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.schema);
+                            const outputSpecificDocuments = (0, plugin_helpers_1.normalizeInstanceOrArray)(outputConfig.documents);
+                            return subTask.newListr([
+                                {
+                                    title: 'Load GraphQL schemas',
+                                    task: wrapTask(async () => {
+                                        (0, debugging_js_1.debugLog)(`[CLI] Loading Schemas`);
+                                        const schemaPointerMap = {};
+                                        const allSchemaDenormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
+                                        for (const denormalizedPtr of allSchemaDenormalizedPointers) {
+                                            if (typeof denormalizedPtr === 'string') {
+                                                schemaPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(schemaPointerMap, denormalizedPtr);
+                                            }
                                         }
-                                        else if (typeof unnormalizedPtr === 'object') {
-                                            Object.assign(documentPointerMap, unnormalizedPtr);
+                                        const hash = JSON.stringify(schemaPointerMap);
+                                        const result = await cache('schema', hash, async () => {
+                                            const outputSchemaAst = await context.loadSchema(schemaPointerMap);
+                                            const outputSchema = (0, plugin_helpers_1.getCachedDocumentNodeFromSchema)(outputSchemaAst);
+                                            return {
+                                                outputSchemaAst,
+                                                outputSchema,
+                                            };
+                                        });
+                                        outputSchemaAst = result.outputSchemaAst;
+                                        outputSchema = result.outputSchema;
+                                    }, filename, `Load GraphQL schemas: ${filename}`, ctx),
+                                },
+                                {
+                                    title: 'Load GraphQL documents',
+                                    task: wrapTask(async () => {
+                                        (0, debugging_js_1.debugLog)(`[CLI] Loading Documents`);
+                                        const documentPointerMap = {};
+                                        const allDocumentsDenormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
+                                        for (const denormalizedPtr of allDocumentsDenormalizedPointers) {
+                                            if (typeof denormalizedPtr === 'string') {
+                                                documentPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(documentPointerMap, denormalizedPtr);
+                                            }
                                         }
-                                    }
-                                    const hash = JSON.stringify(documentPointerMap);
-                                    const result = await cache('documents', hash, async () => {
-                                        const documents = await context.loadDocuments(documentPointerMap);
-                                        return {
-                                            documents,
+                                        const hash = JSON.stringify(documentPointerMap);
+                                        const result = await cache('documents', hash, async () => {
+                                            const documents = await context.loadDocuments(documentPointerMap);
+                                            return {
+                                                documents,
+                                            };
+                                        });
+                                        outputDocuments = result.documents;
+                                    }, filename, `Load GraphQL documents: ${filename}`, ctx),
+                                },
+                                {
+                                    title: 'Generate',
+                                    task: wrapTask(async () => {
+                                        (0, debugging_js_1.debugLog)(`[CLI] Generating output`);
+                                        const normalizedPluginsArray = (0, plugin_helpers_1.normalizeConfig)(outputConfig.plugins);
+                                        const pluginLoader = config.pluginLoader || makeDefaultLoader(context.cwd);
+                                        const pluginPackages = await Promise.all(normalizedPluginsArray.map(plugin => (0, plugins_js_1.getPluginByName)(Object.keys(plugin)[0], pluginLoader)));
+                                        const preset = hasPreset
+                                            ? typeof outputConfig.preset === 'string'
+                                                ? await (0, presets_js_1.getPresetByName)(outputConfig.preset, makeDefaultLoader(context.cwd))
+                                                : outputConfig.preset
+                                            : null;
+                                        const pluginMap = Object.fromEntries(pluginPackages.map((pkg, i) => {
+                                            const plugin = normalizedPluginsArray[i];
+                                            const name = Object.keys(plugin)[0];
+                                            return [name, pkg];
+                                        }));
+                                        const mergedConfig = {
+                                            ...rootConfig,
+                                            ...(typeof outputFileTemplateConfig === 'string'
+                                                ? { value: outputFileTemplateConfig }
+                                                : outputFileTemplateConfig),
                                         };
-                                    });
-                                    outputDocuments = await result.documents;
-                                }, filename, `Load GraphQL documents: ${filename}`),
-                            },
-                            {
-                                title: 'Generate',
-                                task: wrapTask(async () => {
-                                    (0, debugging_js_1.debugLog)(`[CLI] Generating output`);
-                                    const normalizedPluginsArray = (0, plugin_helpers_1.normalizeConfig)(outputConfig.plugins);
-                                    const pluginLoader = config.pluginLoader || makeDefaultLoader(context.cwd);
-                                    const pluginPackages = await Promise.all(normalizedPluginsArray.map(plugin => (0, plugins_js_1.getPluginByName)(Object.keys(plugin)[0], pluginLoader)));
-                                    const pluginMap = {};
-                                    const preset = hasPreset
-                                        ? typeof outputConfig.preset === 'string'
-                                            ? await (0, presets_js_1.getPresetByName)(outputConfig.preset, makeDefaultLoader(context.cwd))
-                                            : outputConfig.preset
-                                        : null;
-                                    pluginPackages.forEach((pluginPackage, i) => {
-                                        const plugin = normalizedPluginsArray[i];
-                                        const name = Object.keys(plugin)[0];
-                                        pluginMap[name] = pluginPackage;
-                                    });
-                                    const mergedConfig = {
-                                        ...rootConfig,
-                                        ...(typeof outputFileTemplateConfig === 'string'
-                                            ? { value: outputFileTemplateConfig }
-                                            : outputFileTemplateConfig),
-                                    };
-                                    let outputs = [];
-                                    if (hasPreset) {
-                                        outputs = await context.profiler.run(async () => preset.buildGeneratesSection({
-                                            baseOutputDir: filename,
-                                            presetConfig: outputConfig.presetConfig || {},
-                                            plugins: normalizedPluginsArray,
-                                            schema: outputSchema,
-                                            schemaAst: outputSchemaAst,
-                                            documents: outputDocuments,
-                                            config: mergedConfig,
-                                            pluginMap,
-                                            pluginContext,
-                                            profiler: context.profiler,
-                                        }), `Build Generates Section: ${filename}`);
-                                    }
-                                    else {
-                                        outputs = [
-                                            {
-                                                filename,
+                                        const outputs = hasPreset
+                                            ? await context.profiler.run(async () => preset.buildGeneratesSection({
+                                                baseOutputDir: filename,
+                                                presetConfig: outputConfig.presetConfig || {},
                                                 plugins: normalizedPluginsArray,
                                                 schema: outputSchema,
                                                 schemaAst: outputSchemaAst,
@@ -294,50 +252,67 @@ async function executeCodegen(input) {
                                                 pluginMap,
                                                 pluginContext,
                                                 profiler: context.profiler,
-                                            },
-                                        ];
-                                    }
-                                    const process = async (outputArgs) => {
-                                        const output = await (0, core_1.codegen)({
-                                            ...outputArgs,
-                                            cache,
-                                        });
-                                        result.push({
-                                            filename: outputArgs.filename,
-                                            content: output,
-                                            hooks: outputConfig.hooks || {},
-                                        });
-                                    };
-                                    await context.profiler.run(() => Promise.all(outputs.map(process)), `Codegen: ${filename}`);
-                                }, filename, `Generate: ${filename}`),
-                            },
-                        ], {
-                            // it stops when one of tasks failed
-                            exitOnError: true,
-                        });
-                    },
-                };
-            }), {
-                // it doesn't stop when one of tasks failed, to finish at least some of outputs
-                exitOnError: false,
-                concurrent: (0, os_1.cpus)().length,
-            });
+                                            }), `Build Generates Section: ${filename}`)
+                                            : [
+                                                {
+                                                    filename,
+                                                    plugins: normalizedPluginsArray,
+                                                    schema: outputSchema,
+                                                    schemaAst: outputSchemaAst,
+                                                    documents: outputDocuments,
+                                                    config: mergedConfig,
+                                                    pluginMap,
+                                                    pluginContext,
+                                                    profiler: context.profiler,
+                                                },
+                                            ];
+                                        const process = async (outputArgs) => {
+                                            const output = await (0, core_1.codegen)({
+                                                ...outputArgs,
+                                                cache,
+                                            });
+                                            result.push({
+                                                filename: outputArgs.filename,
+                                                content: output,
+                                                hooks: outputConfig.hooks || {},
+                                            });
+                                        };
+                                        await context.profiler.run(() => Promise.all(outputs.map(process)), `Codegen: ${filename}`);
+                                    }, filename, `Generate: ${filename}`, ctx),
+                                },
+                            ], {
+                                // it stops when of the tasks failed
+                                exitOnError: true,
+                            });
+                        },
+                        // It doesn't stop when one of tasks failed, to finish at least some of outputs
+                        exitOnError: false,
+                        concurrent: (0, os_1.cpus)().length,
+                    };
+                });
+                return task.newListr(generateTasks);
+            },
         },
+    ], {
+        rendererOptions: {
+            clearOutput: false,
+            collapse: true,
+        },
+        ctx: { errors: [] },
+        rendererSilent: isTest || config.silent,
+        exitOnError: true,
     });
-    try {
-        await listr.run();
-    }
-    catch (err) {
-        if ((0, cli_error_js_1.isListrError)(err)) {
-            const allErrs = err.errors.map(subErr => (0, plugin_helpers_1.isDetailedError)(subErr)
-                ? `${subErr.message} for "${subErr.source}"${subErr.details}`
-                : subErr.message || subErr.toString());
-            const newErr = new utils_1.AggregateError(err.errors, `${err.message} ${allErrs.join('\n\n')}`);
-            // Best-effort to all stack traces for debugging
-            newErr.stack = `${newErr.stack}\n\n${err.errors.map(subErr => subErr.stack).join('\n\n')}`;
-            throw newErr;
-        }
-        throw err;
+    // All the errors throw in `listr2` are collected in context
+    // Running tasks doesn't throw anything
+    const executedContext = await tasks.run();
+    if (executedContext.errors.length > 0) {
+        const errors = executedContext.errors.map(subErr => (0, plugin_helpers_1.isDetailedError)(subErr)
+            ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+            : subErr.message || subErr.toString());
+        const newErr = new utils_1.AggregateError(executedContext.errors, `${errors.join('\n\n')}`);
+        // Best-effort to all stack traces for debugging
+        newErr.stack = `${newErr.stack}\n\n${executedContext.errors.map(subErr => subErr.stack).join('\n\n')}`;
+        throw newErr;
     }
     return result;
 }

package/cjs/config.js

@@ -195,6 +195,10 @@ function updateContextWithCliFlags(context, cliFlags) {
         // for some reason parsed value is `'false'` string so this ensure it always is a boolean.
         config.ignoreNoDocuments = cliFlags['ignore-no-documents'] === true;
     }
+    if (cliFlags['emit-legacy-common-js-imports'] !== undefined) {
+        // for some reason parsed value is `'false'` string so this ensure it always is a boolean.
+        config.emitLegacyCommonJSImports = cliFlags['emit-legacy-common-js-imports'] === true;
+    }
     if (cliFlags.project) {
         context.useProject(cliFlags.project);
     }

package/esm/codegen.js

@@ -1,7 +1,6 @@
 import { DetailedError, normalizeOutputParam, normalizeInstanceOrArray, normalizeConfig, getCachedDocumentNodeFromSchema, isDetailedError, } from '@graphql-codegen/plugin-helpers';
 import { codegen } from '@graphql-codegen/core';
 import { AggregateError } from '@graphql-tools/utils';
-import { Renderer, ErrorRenderer } from './utils/listr-renderer.js';
 import { GraphQLError } from 'graphql';
 import { getPluginByName } from './plugins.js';
 import { getPresetByName } from './presets.js';
@@ -11,8 +10,7 @@ import fs from 'fs';
 import path from 'path';
 import { cpus } from 'os';
 import { createRequire } from 'module';
-import Listr from 'listr';
-import { isListrError } from './utils/cli-error.js';
+import { Listr } from 'listr2';
 /**
  * Poor mans ESM detection.
  * Looking at this and you have a better method?
@@ -53,39 +51,12 @@ export async function executeCodegen(input) {
     const config = context.getConfig();
     const pluginContext = context.getPluginContext();
     const result = [];
-    const commonListrOptions = {
-        exitOnError: true,
-    };
-    let listr;
-    if (process.env.VERBOSE) {
-        listr = new Listr({
-            ...commonListrOptions,
-            renderer: 'verbose',
-            nonTTYRenderer: 'verbose',
-        });
-    }
-    else if (process.env.NODE_ENV === 'test') {
-        listr = new Listr({
-            ...commonListrOptions,
-            renderer: 'silent',
-            nonTTYRenderer: 'silent',
-        });
-    }
-    else {
-        listr = new Listr({
-            ...commonListrOptions,
-            renderer: config.silent ? 'silent' : config.errorsOnly ? ErrorRenderer : Renderer,
-            nonTTYRenderer: config.silent ? 'silent' : 'default',
-            collapse: true,
-            clearOutput: false,
-        });
-    }
     let rootConfig = {};
     let rootSchemas;
     let rootDocuments;
     const generates = {};
     const cache = createCache();
-    function wrapTask(task, source, taskName) {
+    function wrapTask(task, source, taskName, ctx) {
         return () => {
             return context.profiler.run(async () => {
                 try {
@@ -95,6 +66,7 @@ export async function executeCodegen(input) {
                     if (source && !(error instanceof GraphQLError)) {
                         error.source = source;
                     }
+                    ctx.errors.push(error);
                     throw error;
                 }
             }, taskName);
@@ -165,123 +137,109 @@ export async function executeCodegen(input) {
       `);
         }
     }
-    listr.add({
-        title: 'Parse configuration',
-        task: () => normalize(),
-    });
-    listr.add({
-        title: 'Generate outputs',
-        task: () => {
-            return new Listr(Object.keys(generates).map(filename => {
-                const outputConfig = generates[filename];
-                const hasPreset = !!outputConfig.preset;
-                return {
-                    title: hasPreset
+    const isTest = process.env.NODE_ENV === 'test';
+    const tasks = new Listr([
+        {
+            title: 'Parse Configuration',
+            task: () => normalize(),
+        },
+        {
+            title: 'Generate outputs',
+            task: (ctx, task) => {
+                const generateTasks = Object.keys(generates).map(filename => {
+                    const outputConfig = generates[filename];
+                    const hasPreset = !!outputConfig.preset;
+                    const title = hasPreset
                         ? `Generate to ${filename} (using EXPERIMENTAL preset "${outputConfig.preset}")`
-                        : `Generate ${filename}`,
-                    task: () => {
-                        let outputSchemaAst;
-                        let outputSchema;
-                        const outputFileTemplateConfig = outputConfig.config || {};
-                        let outputDocuments = [];
-                        const outputSpecificSchemas = normalizeInstanceOrArray(outputConfig.schema);
-                        const outputSpecificDocuments = normalizeInstanceOrArray(outputConfig.documents);
-                        return new Listr([
-                            {
-                                title: 'Load GraphQL schemas',
-                                task: wrapTask(async () => {
-                                    debugLog(`[CLI] Loading Schemas`);
-                                    const schemaPointerMap = {};
-                                    const allSchemaUnnormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
-                                    for (const unnormalizedPtr of allSchemaUnnormalizedPointers) {
-                                        if (typeof unnormalizedPtr === 'string') {
-                                            schemaPointerMap[unnormalizedPtr] = {};
-                                        }
-                                        else if (typeof unnormalizedPtr === 'object') {
-                                            Object.assign(schemaPointerMap, unnormalizedPtr);
-                                        }
-                                    }
-                                    const hash = JSON.stringify(schemaPointerMap);
-                                    const result = await cache('schema', hash, async () => {
-                                        const outputSchemaAst = await context.loadSchema(schemaPointerMap);
-                                        const outputSchema = getCachedDocumentNodeFromSchema(outputSchemaAst);
-                                        return {
-                                            outputSchemaAst,
-                                            outputSchema,
-                                        };
-                                    });
-                                    outputSchemaAst = await result.outputSchemaAst;
-                                    outputSchema = result.outputSchema;
-                                }, filename, `Load GraphQL schemas: ${filename}`),
-                            },
-                            {
-                                title: 'Load GraphQL documents',
-                                task: wrapTask(async () => {
-                                    debugLog(`[CLI] Loading Documents`);
-                                    // get different cache for shared docs and output specific docs
-                                    const documentPointerMap = {};
-                                    const allDocumentsUnnormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
-                                    for (const unnormalizedPtr of allDocumentsUnnormalizedPointers) {
-                                        if (typeof unnormalizedPtr === 'string') {
-                                            documentPointerMap[unnormalizedPtr] = {};
+                        : `Generate ${filename}`;
+                    return {
+                        title,
+                        task: (_, subTask) => {
+                            let outputSchemaAst;
+                            let outputSchema;
+                            const outputFileTemplateConfig = outputConfig.config || {};
+                            let outputDocuments = [];
+                            const outputSpecificSchemas = normalizeInstanceOrArray(outputConfig.schema);
+                            const outputSpecificDocuments = normalizeInstanceOrArray(outputConfig.documents);
+                            return subTask.newListr([
+                                {
+                                    title: 'Load GraphQL schemas',
+                                    task: wrapTask(async () => {
+                                        debugLog(`[CLI] Loading Schemas`);
+                                        const schemaPointerMap = {};
+                                        const allSchemaDenormalizedPointers = [...rootSchemas, ...outputSpecificSchemas];
+                                        for (const denormalizedPtr of allSchemaDenormalizedPointers) {
+                                            if (typeof denormalizedPtr === 'string') {
+                                                schemaPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(schemaPointerMap, denormalizedPtr);
+                                            }
                                         }
-                                        else if (typeof unnormalizedPtr === 'object') {
-                                            Object.assign(documentPointerMap, unnormalizedPtr);
+                                        const hash = JSON.stringify(schemaPointerMap);
+                                        const result = await cache('schema', hash, async () => {
+                                            const outputSchemaAst = await context.loadSchema(schemaPointerMap);
+                                            const outputSchema = getCachedDocumentNodeFromSchema(outputSchemaAst);
+                                            return {
+                                                outputSchemaAst,
+                                                outputSchema,
+                                            };
+                                        });
+                                        outputSchemaAst = result.outputSchemaAst;
+                                        outputSchema = result.outputSchema;
+                                    }, filename, `Load GraphQL schemas: ${filename}`, ctx),
+                                },
+                                {
+                                    title: 'Load GraphQL documents',
+                                    task: wrapTask(async () => {
+                                        debugLog(`[CLI] Loading Documents`);
+                                        const documentPointerMap = {};
+                                        const allDocumentsDenormalizedPointers = [...rootDocuments, ...outputSpecificDocuments];
+                                        for (const denormalizedPtr of allDocumentsDenormalizedPointers) {
+                                            if (typeof denormalizedPtr === 'string') {
+                                                documentPointerMap[denormalizedPtr] = {};
+                                            }
+                                            else if (typeof denormalizedPtr === 'object') {
+                                                Object.assign(documentPointerMap, denormalizedPtr);
+                                            }
                                         }
-                                    }
-                                    const hash = JSON.stringify(documentPointerMap);
-                                    const result = await cache('documents', hash, async () => {
-                                        const documents = await context.loadDocuments(documentPointerMap);
-                                        return {
-                                            documents,
+                                        const hash = JSON.stringify(documentPointerMap);
+                                        const result = await cache('documents', hash, async () => {
+                                            const documents = await context.loadDocuments(documentPointerMap);
+                                            return {
+                                                documents,
+                                            };
+                                        });
+                                        outputDocuments = result.documents;
+                                    }, filename, `Load GraphQL documents: ${filename}`, ctx),
+                                },
+                                {
+                                    title: 'Generate',
+                                    task: wrapTask(async () => {
+                                        debugLog(`[CLI] Generating output`);
+                                        const normalizedPluginsArray = normalizeConfig(outputConfig.plugins);
+                                        const pluginLoader = config.pluginLoader || makeDefaultLoader(context.cwd);
+                                        const pluginPackages = await Promise.all(normalizedPluginsArray.map(plugin => getPluginByName(Object.keys(plugin)[0], pluginLoader)));
+                                        const preset = hasPreset
+                                            ? typeof outputConfig.preset === 'string'
+                                                ? await getPresetByName(outputConfig.preset, makeDefaultLoader(context.cwd))
+                                                : outputConfig.preset
+                                            : null;
+                                        const pluginMap = Object.fromEntries(pluginPackages.map((pkg, i) => {
+                                            const plugin = normalizedPluginsArray[i];
+                                            const name = Object.keys(plugin)[0];
+                                            return [name, pkg];
+                                        }));
+                                        const mergedConfig = {
+                                            ...rootConfig,
+                                            ...(typeof outputFileTemplateConfig === 'string'
+                                                ? { value: outputFileTemplateConfig }
+                                                : outputFileTemplateConfig),
                                         };
-                                    });
-                                    outputDocuments = await result.documents;
-                                }, filename, `Load GraphQL documents: ${filename}`),
-                            },
-                            {
-                                title: 'Generate',
-                                task: wrapTask(async () => {
-                                    debugLog(`[CLI] Generating output`);
-                                    const normalizedPluginsArray = normalizeConfig(outputConfig.plugins);
-                                    const pluginLoader = config.pluginLoader || makeDefaultLoader(context.cwd);
-                                    const pluginPackages = await Promise.all(normalizedPluginsArray.map(plugin => getPluginByName(Object.keys(plugin)[0], pluginLoader)));
-                                    const pluginMap = {};
-                                    const preset = hasPreset
-                                        ? typeof outputConfig.preset === 'string'
-                                            ? await getPresetByName(outputConfig.preset, makeDefaultLoader(context.cwd))
-                                            : outputConfig.preset
-                                        : null;
-                                    pluginPackages.forEach((pluginPackage, i) => {
-                                        const plugin = normalizedPluginsArray[i];
-                                        const name = Object.keys(plugin)[0];
-                                        pluginMap[name] = pluginPackage;
-                                    });
-                                    const mergedConfig = {
-                                        ...rootConfig,
-                                        ...(typeof outputFileTemplateConfig === 'string'
-                                            ? { value: outputFileTemplateConfig }
-                                            : outputFileTemplateConfig),
-                                    };
-                                    let outputs = [];
-                                    if (hasPreset) {
-                                        outputs = await context.profiler.run(async () => preset.buildGeneratesSection({
-                                            baseOutputDir: filename,
-                                            presetConfig: outputConfig.presetConfig || {},
-                                            plugins: normalizedPluginsArray,
-                                            schema: outputSchema,
-                                            schemaAst: outputSchemaAst,
-                                            documents: outputDocuments,
-                                            config: mergedConfig,
-                                            pluginMap,
-                                            pluginContext,
-                                            profiler: context.profiler,
-                                        }), `Build Generates Section: ${filename}`);
-                                    }
-                                    else {
-                                        outputs = [
-                                            {
-                                                filename,
+                                        const outputs = hasPreset
+                                            ? await context.profiler.run(async () => preset.buildGeneratesSection({
+                                                baseOutputDir: filename,
+                                                presetConfig: outputConfig.presetConfig || {},
                                                 plugins: normalizedPluginsArray,
                                                 schema: outputSchema,
                                                 schemaAst: outputSchemaAst,
@@ -290,50 +248,67 @@ export async function executeCodegen(input) {
                                                 pluginMap,
                                                 pluginContext,
                                                 profiler: context.profiler,
-                                            },
-                                        ];
-                                    }
-                                    const process = async (outputArgs) => {
-                                        const output = await codegen({
-                                            ...outputArgs,
-                                            cache,
-                                        });
-                                        result.push({
-                                            filename: outputArgs.filename,
-                                            content: output,
-                                            hooks: outputConfig.hooks || {},
-                                        });
-                                    };
-                                    await context.profiler.run(() => Promise.all(outputs.map(process)), `Codegen: ${filename}`);
-                                }, filename, `Generate: ${filename}`),
-                            },
-                        ], {
-                            // it stops when one of tasks failed
-                            exitOnError: true,
-                        });
-                    },
-                };
-            }), {
-                // it doesn't stop when one of tasks failed, to finish at least some of outputs
-                exitOnError: false,
-                concurrent: cpus().length,
-            });
+                                            }), `Build Generates Section: ${filename}`)
+                                            : [
+                                                {
+                                                    filename,
+                                                    plugins: normalizedPluginsArray,
+                                                    schema: outputSchema,
+                                                    schemaAst: outputSchemaAst,
+                                                    documents: outputDocuments,
+                                                    config: mergedConfig,
+                                                    pluginMap,
+                                                    pluginContext,
+                                                    profiler: context.profiler,
+                                                },
+                                            ];
+                                        const process = async (outputArgs) => {
+                                            const output = await codegen({
+                                                ...outputArgs,
+                                                cache,
+                                            });
+                                            result.push({
+                                                filename: outputArgs.filename,
+                                                content: output,
+                                                hooks: outputConfig.hooks || {},
+                                            });
+                                        };
+                                        await context.profiler.run(() => Promise.all(outputs.map(process)), `Codegen: ${filename}`);
+                                    }, filename, `Generate: ${filename}`, ctx),
+                                },
+                            ], {
+                                // it stops when of the tasks failed
+                                exitOnError: true,
+                            });
+                        },
+                        // It doesn't stop when one of tasks failed, to finish at least some of outputs
+                        exitOnError: false,
+                        concurrent: cpus().length,
+                    };
+                });
+                return task.newListr(generateTasks);
+            },
         },
+    ], {
+        rendererOptions: {
+            clearOutput: false,
+            collapse: true,
+        },
+        ctx: { errors: [] },
+        rendererSilent: isTest || config.silent,
+        exitOnError: true,
     });
-    try {
-        await listr.run();
-    }
-    catch (err) {
-        if (isListrError(err)) {
-            const allErrs = err.errors.map(subErr => isDetailedError(subErr)
-                ? `${subErr.message} for "${subErr.source}"${subErr.details}`
-                : subErr.message || subErr.toString());
-            const newErr = new AggregateError(err.errors, `${err.message} ${allErrs.join('\n\n')}`);
-            // Best-effort to all stack traces for debugging
-            newErr.stack = `${newErr.stack}\n\n${err.errors.map(subErr => subErr.stack).join('\n\n')}`;
-            throw newErr;
-        }
-        throw err;
+    // All the errors throw in `listr2` are collected in context
+    // Running tasks doesn't throw anything
+    const executedContext = await tasks.run();
+    if (executedContext.errors.length > 0) {
+        const errors = executedContext.errors.map(subErr => isDetailedError(subErr)
+            ? `${subErr.message} for "${subErr.source}"${subErr.details}`
+            : subErr.message || subErr.toString());
+        const newErr = new AggregateError(executedContext.errors, `${errors.join('\n\n')}`);
+        // Best-effort to all stack traces for debugging
+        newErr.stack = `${newErr.stack}\n\n${executedContext.errors.map(subErr => subErr.stack).join('\n\n')}`;
+        throw newErr;
     }
     return result;
 }

package/esm/config.js

@@ -185,6 +185,10 @@ export function updateContextWithCliFlags(context, cliFlags) {
         // for some reason parsed value is `'false'` string so this ensure it always is a boolean.
         config.ignoreNoDocuments = cliFlags['ignore-no-documents'] === true;
     }
+    if (cliFlags['emit-legacy-common-js-imports'] !== undefined) {
+        // for some reason parsed value is `'false'` string so this ensure it always is a boolean.
+        config.emitLegacyCommonJSImports = cliFlags['emit-legacy-common-js-imports'] === true;
+    }
     if (cliFlags.project) {
         context.useProject(cliFlags.project);
     }

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@graphql-codegen/cli",
-  "version": "2.8.0-alpha-2ada7b533.0",
+  "version": "2.9.0-alpha-33d33bf6b.0",
   "peerDependencies": {
     "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
   },
   "dependencies": {
-    "@graphql-codegen/core": "2.5.2-alpha-2ada7b533.0",
-    "@graphql-codegen/plugin-helpers": "^2.5.0-alpha-2ada7b533.0",
+    "@graphql-codegen/core": "2.6.1-alpha-33d33bf6b.0",
+    "@graphql-codegen/plugin-helpers": "^2.6.0-alpha-33d33bf6b.0",
     "@graphql-tools/apollo-engine-loader": "^7.3.1",
     "@graphql-tools/code-file-loader": "^7.3.0",
     "@graphql-tools/git-loader": "^7.2.0",
@@ -19,9 +19,7 @@
     "@graphql-tools/utils": "^8.8.0",
     "ansi-escapes": "^4.3.1",
     "chalk": "^4.1.0",
-    "change-case-all": "1.0.14",
     "chokidar": "^3.5.2",
-    "common-tags": "^1.8.0",
     "cosmiconfig": "^7.0.0",
     "cross-undici-fetch": "^0.4.11",
     "debounce": "^1.2.0",
@@ -30,13 +28,11 @@
     "inquirer": "^8.0.0",
     "is-glob": "^4.0.1",
     "json-to-pretty-yaml": "^1.2.2",
-    "listr": "^0.14.3",
-    "listr-update-renderer": "^0.5.0",
+    "listr2": "^4.0.5",
     "log-symbols": "^4.0.0",
     "mkdirp": "^1.0.4",
     "string-env-interpolation": "^1.0.1",
     "ts-log": "^2.2.3",
-    "wrap-ansi": "^7.0.0",
     "yaml": "^1.10.0",
     "yargs": "^17.0.0"
   },

package/typings/config.d.ts

@@ -11,6 +11,7 @@ export declare type YamlCliFlags = {
     errorsOnly: boolean;
     profile: boolean;
     ignoreNoDocuments?: boolean;
+    emitLegacyCommonJSImports?: boolean;
 };
 export declare function generateSearchPlaces(moduleName: string): string[];
 export interface LoadCodegenConfigOptions {

package/cjs/utils/indentString.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.indentString = void 0;
-/**
-Indent each line in a string.
-@param string - The string to indent.
-@param count - How many times you want `options.indent` repeated. Default: `1`.
-@example
-```
-import indentString from 'indent-string';
-indentString('Unicorns\nRainbows', 4);
-//=> '    Unicorns\n    Rainbows'
-indentString('Unicorns\nRainbows', 4, {indent: '♥'});
-//=> '♥♥♥♥Unicorns\n♥♥♥♥Rainbows'
-```
-*/
-function indentString(string, count = 1, options = {}) {
-    const { indent = ' ', includeEmptyLines = false } = options;
-    if (typeof string !== 'string') {
-        throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof string}\``);
-    }
-    if (typeof count !== 'number') {
-        throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof count}\``);
-    }
-    if (count < 0) {
-        throw new RangeError(`Expected \`count\` to be at least 0, got \`${count}\``);
-    }
-    if (typeof indent !== 'string') {
-        throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof indent}\``);
-    }
-    if (count === 0) {
-        return string;
-    }
-    const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
-    return string.replace(regex, indent.repeat(count));
-}
-exports.indentString = indentString;

package/cjs/utils/listr-renderer.js

@@ -1,136 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorRenderer = exports.Renderer = void 0;
-const tslib_1 = require("tslib");
-const chalk_1 = tslib_1.__importDefault(require("chalk"));
-const indentString_js_1 = require("./indentString.js");
-const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
-const ansi_escapes_1 = tslib_1.__importDefault(require("ansi-escapes"));
-const wrap_ansi_1 = tslib_1.__importDefault(require("wrap-ansi"));
-const common_tags_1 = require("common-tags");
-const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
-const debugging_js_1 = require("./debugging.js");
-const listr_update_renderer_1 = tslib_1.__importDefault(require("listr-update-renderer"));
-class Renderer {
-    constructor(tasks, options) {
-        this.updateRenderer = new listr_update_renderer_1.default(tasks, options);
-    }
-    render() {
-        return this.updateRenderer.render();
-    }
-    end(err) {
-        this.updateRenderer.end(err);
-        if (typeof err === 'undefined') {
-            logUpdate.clear();
-            return;
-        }
-        // persist the output
-        logUpdate.done();
-        // show errors
-        if (err) {
-            const errorCount = err.errors ? err.errors.length : 0;
-            if (errorCount > 0) {
-                const count = (0, indentString_js_1.indentString)(chalk_1.default.red.bold(`Found ${errorCount} error${errorCount > 1 ? 's' : ''}`), 1);
-                const details = err.errors
-                    .map(error => {
-                    (0, debugging_js_1.debugLog)(`[CLI] Exited with an error`, error);
-                    return { msg: (0, plugin_helpers_1.isDetailedError)(error) ? error.details : null, rawError: error };
-                })
-                    .map(({ msg, rawError }, i) => {
-                    const source = err.errors[i].source;
-                    msg = msg ? chalk_1.default.gray((0, indentString_js_1.indentString)((0, common_tags_1.stripIndent)(`${msg}`), 4)) : null;
-                    const stack = rawError.stack ? chalk_1.default.gray((0, indentString_js_1.indentString)((0, common_tags_1.stripIndent)(rawError.stack), 4)) : null;
-                    if (source) {
-                        const sourceOfError = typeof source === 'string' ? source : source.name;
-                        const title = (0, indentString_js_1.indentString)(`${log_symbols_1.default.error} ${sourceOfError}`, 2);
-                        return [title, msg, stack, stack].filter(Boolean).join('\n');
-                    }
-                    return [msg, stack].filter(Boolean).join('\n');
-                })
-                    .join('\n\n');
-                logUpdate.emit(['', count, details, ''].join('\n\n'));
-            }
-            else {
-                const details = err.details ? err.details : '';
-                logUpdate.emit(`${chalk_1.default.red.bold(`${(0, indentString_js_1.indentString)(err.message, 2)}`)}\n${details}\n${chalk_1.default.grey(err.stack)}`);
-            }
-        }
-        logUpdate.done();
-        (0, debugging_js_1.printLogs)();
-    }
-}
-exports.Renderer = Renderer;
-const render = tasks => {
-    for (const task of tasks) {
-        task.subscribe(event => {
-            if (event.type === 'SUBTASKS') {
-                render(task.subtasks);
-                return;
-            }
-            if (event.type === 'DATA') {
-                logUpdate.emit(chalk_1.default.dim(`${event.data}`));
-            }
-            logUpdate.done();
-        }, err => {
-            logUpdate.emit(err);
-            logUpdate.done();
-        });
-    }
-};
-class ErrorRenderer {
-    constructor(tasks, _options) {
-        this.tasks = tasks;
-    }
-    render() {
-        render(this.tasks);
-    }
-    static get nonTTY() {
-        return true;
-    }
-    end() { }
-}
-exports.ErrorRenderer = ErrorRenderer;
-class LogUpdate {
-    constructor() {
-        this.stream = process.stdout;
-        // state
-        this.previousLineCount = 0;
-        this.previousOutput = '';
-        this.previousWidth = this.getWidth();
-    }
-    emit(...args) {
-        let output = args.join(' ') + '\n';
-        const width = this.getWidth();
-        if (output === this.previousOutput && this.previousWidth === width) {
-            return;
-        }
-        this.previousOutput = output;
-        this.previousWidth = width;
-        output = (0, wrap_ansi_1.default)(output, width, {
-            trim: false,
-            hard: true,
-            wordWrap: false,
-        });
-        this.stream.write(ansi_escapes_1.default.eraseLines(this.previousLineCount) + output);
-        this.previousLineCount = output.split('\n').length;
-    }
-    clear() {
-        this.stream.write(ansi_escapes_1.default.eraseLines(this.previousLineCount));
-        this.previousOutput = '';
-        this.previousWidth = this.getWidth();
-        this.previousLineCount = 0;
-    }
-    done() {
-        this.previousOutput = '';
-        this.previousWidth = this.getWidth();
-        this.previousLineCount = 0;
-    }
-    getWidth() {
-        const { columns } = this.stream;
-        if (!columns) {
-            return 80;
-        }
-        return columns;
-    }
-}
-const logUpdate = new LogUpdate();

package/esm/utils/indentString.js

@@ -1,33 +0,0 @@
-/**
-Indent each line in a string.
-@param string - The string to indent.
-@param count - How many times you want `options.indent` repeated. Default: `1`.
-@example
-```
-import indentString from 'indent-string';
-indentString('Unicorns\nRainbows', 4);
-//=> '    Unicorns\n    Rainbows'
-indentString('Unicorns\nRainbows', 4, {indent: '♥'});
-//=> '♥♥♥♥Unicorns\n♥♥♥♥Rainbows'
-```
-*/
-export function indentString(string, count = 1, options = {}) {
-    const { indent = ' ', includeEmptyLines = false } = options;
-    if (typeof string !== 'string') {
-        throw new TypeError(`Expected \`input\` to be a \`string\`, got \`${typeof string}\``);
-    }
-    if (typeof count !== 'number') {
-        throw new TypeError(`Expected \`count\` to be a \`number\`, got \`${typeof count}\``);
-    }
-    if (count < 0) {
-        throw new RangeError(`Expected \`count\` to be at least 0, got \`${count}\``);
-    }
-    if (typeof indent !== 'string') {
-        throw new TypeError(`Expected \`options.indent\` to be a \`string\`, got \`${typeof indent}\``);
-    }
-    if (count === 0) {
-        return string;
-    }
-    const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
-    return string.replace(regex, indent.repeat(count));
-}

package/esm/utils/listr-renderer.js

@@ -1,130 +0,0 @@
-import chalk from 'chalk';
-import { indentString } from './indentString.js';
-import logSymbol from 'log-symbols';
-import ansiEscapes from 'ansi-escapes';
-import wrapAnsi from 'wrap-ansi';
-import { stripIndent } from 'common-tags';
-import { isDetailedError } from '@graphql-codegen/plugin-helpers';
-import { debugLog, printLogs } from './debugging.js';
-import UpdateRenderer from 'listr-update-renderer';
-export class Renderer {
-    constructor(tasks, options) {
-        this.updateRenderer = new UpdateRenderer(tasks, options);
-    }
-    render() {
-        return this.updateRenderer.render();
-    }
-    end(err) {
-        this.updateRenderer.end(err);
-        if (typeof err === 'undefined') {
-            logUpdate.clear();
-            return;
-        }
-        // persist the output
-        logUpdate.done();
-        // show errors
-        if (err) {
-            const errorCount = err.errors ? err.errors.length : 0;
-            if (errorCount > 0) {
-                const count = indentString(chalk.red.bold(`Found ${errorCount} error${errorCount > 1 ? 's' : ''}`), 1);
-                const details = err.errors
-                    .map(error => {
-                    debugLog(`[CLI] Exited with an error`, error);
-                    return { msg: isDetailedError(error) ? error.details : null, rawError: error };
-                })
-                    .map(({ msg, rawError }, i) => {
-                    const source = err.errors[i].source;
-                    msg = msg ? chalk.gray(indentString(stripIndent(`${msg}`), 4)) : null;
-                    const stack = rawError.stack ? chalk.gray(indentString(stripIndent(rawError.stack), 4)) : null;
-                    if (source) {
-                        const sourceOfError = typeof source === 'string' ? source : source.name;
-                        const title = indentString(`${logSymbol.error} ${sourceOfError}`, 2);
-                        return [title, msg, stack, stack].filter(Boolean).join('\n');
-                    }
-                    return [msg, stack].filter(Boolean).join('\n');
-                })
-                    .join('\n\n');
-                logUpdate.emit(['', count, details, ''].join('\n\n'));
-            }
-            else {
-                const details = err.details ? err.details : '';
-                logUpdate.emit(`${chalk.red.bold(`${indentString(err.message, 2)}`)}\n${details}\n${chalk.grey(err.stack)}`);
-            }
-        }
-        logUpdate.done();
-        printLogs();
-    }
-}
-const render = tasks => {
-    for (const task of tasks) {
-        task.subscribe(event => {
-            if (event.type === 'SUBTASKS') {
-                render(task.subtasks);
-                return;
-            }
-            if (event.type === 'DATA') {
-                logUpdate.emit(chalk.dim(`${event.data}`));
-            }
-            logUpdate.done();
-        }, err => {
-            logUpdate.emit(err);
-            logUpdate.done();
-        });
-    }
-};
-export class ErrorRenderer {
-    constructor(tasks, _options) {
-        this.tasks = tasks;
-    }
-    render() {
-        render(this.tasks);
-    }
-    static get nonTTY() {
-        return true;
-    }
-    end() { }
-}
-class LogUpdate {
-    constructor() {
-        this.stream = process.stdout;
-        // state
-        this.previousLineCount = 0;
-        this.previousOutput = '';
-        this.previousWidth = this.getWidth();
-    }
-    emit(...args) {
-        let output = args.join(' ') + '\n';
-        const width = this.getWidth();
-        if (output === this.previousOutput && this.previousWidth === width) {
-            return;
-        }
-        this.previousOutput = output;
-        this.previousWidth = width;
-        output = wrapAnsi(output, width, {
-            trim: false,
-            hard: true,
-            wordWrap: false,
-        });
-        this.stream.write(ansiEscapes.eraseLines(this.previousLineCount) + output);
-        this.previousLineCount = output.split('\n').length;
-    }
-    clear() {
-        this.stream.write(ansiEscapes.eraseLines(this.previousLineCount));
-        this.previousOutput = '';
-        this.previousWidth = this.getWidth();
-        this.previousLineCount = 0;
-    }
-    done() {
-        this.previousOutput = '';
-        this.previousWidth = this.getWidth();
-        this.previousLineCount = 0;
-    }
-    getWidth() {
-        const { columns } = this.stream;
-        if (!columns) {
-            return 80;
-        }
-        return columns;
-    }
-}
-const logUpdate = new LogUpdate();

package/typings/utils/indentString.d.ts

@@ -1,26 +0,0 @@
-export interface IndentStringOptions {
-    /**
-      The string to use for the indent.
-      @default ' '
-      */
-    readonly indent?: string;
-    /**
-      Also indent empty lines.
-      @default false
-      */
-    readonly includeEmptyLines?: boolean;
-}
-/**
-Indent each line in a string.
-@param string - The string to indent.
-@param count - How many times you want `options.indent` repeated. Default: `1`.
-@example
-```
-import indentString from 'indent-string';
-indentString('Unicorns\nRainbows', 4);
-//=> '    Unicorns\n    Rainbows'
-indentString('Unicorns\nRainbows', 4, {indent: '♥'});
-//=> '♥♥♥♥Unicorns\n♥♥♥♥Rainbows'
-```
-*/
-export declare function indentString(string: string, count?: number, options?: IndentStringOptions): string;

package/typings/utils/listr-renderer.d.ts

@@ -1,18 +0,0 @@
-import { ListrTask } from 'listr';
-import { DetailedError } from '@graphql-codegen/plugin-helpers';
-export declare class Renderer {
-    private updateRenderer;
-    constructor(tasks: ListrTask, options: any);
-    render(): any;
-    end(err: Error & {
-        errors?: (Error | DetailedError)[];
-        details?: string;
-    }): void;
-}
-export declare class ErrorRenderer {
-    private tasks;
-    constructor(tasks: any, _options: any);
-    render(): void;
-    static get nonTTY(): boolean;
-    end(): void;
-}