Bug: There was a problem loading formatter: ...\node_modules\eslint\lib\cli-engine\formatters\stylish

[santi100a]

Environment

Node version: v19.6.1
npm version: v9.5.0
Local ESLint version: v8.41.0 (Currently used)
Global ESLint version: Not found
Operating System: win32 10.0.19045

What parser are you using?

TypeScript Parser (@typescript-eslint/parser)

What did you do?

Configuration

{
    "env": {
        "browser": true,
        "commonjs": true,
        "es2021": true,
        "node": true
    },
    "extends": [
        "eslint:recommended",
        "plugin:@typescript-eslint/recommended"
    ],
    "overrides": [
    ],
    "parser": "@typescript-eslint/parser",
    "parserOptions": {
        "ecmaVersion": "latest"
    },
    "plugins": [
        "@typescript-eslint"
    ],
    "rules": {
    }
}

import { deepEquality } from '@santi100/equal-lib';

function indexOf(arr: any[], item: any) {
	for (const idx in arr) {
		if (deepEquality(arr[idx], item)) return arr[idx];
	}
	return -1;
}

export class AssertionError<E = unknown, A = unknown>
	extends Error
	implements AssertOptionalParams<E, A>
{
	/**
	 * Expected value for the assertion.
	 */
	readonly expected: E;
	/**
	 * Received value for the assertion.
	 */
	readonly actual: A;
	/**
	 * Optional operator used for the assertion.
	 */
	readonly operator?: string;
	constructor(expected: E, actual: A, operator?: string) {
		super(
			`Assertion failed! Expected ${expected}. Got ${actual} when using operator ${operator}.`
		);
		this.expected = expected;
		this.actual = actual;
		this.operator = operator;
	}
}
/**
 * Asserts that `condition` is truthy.
 * Throws an {@link AssertionError} otherwise.
 *
 * @param {boolean} condition A boolean condition to assert.
 * @param {AssertOptionalParams} errorParams Parameters for the {@link AssertionError} that will be
 * thrown in case the condition is falsy.
 * @param {unknown} errorParams.expected Expected value for the assertion.
 * @param {unknown} errorParams.actual   Received value for the assertion.
 * @param {string?} errorParams.operator Optional operator used for the assertion.
 * @returns {void} Nothing.
 */
export function assert(
	condition: boolean,
	errorParams: AssertOptionalParams<true, boolean> = {
		expected: true,
		actual: false,
		operator: '==='
	}
): void {
	const { expected, actual, operator } = errorParams;
	if (!condition) throw new AssertionError(expected, actual, operator);
}
/**
 * Asserts that the type of `val` is `expectedType`.
 * Throws an {@link AssertionError} otherwise.
 *
 * @param val An expression whose type is to be asserted.
 * @param expectedType The expected type. Must be one of {@link Type}.
 * @deprecated Use {@link assertTypeOf} instead.
 */
export function assertType<T = unknown>(val: T, expectedType: Type): void {
	const wrongType = typeof val !== expectedType;
	if (wrongType) throw new AssertionError(expectedType, typeof val, 'typeof');
}

export type Type =
	| 'string'
	| 'number'
	| 'bigint'
	| 'boolean'
	| 'symbol'
	| 'undefined'
	| 'object'
	| 'function';
/**
 * The shape of the assertion options.
 */
export interface AssertOptionalParams<E, A> {
	/**
	 * Expected value for the assertion.
	 */
	readonly expected: E;
	/**
	 * Received value for the assertion.
	 */
	readonly actual: A;
	/**
	 * Optional operator used for the assertion.
	 */
	readonly operator?: string;
}
/**
 * Asserts that the type of `arg` is `expectedType`. Throws a `TypeError` otherwise.
 *
 * @param arg An expression whose type is to be asserted.
 * @param expectedType The expected type. Must be one of {@link Type}.
 * @param name An optional expression name to be put in the `TypeError`'s message. Defaults to "arg".
 */
