RubyMine 2023.3 Help

Vite

RubyMine integrates with the Vite build tool that improves the frontend development experience. Vite consists of a dev server and a build command. The build server serves your source files over native ES modules. The build command bundles your code with Rollup, which is pre-configured to output highly optimized static assets for production.

RubyMine supports tsconfig.json and jsconfig.json path mappings in Vue style tags and recognizes Vite aliases.

In projects that consist of multiple modules with different Vite configurations, RubyMine can automatically detect the relevant configuration file for each module and use the module resolution rules from it, refer to Specifying the Vite configuration file to use below.

Before you start

  1. Download and install Node.js.

  2. Make sure the JavaScript and TypeScript and Vite required plugins are enabled on the Settings | Plugins page, tab Installed. For more information, refer to Managing plugins.

Create a new Vite application

The recommended way to start a new Vite application is the create-vite package, which RubyMine downloads and runs for you using npx. As a result, your development environment is preconfigured to use Vite and a basic template for one of the popular frameworks.

Of course, you can still download create-vite yourself or create an empty RubyMine project and install Vite in it.

Generate a Vite application with create-vite

  1. Click Create New Project on the Welcome screen or select File | New | Project from the main menu. The New Project dialog opens.

  2. In the left-hand pane, choose Vite.

  3. In the right-hand pane:

    1. Specify The path to the folder where the project-related files will be stored.

    2. In the Node Interpreter field, specify the Node.js interpreter to use. Select a configured interpreter from the list or choose Add to configure a new one.

    3. From the Vite list, select npx create-vite.

      Alternatively, for npm version 5.1 and earlier, install the create-vite package yourself by running npm install --g create-vite in the Terminal Alt+F12. When creating an application, select the folder where the create-vite package is stored.

    4. From the Template list, select the community maintained Vite template that targets the framework you are going to use in your application.

    5. Optionally:

      To use TypeScript instead of JavaScript, select the Use TypeScript template checkbox. RubyMine will generate .ts files for your application and a tsconfig.json configuration file.

  4. When you click Create, RubyMine generates a Vite-specific project with all the required configuration files and downloads the required dependencies. RubyMine also creates an npm start and JavaScript Debug configurations with default settings for running or debugging your application.

Install Vite in an empty RubyMine project

In this case, you will have to configure the build pipeline yourself. Learn more about adding Vite to a project from the Vite official website.

Create an empty RubyMine project

  1. Click Create New Project on the Welcome screen or select File | New | Project from the main menu. The New Project dialog opens.

  2. In the left-hand pane, choose Empty Project. In the right-hand pane, specify the application folder and click Create.

Install Vite in an empty project

  1. Open the empty project where you will use Vite.

  2. In the embedded Terminal (Alt+F12) , type:

    npm install --save-dev vite

Start with an existing Vite application

To continue developing an existing Vite application, open it in RubyMine and download the required dependencies.

Open the application sources that are already on your machine

  • Click Open on the Welcome screen or select File | Open from the main menu. In the dialog that opens, select the folder where your sources are stored.

Check out the application sources from your version control

  1. Click Get from VCS on the Welcome screen.

    Alternatively, select File | New | Project from Version Control or Git | Clone or VCS | Get from Version Control from the main menu.

    Instead of Git in the main menu, you may see any other Version Control System that is associated with your project. For example, Mercurial or Perforce.

  2. In the dialog that opens, select your version control system from the list and specify the repository to check out the application sources from. For more information, refer to Check out a project (clone).

Download the dependencies

  • Click Run 'npm install' or Run 'yarn install' in the popup:

    Open an application and download the dependencies

    You can use npm, Yarn 1, or Yarn 2, refer to npm and Yarn for details.

  • Alternatively, select Run 'npm install' or Run 'yarn install' from the context menu of package.json in the editor or in the Project tool window.

Project security

When you open a project that was created outside RubyMine and was imported into it, RubyMine displays a dialog where you can decide how to handle this project with unfamiliar source code.

Untrusted project warning

Select one of the following options:

  • Preview in Safe Mode: in this case, RubyMine opens the project in a preview mode. It means that you can browse the project's sources but you cannot run tasks and script or run/debug your project.

    RubyMine displays a notification on top of the editor area, and you can click the Trust project link and load your project at any time.

  • Trust Project: in this case, RubyMine opens and loads a project. That means the project is initialized, project's plugins are resolved, dependencies are added, and all RubyMine features are available.

  • Don't Open: in this case, RubyMine doesn't open the project.

Learn more from Project security.

Configure Vite in RubyMine

Create Vite configuration files

  • Create one or several configuration files depending on your project structure: select a parent folder in the Project tool window and then select New | JavaScript file from the context menu.

    Create a Vite configuration file

    The acceptable names are vite.config.js/vite.config.ts, vite.config.mjs, or vite.config.cjs.

    Learn more from the Vite official website.

  • If necessary, use alias that will be later recognized in import statements. Make sure you specify absolute paths in definitions of aliases. Learn more from the Vite official website.

    Completing alias in import statements

Specify the Vite configuration files to use

Based on the analysis of a Vite configuration file, RubyMine understands the Vite configuration, resolves modules, and provides coding assistance in JavaScript and TypeScript files.

In RubyMine, you can choose between two configuration modes – automatic and manual.

With automatic configuration, RubyMine auto-detects the relevant Vite configuration file for each JavaScript or TypeScript file.

With manual configuration, you specify the Vite configuration file to use in your project. Manual configuration is useful if the name of your Vite configuration file is not recognized by RubyMine, refer to the list of recognized Vite config names below.

Choose how to detect Vite configuration

  1. Open the Settings dialog (Ctrl+Alt+S) and go to Languages & Frameworks | JavaScript | Vite.

  2. In the Detect Vite configuration files for module resolution area, select one of the following options:

    • Automatically: In this mode, for a JavaScript or TypeScript file, RubyMine will first look for a Vite configuration file in the folder where this JavaScript or TypeScript file is located, then in its parent folder, and so on.

      As a result, if your project consists of multiple modules with different Vite configurations, each module will use the module resolution rules from its own Vite configuration file (if such config is found).

      RubyMine recognizes JavaScript or TypeScript Vite configuration files with the following names and in the following order:

      • vite.config.js/vite.config.ts

      • vite.config.mjs

      • vite.config.cjs

    • Manually: In the Configuration file field, specify the location of the Vite config to use.

      In this mode, the resolution rules from the specified configuration file will be applied to all modules in your project.

      Select this option if the name of your Vite configuration file is not recognized by RubyMine, refer to the list of recognized Vite config names above.

      Select a vite configuration file manually

Run a Vite application

For applications created with create-vite in the RubyMine New Project wizard as described above, RubyMine generates an npm configuration with the default name npm dev. This configuration runs the vite command that launches the development server and starts your application in the development mode.

In other cases, you need to create a run/debug configuration with the actual settings, such as, host, port, etc., manually.

  1. Select the npm dev run configuration from the list on the toolbar and click Run next to it.

    Run a Vite app in the development mode via a run/debug configuration

    Alternatively, run npm dev in the Terminal Alt+F12, or double-click the dev task in the npm tool window (View | Tool Windows | npm), or click the Run icon in the gutter next to the dev script in package.json.

    Run a Vite app in the development mode from package.json

  2. Wait till the application is compiled and the development server is ready.

    The Run tool window or the Terminal shows the URL at which your application is running, by default it is http://localhost:4200/. Click this link to view the application.

    Running Vite app: the Development server is ready

Debug a Vite application

Debug applications created with create-vite

  1. Set the breakpoints in your code.

  2. Start the application in the development mode as described above and wait till the application is compiled and the development server is ready.

  3. In the Run tool window or the Terminal, hold Ctrl+Shift, and click this URL link.

    start debugging a generated Vite app from the Run tool window

Debug applications running on localhost

  1. Set the breakpoints in your code.

  2. Start the application in the development mode as described above and wait till the application is compiled and the development server is ready.

  3. The Run tool window or the Terminal shows the URL at which your application is running, by default it is http://localhost:<port>/. Hold Ctrl+Shift and click this URL link. RubyMine starts a debugging session with an automatically generated localhost:<port> configuration of the type JavaScript Debug.

    Starting a debugging session from the Run tool window, the application is running on localhost

Debug applications running on custom URLs

  1. Set the breakpoints in your code.

  2. Start the application in the development mode as described above and wait till the application is compiled and the Webpack development server is ready.

  3. The Run tool window or the Terminal shows the URL at which your application is running. Copy this URL address, you will later specify it in a debug configuration. To view your application, just click the link.

  4. Create a JavaScript Debug configuration. To do that, go to Run | Edit Configurations in the main menu, click the Add icon, and select JavaScript Debug from the list. In the Run/Debug Configuration: JavaScript Debug dialog, paste the saved URL in the URL field and save the configuration.

  5. To launch your newly created configuration, select it from the list of configurations and click the Debug button next to the list.

Troubleshooting for Node.js 17+

If you are using Node.js version 17 or later, during a debugging session you may face network connectivity issues that result in problems with attaching the debugger or with loading sourcemaps.

The workaround is to pass --host 127.0.0.1 to the server. You can do that in one of the following ways:

  • Update the dev script in your package.json:

    "dev": "vite --host=127.0.0.1"

  • Alternatively, add dns.setDefaultResultOrder('ipv4first') to your vite.config.ts.

Last modified: 04 April 2024
VitestWebpack