@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/display-path.js

@@ -0,0 +1,12 @@
+import * as path from 'node:path';
+import * as process from 'node:process';
+export function getDisplayPath(filePath, cwd = process.cwd()) {
+    let relativePath = path.relative(path.resolve(cwd), path.resolve(filePath));
+    if (relativePath.length === 0) {
+        return '.';
+    }
+    if (path.isAbsolute(relativePath)) {
+        return filePath;
+    }
+    return relativePath;
+}

package/dist/lib/doctor/controller-findings.d.ts

@@ -0,0 +1,4 @@
+import type { ControllerOwnership } from '../controller-ownership.ts';
+import type { DoctorFinding, DoctorFixPlan } from './types.ts';
+export declare function getControllerFindings(ownership: ControllerOwnership, fixPlans: DoctorFixPlan[]): DoctorFinding[];
+//# sourceMappingURL=controller-findings.d.ts.map

package/dist/lib/doctor/controller-findings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-findings.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-findings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAgB,MAAM,4BAA4B,CAAA;AACnF,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAE9D,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,mBAAmB,EAC9B,QAAQ,EAAE,aAAa,EAAE,GACxB,aAAa,EAAE,CAyBjB"}

package/dist/lib/doctor/controller-findings.js

@@ -0,0 +1,132 @@
+export function getControllerFindings(ownership, fixPlans) {
+    return [
+        ...getSubtreeFindings(ownership.subtrees, fixPlans),
+        ...ownership.orphanActionPaths.map((actualPath) => ({
+            actualPath,
+            code: 'orphan-action',
+            message: `Standalone action ${actualPath} does not match any top-level route.`,
+            severity: 'warn',
+            suite: 'controllers',
+        })),
+        ...ownership.orphanControllerPaths.map((actualPath) => ({
+            actualPath,
+            code: 'orphan-controller',
+            message: `Controller ${actualPath} does not match any route group.`,
+            severity: 'warn',
+            suite: 'controllers',
+        })),
+        ...ownership.orphanRouteDirectoryPaths.map((actualPath) => ({
+            actualPath,
+            code: 'orphan-route-directory',
+            message: `Directory ${actualPath} does not match any route subtree.`,
+            severity: 'warn',
+            suite: 'controllers',
+        })),
+    ];
+}
+function getSubtreeFindings(subtrees, fixPlans) {
+    let findings = [];
+    let fixableFindingKeys = new Set(fixPlans.map((fixPlan) => `${fixPlan.code}:${fixPlan.routeName ?? ''}`));
+    for (let subtree of subtrees) {
+        let actualEntryPath = subtree.actualEntryPath ?? undefined;
+        let actualAlternatePath = subtree.actualAlternatePath ?? undefined;
+        if (subtree.actualEntryPaths.length > 1) {
+            findings.push({
+                actualPath: subtree.actualEntryPaths[0],
+                code: 'duplicate-owner-file',
+                expectedPath: subtree.entryDisplayPath,
+                message: `Route "${subtree.routeName}" has multiple ${subtree.kind} files: ${subtree.actualEntryPaths.join(', ')}. Keep only one ${subtree.kind} owner file.`,
+                routeName: subtree.routeName,
+                severity: 'warn',
+                suite: 'controllers',
+            });
+            continue;
+        }
+        if (subtree.actualAlternatePaths.length > 1) {
+            let alternateKind = subtree.kind === 'action' ? 'controller' : 'action';
+            findings.push({
+                actualPath: subtree.actualAlternatePaths[0],
+                code: 'duplicate-owner-file',
+                expectedPath: subtree.entryDisplayPath,
+                message: `Route "${subtree.routeName}" has multiple ${alternateKind} files: ${subtree.actualAlternatePaths.join(', ')}. Keep only one ${alternateKind} owner file.`,
+                routeName: subtree.routeName,
+                severity: 'warn',
+                suite: 'controllers',
+            });
+            continue;
+        }
+        if (actualEntryPath != null && actualAlternatePath != null) {
+            findings.push({
+                actualPath: actualAlternatePath,
+                code: 'ambiguous-owner',
+                expectedPath: actualEntryPath,
+                message: subtree.kind === 'action'
+                    ? `Route "${subtree.routeName}" has both action ${actualEntryPath} and controller ${actualAlternatePath}.`
+                    : `Route "${subtree.routeName}" has both controller ${actualEntryPath} and standalone action ${actualAlternatePath}.`,
+                routeName: subtree.routeName,
+                severity: 'warn',
+                suite: 'controllers',
+            });
+            continue;
+        }
+        if (actualAlternatePath != null) {
+            findings.push({
+                actualPath: actualAlternatePath,
+                code: 'wrong-owner-kind',
+                expectedPath: subtree.entryDisplayPath,
+                message: subtree.kind === 'action'
+                    ? `Route "${subtree.routeName}" expects action ${subtree.entryDisplayPath}, but found controller ${actualAlternatePath}.`
+                    : `Route "${subtree.routeName}" expects controller ${subtree.entryDisplayPath}, but found standalone action ${actualAlternatePath}.`,
+                fixable: fixableFindingKeys.has(`wrong-owner-kind:${subtree.routeName}`),
+                routeName: subtree.routeName,
+                severity: 'warn',
+                suite: 'controllers',
+            });
+            continue;
+        }
+        if (subtree.kind === 'controller' && subtree.actualEntryPath == null) {
+            let code = subtree.claimedFilePaths.length > 0
+                ? 'incomplete-controller'
+                : 'missing-owner';
+            findings.push({
+                actualPath: subtree.claimedFilePaths.length > 0 ? subtree.subtreePath : undefined,
+                code,
+                expectedPath: subtree.entryDisplayPath,
+                fixable: fixableFindingKeys.has(`${code}:${subtree.routeName}`),
+                message: subtree.claimedFilePaths.length > 0
+                    ? `Route "${subtree.routeName}" has files under ${subtree.subtreePath}, but is missing controller ${subtree.entryDisplayPath}.`
+                    : `Route "${subtree.routeName}" is missing controller ${subtree.entryDisplayPath}.`,
+                routeName: subtree.routeName,
+                severity: 'warn',
+                suite: 'controllers',
+            });
+            continue;
+        }
+        if (subtree.kind === 'action' && subtree.claimedFilePaths.length > 0) {
+            findings.push({
+                actualPath: subtree.subtreePath,
+                code: 'promotion-drift',
+                expectedPath: actualEntryPath ?? subtree.entryDisplayPath,
+                message: actualEntryPath == null
+                    ? `Route "${subtree.routeName}" has files under ${subtree.subtreePath}, but is still expected to use action ${subtree.entryDisplayPath}. Promote it to controller ${subtree.alternateDisplayPath} or move the files back into ${subtree.entryDisplayPath}.`
+                    : `Route "${subtree.routeName}" uses action ${actualEntryPath}, but also has files under ${subtree.subtreePath}. Promote it to controller ${subtree.alternateDisplayPath} or keep the route in ${actualEntryPath}.`,
+                routeName: subtree.routeName,
+                severity: 'warn',
+                suite: 'controllers',
+            });
+            continue;
+        }
+        if (subtree.actualEntryPath == null) {
+            findings.push({
+                code: 'missing-owner',
+                expectedPath: subtree.entryDisplayPath,
+                fixable: fixableFindingKeys.has(`missing-owner:${subtree.routeName}`),
+                message: `Route "${subtree.routeName}" is missing action ${subtree.entryDisplayPath}.`,
+                routeName: subtree.routeName,
+                severity: 'warn',
+                suite: 'controllers',
+            });
+        }
+    }
+    return findings;
+}