export function assertTypeOf(arg: any, expectedType: Type, name = 'arg') {
	const TYPES = [
		'string',
		'number',
		'bigint',
		'boolean',
		'symbol',
		'undefined',
		'object',
		'function'
	];
	assertOneOf(expectedType, 'expectedType', TYPES);
	if (typeof arg !== expectedType)
		throw new TypeError(
			`"${name}" must be of type "${expectedType}". Got "${arg}" of type "${typeof arg}".`
		);
}
/**
 * Asserts `arg` is one of `choices`.  Throws a `TypeError` otherwise.
 *
 * @param arg The value that's expected to be included within `choices`.
 * @param name An expression name to be put in the `TypeError`'s message.
 * @param choices An array containing the posible values `arg` should have in order for an error not
 * to be thrown.
 * @param shallow Whether or not to use shallow equality (default deep equality is powered by 
   `@santi100/equal-lib` 😉).
 */
export function assertOneOf<T = unknown>(arg: any, name: string, choices: T[], shallow = false) {
	if (shallow ? choices.indexOf(arg) : indexOf(choices, arg) === -1)
		throw new TypeError(
			`"${name}" must be one of "${choices.join(
				', '
			)}". Got "${arg}" of type "${typeof arg}".`
		);
}
function __isInteger(n: number) {
	return n - Math.floor(n) <= 0;
}
/**
 * Asserts `arg` is an integer. Throws a `TypeError` otherwise.
 *
 * @param arg Any number.
 * @param name An optional expression name to be put in the `TypeError`'s message. Defaults to "arg".
 */
export function assertInteger(arg: number, name = 'arg') {
	if (!__isInteger(arg))
		throw new TypeError(
			`"${name}" must be an integer. Got "${arg}" of type "${typeof arg}".`
		);
}
/**
 * Asserts `arg` is bigger than or equal than `min`. Throws a `RangeError` otherwise.
 *
 * @param arg Any value.
 * @param name An expression name to be put in the `TypeError`'s message.
 * @param min The minimum value for `arg`.
 */
export function assertMin(arg: any, name: string, min: any) {
	if (arg < min)
		throw new RangeError(
			`"${name}" must be bigger than or equal to ${min}. Got "${arg}" of type "${typeof arg}".`
		);
}

/**
 * Asserts `arg` is smaller or equal than `max`. Throws a `RangeError` otherwise.
 *
 * @param arg Any value.
 * @param name An expression name to be put in the `TypeError`'s message.

 * @param max The maximum value for `arg`.
 */
export function assertMax(arg: any, name: string, max: any) {
	if (arg > max)
		throw new RangeError(
			`"${name}" must be smaller than or equal to ${max}. Got "${arg}" of type "${typeof arg}".`
		);
}
/**
 * Asserts `arg` is between `min + 1` and `max + 1` (inclusive). Throws a `RangeError` otherwise.
 *
 * @param arg Any value.
 * @param name An expression name to be put in the `TypeError`'s message. 
 * @param min The minimum value for `arg`.
 * @param max The maximum value for `arg`.
 */
export function assertRange(arg: any, name: string, min: any, max: any) {
	if (arg > max || arg < min)
		throw new RangeError(
			`"${name}" must be smaller than ${max} and bigger than ${min}. Got "${arg}" of type "${typeof arg}".`
		);
}
/**
 * Asserts `arg` is an Array. Throws a `TypeError` otherwise.
 *
 * @param arg Any value.
 * @param name An optional expression name to be put in the `TypeError`'s message. Defaults to "arg".
 */
export function assertArray(arg: any, name = 'arg') {
	if (!(arg instanceof Array))
		throw new TypeError(
			`"${name}" must be an Array. Got "${arg}" of type "${typeof arg}".`
		);
}
/**
 * Asserts `arg` is an instance of `clas`. Throws a `TypeError` otherwise.
 * 
 * @param arg An object whose class is to be asserted to be `clas`.
 * @param clas Any valid constructor.
 * @param name An optional expression name to be put in the `TypeError`'s message. Defaults to "arg".
 * @since 1.0.8
 */
export function assertInstanceOf<T = any>(
	arg: any,
	clas: new (...args: any[]) => T,
	name = 'arg'
) {
	try {
		new clas();
	} catch (_) {
		throw new TypeError(
			`"clas" must be a valid constructor. Got ${clas} of type ${typeof clas}.`
		);
	}
	if (!(arg instanceof clas))
		throw new TypeError(
			`${name} must be an instance of ${
				clas.name
			}. Got ${arg} of type ${typeof arg}.`
		);
}
/**
 * Asserts `arg` is smaller than `max`. Throws a `TypeError` otherwise.
 * 
 * @param arg The value whose value is to be asserted to be smaller than `max`.
 * @param max The maximum value `arg` is allowed to have.
 * @param name An optional expression name to be put in the `TypeError`'s message. Defaults to "arg".
 * @since 1.0.8
 */
