@nx/remix 0.0.0-pr-22179-271588f

package/src/utils/insert-import.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertImport = void 0;
+const devkit_1 = require("@nx/devkit");
+const typescript_1 = require("typescript");
+const insert_statement_after_imports_1 = require("./insert-statement-after-imports");
+function insertImport(tree, path, name, modulePath, options = { typeOnly: false }) {
+    if (!tree.exists(path))
+        throw Error(`Could not insert import ${name} from ${modulePath} in ${path}: path not found`);
+    const contents = tree.read(path, 'utf-8');
+    const sourceFile = (0, typescript_1.createSourceFile)(path, contents, typescript_1.ScriptTarget.ESNext);
+    let importStatements = sourceFile.statements.filter(typescript_1.isImportDeclaration);
+    if (options.typeOnly) {
+        importStatements = importStatements.filter((node) => node.importClause.isTypeOnly);
+    }
+    else {
+        importStatements = importStatements.filter((node) => !node.importClause.isTypeOnly);
+    }
+    const existingImport = importStatements.find((statement) => (0, typescript_1.isStringLiteral)(statement.moduleSpecifier) &&
+        statement.moduleSpecifier
+            .getText(sourceFile)
+            .replace(/['"`]/g, '')
+            .trim() === modulePath &&
+        statement.importClause.namedBindings &&
+        (0, typescript_1.isNamedImports)(statement.importClause.namedBindings));
+    if (!existingImport) {
+        (0, insert_statement_after_imports_1.insertStatementAfterImports)(tree, path, options.typeOnly
+            ? `import type { ${name} } from '${modulePath}';`
+            : `import { ${name} } from '${modulePath}';`);
+        return;
+    }
+    const namedImports = existingImport.importClause
+        .namedBindings;
+    const alreadyImported = namedImports.elements.find((element) => element.name.escapedText === name) !== undefined;
+    if (!alreadyImported) {
+        const index = namedImports.getEnd() - 1;
+        let text;
+        if (namedImports.elements.hasTrailingComma) {
+            text = `${name},`;
+        }
+        else {
+            text = `,${name}`;
+        }
+        const newContents = (0, devkit_1.applyChangesToString)(contents, [
+            {
+                type: devkit_1.ChangeType.Insert,
+                index,
+                text,
+            },
+        ]);
+        tree.write(path, newContents);
+    }
+}
+exports.insertImport = insertImport;

package/src/utils/insert-statement-after-imports.d.ts

@@ -0,0 +1,5 @@
+import { Tree } from '@nx/devkit';
+/**
+ * Insert a statement after the last import statement in a file
+ */
+export declare function insertStatementAfterImports(tree: Tree, path: string, statement: string): void;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertStatementAfterImports = void 0;
+const devkit_1 = require("@nx/devkit");
+const typescript_1 = require("typescript");
+/**
+ * Insert a statement after the last import statement in a file
+ */
+function insertStatementAfterImports(tree, path, statement) {
+    const contents = tree.read(path, 'utf-8');
+    const sourceFile = (0, typescript_1.createSourceFile)(path, contents, typescript_1.ScriptTarget.ESNext);
+    const importStatements = sourceFile.statements.filter(typescript_1.isImportDeclaration);
+    const index = importStatements.length > 0
+        ? importStatements[importStatements.length - 1].getEnd()
+        : 0;
+    if (importStatements.length > 0) {
+        statement = `\n${statement}`;
+    }
+    const newContents = (0, devkit_1.applyChangesToString)(contents, [
+        {
+            type: devkit_1.ChangeType.Insert,
+            index,
+            text: statement,
+        },
+    ]);
+    tree.write(path, newContents);
+}
+exports.insertStatementAfterImports = insertStatementAfterImports;

package/src/utils/insert-statement-in-default-function.d.ts

@@ -0,0 +1,2 @@
+import { Tree } from '@nx/devkit';
+export declare function insertStatementInDefaultFunction(tree: Tree, path: string, statement: any): void;

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insertStatementInDefaultFunction = void 0;
+const devkit_1 = require("@nx/devkit");
+const get_default_export_1 = require("./get-default-export");
+function insertStatementInDefaultFunction(tree, path, statement) {
+    const defaultExport = (0, get_default_export_1.getDefaultExport)(tree, path);
+    if (!defaultExport) {
+        throw Error('No default export found!');
+    }
+    const index = defaultExport.body.statements.length > 0
+        ? defaultExport.body.statements[0].pos
+        : 0;
+    const newContents = (0, devkit_1.applyChangesToString)(tree.read(path, 'utf-8'), [
+        {
+            type: devkit_1.ChangeType.Insert,
+            index,
+            text: statement,
+        },
+    ]);
+    tree.write(path, newContents);
+}
+exports.insertStatementInDefaultFunction = insertStatementInDefaultFunction;

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

@@ -0,0 +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 getRemixConfigPathFromProjectRoot(tree: Tree, projectRoot: string): string;
+export declare function getRemixConfigValues(tree: Tree, projectName: string): Promise<AppConfig>;

package/src/utils/remix-config.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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}`);
+    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 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.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.getRemixConfigValues = getRemixConfigValues;

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

@@ -0,0 +1,13 @@
+import { Tree } from '@nx/devkit';
+/**
+ *
+ * @param tree
+ * @param path to the route which could be fully specified or just "foo/bar"
+ * @param projectName the name of the project where the route should be added
+ * @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): Promise<string>;
+export declare function normalizeRoutePath(path: string): string;
+export declare function checkRoutePathForErrors(path: string): RegExpMatchArray;
+export declare function resolveRemixAppDirectory(tree: Tree, projectName: string): Promise<string>;

package/src/utils/remix-route-utils.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRemixAppDirectory = exports.checkRoutePathForErrors = exports.normalizeRoutePath = exports.resolveRemixRouteFile = void 0;
+const devkit_1 = require("@nx/devkit");
+const remix_config_1 = require("./remix-config");
+/**
+ *
+ * @param tree
+ * @param path to the route which could be fully specified or just "foo/bar"
+ * @param projectName the name of the project where the route should be added
+ * @param fileExtension the file extension to add to resolved route file
+ * @returns file path to the route
+ */
+async function resolveRemixRouteFile(tree, path, projectName, fileExtension) {
+    const { name: routePath } = (0, devkit_1.names)(path.replace(/^\//, '').replace(/\/$/, ''));
+    if (!projectName) {
+        return appendRouteFileExtension(tree, routePath, fileExtension);
+    }
+    else {
+        const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+        if (!project)
+            throw new Error(`Project does not exist: ${projectName}`);
+        const normalizedRoutePath = normalizeRoutePath(routePath);
+        const fileName = appendRouteFileExtension(tree, normalizedRoutePath, fileExtension);
+        return (0, devkit_1.joinPathFragments)(await resolveRemixAppDirectory(tree, projectName), 'routes', fileName);
+    }
+}
+exports.resolveRemixRouteFile = resolveRemixRouteFile;
+function appendRouteFileExtension(tree, routePath, fileExtension) {
+    // if no file extension specified, let's try to find it
+    if (!fileExtension) {
+        // see if the path already has it
+        const extensionMatch = routePath.match(/(\.[^.]+)$/);
+        if (extensionMatch) {
+            fileExtension = extensionMatch[0];
+        }
+        else {
+            // look for either .ts or .tsx to exist in tree
+            if (tree.exists(`${routePath}.ts`)) {
+                fileExtension = '.ts';
+            }
+            else {
+                // default to .tsx if nothing else found
+                fileExtension = '.tsx';
+            }
+        }
+    }
+    return routePath.endsWith(fileExtension)
+        ? routePath
+        : `${routePath}${fileExtension}`;
+}
+function normalizeRoutePath(path) {
+    return path.indexOf('/routes/') > -1
+        ? path.substring(path.indexOf('/routes/') + 8)
+        : path;
+}
+exports.normalizeRoutePath = normalizeRoutePath;
+function checkRoutePathForErrors(path) {
+    return (path.match(/\w\.\.\w/) || // route.$withParams.tsx => route..tsx
+        path.match(/\w\/\/\w/) || // route/$withParams/index.tsx => route//index.tsx
+        path.match(/\w\/\.\w/) // route/$withParams.tsx => route/.tsx
+    );
+}
+exports.checkRoutePathForErrors = checkRoutePathForErrors;
+async function resolveRemixAppDirectory(tree, projectName) {
+    const project = (0, devkit_1.readProjectConfiguration)(tree, projectName);
+    const remixConfig = await (0, remix_config_1.getRemixConfigValues)(tree, projectName);
+    return (0, devkit_1.joinPathFragments)(project.root, remixConfig.appDirectory ?? 'app');
+}
+exports.resolveRemixAppDirectory = resolveRemixAppDirectory;

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

@@ -0,0 +1,4 @@
+import { type Tree } from '@nx/devkit';
+export declare function updateVitestTestSetup(tree: Tree, pathToVitestConfig: string, pathToTestSetup: string): void;
+export declare function updateJestTestSetup(tree: Tree, pathToJestConfig: string, pathToTestSetup: string): void;
+export declare function updateVitestTestIncludes(tree: Tree, pathToVitestConfig: string, includesString: string): void;

package/src/utils/testing-config-utils.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateVitestTestIncludes = exports.updateJestTestSetup = exports.updateVitestTestSetup = void 0;
+const devkit_1 = require("@nx/devkit");
+const ensure_typescript_1 = require("@nx/js/src/utils/typescript/ensure-typescript");
+let tsModule;
+function updateVitestTestSetup(tree, pathToVitestConfig, pathToTestSetup) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const fileContents = tree.read(pathToVitestConfig, 'utf-8');
+    const ast = tsquery.ast(fileContents);
+    const TEST_SETUPFILES_SELECTOR = 'PropertyAssignment:has(Identifier[name=test]) PropertyAssignment:has(Identifier[name=setupFiles])';
+    const nodes = tsquery(ast, TEST_SETUPFILES_SELECTOR, {
+        visitAllChildren: true,
+    });
+    let updatedFileContents = fileContents;
+    if (nodes.length === 0) {
+        const TEST_CONFIG_SELECTOR = 'PropertyAssignment:has(Identifier[name=test]) > ObjectLiteralExpression';
+        const testConfigNodes = tsquery(ast, TEST_CONFIG_SELECTOR, {
+            visitAllChildren: true,
+        });
+        updatedFileContents = (0, devkit_1.stripIndents) `${fileContents.slice(0, testConfigNodes[0].getStart() + 1)}setupFiles: ['${pathToTestSetup}'],${fileContents.slice(testConfigNodes[0].getStart() + 1)}`;
+    }
+    else {
+        const arrayNodes = tsquery(nodes[0], 'ArrayLiteralExpression', {
+            visitAllChildren: true,
+        });
+        if (arrayNodes.length !== 0) {
+            updatedFileContents = (0, devkit_1.stripIndents) `${fileContents.slice(0, arrayNodes[0].getStart() + 1)}'${pathToTestSetup}',${fileContents.slice(arrayNodes[0].getStart() + 1)}`;
+        }
+    }
+    tree.write(pathToVitestConfig, updatedFileContents);
+}
+exports.updateVitestTestSetup = updateVitestTestSetup;
+function updateJestTestSetup(tree, pathToJestConfig, pathToTestSetup) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const fileContents = tree.read(pathToJestConfig, 'utf-8');
+    const ast = tsquery.ast(fileContents);
+    const TEST_SETUPFILES_SELECTOR = 'PropertyAssignment:has(Identifier[name=setupFilesAfterEnv])';
+    const nodes = tsquery(ast, TEST_SETUPFILES_SELECTOR, {
+        visitAllChildren: true,
+    });
+    if (nodes.length === 0) {
+        const CONFIG_SELECTOR = 'ObjectLiteralExpression';
+        const nodes = tsquery(ast, CONFIG_SELECTOR, { visitAllChildren: true });
+        const updatedFileContents = (0, devkit_1.stripIndents) `${fileContents.slice(0, nodes[0].getStart() + 1)}setupFilesAfterEnv: ['${pathToTestSetup}'],${fileContents.slice(nodes[0].getStart() + 1)}`;
+        tree.write(pathToJestConfig, updatedFileContents);
+    }
+    else {
+        const arrayNodes = tsquery(nodes[0], 'ArrayLiteralExpression', {
+            visitAllChildren: true,
+        });
+        if (arrayNodes.length !== 0) {
+            const updatedFileContents = (0, devkit_1.stripIndents) `${fileContents.slice(0, arrayNodes[0].getStart() + 1)}'${pathToTestSetup}',${fileContents.slice(arrayNodes[0].getStart() + 1)}`;
+            tree.write(pathToJestConfig, updatedFileContents);
+        }
+    }
+}
+exports.updateJestTestSetup = updateJestTestSetup;
+function updateVitestTestIncludes(tree, pathToVitestConfig, includesString) {
+    if (!tsModule) {
+        tsModule = (0, ensure_typescript_1.ensureTypescript)();
+    }
+    const { tsquery } = require('@phenomnomnominal/tsquery');
+    const fileContents = tree.read(pathToVitestConfig, 'utf-8');
+    const ast = tsquery.ast(fileContents);
+    const TEST_INCLUDE_SELECTOR = 'PropertyAssignment:has(Identifier[name=test]) PropertyAssignment:has(Identifier[name=include])';
+    const nodes = tsquery(ast, TEST_INCLUDE_SELECTOR, { visitAllChildren: true });
+    if (nodes.length !== 0) {
+        const updatedFileContents = (0, devkit_1.stripIndents) `${fileContents.slice(0, nodes[0].getStart())}include: ["${includesString}"]${fileContents.slice(nodes[0].getEnd())}`;
+        tree.write(pathToVitestConfig, updatedFileContents);
+    }
+}
+exports.updateVitestTestIncludes = updateVitestTestIncludes;

package/src/utils/upsert-links-function.d.ts

@@ -0,0 +1,2 @@
+import { type Tree } from '@nx/devkit';
+export declare function upsertLinksFunction(tree: Tree, filePath: string, importName: string, importPath: string, linkObject: string): void;

package/src/utils/upsert-links-function.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertLinksFunction = void 0;
+const devkit_1 = require("@nx/devkit");
+const tsquery_1 = require("@phenomnomnominal/tsquery");
+const insert_import_1 = require("./insert-import");
+const insert_statement_after_imports_1 = require("./insert-statement-after-imports");
+function upsertLinksFunction(tree, filePath, importName, importPath, linkObject) {
+    (0, insert_import_1.insertImport)(tree, filePath, 'LinksFunction', '@remix-run/node', {
+        typeOnly: true,
+    });
+    (0, insert_statement_after_imports_1.insertStatementAfterImports)(tree, filePath, (0, devkit_1.stripIndents) `import ${importName} from "${importPath}";`);
+    const fileContents = tree.read(filePath, 'utf-8');
+    const LINKS_FUNCTION_SELECTOR = 'VariableDeclaration:has(TypeReference > Identifier[name=LinksFunction])';
+    const ast = tsquery_1.tsquery.ast(fileContents);
+    const linksFunctionNodes = (0, tsquery_1.tsquery)(ast, LINKS_FUNCTION_SELECTOR, {
+        visitAllChildren: true,
+    });
+    if (linksFunctionNodes.length === 0) {
+        (0, insert_statement_after_imports_1.insertStatementAfterImports)(tree, filePath, (0, devkit_1.stripIndents) `export const links: LinksFunction = () => [
+  ${linkObject},
+];`);
+    }
+    else {
+        const linksArrayNodes = (0, tsquery_1.tsquery)(linksFunctionNodes[0], 'ArrayLiteralExpression', { visitAllChildren: true });
+        const arrayNode = linksArrayNodes[0];
+        const updatedFileContents = `${fileContents.slice(0, arrayNode.getStart() + 1)}\n${linkObject},${fileContents.slice(arrayNode.getStart() + 1)}`;
+        tree.write(filePath, updatedFileContents);
+    }
+}
+exports.upsertLinksFunction = upsertLinksFunction;

package/src/utils/versions.d.ts

@@ -0,0 +1,16 @@
+import { Tree } from '@nx/devkit';
+export declare const nxVersion: any;
+export declare const remixVersion = "^2.6.0";
+export declare const isbotVersion = "^4.4.0";
+export declare const reactVersion = "^18.2.0";
+export declare const reactDomVersion = "^18.2.0";
+export declare const typesReactVersion = "^18.2.0";
+export declare const typesReactDomVersion = "^18.2.0";
+export declare const eslintVersion = "^8.56.0";
+export declare const typescriptVersion = "^5.3.3";
+export declare const tailwindVersion = "^3.3.0";
+export declare const testingLibraryReactVersion = "^14.1.2";
+export declare const testingLibraryJestDomVersion = "^6.2.0";
+export declare const testingLibraryUserEventsVersion = "^14.5.2";
+export declare function getRemixVersion(tree: Tree): string;
+export declare function getPackageVersion(tree: Tree, packageName: string): any;

package/src/utils/versions.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageVersion = exports.getRemixVersion = exports.testingLibraryUserEventsVersion = exports.testingLibraryJestDomVersion = exports.testingLibraryReactVersion = exports.tailwindVersion = exports.typescriptVersion = exports.eslintVersion = exports.typesReactDomVersion = exports.typesReactVersion = exports.reactDomVersion = exports.reactVersion = exports.isbotVersion = exports.remixVersion = exports.nxVersion = void 0;
+const devkit_1 = require("@nx/devkit");
+exports.nxVersion = require('../../package.json').version;
+exports.remixVersion = '^2.6.0';
+exports.isbotVersion = '^4.4.0';
+exports.reactVersion = '^18.2.0';
+exports.reactDomVersion = '^18.2.0';
+exports.typesReactVersion = '^18.2.0';
+exports.typesReactDomVersion = '^18.2.0';
+exports.eslintVersion = '^8.56.0';
+exports.typescriptVersion = '^5.3.3';
+exports.tailwindVersion = '^3.3.0';
+exports.testingLibraryReactVersion = '^14.1.2';
+exports.testingLibraryJestDomVersion = '^6.2.0';
+exports.testingLibraryUserEventsVersion = '^14.5.2';
+function getRemixVersion(tree) {
+    return getPackageVersion(tree, '@remix-run/dev') ?? exports.remixVersion;
+}
+exports.getRemixVersion = getRemixVersion;
+function getPackageVersion(tree, packageName) {
+    const packageJsonContents = (0, devkit_1.readJson)(tree, 'package.json');
+    return (packageJsonContents?.['devDependencies']?.[packageName] ??
+        packageJsonContents?.['dependencies']?.[packageName] ??
+        null);
+}
+exports.getPackageVersion = getPackageVersion;