package/dist/lib/doctor/controller-fix-plans.d.ts

@@ -0,0 +1,4 @@
+import type { ControllerOwnership, OwnershipRouteNode } from '../controller-ownership.ts';
+import type { DoctorFixPlan } from './types.ts';
+export declare function getControllerFixPlans(appRoot: string, tree: OwnershipRouteNode[], ownership: ControllerOwnership): Promise<DoctorFixPlan[]>;
+//# sourceMappingURL=controller-fix-plans.d.ts.map

package/dist/lib/doctor/controller-fix-plans.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-fix-plans.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-fix-plans.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EACV,mBAAmB,EAEnB,kBAAkB,EACnB,MAAM,4BAA4B,CAAA;AAEnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,YAAY,CAAA;AAI/C,wBAAsB,qBAAqB,CACzC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,kBAAkB,EAAE,EAC1B,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,aAAa,EAAE,CAAC,CAqD1B"}

package/dist/lib/doctor/controller-fix-plans.js

@@ -0,0 +1,130 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { getOwnerCandidateForExtension, getOwnerFileExtension, } from "../controller-files.js";
+import { renderActionPlaceholder, renderControllerPlaceholder } from "./controller-placeholders.js";
+const OWNER_EXTENSION_PRIORITY = ['.tsx', '.ts', '.jsx', '.js'];
+export async function getControllerFixPlans(appRoot, tree, ownership) {
+    let routeNodesByName = getRouteNodesByName(tree);
+    let hasTsconfig = await pathExists(path.join(appRoot, 'tsconfig.json'));
+    let resolvedEntryPathByRouteName = new Map();
+    for (let subtree of ownership.subtrees) {
+        if (subtree.actualEntryPath != null) {
+            resolvedEntryPathByRouteName.set(subtree.routeName, subtree.actualEntryPath);
+            continue;
+        }
+        let fixCode = getFixCodeForSubtree(subtree);
+        if (fixCode == null) {
+            continue;
+        }
+        let extension = inferOwnerExtension(subtree, ownership, hasTsconfig);
+        let targetPath = getOwnerCandidateForExtension(subtree.entryCandidates, extension) ?? subtree.entryDisplayPath;
+        resolvedEntryPathByRouteName.set(subtree.routeName, targetPath);
+    }
+    let fixPlans = [];
+    for (let subtree of ownership.subtrees) {
+        let code = getFixCodeForSubtree(subtree);
+        if (code == null) {
+            continue;
+        }
+        let routeNode = routeNodesByName.get(subtree.routeName);
+        let entryPath = resolvedEntryPathByRouteName.get(subtree.routeName);
+        if (routeNode == null || entryPath == null) {
+            continue;
+        }
+        let contents = subtree.kind === 'action'
+            ? renderActionPlaceholder(routeNode, entryPath)
+            : renderControllerPlaceholder(routeNode, entryPath, resolvedEntryPathByRouteName);
+        fixPlans.push({
+            code,
+            contents,
+            kind: 'create-file',
+            path: entryPath,
+            routeName: subtree.routeName,
+            suite: 'controllers',
+        });
+    }
+    return fixPlans;
+}
+function getFixCodeForSubtree(subtree) {
+    if (subtree.actualEntryPaths.length > 1 || subtree.actualAlternatePaths.length > 1) {
+        return null;
+    }
+    if (subtree.actualEntryPath != null) {
+        return null;
+    }
+    if (subtree.actualAlternatePath != null) {
+        return 'wrong-owner-kind';
+    }
+    if (subtree.kind === 'controller') {
+        return subtree.claimedFilePaths.length > 0 ? 'incomplete-controller' : 'missing-owner';
+    }
+    if (subtree.claimedFilePaths.length > 0) {
+        return null;
+    }
+    return 'missing-owner';
+}
+function inferOwnerExtension(subtree, ownership, hasTsconfig) {
+    let subtreeExtension = getMostCommonOwnerExtension(subtree.claimedRouteLocalFilePaths);
+    if (subtreeExtension != null) {
+        return subtreeExtension;
+    }
+    let alternateExtension = getMostCommonOwnerExtension(subtree.actualAlternatePaths);
+    if (alternateExtension != null) {
+        return alternateExtension;
+    }
+    let projectExtension = getMostCommonOwnerExtension([
+        ...ownership.scan.actionEntryPaths,
+        ...ownership.scan.controllerEntryPaths,
+    ]);
+    if (projectExtension != null) {
+        return projectExtension;
+    }
+    return hasTsconfig ? '.tsx' : '.js';
+}
+function getMostCommonOwnerExtension(filePaths) {
+    let counts = new Map();
+    for (let filePath of filePaths) {
+        let extension = getOwnerFileExtension(filePath);
+        if (extension == null) {
+            continue;
+        }
+        counts.set(extension, (counts.get(extension) ?? 0) + 1);
+    }
+    if (counts.size === 0) {
+        return null;
+    }
+    let bestExtension = null;
+    let bestCount = -1;
+    for (let extension of OWNER_EXTENSION_PRIORITY) {
+        let count = counts.get(extension) ?? 0;
+        if (count > bestCount) {
+            bestCount = count;
+            bestExtension = extension;
+        }
+    }
+    return bestExtension;
+}
+function getRouteNodesByName(tree) {
+    let routeNodesByName = new Map();
+    function visit(nodes) {
+        for (let node of nodes) {
+            routeNodesByName.set(node.name, node);
+            visit(node.children);
+        }
+    }
+    visit(tree);
+    return routeNodesByName;
+}
+async function pathExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch (error) {
+        let nodeError = error;
+        if (nodeError.code === 'ENOENT') {
+            return false;
+        }
+        throw error;
+    }
+}