export function assertExclusiveMax(arg: any, max: any, name = 'arg') {
	if (arg >= max)
		throw new TypeError(
			`"${name}" must be smaller than ${max}. Got ${arg} of type ${typeof arg}.`
		);
}
/**
 * Asserts `arg` is bigger than `min`. Throws a `TypeError` otherwise.
 * 
 * @param arg The value whose value is to be asserted to be bigger than `max`.
 * @param min The minimum value `arg` is allowed to have.
 * @param name An optional expression name to be put in the `TypeError`'s message. Defaults to "arg".
 * @since 1.0.8
 */
export function assertExclusiveMin(arg: any, min: any, name = 'arg') {
	if (arg <= min)
		throw new TypeError(
			`"${name}" must be bigger than ${min}. Got ${arg} of type ${typeof arg}.`
		);
}

What did you expect to happen?

I expected ESLint to run correctly and lint through my source code.

What actually happened?

I got this error:

There was a problem loading formatter: ...\node_modules\eslint\lib\cli-engine\formatters\stylish
Error: require() of ES Module ...\node_modules\strip-ansi\index.js from ...\assertion-lib\node_modules\eslint\lib\cli-engine\formatters\stylish.js not supported.
Instead change the require of index.js in ...\node_modules\eslint\lib\cli-engine\formatters\stylish.js to a dynamic import() which is available in all CommonJS modules.

Link to Minimal Reproducible Example

https://github.com/santi100a/assertion-lib

Participation

• I am willing to submit a pull request for this issue.

Additional comments

No response

[Rec0iL99]

Hi @santi100a, thanks for the issue. I wasn't able to reproduce the error you are getting.

Here are the steps I followed (with output):

> yarn install

# script from package.json
> yarn lint 

/Users/joelmathew/Desktop/assertion-lib/src/index.ts
    3:23  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
    3:36  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  104:35  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  131:47  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  161:32  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  161:56  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  176:32  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  176:56  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  190:34  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  190:58  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  190:68  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  202:34  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  216:38  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  217:7   warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  218:22  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  243:41  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  243:51  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  257:41  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any
  257:51  warning  Unexpected any. Specify a different type  @typescript-eslint/no-explicit-any

✖ 19 problems (0 errors, 19 warnings)

ESLint is working as expected.

It could be an issue with your node_modules, I think deleting your node_modules and doing a clean install should work .

Thanks for using ESLint.

[guilbaultcarbo]

I have the same issue. The workaround works but then it happens again.

[karachungen]

As a workaroud you could put these lines to package.json

"resolutions": {
    "strip-ansi": "6.0.1",
    "string-width": "4.2.2",
    "wrap-ansi": "7.0.0"
  },

[elser]

Thanks. Worth to mention, that after applying this fix you need to remove node_modules once again

[pcoyoy8]

For me just

"resolutions": {
    "strip-ansi": "6.0.1"
  },

was enough.

Btw, my issue was generated by "eslint" as it cannot use strip ansi 7. Ref: #15218

[Frexuz]

thx @pcoyoy8 this worked for me too :)

[troyere]

Got the error too, when using latest versions at this day :

There was a problem loading formatter: [...]/node_modules/eslint/lib/cli-engine/formatters/stylish
Error: require() of ES Module [...]/node_modules/strip-ansi/index.js from [...]/node_modules/eslint/lib/cli-engine/formatters/stylish.js not supported.
Instead change the require of index.js in [...]/node_modules/eslint/lib/cli-engine/formatters/stylish.js to a dynamic import() which is available in all CommonJS modules.
error Command failed with exit code 2.

[mhp-borisbojic]

Happens to me as well. Adding the resolutions mentioned above, helps, but this can't be the long term solution.

[troyere]

I refuse to do that lol. Instead, I gave up using stylish everywhere : I didn't choose it, and its full of bugs. It ends now.

I use the visualstudio eslint formatter, it works well.

[Idildndr]

what did you use instead of stylish, my error is from that line. formatter: require('eslint').CLIEngine.getFormatter('stylish')

[johnnyshankman]

Having this too. Dang. What works in one environment wont work in another using the same version of node.

"resolutions": {
    "strip-ansi": "6.0.1"
}

