@nx/remix 16.8.2 → 17.0.4

package/src/generators/storybook-configuration/storybook-configuration.impl.js

@@ -1,19 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
+exports.remixStorybookConfiguration = void 0;
 const devkit_1 = require("@nx/devkit");
 const path_1 = require("path");
-const versions_1 = require("../../utils/versions");
+const react_1 = require("@nx/react");
 function remixStorybookConfiguration(tree, schema) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { root } = (0, devkit_1.readProjectConfiguration)(tree, schema.name);
-        if (!tree.exists((0, devkit_1.joinPathFragments)(root, 'vite.config.ts'))) {
-            (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), root, { tpl: '' });
-        }
-        const { storybookConfigurationGenerator } = (0, devkit_1.ensurePackage)('@nx/react', (0, versions_1.getPackageVersion)(tree, 'nx'));
-        const task = yield storybookConfigurationGenerator(tree, schema);
-        return task;
+    return remixStorybookConfigurationInternal(tree, {
+        addPlugin: false,
+        ...schema,
     });
 }
-exports.default = remixStorybookConfiguration;
-//# sourceMappingURL=storybook-configuration.impl.js.map
+exports.remixStorybookConfiguration = remixStorybookConfiguration;
+async function remixStorybookConfigurationInternal(tree, schema) {
+    const nxJson = (0, devkit_1.readNxJson)(tree);
+    const addPluginDefault = process.env.NX_ADD_PLUGINS !== 'false' &&
+        nxJson.useInferencePlugins !== false;
+    schema.addPlugin ??= addPluginDefault;
+    const { root } = (0, devkit_1.readProjectConfiguration)(tree, schema.project);
+    if (!tree.exists((0, devkit_1.joinPathFragments)(root, 'vite.config.ts'))) {
+        (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files'), root, { tpl: '' });
+    }
+    const task = await (0, react_1.storybookConfigurationGenerator)(tree, schema);
+    return task;
+}
+exports.default = remixStorybookConfigurationInternal;

package/src/generators/style/schema.d.ts

@@ -1,4 +1,10 @@
+import { NameAndDirectoryFormat } from '@nx/devkit/src/generators/artifact-name-and-directory-utils';
+
 export interface RemixStyleSchema {
-  project: string;
   path: string;
+  nameAndDirectoryFormat?: NameAndDirectoryFormat;
+  /**
+   * @deprecated Provide the `path` option instead. The project will be determined from the path provided. It will be removed in Nx v19.
+   */
+  project?: string;
 }

package/src/generators/style/schema.json

@@ -1,12 +1,13 @@
 {
-  "$schema": "http://json-schema.org/schema",
+  "$schema": "https://json-schema.org/schema",
   "$id": "NxRemixRouteStyle",
   "title": "Add style import to a route",
+  "description": "Generate a style import and file for a given route.",
   "type": "object",
   "examples": [
     {
-      "command": "g style --project=webapp --path='path/to/page'",
-      "description": "Generate route at /path/to/page"
+      "command": "g style --path='apps/demo/app/routes/path/to/page.tsx'",
+      "description": "Generate route at apps/demo/app/routes/path/to/page.tsx"
     }
   ],
   "properties": {
@@ -17,17 +18,19 @@
         "$source": "argv",
         "index": 0
       },
-      "x-prompt": "What is the path of the route? (e.g. 'foo/bar')"
+      "x-prompt": "What is the path of the route? (e.g. 'apps/demo/app/routes/foo/bar.tsx')"
+    },
+    "nameAndDirectoryFormat": {
+      "description": "Whether to generate the styles in the path as provided, relative to the current working directory and ignoring the project (`as-provided`) or generate it using the project and directory relative to the workspace root (`derived`).",
+      "type": "string",
+      "enum": ["as-provided", "derived"]
     },
     "project": {
       "type": "string",
       "description": "The name of the project.",
-      "$default": {
-        "$source": "projectName"
-      },
-      "x-prompt": "What project is this route in?",
-      "pattern": "^[a-zA-Z].*$"
+      "pattern": "^[a-zA-Z].*$",
+      "x-deprecated": "Provide the `path` option instead and use the `as-provided` format. The project will be determined from the path provided. It will be removed in Nx v19."
     }
   },