package/dist/lib/doctor/controller-placeholders.d.ts

@@ -0,0 +1,4 @@
+import type { OwnershipRouteNode } from '../controller-ownership.ts';
+export declare function renderActionPlaceholder(routeNode: OwnershipRouteNode, entryPath: string): string;
+export declare function renderControllerPlaceholder(routeNode: OwnershipRouteNode, entryPath: string, resolvedEntryPathByRouteName: Map<string, string>): string;
+//# sourceMappingURL=controller-placeholders.d.ts.map

package/dist/lib/doctor/controller-placeholders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-placeholders.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controller-placeholders.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAmDpE,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,kBAAkB,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAgChG;AAED,wBAAgB,2BAA2B,CACzC,SAAS,EAAE,kBAAkB,EAC7B,SAAS,EAAE,MAAM,EACjB,4BAA4B,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAChD,MAAM,CAkCR"}

package/dist/lib/doctor/controller-placeholders.js

@@ -0,0 +1,183 @@
+import * as path from 'node:path';
+import { getOwnerFileExtension } from "../controller-files.js";
+const RESERVED_BINDING_IDENTIFIERS = new Set([
+    'await',
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'interface',
+    'let',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'static',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'yield',
+]);
+export function renderActionPlaceholder(routeNode, entryPath) {
+    let routeMessage = `TODO: implement routes.${routeNode.name}`;
+    let extension = getOwnerFileExtension(entryPath);
+    let exportName = getActionExportName(routeNode.key);
+    if (extension === '.js' || extension === '.jsx') {
+        return [
+            `export const ${exportName} = {`,
+            `  handler() {`,
+            `    return new Response(${JSON.stringify(routeMessage)})`,
+            `  },`,
+            `}`,
+            '',
+        ].join('\n');
+    }
+    let routeExpression = getRouteAccessExpression(routeNode.name);
+    let routesImportPath = getRelativeImportPath(entryPath, 'app/routes.ts');
+    let method = routeNode.method ?? 'ANY';
+    return [
+        `import type { BuildAction } from 'remix/fetch-router'`,
+        '',
+        `import type { routes } from '${routesImportPath}'`,
+        '',
+        `export const ${exportName}: BuildAction<'${method}', typeof ${routeExpression}> = {`,
+        `  handler() {`,
+        `    return new Response(${JSON.stringify(routeMessage)})`,
+        `  },`,
+        `}`,
+        '',
+    ].join('\n');
+}
+export function renderControllerPlaceholder(routeNode, entryPath, resolvedEntryPathByRouteName) {
+    let extension = getOwnerFileExtension(entryPath);
+    let lines = [];
+    let childImports = getControllerChildImports(routeNode, entryPath, resolvedEntryPathByRouteName);
+    let actionEntries = routeNode.children.map((childNode) => renderControllerActionEntry(childNode, entryPath, resolvedEntryPathByRouteName));
+    if (extension === '.js' || extension === '.jsx') {
+        if (childImports.length > 0) {
+            lines.push(...childImports, '');
+        }
+        lines.push('export default {', '  actions: {');
+        lines.push(...actionEntries);
+        lines.push('  },', '}', '');
+        return lines.join('\n');
+    }
+    let routeExpression = getRouteAccessExpression(routeNode.name);
+    let routesImportPath = getRelativeImportPath(entryPath, 'app/routes.ts');
+    lines.push(`import type { Controller } from 'remix/fetch-router'`, '');
+    lines.push(`import type { routes } from '${routesImportPath}'`);
+    if (childImports.length > 0) {
+        lines.push('', ...childImports);
+    }
+    lines.push('', 'export default {', '  actions: {');
+    lines.push(...actionEntries);
+    lines.push('  },', `} satisfies Controller<typeof ${routeExpression}>`, '');
+    return lines.join('\n');
+}
+function getControllerChildImports(routeNode, entryPath, resolvedEntryPathByRouteName) {
+    let imports = [];
+    for (let childNode of routeNode.children) {
+        if (childNode.kind !== 'group') {
+            continue;
+        }
+        let childEntryPath = resolvedEntryPathByRouteName.get(childNode.name);
+        if (childEntryPath == null) {
+            continue;
+        }
+        imports.push(`import ${getControllerImportName(childNode.key)} from '${getRelativeImportPath(entryPath, childEntryPath)}'`);
+    }
+    return imports;
+}
+function renderControllerActionEntry(childNode, entryPath, resolvedEntryPathByRouteName) {
+    if (childNode.kind === 'route') {
+        return [
+            `    ${formatObjectKey(childNode.key)}() {`,
+            `      return new Response(${JSON.stringify(`TODO: implement routes.${childNode.name}`)})`,
+            `    },`,
+        ].join('\n');
+    }
+    let childEntryPath = resolvedEntryPathByRouteName.get(childNode.name);
+    if (childEntryPath != null) {
+        return `    ${formatObjectKey(childNode.key)}: ${getControllerImportName(childNode.key)},`;
+    }
+    return `    ${formatObjectKey(childNode.key)}: ${renderInlineControllerPlaceholder(childNode)},`;
+}
+function renderInlineControllerPlaceholder(routeNode) {
+    let childEntries = routeNode.children.map((childNode) => childNode.kind === 'route'
+        ? `${formatObjectKey(childNode.key)}() { return new Response(${JSON.stringify(`TODO: implement routes.${childNode.name}`)}) }`
+        : `${formatObjectKey(childNode.key)}: ${renderInlineControllerPlaceholder(childNode)}`);
+    return `{ actions: { ${childEntries.join(', ')} } }`;
+}
+function getControllerImportName(key) {
+    return `${toIdentifier(key)}Controller`;
+}
+function getActionExportName(key) {
+    return toIdentifier(key);
+}
+function getRouteAccessExpression(routeName) {
+    let segments = routeName.split('.');
+    let expression = 'routes';
+    for (let segment of segments) {
+        expression += isIdentifier(segment) ? `.${segment}` : `[${JSON.stringify(segment)}]`;
+    }
+    return expression;
+}
+function getRelativeImportPath(fromFilePath, toFilePath) {
+    let relativePath = path.posix.relative(path.posix.dirname(fromFilePath), toFilePath);
+    return relativePath.startsWith('.') ? relativePath : `./${relativePath}`;
+}
+function formatObjectKey(key) {
+    return isIdentifier(key) ? key : JSON.stringify(key);
+}
+function toIdentifier(value) {
+    let parts = value.split(/[^A-Za-z0-9_$]+/).filter(Boolean);
+    if (parts.length === 0) {
+        return 'route';
+    }
+    let identifier = parts
+        .map((part, index) => index === 0 ? part.replace(/^./, (char) => char.toLowerCase()) : capitalize(part))
+        .join('');
+    if (!/^[A-Za-z_$]/.test(identifier)) {
+        return `route${capitalize(identifier)}`;
+    }
+    if (RESERVED_BINDING_IDENTIFIERS.has(identifier)) {
+        return `route${capitalize(identifier)}`;
+    }
+    return identifier;
+}
+function capitalize(value) {
+    return value.length === 0 ? value : `${value[0].toUpperCase()}${value.slice(1)}`;
+}
+function isIdentifier(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value);
+}

package/dist/lib/doctor/controllers.d.ts

@@ -0,0 +1,8 @@
+import { type OwnershipRouteNode } from '../controller-ownership.ts';
+import { type DoctorFixPlan, type DoctorSuiteResult } from './types.ts';
+export interface ControllerDoctorResult {
+    fixPlans: DoctorFixPlan[];
+    suite: DoctorSuiteResult;
+}
+export declare function checkControllerConventions(appRoot: string, tree: OwnershipRouteNode[]): Promise<ControllerDoctorResult>;
+//# sourceMappingURL=controllers.d.ts.map

package/dist/lib/doctor/controllers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controllers.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/controllers.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAGhG,OAAO,EAAqB,KAAK,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAE1F,MAAM,WAAW,sBAAsB;IACrC,QAAQ,EAAE,aAAa,EAAE,CAAA;IACzB,KAAK,EAAE,iBAAiB,CAAA;CACzB;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,kBAAkB,EAAE,GACzB,OAAO,CAAC,sBAAsB,CAAC,CASjC"}

package/dist/lib/doctor/controllers.js

@@ -0,0 +1,13 @@
+import { inspectControllerOwnership } from "../controller-ownership.js";
+import { getControllerFindings } from "./controller-findings.js";
+import { getControllerFixPlans } from "./controller-fix-plans.js";
+import { createDoctorSuite } from "./types.js";
+export async function checkControllerConventions(appRoot, tree) {
+    let ownership = await inspectControllerOwnership(appRoot, tree);
+    let fixPlans = await getControllerFixPlans(appRoot, tree, ownership);
+    let findings = getControllerFindings(ownership, fixPlans);
+    return {
+        fixPlans,
+        suite: createDoctorSuite('controllers', findings),
+    };
+}

