sync-promise | Compact synchronized promise implementation | Reactive Programming library

It may be that you're using v6.

It looks like v6 doesn't have a simple-import-sort/sort rule, see usage in the README. This was a change from v5 on Nov 15.

You probably need to make the following change:

You can refer to the Specifying Parser Options reference:

ecmaVersion - set to 3, 5 (default), 6, 7, 8, 9, 10, 11, or 12 to specify the version of ECMAScript syntax you want to use. You can also set to 2015 (same as 6), 2016 (same as 7), 2017 (same as 8), 2018 (same as 9), 2019 (same as 10), 2020 (same as 11), or 2021 (same as 12) to use the year-based naming.

As you can see, the default value is 5, meaning it only supports ES5. Lookbehinds are compliant with ECMAScript 2018, so you need to make sure you set ecmaVersion to at least 9:

You don't need to create a new promise yourself because async functions always return a promise. If the return value of an async function is not a promise, it is implicitly wrapped in a promise.

So you need to remove the code that creates a new promise instance and the code inside the executor function should be at the top-level in the processFolder function.

Your code can be simplified as shown below:

After some research, I was able to find specific documentation:

Visual Studio will use its installation of ESLint 4 by default. However, if you would like to use a different version, Visual Studio will pick up a local installation of ESLint and use it instead. In particular, if any parent directory of the file you want to be linted contains a package.json that lists ESLint as a dependency, as well as a node_modules folder with an installation of ESLint, then it will use that copy of the linter.

The solution was then to have a package.json file at the root of the project:

You really don't need the call to be synchronous, and personally that's something I would probably avoid.

The reason you're getting the console error is because you're trying to access a property on an object that hasn't been initialised yet.

async functions always return promises.

By wrapping your anonymous async function in new Promise(...) you are creating a Promise which only and always adopts the promise returned by the async function.

Just get rid of the wrapper, replace your resolve calls with return and your reject with throw.

Don't do any awaiting inside the Promise constructor - you only should do the promisification of the asynchronous callback in there:

The following installed the Terminalizer (adding the --unsafe-perm flag) (please pitch in if there's a better solution. I am no expert in npm):

It is strange that the typing isn't a single function signature with the union of the three possible types for the arr parameter. You might want to consider filing an issue or a pull request to the async typing library to fix it.

Even so, it would be nice if the compiler would allow you to call the function the way you have, since you know it is safe to do so. But as you see, it won't, at least as of TypeScript v2.5.

The easiest workaround: since you know for a fact what the compiler doesn't know... namely, that the existing filter function will indeed accept an arr of type T[] | IterableIterator | Dictionary, it is safe to tell the compiler not to worry by asserting arr is of type any which disables type checking: