@cypress/vite-dev-server 6.0.2 → 7.0.0

package/README.md

@@ -56,8 +56,9 @@ We then merge the sourced config with the user's vite config, and layer on our o
 | <= v2                    | <= v9         |
 | >= v3 <= v5              | >= v10 <= v13 |
 | >= v6                    | >= v14        |
+| >= v7 (esm only)         | >= v15        |
 
-#### `devServerPublicPathRoute` for Vite v5
+#### `devServerPublicPathRoute` for Vite v5+
 
 If using Vite version 5, setting `devServerPublicPathRoute` may be needed if directly referencing public path url assets in components under test. This is due to Cypress using its own public path, `/__cypress/src`, when running component tests. This can be configured within the `component` namespace below if you wish you set your public path to be the same as your app:
 

package/dist/constants.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.configFiles = void 0;
-exports.configFiles = [
+export const configFiles = [
     'vite.config.ts',
     'vite.config.js',
     'vite.config.mjs',

package/dist/devServer.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="cypress" />
-/// <reference types="node" />
-import type { UserConfig } from 'vite-6';
+/// <reference types="cypress" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { UserConfig } from 'vite-7';
 declare const ALL_FRAMEWORKS: readonly ["react", "vue"];
 type ConfigHandler = UserConfig | (() => UserConfig | Promise<UserConfig>);
 export type ViteDevServerConfig = {
@@ -14,6 +14,6 @@ export type ViteDevServerConfig = {
 };
 export declare function devServer(config: ViteDevServerConfig): Promise<Cypress.ResolvedDevServerConfig>;
 export declare namespace devServer {
-    var create: (devServerConfig: ViteDevServerConfig, vite: typeof import("vite-6")) => Promise<import("vite-6").ViteDevServer>;
+    var create: (devServerConfig: ViteDevServerConfig, vite: typeof import("vite-7")) => Promise<import("vite-7").ViteDevServer>;
 }
 export {};

package/dist/devServer.js

@@ -1,19 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.devServer = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const major_1 = tslib_1.__importDefault(require("semver/functions/major"));
-const getVite_1 = require("./getVite");
-const resolveConfig_1 = require("./resolveConfig");
-const debug = (0, debug_1.default)('cypress:vite-dev-server:devServer');
+import debugFn from 'debug';
+import semverMajor from 'semver/functions/major.js';
+import { getVite } from './getVite.js';
+import { createViteDevServerConfig } from './resolveConfig.js';
+const debug = debugFn('cypress:vite-dev-server:devServer');
 const ALL_FRAMEWORKS = ['react', 'vue'];
-async function devServer(config) {
+export async function devServer(config) {
     // This has to be the first thing we do as we need to source vite from their project's dependencies
-    const vite = (0, getVite_1.getVite)(config);
+    const vite = await getVite(config);
     let majorVersion = undefined;
     if (vite.version) {
-        majorVersion = (0, major_1.default)(vite.version);
+        majorVersion = semverMajor(vite.version);
         debug(`Found vite version v${majorVersion}`);
     }
     else {
@@ -35,15 +31,14 @@ async function devServer(config) {
             debug('closing dev server');
             return server.close().then(() => {
                 debug('closed dev server');
-                cb === null || cb === void 0 ? void 0 : cb();
+                cb?.();
             }).catch(cb);
         },
     };
 }
-exports.devServer = devServer;
 devServer.create = async function createDevServer(devServerConfig, vite) {
     try {
-        const config = await (0, resolveConfig_1.createViteDevServerConfig)(devServerConfig, vite);
+        const config = await createViteDevServerConfig(devServerConfig, vite);
         return await vite.createServer(config);
     }
     catch (err) {

package/dist/getVite.d.ts

@@ -1,3 +1,3 @@
-import type { ViteDevServerConfig } from './devServer';
-export type Vite = typeof import('vite-6');
-export declare function getVite(config: ViteDevServerConfig): Vite;
+import type { ViteDevServerConfig } from './devServer.js';
+export type Vite = typeof import('vite-7');
+export declare function getVite(config: ViteDevServerConfig): Promise<Vite>;

package/dist/getVite.js

@@ -1,20 +1,75 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVite = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const debug = (0, debug_1.default)('cypress:vite-dev-server:getVite');
+import debugFn from 'debug';
+import { createRequire } from 'module';
+import path from 'path';
+import os from 'os';
+import majorVersion from 'semver/functions/major.js';
+const debug = debugFn('cypress:vite-dev-server:getVite');
+class CJSNotSupportedError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CJSNotSupportedError';
+    }
+}
 // "vite-dev-server" is bundled in the binary, so we need to require.resolve "vite"
 // from root of the active project since we don't bundle vite internally but rather
 // use the version the user has installed
-function getVite(config) {
+export async function getVite(config) {
+    const filePrefix = os.platform() === 'win32' ? 'file://' : '';
     try {
-        const viteImportPath = require.resolve('vite', { paths: [config.cypressConfig.projectRoot] });
-        debug('resolved viteImportPath as %s', viteImportPath);
-        return require(viteImportPath);
+        const require = createRequire(import.meta.url);
+        const vitePackageJsonPath = require.resolve('vite/package.json', { paths: [config.cypressConfig.projectRoot] });
+        const vitePackageJson = (await import(`${filePrefix}${vitePackageJsonPath}`, {
+            with: {
+                type: 'json',
+            },
+        })).default;
+        const viteExports = vitePackageJson.exports['.'];
+        let esmPath = null;
+        let cjsPath = null;
+        // In Node 20, require.resolve in the ESM context returns the CJS path as if we were in a CJS context.
+        // In Node 22, this is not the case and the ESM context is returned correctly.
+        // In order to work around this, we need to check where the ESM path is so we can import the correct path.
+        // In Vite 7, the CJS build was removed so there is only a single string entry in the export.
+        // Otherwise, both builds exists in Vite 6 and under and we only want to get the ESM path.
+        const majorVersionNumber = majorVersion(vitePackageJson.version);
+        if (majorVersionNumber >= 7) {
+            esmPath = viteExports;
+        }
+        else if (majorVersionNumber === 5) {
+            esmPath = viteExports.import.default;
+            cjsPath = viteExports.require.default;
+        }
+        else {
+            esmPath = viteExports.import;
+            cjsPath = viteExports.require;
+        }
+        debug('vite ESM build path: %s', esmPath);
+        debug('vite CJS build path: %s', cjsPath);
+        try {
+            // try to import the ESM build of Vite
+            const esmViteImportPath = path.resolve(vitePackageJsonPath, '../', esmPath);
+            debug('resolved esmViteImportPath as %s', esmViteImportPath);
+            const viteImport = await import(`${filePrefix}${esmViteImportPath}`);
+            return viteImport;
+        }
+        catch (err) {
+            if (majorVersionNumber >= 7) {
+                throw new CJSNotSupportedError(`CJS builds of vite ${majorVersionNumber} are not supported`);
+            }
+            // if the ESM build import fails, try to import the CJS build
+            debug('importing vite as ESM failed:', err);
+            debug('importing vite as CJS');
+            // Vite 4-6 both include the CJS distribution of Vite
+            const cjsViteImportPath = path.resolve(vitePackageJsonPath, '../', cjsPath);
+            debug('resolved cjsViteImportPath as %s', cjsViteImportPath);
+            const viteImport = await import(`${filePrefix}${cjsViteImportPath}`);
+            return viteImport.default;
+        }
     }
     catch (err) {
+        if (err instanceof CJSNotSupportedError) {
+            throw err;
+        }
         throw new Error(`Could not find "vite" in your project's dependencies. Please install "vite" to fix this error.\n\n${err}`);
     }
 }
-exports.getVite = getVite;

package/dist/index.d.ts

@@ -1,3 +1,6 @@
-import { devServer } from './devServer';
+import { devServer } from './devServer.js';
 export { devServer };
-export default devServer;
+declare const _default: {
+    devServer: typeof devServer;
+};
+export default _default;

package/dist/index.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.devServer = void 0;
-const devServer_1 = require("./devServer");
-Object.defineProperty(exports, "devServer", { enumerable: true, get: function () { return devServer_1.devServer; } });
-exports.default = devServer_1.devServer;
+import { devServer } from './devServer.js';
+export { devServer };
+export default { devServer };

package/dist/plugins/cypress.d.ts

@@ -1,4 +1,4 @@
-import type { PluginOption } from 'vite-6';
-import type { Vite } from '../getVite';
-import type { ViteDevServerConfig } from '../devServer';
+import type { PluginOption } from 'vite-7';
+import type { Vite } from '../getVite.js';
+import type { ViteDevServerConfig } from '../devServer.js';
 export declare const Cypress: (options: ViteDevServerConfig, vite: Vite) => PluginOption;

package/dist/plugins/cypress.js

@@ -1,30 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cypress = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const node_html_parser_1 = require("node-html-parser");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const debug = (0, debug_1.default)('cypress:vite-dev-server:plugins:cypress');
-const INIT_FILEPATH = path_1.default.resolve(__dirname, '../../client/initCypressTests.js');
+import debugFn from 'debug';
+import { parse, HTMLElement } from 'node-html-parser';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const debug = debugFn('cypress:vite-dev-server:plugins:cypress');
+const INIT_FILEPATH = path.resolve(__dirname, '../../client/initCypressTests.js');
 const HMR_DEPENDENCY_LOOKUP_MAX_ITERATION = 50;
 function getSpecsPathsSet(specs) {
     return new Set(specs.map((spec) => spec.absolute));
 }
-const Cypress = (options, vite) => {
+export const Cypress = (options, vite) => {
     let base = '/';
     const projectRoot = options.cypressConfig.projectRoot;
-    const supportFilePath = options.cypressConfig.supportFile ? path_1.default.resolve(projectRoot, options.cypressConfig.supportFile) : false;
+    const supportFilePath = options.cypressConfig.supportFile ? path.resolve(projectRoot, options.cypressConfig.supportFile) : false;
     const devServerEvents = options.devServerEvents;
     const specs = options.specs;
     const indexHtmlFile = options.cypressConfig.indexHtmlFile;
     let specsPathsSet = getSpecsPathsSet(specs);
     // TODO: use async fs methods here
     // eslint-disable-next-line no-restricted-syntax
-    let loader = fs_1.default.readFileSync(INIT_FILEPATH, 'utf8');
+    let loader = fs.readFileSync(INIT_FILEPATH, 'utf8');
     devServerEvents.on('dev-server:specs:changed', ({ specs, options }) => {
-        if (options === null || options === void 0 ? void 0 : options.neededForJustInTimeCompile) {
+        if (options?.neededForJustInTimeCompile) {
             // if an option is needed for just in time compile, no-op as this isn't supported in vite
             return;
         }
@@ -44,13 +43,13 @@ const Cypress = (options, vite) => {
             // receive and inject it.
             // For now we just grab any `<script>` tags and inject them to <head>.
             // We will add more handling as we learn the use cases.
-            const root = (0, node_html_parser_1.parse)(html);
+            const root = parse(html);
             const scriptTagsToInject = root.childNodes.filter((node) => {
-                return node instanceof node_html_parser_1.HTMLElement && node.rawTagName === 'script';
+                return node instanceof HTMLElement && node.rawTagName === 'script';
             });
-            const indexHtmlPath = path_1.default.resolve(projectRoot, indexHtmlFile);
+            const indexHtmlPath = path.resolve(projectRoot, indexHtmlFile);
             debug('resolved the indexHtmlPath as', indexHtmlPath, 'from', indexHtmlFile);
-            let indexHtmlContent = await fs_1.default.promises.readFile(indexHtmlPath, { encoding: 'utf8' });
+            let indexHtmlContent = await fs.promises.readFile(indexHtmlPath, { encoding: 'utf8' });
             // Inject the script tags
             indexHtmlContent = indexHtmlContent.replace('<head>', `<head>
         ${scriptTagsToInject.join('')}
@@ -74,7 +73,7 @@ const Cypress = (options, vite) => {
         handleHotUpdate: ({ server, file }) => {
             debug('handleHotUpdate - file', file);
             // If the user provided IndexHtml is changed, do a full-reload
-            if (vite.normalizePath(file) === path_1.default.resolve(projectRoot, indexHtmlFile)) {
+            if (vite.normalizePath(file) === path.resolve(projectRoot, indexHtmlFile)) {
                 server.ws.send({
                     type: 'full-reload',
                 });
@@ -85,7 +84,7 @@ const Cypress = (options, vite) => {
             let iterationNumber = 0;
             const exploredFiles = new Set();
             // until we reached a point where the current module is imported by no other
-            while (moduleImporters === null || moduleImporters === void 0 ? void 0 : moduleImporters.size) {
+            while (moduleImporters?.size) {
                 if (iterationNumber > HMR_DEPENDENCY_LOOKUP_MAX_ITERATION) {
                     debug(`max hmr iteration reached: ${HMR_DEPENDENCY_LOOKUP_MAX_ITERATION}; Rerun will not happen on this file change.`);
                     return;
@@ -116,7 +115,6 @@ const Cypress = (options, vite) => {
         },
     };
 };
-exports.Cypress = Cypress;
 /**
  * Gets all the modules that import the set of modules passed in parameters
  * @param modules the set of module whose dependents to return

package/dist/plugins/index.d.ts

@@ -1,2 +1,2 @@
-export * from './cypress';
-export * from './sourcemap';
+export * from './cypress.js';
+export * from './sourcemap.js';

package/dist/plugins/index.js

@@ -1,5 +1,2 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
-tslib_1.__exportStar(require("./cypress"), exports);
-tslib_1.__exportStar(require("./sourcemap"), exports);
+export * from './cypress.js';
+export * from './sourcemap.js';

package/dist/plugins/sourcemap.d.ts

@@ -1,4 +1,4 @@
-import type { PluginOption } from 'vite-6';
-import type { Vite } from '../getVite';
-import type { ViteDevServerConfig } from '../devServer';
+import type { PluginOption } from 'vite-7';
+import type { Vite } from '../getVite.js';
+import type { ViteDevServerConfig } from '../devServer.js';
 export declare const CypressSourcemap: (options: ViteDevServerConfig, vite: Vite) => PluginOption;

package/dist/plugins/sourcemap.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CypressSourcemap = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const debug = (0, debug_1.default)('cypress:vite-dev-server:plugins:sourcemap');
-const CypressSourcemap = (options, vite) => {
+import debugFn from 'debug';
+const debug = debugFn('cypress:vite-dev-server:plugins:sourcemap');
+export const CypressSourcemap = (options, vite) => {
     return {
         name: 'cypress:sourcemap',
         enforce: 'post',
@@ -47,4 +43,3 @@ const CypressSourcemap = (options, vite) => {
         },
     };
 };
-exports.CypressSourcemap = CypressSourcemap;

package/dist/resolveConfig.d.ts

@@ -1,4 +1,4 @@
-import type { InlineConfig } from 'vite-6';
-import type { ViteDevServerConfig } from './devServer';
-import type { Vite } from './getVite';
+import type { InlineConfig } from 'vite-7';
+import type { ViteDevServerConfig } from './devServer.js';
+import type { Vite } from './getVite.js';
 export declare const createViteDevServerConfig: (config: ViteDevServerConfig, vite: Vite) => Promise<InlineConfig>;

package/dist/resolveConfig.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createViteDevServerConfig = void 0;
-const tslib_1 = require("tslib");
 /**
  * The logic inside of this file is heavily reused from
  * Vitest's own config resolution logic.
  * You can find it here https://github.com/vitest-dev/vitest/blob/main/packages/vitest/src/node/create.ts
  */
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const path_1 = tslib_1.__importDefault(require("path"));
-const gte_1 = tslib_1.__importDefault(require("semver/functions/gte"));
-const constants_1 = require("./constants");
-const index_1 = require("./plugins/index");
-const dynamic_import_1 = require("./dynamic-import");
-const debug = (0, debug_1.default)('cypress:vite-dev-server:resolve-config');
-const createViteDevServerConfig = async (config, vite) => {
+import debugFn from 'debug';
+import path from 'path';
+import { createRequire } from 'module';
+import semverGte from 'semver/functions/gte.js';
+import { configFiles } from './constants.js';
+import { Cypress, CypressSourcemap } from './plugins/index.js';
+const debug = debugFn('cypress:vite-dev-server:resolve-config');
+export const createViteDevServerConfig = async (config, vite) => {
     const { viteConfig: inlineViteConfig, cypressConfig: { projectRoot } } = config;
     let resolvedOverrides = {};
     if (inlineViteConfig) {
@@ -26,14 +22,14 @@ const createViteDevServerConfig = async (config, vite) => {
             resolvedOverrides = inlineViteConfig;
         }
         // Set "configFile: false" to disable auto resolution of <project-root>/vite.config.js
-        resolvedOverrides = Object.assign({ configFile: false }, resolvedOverrides);
+        resolvedOverrides = { configFile: false, ...resolvedOverrides };
     }
     else {
-        const { findUp } = await (0, dynamic_import_1.dynamicImport)('find-up');
-        const configFile = await findUp(constants_1.configFiles, { cwd: projectRoot });
+        const { findUp } = await import('find-up');
+        const configFile = await findUp(configFiles, { cwd: projectRoot });
         if (!configFile) {
             if (config.onConfigNotFound) {
-                config.onConfigNotFound('vite', projectRoot, constants_1.configFiles);
+                config.onConfigNotFound('vite', projectRoot, configFiles);
                 // The config process will be killed from the parent, but we want to early exit so we don't get
                 // any additional errors related to not having a config
                 process.exit(0);
@@ -49,14 +45,13 @@ const createViteDevServerConfig = async (config, vite) => {
     debug('The resolved server config is', JSON.stringify(finalConfig, null, 2));
     return finalConfig;
 };
-exports.createViteDevServerConfig = createViteDevServerConfig;
 function makeCypressViteConfig(config, vite) {
-    var _a, _b, _c;
     const { cypressConfig: { port, projectRoot, devServerPublicPathRoute, supportFile, cypressBinaryRoot, isTextTerminal, }, specs, } = config;
-    const vitePort = port !== null && port !== void 0 ? port : undefined;
+    const vitePort = port ?? undefined;
+    const require = createRequire(import.meta.url);
     // Vite caches its output in the .vite directory in the node_modules where vite lives.
     // So we want to find that node_modules path and ensure it's added to the "allow" list
-    const vitePathNodeModules = path_1.default.dirname(path_1.default.dirname(require.resolve(`vite/package.json`, {
+    const vitePathNodeModules = path.dirname(path.dirname(require.resolve(`vite/package.json`, {
         paths: [projectRoot],
     })));
     const viteConfig = {
@@ -82,29 +77,35 @@ function makeCypressViteConfig(config, vite) {
                 ],
             },
             entries: [
-                ...specs.map((s) => path_1.default.relative(projectRoot, s.relative)),
-                ...(supportFile ? [path_1.default.resolve(projectRoot, supportFile)] : []),
+                ...specs.map((s) => path.relative(projectRoot, s.relative)),
+                ...(supportFile ? [path.resolve(projectRoot, supportFile)] : []),
             ].filter((v) => v != null),
         },
-        server: Object.assign({ fs: {
+        server: {
+            fs: {
                 allow: [
                     projectRoot,
                     vitePathNodeModules,
                     cypressBinaryRoot,
                     // Allow in monorepo: https://vitejs.dev/config/server-options.html#server-fs-allow
                     // Supported from Vite v3 - add null check for v2 users.
-                    (_a = vite.searchForWorkspaceRoot) === null || _a === void 0 ? void 0 : _a.call(vite, process.cwd()),
+                    vite.searchForWorkspaceRoot?.(process.cwd()),
                 ],
-            }, port: vitePort, host: '127.0.0.1' }, (isTextTerminal
-            ? { watch: { ignored: '**/*' }, hmr: false }
-            : {})),
+            },
+            port: vitePort,
+            host: '127.0.0.1',
+            // Disable file watching and HMR when executing tests in `run` mode
+            ...(isTextTerminal
+                ? { watch: { ignored: '**/*' }, hmr: false }
+                : {}),
+        },
         plugins: [
-            (0, index_1.Cypress)(config, vite),
-            (0, index_1.CypressSourcemap)(config, vite),
+            Cypress(config, vite),
+            CypressSourcemap(config, vite),
         ],
     };
-    if (vite.version && (0, gte_1.default)(vite.version, '4.2.0')) {
-        (_c = (_b = viteConfig.optimizeDeps) === null || _b === void 0 ? void 0 : _b.esbuildOptions) === null || _c === void 0 ? true : delete _c.incremental;
+    if (vite.version && semverGte(vite.version, '4.2.0')) {
+        delete viteConfig.optimizeDeps?.esbuildOptions?.incremental;
     }
     return viteConfig;
 }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@cypress/vite-dev-server",
-  "version": "6.0.2",
+  "version": "7.0.0",
   "description": "Launches Vite Dev Server for Component Testing",
-  "main": "index.js",
+  "main": "dist/index.js",
   "scripts": {
     "build": "tsc || echo 'built, with type errors'",
     "check-ts": "tsc --noEmit",
@@ -10,30 +10,26 @@
     "cypress:run": "yarn cypress:run-cypress-in-cypress node ../../scripts/cypress run --project . --browser chrome",
     "cypress:run-cypress-in-cypress": "cross-env CYPRESS_INTERNAL_E2E_TESTING_SELF_PARENT_PROJECT=1 HTTP_PROXY_TARGET_FOR_ORIGIN_REQUESTS=http://localhost:4455 CYPRESS_REMOTE_DEBUGGING_PORT=6666 TZ=America/New_York",
     "lint": "eslint --ext .js,.ts,.json, .",
-    "test": "yarn test-unit",
-    "test-unit": "mocha -r ts-node/register/transpile-only --config ./test/.mocharc.js",
+    "test": "vitest run --no-file-parallelism",
     "watch": "tsc -w"
   },
   "dependencies": {
     "debug": "^4.3.4",
     "find-up": "6.3.0",
     "node-html-parser": "5.3.3",
-    "semver": "^7.5.3"
+    "semver": "^7.7.1"
   },
   "devDependencies": {
-    "chai": "^4.3.6",
-    "decache": "^4.6.2",
+    "cross-env": "7.0.3",
     "dedent": "^0.7.0",
-    "mocha": "^9.2.2",
-    "sinon": "^13.0.1",
-    "ts-node": "^10.9.2",
-    "vite-4": "npm:vite@^4.5.3",
-    "vite-5": "npm:vite@^5.2.8",
-    "vite-6": "npm:vite@^6.0.0",
-    "vite-plugin-inspect": "0.8.4"
+    "vite-5": "npm:vite@^5.4.18",
+    "vite-6": "npm:vite@^6.2.5",
+    "vite-7": "npm:vite@^7.0.0",
+    "vite-plugin-inspect": "0.8.4",
+    "vitest": "2.1.4"
   },
   "peerDependencies": {
-    "cypress": ">=14.0.0"
+    "cypress": ">=15.0.0"
   },
   "files": [
     "dist",
@@ -48,6 +44,7 @@
   },
   "homepage": "https://github.com/cypress-io/cypress/tree/develop/npm/vite-dev-server#readme",
   "bugs": "https://github.com/cypress-io/cypress/issues/new?template=1-bug-report.md",
+  "type": "module",
   "module": "dist/index.js",
   "publishConfig": {
     "access": "public"

package/dist/dynamic-import.d.ts

@@ -1 +0,0 @@
-export declare const dynamicImport: <T>(module: string) => Promise<T>;

package/dist/dynamic-import.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dynamicImport = void 0;
-// tsc will compile `import(...)` calls to require unless a different tsconfig.module value
-// is used (e.g. module=node16). To change this, we would also have to change the ts-node behavior when requiring the
-// Cypress config file. This hack for keeping dynamic imports from being converted works across all
-// of our supported node versions
-const _dynamicImport = new Function('specifier', 'return import(specifier)');
-const dynamicImport = (module) => _dynamicImport(module);
-exports.dynamicImport = dynamicImport;

package/index.js

@@ -1 +0,0 @@
-module.exports = require('./dist')