Worked which is absolutely not a good solve. Also breaks once you intstall a new pkg without regenerating the lock.

Why is this affecting yarn repos? Can we get more information on the actual bug here? I can't get anything to work on v18 unless I do this everywhere. Willing to lend a hand with a PR.

Update: long term the best solve really is to just use npm.

[isaacs]

@arcanis Don't be passive aggressive, it's undignified. If I said something untrue, please, show me where I'm mistaken.

Yarn 1 is clearly doing the wrong thing here, and I stand by my assessment that it should not be used. If it took me 5 minutes to reproduce it by just trying the most obvious steps to put the conflicting packages in the same project, then I don't believe that you actually tried, because you surely would have found it just as quickly.

I'm not just "an npm author", I'm also a package maintainer, and I get yarn users in my issues constantly due to this. It's a serious shortcoming, and it seems no one is bothering to even look at it. Which, actually, is completely fine, and I don't take issue with at all. "THE SOFTWARE IS PROVIDED AS IS" is what makes this whole OSS thing work.

But if that's the case, and the intent is for yarn 1 to be unsupported, then the responsible thing to do is fully deprecate yarn 1. That's the part that I find annoying: that yarn classic is presented as "stable", when it is in fact pretty badly broken, always has been, and there are no plans to fix it.

[arcanis]

Only thing I'll bother to say is that as a package maintainer I'd expect you to know that "It seems to be the npm: hoisting issue; @arcanis, are you aware of it?" is better received than the typical pre-2020 npm tweetstorm dramas I absolutely didn't miss.

[isaacs]

@arcanis It would be more pleasant for you if I was more pleasant, I'm sure. But I disagree that it would be better received. As far as I can tell, it was not received at all until I shared this frustration and resentment. 🤷

[Johnrobmiller]

@arcanis When someone says mean things about the project you're working on, getting emotional and defensive is a bad move. Better to just fully accept the problem, which means fully accepting the criticisms about the problem. This is an ideal attitude for fixing problems and not making excuses.

All of this fits under the overarching "umbrella value" that is accountability. When you fully accept criticism, you put yourself in a position to be accountable for it.

[isaacs]

Maybe it's the tism talking, but I really don't even see what was mean about what I had to say about yarn? Yarn 1 has a bug that leads to serving incorrect dependency versions. That bug has been around for many years, has been brought up a bunch of times, and isn't being fixed. That's 100% fine, "AS IS" etc. But likewise, I'm not responsible for making my code work with a tool that has such a critical known bug and isn't being fixed. People ask me to fix this bug, but it's a bug in a project I don't own or really know all that much about, so yeah, I'm gonna say "don't use the broken thing", but then people get mad. Hence: why are you hitting yourself? Stop that.

Lots of my code has bugs, I'd be willing to guess almost all of the code I've ever written has had bugs that had to be fixed, and every project eventually has versions that get abandoned and will never be fixed, that's just how it goes. Is that a mean thing to say? It seems pretty normal and obvious, I'd think.

[mdjermanovic]

To clarify, ESLint requires strip-ansi v6:

eslint/package.json

Line 99 in d31c180

"strip-ansi": "^6.0.1",

By the error messages posted in this discussion, it seems that ESLint is getting strip-ansi v7 to work with.

I'm not sure what exactly is causing this, but this is not a problem in ESLint. It's the responsibility of package managers to provide packages with dependencies that satisfy the declared ranges. 7.x does not satisfy ^6.0.1.

[isaacs]

Yes, this is 100% a yarn bug, and it's a common one I get to hear about very frequently. #17215 (reply in thread)

[johnnyshankman]

@isaacs we should mark this package doesn't work with yarn 1. this just isn't clearly documented, so clearly we're going to have tons of people pouring in reporting the issue.

---

---

just let us know ahead of time so we don't get confused and open an issue!

Anything that uses glob, rimraf, or countless others will encounter this at some point...

Also the thing marked as the "answer" just says it cant recreate. Let's mark one of the various hacks as the solve for v1 yarn users and attach an explainer!

[platinumazure]

Isaacs is not a maintainer of ESLint. Please don't ask him to do anything more than he is already doing, which is volunteering his time to explain why an unsupported package manager is broken. He's already doing much more than could be expected.

I can't speak to whether the team will or should add a note about Yarn 1 being unsupported.

[isaacs]

Thanks for the understanding words, @platinumazure

