prettier-plugin-sort-imports VS tools

In a similar vein, you can sort imports with Prettier using Trivago’s plugin.

https://github.com/trivago/prettier-plugin-sort-imports

I went with my configuration you can go with one you like more. Find out more by clicking here

For most conventions regarding file structure, I would use tools like ESLint / Prettier instead of trying to enforce it with comments. For example this Prettier plugin allows you to enforce a specific import order without any extra effort.

Unsorted imports look ugly. Also, it could be hard to read and add new imports. So why not sort them automatically? We can do it with trivago/prettier-plugin-sort-imports.

Your suggestion to sort imports is valid, but depends on VSCode as an IDE. It would be better to use Prettier with this plugin that sorts imports for you.

Despite the existence of Prettier, arguments about code style such as how to sort ES module imports still exist. Manually sorting ES modules wastes time, and usually leads to losing context when you are writing code and then have to navigate to the top of a file to modify your import statements. I love using the @trivago/prettier-plugin-sort-imports plugin which automatically sorts new imports, and works perfectly together with TypeScript's auto-import feature. Similarly, prettier-plugin-tailwindcss automatically sorts Tailwind classes in your code.

If you are using prettier, you can use https://github.com/trivago/prettier-plugin-sort-imports

In this GitHub repo, you can find a list of the other rules that are available.

For imports I like to use https://github.com/trivago/prettier-plugin-sort-imports so I don't have to think about it. Also, I think it's cleaner to have an index in your components folder that exports all of the named functions do you can import them into your files like:

Biome is a fork of Rome, which was originally an ambitious tool written in Rust but abandoned in October 2023. It includes both a linter and a formatter, putting an end to the time-consuming difficulties associated with reconciling ESLint and Prettier rules.

When I saw the release of bun six months ago, I was not that hyped as I saw a tool that had similar ambitions, Rome, and dissapointed many. But it was different this time. It really is a drop in replacement for Node.js so you can start using it by replacing the npm and node commands in your package.json file. The main feature that captured my interest was the ability to use require and import statemtents in the same file. This allows you to keep using CommonJS modules and use import statemtents for any new modules that drop support for it. The only catch I could find so far is that if you decide to mix import and require statements, you cannot use module.exports but instead use export statement. I did exactly that and now I have a fully functional backend with admin panel that won't make your head scratch fighting with CommonJS and ESModules.

Once you build a simple Vite backend integration, try not to complicate Vite's configuration unless you absolutely must. Vite has become one of the most popular bundlers in the frontend space, but it wasn't the first and it certainly won't be the last. In my 7 years of building for the web, I've used Grunt, Gulp, Webpack, esbuild, and Parcel. Snowpack and Rome came-and-went before I ever had a chance to try them. Bun is vying for the spot of The New Hotness in bundling, Rome has been forked into Biome, and Vercel is building a Rust-based Webpack alternative.

It definitely existed by the time rome_console/biome_console was created! The crate was created 2 years ago[1] and miette was released more than 2 years ago[2]. By the time rome_console was created miette was on v4, so presumably somewhat mature.

[1]: https://github.com/rome/tools/commits/main/crates/rome_conso...

[2]: https://crates.io/crates/miette/versions

Biome formats and lints your JavaScript and TypeScript code in a fraction of a second. Biome is the community successor of Rome Tools [0].

As part of this announcement, we have released the first stable version of Biome [1]. Join us on our Discord [2] and support us via our open collective [3].

I am one of the main maintainers of Biome. I will be happy to answer any questions :)

[0] https://github.com/rome/tools

I have no idea how true this is, but the source of the claim seems to come from here:

https://github.com/rome/tools/discussions/4302

"But in short, the company Rome Tools ran out of funding, so the core team of last year are no longer working on the project."

For now, Rome implements most of the ESLint recommended rules (including TypeScript ESLint) and some additional rules that are enabled by default. In the future, you can expect a recommended preset that is a superset of the ESLint recommended preset. So if you're not heavily customising ESLint, you should be able to use Rome.

Otherwise, most of the rules are not fine-tunable in the way that ESLint is. Rome tries to provide the experience that Prettier provided in the formatting tool: good defaults for a near-zero configuration experience. It tries to adopt the conventions of the JS/TS community. Still, some configuration is provided when the community is divided on some opinions (e.g. space vs. tab indentation, semicolons or as-needed semicolons, ...).

There is an open issue [1] for listing equivalent rules between ESLint and Rome. Expect more documentation in the future, and maybe a migration tool.

If I had been one of the founders of Rome, I could have pushed for more compatibility with ESLint. In particular, using the same naming conventions and thus the same names for most rules, and recognising ESLint ignore comments.

[1] https://github.com/rome/tools/issues/3892

Today we are going to talk about Rome. According to their github page

I must say, although it doesn't (of course) have anywhere near the configuration or plugin-capability of eslint, I've found Rome impressive so far. I have access to a range of PCs and the performance boost of a compiled binary makes a pretty big difference on a large repo on a slower machine.

Fast compilation seems very appealing. It is one of the main reason why I am interested into Go and Zig.

I recently started working with Rust for contributing to projects like Rome/tools [1] and deno_lint [2]. The compilation and IDE experience is frustrating. Compilation is slow. I am afraid that this is rooted to the inherent complexity of Rust.

[1] https://github.com/rome/tools

[2] https://github.com/denoland/deno_lint