package/dist/lib/doctor/environment.d.ts

@@ -0,0 +1,17 @@
+import { type DoctorFixPlan, type DoctorSuiteResult } from './types.ts';
+interface DoctorPackageJson {
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    engines?: Record<string, string>;
+    name?: string;
+}
+export interface EnvironmentDoctorResult {
+    packageJson?: DoctorPackageJson;
+    packageJsonPath?: string;
+    projectRoot?: string;
+    suite: DoctorSuiteResult;
+}
+export declare function checkEnvironment(cwd?: string): Promise<EnvironmentDoctorResult>;
+export declare function getEnvironmentFixPlans(result: EnvironmentDoctorResult, remixVersion: string | undefined): DoctorFixPlan[];
+export {};
+//# sourceMappingURL=environment.d.ts.map

package/dist/lib/doctor/environment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"environment.d.ts","sourceRoot":"","sources":["../../../src/lib/doctor/environment.ts"],"names":[],"mappings":"AAOA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACvB,MAAM,YAAY,CAAA;AAEnB,UAAU,iBAAiB;IACzB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,MAAM,WAAW,uBAAuB;IACtC,WAAW,CAAC,EAAE,iBAAiB,CAAA;IAC/B,eAAe,CAAC,EAAE,MAAM,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,KAAK,EAAE,iBAAiB,CAAA;CACzB;AAED,wBAAsB,gBAAgB,CACpC,GAAG,GAAE,MAAsB,GAC1B,OAAO,CAAC,uBAAuB,CAAC,CAwFlC;AAED,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,YAAY,EAAE,MAAM,GAAG,SAAS,GAC/B,aAAa,EAAE,CA6CjB"}