@remix-run/cli 0.0.0 → 0.1.0

package/dist/lib/controller-ownership.js

@@ -0,0 +1,224 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { getActionOwnerCandidates, getControllerOwnerCandidates, getOwnerModuleBaseName, getPreferredOwnerDisplayPath, getRouteSubtreePath, isActionFileName, isControllerEntryFileName, toDiskSegment, } from "./controller-files.js";
+export async function inspectControllerOwnership(appRoot, tree) {
+    let subtreePlans = buildOwnedSubtrees(tree);
+    let scan = await scanControllersDirectory(appRoot);
+    let subtrees = applyScanToSubtrees(subtreePlans, scan);
+    return {
+        orphanActionPaths: getOrphanActionPaths(subtreePlans, scan),
+        orphanControllerPaths: getOrphanControllerPaths(subtreePlans, scan),
+        orphanRouteDirectoryPaths: getOrphanRouteDirectoryPaths(subtreePlans, scan),
+        scan,
+        subtrees,
+    };
+}
+export function buildOwnedSubtrees(tree, parentSegments = [], subtrees = []) {
+    for (let node of tree) {
+        let segments = [...parentSegments, toDiskSegment(node.key)];
+        if (node.kind === 'group') {
+            let alternateCandidates = getActionOwnerCandidates(segments);
+            let entryCandidates = getControllerOwnerCandidates(segments);
+            subtrees.push({
+                alternateCandidates,
+                alternateDisplayPath: getPreferredOwnerDisplayPath(alternateCandidates),
+                entryCandidates,
+                entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
+                kind: 'controller',
+                routeName: node.name,
+                subtreePath: getRouteSubtreePath(segments),
+            });
+            buildOwnedSubtrees(node.children, segments, subtrees);
+            continue;
+        }
+        if (parentSegments.length > 0) {
+            continue;
+        }
+        let alternateCandidates = getControllerOwnerCandidates(segments);
+        let entryCandidates = getActionOwnerCandidates(segments);
+        subtrees.push({
+            alternateCandidates,
+            alternateDisplayPath: getPreferredOwnerDisplayPath(alternateCandidates),
+            entryCandidates,
+            entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
+            kind: 'action',
+            routeName: node.name,
+            subtreePath: getRouteSubtreePath(segments),
+        });
+    }
+    return subtrees;
+}
+async function scanControllersDirectory(appRoot) {
+    let controllersDir = path.join(appRoot, 'app', 'controllers');
+    let controllerEntryPaths = new Set();
+    let actionEntryPaths = new Set();
+    let rootDirectoryPaths = new Set();
+    let routeLocalFilePaths = new Set();
+    async function walk(currentDir, isRoot) {
+        let entries;
+        try {
+            entries = await fs.readdir(currentDir, { withFileTypes: true });
+        }
+        catch (error) {
+            let nodeError = error;
+            if (nodeError.code === 'ENOENT' && isRoot) {
+                return;
+            }
+            throw error;
+        }
+        for (let entry of entries) {
+            let entryPath = path.join(currentDir, entry.name);
+            let relativePath = normalizeRelativePath(path.relative(appRoot, entryPath));
+            if (entry.isDirectory()) {
+                if (isRoot) {
+                    rootDirectoryPaths.add(relativePath);
+                }
+                await walk(entryPath, false);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            if (isControllerEntryFileName(entry.name)) {
+                controllerEntryPaths.add(relativePath);
+                continue;
+            }
+            if (isRoot && isActionCandidate(entry.name)) {
+                actionEntryPaths.add(relativePath);
+                continue;
+            }
+            if (!isRoot && isRouteLocalFileName(entry.name)) {
+                routeLocalFilePaths.add(relativePath);
+            }
+        }
+    }
+    await walk(controllersDir, true);
+    return {
+        actionEntryPaths,
+        controllerEntryPaths,
+        rootDirectoryPaths,
+        routeLocalFilePaths,
+    };
+}
+function applyScanToSubtrees(subtreePlans, scan) {
+    let claimedRouteLocalPaths = claimFilesToDeepestSubtree([...scan.routeLocalFilePaths], subtreePlans);
+    let claimedContentPaths = claimFilesToDeepestSubtree(getNestedContentPaths(scan), subtreePlans);
+    return subtreePlans.map((subtree) => {
+        let actualAlternatePaths = findOwnerPaths(scan, invertOwnerKind(subtree.kind), subtree.alternateCandidates);
+        let actualEntryPaths = findOwnerPaths(scan, subtree.kind, subtree.entryCandidates);
+        return {
+            ...subtree,
+            actualAlternatePath: actualAlternatePaths[0] ?? null,
+            actualAlternatePaths,
+            actualEntryPath: actualEntryPaths[0] ?? null,
+            actualEntryPaths,
+            claimedFilePaths: claimedContentPaths.get(subtree.routeName) ?? [],
+            claimedRouteLocalFilePaths: claimedRouteLocalPaths.get(subtree.routeName) ?? [],
+        };
+    });
+}
+function getNestedContentPaths(scan) {
+    let nestedControllerPaths = [...scan.controllerEntryPaths].filter((filePath) => isNestedControllerPath(filePath));
+    return [...new Set([...nestedControllerPaths, ...scan.routeLocalFilePaths])].sort();
+}
+function claimFilesToDeepestSubtree(filePaths, subtreePlans) {
+    let subtreesByDepth = [...subtreePlans].sort((left, right) => {
+        if (right.subtreePath.length !== left.subtreePath.length) {
+            return right.subtreePath.length - left.subtreePath.length;
+        }
+        return left.routeName.localeCompare(right.routeName);
+    });
+    let claims = new Map();
+    for (let filePath of filePaths.sort()) {
+        let matchingSubtree = subtreesByDepth.find((subtree) => isWithinDirectory(filePath, subtree.subtreePath));
+        if (matchingSubtree == null) {
+            continue;
+        }
+        let claimedPaths = claims.get(matchingSubtree.routeName);
+        if (claimedPaths == null) {
+            claims.set(matchingSubtree.routeName, [filePath]);
+            continue;
+        }
+        claimedPaths.push(filePath);
+    }
+    return claims;
+}
+function getOrphanActionPaths(subtreePlans, scan) {
+    let expectedActionPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'action')
+        .flatMap((subtree) => subtree.entryCandidates));
+    let alternateActionPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'controller')
+        .flatMap((subtree) => subtree.alternateCandidates));
+    return [...scan.actionEntryPaths]
+        .filter((filePath) => !expectedActionPaths.has(filePath))
+        .filter((filePath) => !alternateActionPaths.has(filePath))
+        .sort();
+}
+function getOrphanControllerPaths(subtreePlans, scan) {
+    let expectedControllerPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'controller')
+        .flatMap((subtree) => subtree.entryCandidates));
+    let alternateControllerPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'action')
+        .flatMap((subtree) => subtree.alternateCandidates));
+    return [...scan.controllerEntryPaths]
+        .filter((filePath) => !expectedControllerPaths.has(filePath))
+        .filter((filePath) => !alternateControllerPaths.has(filePath))
+        .sort();
+}
+function getOrphanRouteDirectoryPaths(subtreePlans, scan) {
+    let expectedRootDirectories = new Set(subtreePlans.map((subtree) => getTopLevelSubtreePath(subtree.subtreePath)));
+    let actualControllerDirectories = [...scan.controllerEntryPaths].map((controllerPath) => normalizeRelativePath(path.dirname(controllerPath)));
+    return [...scan.rootDirectoryPaths]
+        .filter((directoryPath) => !expectedRootDirectories.has(directoryPath))
+        .filter((directoryPath) => !actualControllerDirectories.some((controllerPath) => isDirectoryWithinDirectory(controllerPath, directoryPath)))
+        .sort();
+}
+function hasOwnerPath(scan, kind, filePath) {
+    return kind === 'action'
+        ? scan.actionEntryPaths.has(filePath)
+        : scan.controllerEntryPaths.has(filePath);
+}
+function invertOwnerKind(kind) {
+    return kind === 'action' ? 'controller' : 'action';
+}
+function isActionCandidate(fileName) {
+    return isActionFileName(fileName);
+}
+function isRouteLocalFileName(fileName) {
+    let baseName = getOwnerModuleBaseName(fileName);
+    return (baseName != null &&
+        baseName !== 'controller' &&
+        !baseName.endsWith('.test') &&
+        !baseName.endsWith('.spec'));
+}
+function findOwnerPath(scan, kind, candidatePaths) {
+    return findOwnerPaths(scan, kind, candidatePaths)[0] ?? null;
+}
+function findOwnerPaths(scan, kind, candidatePaths) {
+    let existingPaths = [];
+    for (let candidatePath of candidatePaths) {
+        if (hasOwnerPath(scan, kind, candidatePath)) {
+            existingPaths.push(candidatePath);
+        }
+    }
+    return existingPaths;
+}
+function isNestedControllerPath(filePath) {
+    return (filePath.startsWith('app/controllers/') &&
+        filePath.slice('app/controllers/'.length).includes('/'));
+}
+function isWithinDirectory(filePath, directoryPath) {
+    return filePath.startsWith(`${directoryPath}/`);
+}
+function isDirectoryWithinDirectory(directoryPath, parentDirectoryPath) {
+    return (directoryPath === parentDirectoryPath || isWithinDirectory(directoryPath, parentDirectoryPath));
+}
+function getTopLevelSubtreePath(subtreePath) {
+    let subtreeSegments = subtreePath.slice('app/controllers/'.length).split('/');
+    return getRouteSubtreePath([subtreeSegments[0]]);
+}
+function normalizeRelativePath(filePath) {
+    return filePath.split(path.sep).join('/');
+}

package/dist/lib/display-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getDisplayPath(filePath: string, cwd?: string): string;
+//# sourceMappingURL=display-path.d.ts.map

package/dist/lib/display-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-path.d.ts","sourceRoot":"","sources":["../../src/lib/display-path.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,MAAsB,GAAG,MAAM,CAYpF"}

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"}