Yeah, even if I did add a warning in glob (really, even deeper than that, in jackspeak) no one installing ESLint (or any of the other tens of thousands of glob dependents) would be likely to see it, since it'd be in a readme 2 layers deeper in the dep tree than they're likely even aware of.

There's probably some way to unambiguously determine whether it's yarn 1 that's doing the installation, and crash or something. I've considered it, believe me. But the hazard there is that it does work sometimes, as long as nothing in your tree depends on getting the correct version of any of the aliased dependencies, so it feels a bit too heavy handed to take that approach.

[johnnyshankman]

oh i had no idea my bad, @isaacs thank you so much for your help this far and @platinumazure for the explainer.

highly grateful for it. you're a legend in the OSS community and we're lucky to have your brainpower for problems like these <3

[arcanis]

Would someone have an actual reproduction to share? I'm curious about that, but I can't find one in this thread or the Yarn issue, so it's difficult to find out exactly what happens and understand whether this is expected or not. Help appreciated!

[isaacs]

This happens when yarn v1 is used to install a package (such as @isaacs/cliui) that uses npm: aliases, where another package in the tree depends on the aliased version and will break if it gets the wrong version. Yarn v1 serves it the wrong version, which cannot be loaded in this case, because one is ESM and the other is CJS.

This is the set of deps that trigger the issue:

$ npm view @isaacs/cliui dependencies
{
  'string-width': '^5.1.2',
  'string-width-cjs': 'npm:string-width@^4.2.0',
  'strip-ansi': '^7.0.1',
  'strip-ansi-cjs': 'npm:strip-ansi@^6.0.1',
  'wrap-ansi': '^8.1.0',
  'wrap-ansi-cjs': 'npm:wrap-ansi@^7.0.0'
}

Run these commands in a new folder:

echo {} > package.json
npx yarn@1 add @isaacs/cliui
npx yarn@1 add eslint
npm ls -a

Note the multiple errors.

The package at ./node_modules/eslint depends on getting strip-ansi at version 6. But the package at ./node_modules/strip-ansi is version 7, and there is nothing present at ./node_modules/eslint/node_modules/strip-ansi to override it.

[arcanis]

Interesting, thanks for the reproduction. I have a tentative fix in yarnpkg/yarn#9023, I want to think about it some more before landing it.

[andrevitalb]

I was able to solve this issue by just deleting the lock file and reinstalling dependencies

[kai-phan]

Me too. This worked like a champ

[DevJoseManuel]

The same thing has happened to me.

[wolfitoXtreme]

If you add/upgrade/remove another dependency the problem will be there again, so you'll have to repeat the process of deleting and installing manually again, NOT a solution

[wolfitoXtreme]

I can confirm that adding the strip-ansi resolution is a more reliable solution appart from upgrading to yarn 4.

[Rasukarusan]

I originally used yarn, but after doing a npm install to try it out, I no longer get the error.
Then I did yarn lint and no more errors.

[simi]

I just recreated yarn.lock (rm yarn.lock, yarn install) to fix this problem.

[dvzrd]

That's a temp solution, it will come up again after you add, remove or upgrade deps.

[Doko-Demo-Doa]

Upgraded to Yarn 4 as suggested. Problem gone. Nothing else need to be changed. Cheers.

[Frexuz]

I think a package should work in any yarn version. yarn v1.x is still the most used version and its the default
even more so, in CI environments. Installing different yarns in those environements, or across your team, is not trivial.
Things like patch-package also dont work in yarn v2+

[arcanis]

I think a package should work in any yarn version. yarn v1.x is still the most used version and its the default
even more so, in CI environments. Installing different yarns in those environements, or across your team, is not trivial.
Things like patch-package also dont work in yarn v2+

You don't need to use patch-package in modern Yarn releases, since it supports package patching natively

With that said, a fix for the reported issue landed in a patch 1.22 release already. Make sure you update if you still face it (and open a new issue on the Yarn repo if not; I won't monitor this GH discussion thread).

[Frexuz]

I'm already on 1.22.22 🤔

[paolagd]

Deleting the lock file and running yarn install worked for me. I am using the latest version of yarn and ESLint 9.1.1.

[katiacih]

Fixed

1- check you have in eslint config parser: "@babel/eslint-parser"
2- remove yarn.lock
3 - reinstall dependencies

[Yarchick1034]

Such manipulations are temporary...