-  "required": ["project", "path"]
+  "required": ["path"]
 }

package/src/generators/style/style.impl.js

@@ -1,20 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
+const artifact_name_and_directory_utils_1 = require("@nx/devkit/src/generators/artifact-name-and-directory-utils");
 const path_1 = require("path");
 const insert_import_1 = require("../../utils/insert-import");
 const insert_statement_after_imports_1 = require("../../utils/insert-statement-after-imports");
 const remix_route_utils_1 = require("../../utils/remix-route-utils");
-function default_1(tree, options) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const { name: routePath } = (0, devkit_1.names)(options.path.replace(/^\//, '').replace(/\/$/, '').replace('.tsx', ''));
-        const project = (0, devkit_1.readProjectConfiguration)(tree, options.project);
-        if (!project)
-            throw new Error(`Project does not exist: ${options.project}`);
-        const normalizedRoutePath = (0, remix_route_utils_1.normalizeRoutePath)(routePath);
-        const stylesheetPath = (0, devkit_1.joinPathFragments)((0, remix_route_utils_1.resolveRemixAppDirectory)(tree, project.name), 'styles', `${normalizedRoutePath}.css`);
-        tree.write(stylesheetPath, (0, devkit_1.stripIndents) `
+async function default_1(tree, options) {
+    const { project: projectName, artifactName: name } = await (0, artifact_name_and_directory_utils_1.determineArtifactNameAndDirectoryOptions)(tree, {
+        artifactType: 'style',
+        callingGenerator: '@nx/remix:style',
+        name: options.path,
+        nameAndDirectoryFormat: options.nameAndDirectoryFormat,
+        project: options.project,
+    });
+    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    if (!project)
+        throw new Error(`Project does not exist: ${projectName}`);
+    const appDir = await (0, remix_route_utils_1.resolveRemixAppDirectory)(tree, project.name);
+    const normalizedRoutePath = `${(0, remix_route_utils_1.normalizeRoutePath)(options.path)
+        .replace(/^\//, '')
+        .replace('.tsx', '')}.css`;
+    const stylesheetPath = (0, devkit_1.joinPathFragments)(appDir, 'styles', normalizedRoutePath);
+    tree.write(stylesheetPath, (0, devkit_1.stripIndents) `
       :root {
         --color-foreground: #fff;
         --color-background: #143157;
@@ -24,30 +32,30 @@ function default_1(tree, options) {
           Liberation Mono, Courier New, monospace;
       }
     `);
-        const routeFilePath = (0, remix_route_utils_1.resolveRemixRouteFile)(tree, options.path, options.project, '.tsx');
-        (0, insert_import_1.insertImport)(tree, routeFilePath, 'LinksFunction', '@remix-run/node', {
-            typeOnly: true,
-        });
-        if (project.root === '.') {
-            (0, insert_statement_after_imports_1.insertStatementAfterImports)(tree, routeFilePath, `
-    import stylesUrl from '~/styles/${normalizedRoutePath}.css'
+    const routeFilePath = options.nameAndDirectoryFormat
+        ? options.path
+        : await (0, remix_route_utils_1.resolveRemixRouteFile)(tree, options.path, options.project, '.tsx');
+    (0, insert_import_1.insertImport)(tree, routeFilePath, 'LinksFunction', '@remix-run/node', {
+        typeOnly: true,
+    });
+    if (project.root === '.') {
+        (0, insert_statement_after_imports_1.insertStatementAfterImports)(tree, routeFilePath, `
+    import stylesUrl from '~/styles/${normalizedRoutePath}'
 
     export const links: LinksFunction = () => {
       return [{ rel: 'stylesheet', href: stylesUrl }];
     };
   `);
-        }
-        else {
-            (0, insert_statement_after_imports_1.insertStatementAfterImports)(tree, routeFilePath, `
+    }
+    else {
+        (0, insert_statement_after_imports_1.insertStatementAfterImports)(tree, routeFilePath, `
     import stylesUrl from '${(0, path_1.relative)((0, path_1.dirname)(routeFilePath), stylesheetPath)}';
 
     export const links: LinksFunction = () => {
       return [{ rel: 'stylesheet', href: stylesUrl }];
     };
   `);
-        }
-        yield (0, devkit_1.formatFiles)(tree);
-    });
+    }
+    await (0, devkit_1.formatFiles)(tree);
 }
 exports.default = default_1;
-//# sourceMappingURL=style.impl.js.map

package/src/generators/utils/update-dependencies.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function updateDependencies(tree: Tree): import("@nx/devkit").GeneratorCallback;

package/src/generators/utils/update-dependencies.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateDependencies = void 0;
+const devkit_1 = require("@nx/devkit");
+const versions_1 = require("../../utils/versions");
+function updateDependencies(tree) {
+    return (0, devkit_1.addDependenciesToPackageJson)(tree, {
+        '@remix-run/node': versions_1.remixVersion,
+        '@remix-run/react': versions_1.remixVersion,
+        isbot: versions_1.isbotVersion,
+        react: versions_1.reactVersion,
+        'react-dom': versions_1.reactDomVersion,
+    }, {
+        '@remix-run/eslint-config': versions_1.remixVersion,
+        '@types/react': versions_1.typesReactVersion,
+        '@types/react-dom': versions_1.typesReactDomVersion,
+        eslint: versions_1.eslintVersion,
+        typescript: versions_1.typescriptVersion,
+    });
+}
+exports.updateDependencies = updateDependencies;

package/src/plugins/__snapshots__/plugin.spec.ts.snap

@@ -0,0 +1,113 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`@nx/remix/plugin non-root project should create nodes 1`] = `
+{
+  "projects": {
+    "my-app": {
+      "root": "my-app",
+      "targets": {
+        "build": {
+          "cache": true,
+          "command": "remix build",
+          "dependsOn": [
+            "^build",
+          ],
+          "inputs": [
+            "production",
+            "^production",
+          ],
+          "options": {
+            "cwd": "my-app",
+          },
+          "outputs": [
+            "{workspaceRoot}/my-app/build",
+            "{workspaceRoot}/my-app/public/build",
+          ],
+        },
+        "dev": {
+          "command": "remix dev --manual",
+          "options": {
+            "cwd": "my-app",
+          },
+        },
+        "start": {
+          "command": "remix-serve build/index.js",
+          "dependsOn": [
+            "build",
+          ],
+          "options": {
+            "cwd": "my-app",
+          },
+        },
+        "tsc": {
+          "cache": true,
+          "command": "tsc",
+          "inputs": [
+            "production",
+            "^production",
+          ],
+          "options": {
+            "cwd": "my-app",
+          },
+        },
+      },
+    },
+  },
+}
+`;
+
+exports[`@nx/remix/plugin root project should create nodes 1`] = `
+{
+  "projects": {
+    ".": {
+      "root": ".",
+      "targets": {
+        "build": {
+          "cache": true,
+          "command": "remix build",
+          "dependsOn": [
+            "^build",
+          ],
+          "inputs": [
+            "production",
+            "^production",
+          ],
+          "options": {
+            "cwd": ".",
+          },
+          "outputs": [
+            "{workspaceRoot}/build",
+            "{workspaceRoot}/public/build",
+          ],
+        },
+        "dev": {
+          "command": "remix dev --manual",
+          "options": {
+            "cwd": ".",
+          },
+        },
+        "start": {
+          "command": "remix-serve build/index.js",
+          "dependsOn": [
+            "build",
+          ],
+          "options": {
+            "cwd": ".",
+          },
+        },
+        "typecheck": {
+          "cache": true,
+          "command": "tsc",
+          "inputs": [
+            "production",
+            "^production",
+          ],
+          "options": {
+            "cwd": ".",
+          },
+        },
+      },
+    },
+  },
+}
+`;

package/src/plugins/plugin.d.ts

@@ -0,0 +1,9 @@
+import { type CreateDependencies, type CreateNodes } from '@nx/devkit';
+export declare const createDependencies: CreateDependencies;
+export interface RemixPluginOptions {
+    buildTargetName?: string;
+    devTargetName?: string;
+    startTargetName?: string;
+    typecheckTargetName?: string;
+}
+export declare const createNodes: CreateNodes<RemixPluginOptions>;

package/src/plugins/plugin.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createNodes = exports.createDependencies = void 0;
+const cache_directory_1 = require("nx/src/utils/cache-directory");
+const devkit_1 = require("@nx/devkit");
+const calculate_hash_for_create_nodes_1 = require("@nx/devkit/src/utils/calculate-hash-for-create-nodes");
+const get_named_inputs_1 = require("@nx/devkit/src/utils/get-named-inputs");
+const js_1 = require("@nx/js");
+const path_1 = require("path");
+const fs_1 = require("fs");
+const config_utils_1 = require("@nx/devkit/src/utils/config-utils");
+const cachePath = (0, path_1.join)(cache_directory_1.projectGraphCacheDirectory, 'remix.hash');
+const targetsCache = (0, fs_1.existsSync)(cachePath) ? readTargetsCache() : {};
+const calculatedTargets = {};
+function readTargetsCache() {
+    return (0, devkit_1.readJsonFile)(cachePath);
+}
+function writeTargetsToCache(targets) {
+    (0, devkit_1.writeJsonFile)(cachePath, targets);
+}
+const createDependencies = () => {
+    writeTargetsToCache(calculatedTargets);
+    return [];
+};
+exports.createDependencies = createDependencies;
+exports.createNodes = [
+    '**/remix.config.{js,cjs,mjs}',
+    async (configFilePath, options, context) => {
+        const projectRoot = (0, path_1.dirname)(configFilePath);
+        const fullyQualifiedProjectRoot = (0, path_1.join)(context.workspaceRoot, projectRoot);
+        // Do not create a project if package.json and project.json isn't there
+        const siblingFiles = (0, fs_1.readdirSync)(fullyQualifiedProjectRoot);
+        if (!siblingFiles.includes('package.json') &&
+            !siblingFiles.includes('project.json') &&
+            !siblingFiles.includes('vite.config.ts') &&
+            !siblingFiles.includes('vite.config.js')) {
+            return {};
+        }
+        options = normalizeOptions(options);
+        const hash = (0, calculate_hash_for_create_nodes_1.calculateHashForCreateNodes)(projectRoot, options, context, [
+            (0, js_1.getLockFileName)((0, devkit_1.detectPackageManager)(context.workspaceRoot)),
+        ]);
+        const targets = targetsCache[hash]
+            ? targetsCache[hash]
+            : await buildRemixTargets(configFilePath, projectRoot, options, context, siblingFiles);
+        calculatedTargets[hash] = targets;
+        return {
+            projects: {
+                [projectRoot]: {
+                    root: projectRoot,
+                    targets,
+                },
+            },
+        };
+    },
+];
+async function buildRemixTargets(configFilePath, projectRoot, options, context, siblingFiles) {
+    const namedInputs = (0, get_named_inputs_1.getNamedInputs)(projectRoot, context);
+    const { buildDirectory, assetsBuildDirectory, serverBuildPath } = await getBuildPaths(configFilePath, context.workspaceRoot);
+    const targets = {};
+    targets[options.buildTargetName] = buildTarget(options.buildTargetName, projectRoot, buildDirectory, assetsBuildDirectory, namedInputs);
+    targets[options.devTargetName] = devTarget(serverBuildPath, projectRoot);
+    targets[options.startTargetName] = startTarget(projectRoot, serverBuildPath, options.buildTargetName);
+    targets[options.typecheckTargetName] = typecheckTarget(projectRoot, namedInputs, siblingFiles);
+    return targets;
+}
+function buildTarget(buildTargetName, projectRoot, buildDirectory, assetsBuildDirectory, namedInputs) {
+    const serverBuildOutputPath = projectRoot === '.'
+        ? (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, buildDirectory)
+        : (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, projectRoot, buildDirectory);
+    const assetsBuildOutputPath = projectRoot === '.'
+        ? (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, assetsBuildDirectory)
+        : (0, devkit_1.joinPathFragments)(`{workspaceRoot}`, projectRoot, assetsBuildDirectory);
+    return {
+        cache: true,
+        dependsOn: [`^${buildTargetName}`],
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+        ],
+        outputs: [serverBuildOutputPath, assetsBuildOutputPath],
+        command: 'remix build',
+        options: { cwd: projectRoot },
+    };
+}
+function devTarget(serverBuildPath, projectRoot) {
+    return {
+        command: 'remix dev --manual',
+        options: { cwd: projectRoot },
+    };
+}
+function startTarget(projectRoot, serverBuildPath, buildTargetName) {
+    return {
+        dependsOn: [buildTargetName],
+        command: `remix-serve ${serverBuildPath}`,
+        options: {
+            cwd: projectRoot,
+        },
+    };
+}
+function typecheckTarget(projectRoot, namedInputs, siblingFiles) {
+    const hasTsConfigAppJson = siblingFiles.includes('tsconfig.app.json');
+    const command = `tsc${hasTsConfigAppJson ? ` --project tsconfig.app.json` : ``}`;
+    return {
+        command,
+        cache: true,
+        inputs: [
+            ...('production' in namedInputs
+                ? ['production', '^production']
+                : ['default', '^default']),
+        ],
+        options: {
+            cwd: projectRoot,
+        },
+    };
+}
+async function getBuildPaths(configFilePath, workspaceRoot) {
+    const configPath = (0, path_1.join)(workspaceRoot, configFilePath);
+    let appConfig = await (0, config_utils_1.loadConfigFile)(configPath);
+    return {
+        buildDirectory: 'build',
+        serverBuildPath: appConfig.serverBuildPath ?? 'build/index.js',
+        assetsBuildDirectory: appConfig.assetsBuildDirectory ?? 'public/build',
+    };
+}
+function normalizeOptions(options) {
+    options ??= {};
+    options.buildTargetName ??= 'build';
+    options.devTargetName ??= 'dev';
+    options.startTargetName ??= 'start';
+    options.typecheckTargetName ??= 'typecheck';
+    return options;
+}

package/src/utils/create-watch-paths.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getRelativeDependencyPaths = exports.createWatchPaths = void 0;
-const tslib_1 = require("tslib");
 const devkit_1 = require("@nx/devkit");
 const find_project_for_path_1 = require("nx/src/project-graph/utils/find-project-for-path");
 const project_graph_utils_1 = require("nx/src/utils/project-graph-utils");
@@ -11,20 +10,17 @@ const path_1 = require("path");
  *
  * @param {string} dirname The absolute path to the Remix project, typically `__dirname`.
  */
-function createWatchPaths(dirname) {
-    return tslib_1.__awaiter(this, void 0, void 0, function* () {
-        const graph = yield (0, devkit_1.createProjectGraphAsync)();
-        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(graph.nodes);
-        const projectName = (0, find_project_for_path_1.findProjectForPath)((0, path_1.relative)(devkit_1.workspaceRoot, dirname), projectRootMappings);
-        const deps = (0, project_graph_utils_1.findAllProjectNodeDependencies)(projectName, graph);
-        return getRelativeDependencyPaths(graph.nodes[projectName], deps, graph);
-    });
+async function createWatchPaths(dirname) {
+    const graph = await (0, devkit_1.createProjectGraphAsync)();
+    const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappings)(graph.nodes);
+    const projectName = (0, find_project_for_path_1.findProjectForPath)((0, path_1.relative)(devkit_1.workspaceRoot, dirname), projectRootMappings);
+    const deps = (0, project_graph_utils_1.findAllProjectNodeDependencies)(projectName, graph);
+    return getRelativeDependencyPaths(graph.nodes[projectName], deps, graph);
 }
 exports.createWatchPaths = createWatchPaths;
 // Exported for testing
 function getRelativeDependencyPaths(project, deps, graph) {
-    var _a, _b;
-    if (!((_a = project.data) === null || _a === void 0 ? void 0 : _a.root)) {
+    if (!project.data?.root) {
         throw new Error(`Project ${project.name} has no root set. Check the project configuration.`);
     }
     const paths = new Set();
@@ -32,7 +28,7 @@ function getRelativeDependencyPaths(project, deps, graph) {
     const [baseProjectPath] = project.data.root.split('/');
     for (const dep of deps) {
         const node = graph.nodes[dep];
-        if (!((_b = node === null || node === void 0 ? void 0 : node.data) === null || _b === void 0 ? void 0 : _b.root))
+        if (!node?.data?.root)
             continue;
         const [basePath] = (0, path_1.normalize)(node.data.root).split(path_1.sep);
         const watchPath = baseProjectPath !== basePath ? basePath : node.data.root;
@@ -42,4 +38,3 @@ function getRelativeDependencyPaths(project, deps, graph) {
     return Array.from(paths);
 }
 exports.getRelativeDependencyPaths = getRelativeDependencyPaths;
-//# sourceMappingURL=create-watch-paths.js.map

package/src/utils/get-default-export-name.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDefaultExportName = void 0;
 const get_default_export_1 = require("./get-default-export");
 function getDefaultExportName(tree, path) {
-    var _a, _b;
-    return (_b = (_a = (0, get_default_export_1.getDefaultExport)(tree, path)) === null || _a === void 0 ? void 0 : _a.name.text) !== null && _b !== void 0 ? _b : 'Unknown';
+    return (0, get_default_export_1.getDefaultExport)(tree, path)?.name.text ?? 'Unknown';
 }
 exports.getDefaultExportName = getDefaultExportName;
-//# sourceMappingURL=get-default-export-name.js.map

package/src/utils/get-default-export.js

@@ -13,4 +13,3 @@ function getDefaultExport(tree, path) {
     });
 }
 exports.getDefaultExport = getDefaultExport;
-//# sourceMappingURL=get-default-export.js.map

package/src/utils/insert-import.js

@@ -52,4 +52,3 @@ function insertImport(tree, path, name, modulePath, options = { typeOnly: false
     }
 }
 exports.insertImport = insertImport;
-//# sourceMappingURL=insert-import.js.map

package/src/utils/insert-statement-after-imports.js

@@ -26,4 +26,3 @@ function insertStatementAfterImports(tree, path, statement) {
     tree.write(path, newContents);
 }
 exports.insertStatementAfterImports = insertStatementAfterImports;
-//# sourceMappingURL=insert-statement-after-imports.js.map

package/src/utils/insert-statement-in-default-function.js

@@ -21,4 +21,3 @@ function insertStatementInDefaultFunction(tree, path, statement) {
     tree.write(path, newContents);
 }
 exports.insertStatementInDefaultFunction = insertStatementInDefaultFunction;
-//# sourceMappingURL=insert-statement-in-default-function.js.map

package/src/utils/remix-config.d.ts

@@ -1,5 +1,5 @@
 import { Tree } from '@nx/devkit';
 import type { AppConfig } from '@remix-run/dev';
 export declare function getRemixConfigPath(tree: Tree, projectName: string): string;
-export declare function getRemixConfigValues(tree: Tree, projectName: string): AppConfig;
-export declare function getRemixFutureFlags(tree: Tree, projectName: string): AppConfig['future'];
+export declare function getRemixConfigPathFromProjectRoot(tree: Tree, projectRoot: string): string;
+export declare function getRemixConfigValues(tree: Tree, projectName: string): Promise<AppConfig>;

package/src/utils/remix-config.js

@@ -1,22 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRemixFutureFlags = exports.getRemixConfigValues = exports.getRemixConfigPath = void 0;
+exports.getRemixConfigValues = exports.getRemixConfigPathFromProjectRoot = exports.getRemixConfigPath = void 0;
 const devkit_1 = require("@nx/devkit");
 function getRemixConfigPath(tree, projectName) {
     const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
     if (!project)
         throw new Error(`Project does not exist: ${projectName}`);
-    return (0, devkit_1.joinPathFragments)(project.root, 'remix.config.js');
+    for (const ext of ['.mjs', '.cjs', '.js']) {
+        const configPath = (0, devkit_1.joinPathFragments)(project.root, `remix.config${ext}`);
+        if (tree.exists(configPath)) {
+            return configPath;
+        }
+    }
 }
 exports.getRemixConfigPath = getRemixConfigPath;
-function getRemixConfigValues(tree, projectName) {
-    const remixConfigPath = getRemixConfigPath(tree, projectName);
-    return eval(tree.read(remixConfigPath, 'utf-8'));
+function getRemixConfigPathFromProjectRoot(tree, projectRoot) {
+    let pathToRemixConfig;
+    for (const ext of ['.js', '.mjs', '.cjs']) {
+        pathToRemixConfig = (0, devkit_1.joinPathFragments)(projectRoot, `remix.config${ext}`);
+        if (tree.exists(pathToRemixConfig)) {
+            return pathToRemixConfig;
+        }
+    }
+    throw new Error(`Could not find a Remix Config File. Please ensure a "remix.config.js" file exists at the root of your project.`);
 }
-exports.getRemixConfigValues = getRemixConfigValues;
-function getRemixFutureFlags(tree, projectName) {
-    const configValues = getRemixConfigValues(tree, projectName);
-    return configValues === null || configValues === void 0 ? void 0 : configValues.future;
+exports.getRemixConfigPathFromProjectRoot = getRemixConfigPathFromProjectRoot;
+const _remixConfigCache = {};
+async function getRemixConfigValues(tree, projectName) {
+    const remixConfigPath = (0, devkit_1.joinPathFragments)(devkit_1.workspaceRoot, getRemixConfigPath(tree, projectName));
+    const cacheKey = `${projectName}/${remixConfigPath}`;
+    let appConfig = _remixConfigCache[cacheKey];
+    if (!appConfig) {
+        try {
+            const importedConfig = await Function(`return import("${remixConfigPath}?t=${Date.now()}")`)();
+            appConfig = (importedConfig?.default || importedConfig);
+        }
+        catch {
+            appConfig = require(remixConfigPath);
+        }
+        _remixConfigCache[cacheKey] = appConfig;
+    }
+    return appConfig;
 }
-exports.getRemixFutureFlags = getRemixFutureFlags;
-//# sourceMappingURL=remix-config.js.map
+exports.getRemixConfigValues = getRemixConfigValues;

package/src/utils/remix-route-utils.d.ts

@@ -7,7 +7,7 @@ import { Tree } from '@nx/devkit';
  * @param fileExtension the file extension to add to resolved route file
  * @returns file path to the route
  */
-export declare function resolveRemixRouteFile(tree: Tree, path: string, projectName: string, fileExtension?: string): string;
+export declare function resolveRemixRouteFile(tree: Tree, path: string, projectName?: string, fileExtension?: string): Promise<string>;
 export declare function normalizeRoutePath(path: string): string;
 export declare function checkRoutePathForErrors(path: string): RegExpMatchArray;
-export declare function resolveRemixAppDirectory(tree: Tree, projectName: string): string;
+export declare function resolveRemixAppDirectory(tree: Tree, projectName: string): Promise<string>;