@shopify/cli-hydrogen 4.0.0-alpha.9 → 4.0.1

package/dist/utils/config.js

@@ -1,3 +1,5 @@
+import { renderFatalError } from '@shopify/cli-kit/node/ui';
+import { output, file } from '@shopify/cli-kit';
 import { createRequire } from 'module';
 import path from 'path';
 import fs from 'fs/promises';
@@ -11,62 +13,133 @@ function getProjectPaths(appPath, entry) {
   const buildPath = path.join(root, BUILD_DIR);
   const buildPathClient = path.join(buildPath, CLIENT_SUBDIR);
   const buildPathWorkerFile = path.join(buildPath, WORKER_SUBDIR, "index.js");
-  const entryFile = entry ? path.join(root, entry) : "";
   return {
     root,
-    entryFile,
     buildPath,
     buildPathClient,
     buildPathWorkerFile,
     publicPath
   };
 }
-let cachedConfig;
-async function getRemixConfig(root, entryFile, publicPath, bustCacheFile, mode = process.env.NODE_ENV) {
-  if (!cachedConfig || bustCacheFile) {
-    let env = process.env.NODE_ENV;
-    if (bustCacheFile) {
-      const require2 = createRequire(import.meta.url);
-      delete require2.cache[bustCacheFile];
-      process.env.NODE_ENV = "test";
-    }
-    const { readConfig } = await import('@remix-run/dev/dist/config.js');
-    const config = await readConfig(root, mode);
-    process.env.NODE_ENV = env;
-    const hydrogenAssetBase = process.env.HYDROGEN_ASSET_BASE_URL;
-    if (hydrogenAssetBase) {
-      const suffix = config.publicPath?.replace(/\\/g, "/").replace(/^\//, "");
-      config.publicPath = hydrogenAssetBase + suffix;
-    }
-    config.serverEntryPoint ??= entryFile;
+async function getRemixConfig(root, mode = process.env.NODE_ENV) {
+  const { readConfig } = await import('@remix-run/dev/dist/config.js');
+  const config = await readConfig(root, mode);
+  if (!config.serverConditions) {
+    const require2 = createRequire(import.meta.url);
+    const actualConfigFile = require2(path.join(root, "remix.config"));
     config.serverBuildTarget = "cloudflare-workers";
-    config.serverModuleFormat = "esm";
-    config.serverPlatform = "neutral";
-    config.serverBuildPath = path.resolve(
-      root,
-      path.join(BUILD_DIR, WORKER_SUBDIR, "index.js")
+    config.serverConditions = actualConfigFile.serverConditions;
+    config.serverMainFields = actualConfigFile.serverMainFields;
+  }
+  if (!config.serverEntryPoint) {
+    throwConfigError(
+      "Could not find a server entry point.",
+      "Please add a server option to your remix.config.js pointing to an Oxygen worker entry file."
+    );
+  } else {
+    assertEntryFileExists(config.rootDirectory, config.serverEntryPoint);
+  }
+  if (config.serverPlatform !== "neutral") {
+    throwConfigError(
+      'The serverPlatform in remix.config.js must be "neutral".'
+    );
+  }
+  if (config.serverModuleFormat !== "esm") {
+    throwConfigError(
+      'The serverModuleFormat in remix.config.js must be "esm".'
+    );
+  }
+  if (config.serverDependenciesToBundle !== "all") {
+    throwConfigError(
+      'The serverDependenciesToBundle in remix.config.js must be "all".'
+    );
+  }
+  if (!config.serverConditions?.includes("worker")) {
+    throwConfigError(
+      'The serverConditions in remix.config.js must include "worker".'
+    );
+  }
+  if (process.env.NODE_ENV === "development" && !config.serverConditions?.includes("development")) {
+    output.warn(
+      "Add `process.env.NODE_ENV` value to serverConditions in remix.config.js to enable debugging features in development."
     );
-    config.relativeAssetsBuildDirectory = path.join(
-      BUILD_DIR,
-      CLIENT_SUBDIR,
-      "build"
+  }
+  const expectedServerMainFields = ["browser", "module", "main"];
+  if (!config.serverMainFields || !expectedServerMainFields.every(
+    (v, i) => config.serverMainFields?.[i] === v
+  )) {
+    throwConfigError(
+      `The serverMainFields in remix.config.js must be ${JSON.stringify(
+        expectedServerMainFields
+      )}.`
+    );
+  }
+  const cdnUrl = process.env.HYDROGEN_ASSET_BASE_URL;
+  if (cdnUrl && !config.publicPath.startsWith(cdnUrl)) {
+    throwConfigError(
+      "The publicPath in remix.config.js must be prepended with the value of `process.env.HYDROGEN_ASSET_BASE_URL`."
     );
-    config.assetsBuildDirectory = path.resolve(
-      root,
-      config.relativeAssetsBuildDirectory
+  }
+  const expectedServerBuildPath = path.join(
+    BUILD_DIR,
+    WORKER_SUBDIR,
+    "index.js"
+  );
+  if (config.serverBuildPath !== path.resolve(root, expectedServerBuildPath)) {
+    throwConfigError(
+      `The serverBuildPath in remix.config.js must be "${expectedServerBuildPath}".`
     );
-    config.watchPaths = [publicPath, path.resolve(root, "remix.config.*")];
-    if (process.env.LOCAL_DEV) {
-      const packagesPath = new URL("../../..", import.meta.url).pathname;
-      config.watchPaths.push(
-        ...(await fs.readdir(packagesPath)).map(
-          (pkg) => path.resolve(packagesPath, pkg, "dist", "development", "index.js")
-        )
-      );
+  }
+  const expectedAssetsBuildDirectory = path.join(BUILD_DIR, CLIENT_SUBDIR);
+  if (!config.assetsBuildDirectory.startsWith(
+    path.resolve(root, expectedAssetsBuildDirectory)
+  )) {
+    throwConfigError(
+      `The assetsBuildDirectory in remix.config.js must be in "${expectedAssetsBuildDirectory}".`
+    );
+  }
+  if (process.env.LOCAL_DEV) {
+    const packagesPath = new URL("../../..", import.meta.url).pathname;
+    config.watchPaths ??= [];
+    config.watchPaths.push(
+      ...(await fs.readdir(packagesPath)).map(
+        (pkg) => path.resolve(packagesPath, pkg, "dist", "development", "index.js")
+      )
+    );
+    config.watchPaths.push(
+      path.join(packagesPath, "cli", "dist", "virtual-routes", "**", "*")
+    );
+  }
+  return config;
+}
+function throwConfigError(message, tryMessage = null) {
+  renderFatalError({
+    name: "ConfigError",
+    type: 0,
+    message,
+    tryMessage
+  });
+  process.exit(1);
+}
+async function assertEntryFileExists(root, fileRelative) {
+  const fileAbsolute = path.resolve(root, fileRelative);
+  const exists = await file.exists(fileAbsolute);
+  if (!exists) {
+    if (!path.extname(fileAbsolute)) {
+      const { readdir } = await import('fs/promises');
+      const files = await readdir(path.dirname(fileAbsolute));
+      const exists2 = files.some((file2) => {
+        const { name, ext } = path.parse(file2);
+        return name === path.basename(fileAbsolute) && /^\.[jt]s$/.test(ext);
+      });
+      if (exists2)
+        return;
     }
-    cachedConfig = config;
+    throwConfigError(
+      `Entry file "${fileRelative}" not found.`,
+      "Please ensure the file exists and that the path is correctly added to the `server` property in remix.config.js."
+    );
   }
-  return cachedConfig;
 }
 
-export { getProjectPaths, getRemixConfig };
+export { assertEntryFileExists, getProjectPaths, getRemixConfig };

package/dist/utils/flags.d.ts

@@ -0,0 +1,10 @@
+import * as _oclif_core_lib_interfaces_parser_js from '@oclif/core/lib/interfaces/parser.js';
+
+declare const commonFlags: {
+    path: _oclif_core_lib_interfaces_parser_js.OptionFlag<string | undefined>;
+    port: _oclif_core_lib_interfaces_parser_js.OptionFlag<number>;
+    force: _oclif_core_lib_interfaces_parser_js.BooleanFlag<boolean>;
+};
+declare function flagsToCamelObject(obj: Record<string, any>): any;
+
+export { commonFlags, flagsToCamelObject };

package/dist/utils/flags.js

@@ -1,15 +1,27 @@
 import Flags from '@oclif/core/lib/flags.js';
+import { string } from '@shopify/cli-kit';
 
 const commonFlags = {
   path: Flags.string({
-    description: "the path to your hydrogen storefront",
+    description: "The path to the directory of the Hydrogen storefront. The default is the current directory.",
     env: "SHOPIFY_HYDROGEN_FLAG_PATH"
   }),
   port: Flags.integer({
-    description: "Port to run the preview server on",
+    description: "Port to run the server on.",
     env: "SHOPIFY_HYDROGEN_FLAG_PORT",
     default: 3e3
+  }),
+  force: Flags.boolean({
+    description: "Overwrite the destination directory and files if they already exist.",
+    env: "SHOPIFY_HYDROGEN_FLAG_FORCE",
+    char: "f"
   })
 };
+function flagsToCamelObject(obj) {
+  return Object.entries(obj).reduce((acc, [key, value]) => {
+    acc[string.camelize(key)] = value;
+    return acc;
+  }, {});
+}
 
-export { commonFlags };
+export { commonFlags, flagsToCamelObject };

package/dist/utils/flags.test.d.ts

@@ -0,0 +1 @@
+

package/dist/utils/flags.test.js

@@ -0,0 +1,18 @@
+import { describe, it, expect } from 'vitest';
+import { flagsToCamelObject } from './flags.js';
+
+describe("CLI flag utils", () => {
+  it("turns kebab-case flags to camelCase", async () => {
+    expect(
+      flagsToCamelObject({
+        "kebab-case": "value",
+        "another-kebab-case": "value",
+        flag: "value"
+      })
+    ).toMatchObject({
+      kebabCase: "value",
+      anotherKebabCase: "value",
+      flag: "value"
+    });
+  });
+});

package/dist/utils/log.d.ts

@@ -0,0 +1,5 @@
+declare function muteDevLogs({ workerReload }?: {
+    workerReload?: boolean;
+}): void;
+
+export { muteDevLogs };

package/dist/utils/mini-oxygen.d.ts

@@ -0,0 +1,11 @@
+type MiniOxygenOptions = {
+    root: string;
+    port?: number;
+    watch?: boolean;
+    buildPathClient: string;
+    buildPathWorkerFile: string;
+};
+declare function startMiniOxygen({ root, port, watch, buildPathWorkerFile, buildPathClient, }: MiniOxygenOptions): Promise<void>;
+declare function logResponse(request: Request, response: Response): void;
+
+export { logResponse, startMiniOxygen };

package/dist/utils/mini-oxygen.js

@@ -1,5 +1,4 @@
-import path from 'path';
-import { output } from '@shopify/cli-kit';
+import { path, file, output } from '@shopify/cli-kit';
 import colors from '@shopify/cli-kit/node/colors';
 
 async function startMiniOxygen({
@@ -11,6 +10,7 @@ async function startMiniOxygen({
 }) {
   const { default: miniOxygen } = await import('@shopify/mini-oxygen');
   const miniOxygenPreview = miniOxygen.default ?? miniOxygen;
+  const dotenvPath = path.resolve(root, ".env");
   const { port: actualPort } = await miniOxygenPreview({
     workerFile: buildPathWorkerFile,
     assetsDir: buildPathClient,
@@ -20,11 +20,14 @@ async function startMiniOxygen({
     autoReload: watch,
     modules: true,
     env: process.env,
-    envPath: path.resolve(root, ".env"),
+    envPath: await file.exists(dotenvPath) ? dotenvPath : void 0,
     log: () => {
     },
     buildWatchPaths: watch ? [path.resolve(root, buildPathWorkerFile)] : void 0,
-    onResponse: (request, response) => logResponse(request, response)
+    onResponse: (request, response) => logResponse(
+      request,
+      response
+    )
   });
   const listeningAt = `http://localhost:${actualPort}`;
   output.info(

package/dist/utils/missing-routes.d.ts

@@ -0,0 +1,6 @@
+import { RemixConfig } from '@remix-run/dev/dist/config.js';
+
+declare function findMissingRoutes(config: RemixConfig): string[];
+declare function logMissingRoutes(routes: string[]): void;
+
+export { findMissingRoutes, logMissingRoutes };

package/dist/utils/missing-routes.js

@@ -0,0 +1,71 @@
+import { renderWarning, renderSuccess } from '@shopify/cli-kit/node/ui';
+
+const REQUIRED_ROUTES = [
+  "",
+  "cart",
+  "products",
+  "products/:productHandle",
+  "collections",
+  "collections/:collectionHandle",
+  "sitemap.xml",
+  "robots.txt",
+  "pages/:pageHandle",
+  "policies/:policyHandle",
+  "search",
+  "discounts/:discountCode",
+  "account",
+  "account/login",
+  "account/register",
+  "account/orders/:orderId",
+  "account/reset/:id/:token",
+  "account/activate/:id/:token"
+];
+function findMissingRoutes(config) {
+  const userRoutes = Object.values(config.routes);
+  const requiredRoutes = new Set(REQUIRED_ROUTES);
+  for (const requiredRoute of requiredRoutes) {
+    for (const userRoute of userRoutes) {
+      if (!requiredRoute && !userRoute.path) {
+        requiredRoutes.delete(requiredRoute);
+      } else if (requiredRoute && userRoute.path) {
+        const currentRoute = {
+          path: userRoute.path,
+          parentId: userRoute.parentId
+        };
+        while (currentRoute.parentId && currentRoute.parentId !== "root") {
+          const parentRoute = userRoutes.find(
+            (r) => r.id === currentRoute.parentId
+          );
+          if (!parentRoute)
+            break;
+          currentRoute.path = `${parentRoute.path}/${currentRoute.path}`;
+          currentRoute.parentId = parentRoute.parentId;
+        }
+        const reString = "^(:[^\\/\\?]+\\?\\/)?" + requiredRoute.replaceAll(".", "\\.").replace(/:[^/]+/g, ":[^\\/]+") + "$";
+        if (new RegExp(reString).test(currentRoute.path)) {
+          requiredRoutes.delete(requiredRoute);
+        }
+      }
+    }
+  }
+  return [...requiredRoutes];
+}
+const LINE_LIMIT = 100;
+function logMissingRoutes(routes) {
+  if (routes.length) {
+    renderWarning({
+      headline: "Standard Shopify routes missing",
+      body: `Your Hydrogen project is missing ${routes.length} standard Shopify route${routes.length > 1 ? "s" : ""}.
+Including these routes improves compatibility with Shopify\u2019s platform:
+
+` + routes.slice(0, LINE_LIMIT - (routes.length <= LINE_LIMIT ? 0 : 1)).map((route) => `\u2022 /${route}`).join("\n") + (routes.length > LINE_LIMIT ? `
+\u2022 ...and ${routes.length - LINE_LIMIT + 1} more` : "")
+    });
+  } else {
+    renderSuccess({
+      headline: "All standard Shopify routes present"
+    });
+  }
+}
+
+export { findMissingRoutes, logMissingRoutes };

package/dist/utils/template-downloader.d.ts

@@ -0,0 +1,11 @@
+declare function getLatestReleaseDownloadUrl(): Promise<{
+    version: string;
+    url: string;
+}>;
+declare function downloadTarball(url: string, storageDir: string): Promise<void>;
+declare function getLatestTemplates(): Promise<{
+    version: string;
+    templatesDir: string;
+}>;
+
+export { downloadTarball, getLatestReleaseDownloadUrl, getLatestTemplates };

package/dist/utils/template-downloader.js

@@ -0,0 +1,66 @@
+import fs from 'fs';
+import path from 'path';
+import { pipeline } from 'stream/promises';
+import gunzipMaybe from 'gunzip-maybe';
+import { extract } from 'tar-fs';
+import { http } from '@shopify/cli-kit';
+
+const REPO_RELEASES_URL = `https://api.github.com/repos/shopify/hydrogen/releases/latest`;
+async function getLatestReleaseDownloadUrl() {
+  const response = await http.fetch(REPO_RELEASES_URL);
+  if (!response.ok || response.status >= 400) {
+    throw new Error(
+      `Failed to fetch the latest release information. Status ${response.status} ${response.statusText}`
+    );
+  }
+  const release = await response.json();
+  return {
+    version: release.name.split("/").pop() ?? release.name,
+    url: release.tarball_url
+  };
+}
+async function downloadTarball(url, storageDir) {
+  const response = await http.fetch(url);
+  if (!response.ok || response.status >= 400) {
+    throw new Error(
+      `Failed to download the latest release files. Status ${response.status} ${response.statusText}}`
+    );
+  }
+  await pipeline(
+    response.body,
+    gunzipMaybe(),
+    extract(storageDir, {
+      strip: 1,
+      filter: (name) => {
+        name = name.replace(storageDir, "");
+        return !name.startsWith("/templates/") || name.startsWith("/templates/skeleton/");
+      }
+    })
+  );
+}
+async function getLatestTemplates() {
+  try {
+    const { version, url } = await getLatestReleaseDownloadUrl();
+    const templateStoragePath = new URL("../starter-templates", import.meta.url).pathname;
+    if (!fs.existsSync(templateStoragePath)) {
+      fs.mkdirSync(templateStoragePath);
+    }
+    const templateStorageVersionPath = path.join(templateStoragePath, version);
+    if (!fs.existsSync(templateStorageVersionPath)) {
+      await downloadTarball(url, templateStorageVersionPath);
+    }
+    return {
+      version,
+      templatesDir: path.join(templateStorageVersionPath, "templates")
+    };
+  } catch (e) {
+    const error = e;
+    error.message = `Could not download Hydrogen templates from GitHub.
+Please check your internet connection and the following error:
+
+` + error.message;
+    throw error;
+  }
+}
+
+export { downloadTarball, getLatestReleaseDownloadUrl, getLatestTemplates };

package/dist/utils/transpile-ts.d.ts

@@ -0,0 +1,16 @@
+import prettier, { Options } from 'prettier';
+import ts, { CompilerOptions } from 'typescript';
+
+declare function transpileFile(code: string, config?: Omit<ts.CompilerOptions, "target">): string;
+declare function resolveFormatConfig(filePath?: string): Promise<prettier.Options>;
+declare function format(content: string, config: Options, filePath?: string): string;
+declare function convertConfigToJS(tsConfig: {
+    include?: string[];
+    compilerOptions?: CompilerOptions;
+}): {
+    include?: string[] | undefined;
+    compilerOptions?: ts.CompilerOptions | undefined;
+};
+declare function transpileProject(projectDir: string): Promise<void>;
+
+export { convertConfigToJS, format, resolveFormatConfig, transpileFile, transpileProject };

package/dist/utils/transpile-ts.js

@@ -0,0 +1,169 @@
+import path from 'path';
+import fs from 'fs/promises';
+import prettier from 'prettier';
+import ts from 'typescript';
+import glob from 'fast-glob';
+import { output } from '@shopify/cli-kit';
+
+const escapeNewLines = (code) => code.replace(/\n\n/g, "\n/* :newline: */");
+const restoreNewLines = (code) => code.replace(/\/\* :newline: \*\//g, "\n");
+const DEFAULT_TS_CONFIG = {
+  lib: ["DOM", "DOM.Iterable", "ES2022"],
+  isolatedModules: true,
+  esModuleInterop: true,
+  resolveJsonModule: true,
+  target: "ES2022",
+  strict: true,
+  allowJs: true,
+  forceConsistentCasingInFileNames: true,
+  skipLibCheck: true
+};
+function transpileFile(code, config = DEFAULT_TS_CONFIG) {
+  const withArtificialNewLines = escapeNewLines(code);
+  const compiled = ts.transpileModule(withArtificialNewLines, {
+    reportDiagnostics: false,
+    compilerOptions: {
+      ...config,
+      jsx: 1,
+      removeComments: false
+    }
+  });
+  return restoreNewLines(compiled.outputText);
+}
+const DEFAULT_PRETTIER_CONFIG = {
+  arrowParens: "always",
+  singleQuote: true,
+  bracketSpacing: false,
+  trailingComma: "all"
+};
+async function resolveFormatConfig(filePath = process.cwd()) {
+  try {
+    return await prettier.resolveConfig(filePath) || DEFAULT_PRETTIER_CONFIG;
+  } catch {
+    return DEFAULT_PRETTIER_CONFIG;
+  }
+}
+function format(content, config, filePath = "") {
+  const ext = path.extname(filePath);
+  const formattedContent = prettier.format(content, {
+    parser: ext === ".tsx" || ext === ".ts" ? "typescript" : "babel",
+    ...config
+  });
+  return formattedContent;
+}
+const DEFAULT_JS_CONFIG = {
+  allowJs: true,
+  forceConsistentCasingInFileNames: true,
+  strict: true,
+  lib: ["DOM", "DOM.Iterable", "ES2022"],
+  esModuleInterop: true,
+  isolatedModules: true,
+  jsx: "react-jsx",
+  noEmit: true,
+  resolveJsonModule: true
+};
+const JS_CONFIG_KEYS = [
+  "noLib",
+  "target",
+  "module",
+  "moduleResolution",
+  "checkJs",
+  "experimentalDecorators",
+  "allowSyntheticDefaultImports",
+  "baseUrl",
+  "paths",
+  ...Object.keys(DEFAULT_JS_CONFIG)
+];
+function convertConfigToJS(tsConfig) {
+  const jsConfig = {
+    compilerOptions: { ...DEFAULT_JS_CONFIG }
+  };
+  if (tsConfig.include) {
+    jsConfig.include = tsConfig.include.filter((s) => !s.endsWith(".d.ts")).map((s) => s.replace(/\.ts(x?)$/, ".js$1"));
+  }
+  if (tsConfig.compilerOptions) {
+    for (const key of JS_CONFIG_KEYS) {
+      if (tsConfig.compilerOptions[key] !== void 0) {
+        jsConfig.compilerOptions[key] = tsConfig.compilerOptions[key];
+      }
+    }
+  }
+  return jsConfig;
+}
+async function transpileProject(projectDir) {
+  const entries = await glob("**/*.+(ts|tsx)", {
+    absolute: true,
+    cwd: projectDir
+  });
+  const formatConfig = await resolveFormatConfig();
+  for (const entry of entries) {
+    if (entry.endsWith(".d.ts")) {
+      await fs.rm(entry);
+      continue;
+    }
+    const tsx = await fs.readFile(entry, "utf8");
+    const mjs = format(transpileFile(tsx), formatConfig);
+    await fs.rm(entry);
+    await fs.writeFile(entry.replace(/\.ts(x?)$/, ".js$1"), mjs, "utf8");
+  }
+  try {
+    const remixConfigPath = path.join(projectDir, "remix.config.js");
+    let remixConfig = await fs.readFile(remixConfigPath, "utf8");
+    remixConfig = remixConfig.replace(/\/server\.ts/gim, "/server.js");
+    await fs.writeFile(remixConfigPath, remixConfig);
+  } catch (error) {
+    output.debug(
+      "Could not change TS extensions in remix.config.js:\n" + error.stack
+    );
+  }
+  try {
+    const tsConfigPath = path.join(projectDir, "tsconfig.json");
+    const tsConfigWithComments = await fs.readFile(tsConfigPath, "utf8");
+    const jsConfig = convertConfigToJS(
+      JSON.parse(tsConfigWithComments.replace(/^\s*\/\/.*$/gm, ""))
+    );
+    await fs.rm(tsConfigPath);
+    await fs.writeFile(
+      path.join(projectDir, "jsconfig.json"),
+      JSON.stringify(jsConfig, null, 2),
+      "utf8"
+    );
+  } catch (error) {
+    output.debug(
+      "Could not transpile tsconfig.json:\n" + error.stack
+    );
+  }
+  try {
+    const pkgJson = JSON.parse(
+      await fs.readFile(path.join(projectDir, "package.json"), "utf8")
+    );
+    delete pkgJson.scripts["typecheck"];
+    delete pkgJson.devDependencies["typescript"];
+    delete pkgJson.devDependencies["@shopify/oxygen-workers-types"];
+    for (const key of Object.keys(pkgJson.devDependencies)) {
+      if (key.startsWith("@types/")) {
+        delete pkgJson.devDependencies[key];
+      }
+    }
+    await fs.writeFile(
+      path.join(projectDir, "package.json"),
+      JSON.stringify(pkgJson, null, 2)
+    );
+  } catch (error) {
+    output.debug(
+      "Could not remove TS dependencies from package.json:\n" + error.stack
+    );
+  }
+  try {
+    const eslintrcPath = path.join(projectDir, ".eslintrc.js");
+    let eslintrc = await fs.readFile(eslintrcPath, "utf8");
+    eslintrc = eslintrc.replace(/\/\*\*[\s*]+@type.+\s+\*\/\s?/gim, "").replace(/\s*,?\s*['"`]plugin:hydrogen\/typescript['"`]/gim, "").replace(/\s+['"`]@typescript-eslint\/.+,/gim, "");
+    await fs.writeFile(eslintrcPath, eslintrc);
+  } catch (error) {
+    output.debug(
+      "Could not remove TS rules from .eslintrc:\n" + error.stack
+    );
+  }
+}
+
+export { convertConfigToJS, format, resolveFormatConfig, transpileFile, transpileProject };

package/dist/utils/virtual-routes.d.ts

@@ -0,0 +1,7 @@
+import { RemixConfig } from '@remix-run/dev/dist/config.js';
+
+declare const VIRTUAL_ROUTES_DIR = "virtual-routes/routes";
+declare const VIRTUAL_ROOT = "virtual-routes/virtual-root";
+declare function addVirtualRoutes(config: RemixConfig): Promise<RemixConfig>;
+
+export { VIRTUAL_ROOT, VIRTUAL_ROUTES_DIR, addVirtualRoutes };