@craft-ng/dev-tools 0.5.0-beta.4 → 0.5.1-beta.0

package/src/scripts/routes/migrate-routes.js

@@ -0,0 +1,669 @@
+import { __awaiter } from "tslib";
+import { existsSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { basename, dirname, extname, isAbsolute, join, resolve } from 'node:path';
+import { Node, Project, QuoteKind, SyntaxKind, ts, } from 'ts-morph';
+import { findAngularDecoratedClass, transformSourceFile as generateAngularDependencies, } from '../angular-brand-codemod.js';
+import { migrateEslintConfig } from '../migration-workspace.js';
+export function runRoutesMigration() {
+    return __awaiter(this, arguments, void 0, function* (options = {}) {
+        var _a, _b, _c;
+        const rootDir = resolve((_a = options.rootDir) !== null && _a !== void 0 ? _a : process.cwd());
+        const tsConfigFilePath = options.tsConfigFilePath
+            ? resolve(options.tsConfigFilePath)
+            : defaultTsConfig(rootDir);
+        const project = createProject(tsConfigFilePath);
+        project.addSourceFilesAtPaths([
+            join(rootDir, '**/*.ts'),
+            `!${join(rootDir, '**/node_modules/**')}`,
+            `!${join(rootDir, '**/dist/**')}`,
+            `!${join(rootDir, '**/.angular/**')}`,
+        ]);
+        setQuoteKind(project);
+        const selectedFiles = ((_b = options.files) === null || _b === void 0 ? void 0 : _b.length)
+            ? new Set(options.files.map((file) => resolve(file)))
+            : undefined;
+        const sourceFiles = project.getSourceFiles().filter((sourceFile) => {
+            const filePath = sourceFile.getFilePath();
+            return (isInside(filePath, rootDir) &&
+                !sourceFile.isDeclarationFile() &&
+                !/\.(?:spec|test)\.ts$/.test(filePath) &&
+                (!selectedFiles || selectedFiles.has(resolve(filePath))));
+        });
+        const diagnostics = [];
+        const generatedComponentFiles = new Set();
+        const files = [];
+        const legacyCollectionsBefore = sourceFiles.reduce((count, sourceFile) => count + findLegacyRouteDeclarations(sourceFile).length, 0);
+        for (const sourceFile of sourceFiles) {
+            const before = sourceFile.getFullText();
+            const collections = migrateRoutesSourceFile(sourceFile, Object.assign(Object.assign({}, options), { diagnostics,
+                generatedComponentFiles }));
+            files.push({
+                filePath: sourceFile.getFilePath(),
+                changed: before !== sourceFile.getFullText(),
+                collections,
+            });
+        }
+        for (const sourceFile of sourceFiles) {
+            if (rewriteHybridLazyChildren(sourceFile)) {
+                const report = files.find((file) => file.filePath === sourceFile.getFilePath());
+                if (report)
+                    report.changed = true;
+            }
+        }
+        for (const sourceFile of sourceFiles) {
+            const result = generateAngularDependencies(sourceFile);
+            if (result.changed)
+                generatedComponentFiles.add(sourceFile);
+        }
+        for (const sourceFile of sourceFiles) {
+            const before = sourceFile.getFullText();
+            const appConfigMigrated = migrateApplicationConfigSourceFile(sourceFile);
+            if (!appConfigMigrated &&
+                sourceFile.getVariableDeclaration('appConfig') &&
+                sourceFile.getFullText().includes('provideRouter(')) {
+                diagnostics.push({
+                    code: 'APP_CONFIG_REQUIRES_CRAFT_ROUTES',
+                    filePath: sourceFile.getFilePath(),
+                    message: 'appConfig reste en ApplicationConfig tant que la collection racine et ses guards ne sont pas migrés vers craftRoutes.',
+                });
+            }
+            migrateBootstrapSourceFile(sourceFile);
+            if (before === sourceFile.getFullText())
+                continue;
+            sourceFile.organizeImports();
+            const report = files.find((file) => file.filePath === sourceFile.getFilePath());
+            if (report)
+                report.changed = true;
+        }
+        const eslintConfig = migrateEslintConfig(project, tsConfigFilePath ? dirname(tsConfigFilePath) : rootDir);
+        const changedSourceFiles = new Set(files
+            .filter((file) => file.changed)
+            .map((file) => project.getSourceFileOrThrow(file.filePath)));
+        for (const sourceFile of generatedComponentFiles) {
+            if (sourceFile.wasForgotten())
+                continue;
+            changedSourceFiles.add(sourceFile);
+        }
+        if (eslintConfig)
+            changedSourceFiles.add(eslintConfig);
+        if (options.write) {
+            yield Promise.all([...changedSourceFiles].map((file) => file.save()));
+        }
+        const remainingLegacyCollections = options.write
+            ? sourceFiles.reduce((count, sourceFile) => count + findLegacyRouteDeclarations(sourceFile).length, 0)
+            : legacyCollectionsBefore;
+        const changedFiles = [...changedSourceFiles].map((file) => file.getFilePath());
+        const exitCode = (options.check && remainingLegacyCollections > 0) ||
+            (options.failOnManual && diagnostics.length > 0)
+            ? 1
+            : 0;
+        const result = {
+            changedFiles,
+            files,
+            diagnostics,
+            remainingLegacyCollections,
+            exitCode,
+        };
+        if (options.jsonFilePath) {
+            const jsonFilePath = resolve(options.jsonFilePath);
+            yield mkdir(dirname(jsonFilePath), { recursive: true });
+            yield writeFile(jsonFilePath, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+        }
+        logResult(result, (_c = options.log) !== null && _c !== void 0 ? _c : console.log, options.write === true);
+        return result;
+    });
+}
+export function migrateApplicationConfigSourceFile(sourceFile) {
+    const declaration = sourceFile.getVariableDeclaration('appConfig');
+    const initializer = declaration === null || declaration === void 0 ? void 0 : declaration.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+    if (!declaration || !initializer)
+        return false;
+    const routerCall = initializer
+        .getDescendantsOfKind(SyntaxKind.CallExpression)
+        .find((call) => call.getExpression().getText() === 'provideRouter');
+    const routesArgument = routerCall === null || routerCall === void 0 ? void 0 : routerCall.getArguments()[0];
+    if (!routerCall || !Node.isIdentifier(routesArgument))
+        return false;
+    const routesName = routesArgument.getText();
+    if (!isCraftRoutesImport(sourceFile, routesName))
+        return false;
+    routerCall.getExpression().replaceWithText('provideCraftRouter');
+    routesArgument.replaceWithText(`${routesName}.toRoutes()`);
+    const configText = initializer.getText();
+    declaration.setInitializer(`craftAppConfig({ routingDeps: ${routesName}.META_DATA, ${configText.slice(1, -1)} })`);
+    declaration.removeType();
+    ensureValueImport(sourceFile, 'craftAppConfig');
+    ensureValueImport(sourceFile, 'provideCraftRouter');
+    return true;
+}
+function isCraftRoutesImport(sourceFile, name) {
+    var _a;
+    const declaration = sourceFile
+        .getImportDeclarations()
+        .find((item) => item.getNamedImports().some((namedImport) => namedImport.getName() === name));
+    return (((_a = declaration === null || declaration === void 0 ? void 0 : declaration.getModuleSpecifierSourceFile()) === null || _a === void 0 ? void 0 : _a.getFullText().includes('craftRoutes(')) === true);
+}
+export function migrateBootstrapSourceFile(sourceFile) {
+    var _a;
+    const appConfigImport = sourceFile
+        .getImportDeclarations()
+        .find((item) => item
+        .getNamedImports()
+        .some((namedImport) => namedImport.getName() === 'appConfig'));
+    if (appConfigImport &&
+        !((_a = appConfigImport
+            .getModuleSpecifierSourceFile()) === null || _a === void 0 ? void 0 : _a.getFullText().includes('craftAppConfig('))) {
+        return false;
+    }
+    let changed = false;
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        if (call.getExpression().getText() !== 'bootstrapApplication')
+            continue;
+        const config = call.getArguments()[1];
+        if (!Node.isIdentifier(config) || config.getText() !== 'appConfig')
+            continue;
+        config.replaceWithText('toApplicationConfig(appConfig)');
+        ensureValueImport(sourceFile, 'toApplicationConfig');
+        changed = true;
+    }
+    return changed;
+}
+function rewriteHybridLazyChildren(sourceFile) {
+    var _a;
+    let changed = false;
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression)) {
+        const thenAccess = call.getExpression();
+        if (!Node.isPropertyAccessExpression(thenAccess) || thenAccess.getName() !== 'then') {
+            continue;
+        }
+        const importCall = thenAccess.getExpression();
+        if (!Node.isCallExpression(importCall) ||
+            importCall.getExpression().getKind() !== SyntaxKind.ImportKeyword) {
+            continue;
+        }
+        const moduleArgument = importCall.getArguments()[0];
+        const callback = call.getArguments()[0];
+        if (!Node.isStringLiteral(moduleArgument) ||
+            !Node.isArrowFunction(callback) ||
+            !Node.isPropertyAccessExpression(callback.getBody()) ||
+            callback.getBody().getText().endsWith('.toRoutes()')) {
+            continue;
+        }
+        const base = resolve(dirname(sourceFile.getFilePath()), moduleArgument.getLiteralValue());
+        const imported = (_a = sourceFile.getProject().getSourceFile(`${base}.ts`)) !== null && _a !== void 0 ? _a : sourceFile.getProject().getSourceFile(join(base, 'index.ts'));
+        if (!(imported === null || imported === void 0 ? void 0 : imported.getFullText().includes('craftRoutes(')))
+            continue;
+        callback.getBody().replaceWithText(`${callback.getBody().getText()}.toRoutes()`);
+        changed = true;
+    }
+    return changed;
+}
+export function migrateRoutesSourceFile(sourceFile, options = {}) {
+    var _a, _b, _c;
+    const declarations = findLegacyRouteDeclarations(sourceFile);
+    if (declarations.length === 0)
+        return [];
+    const diagnostics = (_a = options.diagnostics) !== null && _a !== void 0 ? _a : [];
+    const generatedComponentFiles = (_b = options.generatedComponentFiles) !== null && _b !== void 0 ? _b : new Set();
+    const migratedCollections = [];
+    for (const declaration of declarations) {
+        const array = getRoutesArray(declaration);
+        if (!array)
+            continue;
+        const collectionName = (_c = options.collectionName) !== null && _c !== void 0 ? _c : inferCollectionName(sourceFile, declaration);
+        const generatedRoutesName = `${collectionName}Routes`;
+        const exportedName = declaration.getName();
+        const context = {
+            sourceFile,
+            diagnostics,
+            usedCraftRoute: false,
+            generatedComponentFiles,
+        };
+        if (hasBlockingAngularRoute(array, context, ''))
+            continue;
+        if (options.parentMount && options.parentNames === undefined) {
+            diagnostics.push({
+                code: 'PARENT_CONTEXT_UNKNOWN',
+                filePath: sourceFile.getFilePath(),
+                routePath: options.parentMount,
+                message: 'Le contexte DI du parent n’est pas déclaré. Passez --parent-names (une valeur vide confirme explicitement qu’aucun provider nommé n’est hérité).',
+            });
+        }
+        for (const element of [...array.getElements()]) {
+            if (Node.isObjectLiteralExpression(element)) {
+                transformRoute(element, context, '');
+            }
+        }
+        const arrayText = array.getText();
+        const binding = exportedName === generatedRoutesName
+            ? generatedRoutesName
+            : `${generatedRoutesName}: ${exportedName}`;
+        const parentSuffix = options.parentMount
+            ? `.withParent<ParentRoutes<${JSON.stringify(options.parentMount)}>>()`
+            : '';
+        declaration
+            .getVariableStatementOrThrow()
+            .replaceWithText(`export const { ${binding} } = craftRoutes(${JSON.stringify(collectionName)}, ${arrayText})${parentSuffix};`);
+        ensureValueImport(sourceFile, 'craftRoutes');
+        if (context.usedCraftRoute)
+            ensureValueImport(sourceFile, 'craftRoute');
+        if (options.parentMount)
+            ensureTypeImport(sourceFile, 'ParentRoutes');
+        addDiCheck(sourceFile, exportedName, collectionName, options.parentNames);
+        removeUnusedAngularRoutesImport(sourceFile);
+        migratedCollections.push(exportedName);
+    }
+    if (migratedCollections.length > 0)
+        sourceFile.formatText();
+    return migratedCollections;
+}
+function findLegacyRouteDeclarations(sourceFile) {
+    return sourceFile.getVariableDeclarations().filter((declaration) => {
+        var _a, _b;
+        const statement = declaration.getVariableStatement();
+        if (!(statement === null || statement === void 0 ? void 0 : statement.isExported()) || !getRoutesArray(declaration))
+            return false;
+        const typeText = (_a = declaration.getTypeNode()) === null || _a === void 0 ? void 0 : _a.getText();
+        const initializer = declaration.getInitializer();
+        if (typeText === 'Routes')
+            return true;
+        if (!initializer || !Node.isSatisfiesExpression(initializer))
+            return false;
+        return ((_b = initializer.getTypeNode()) === null || _b === void 0 ? void 0 : _b.getText()) === 'Routes';
+    });
+}
+function getRoutesArray(declaration) {
+    let initializer = declaration.getInitializer();
+    if (Node.isSatisfiesExpression(initializer) || Node.isAsExpression(initializer)) {
+        initializer = initializer.getExpression();
+    }
+    return Node.isArrayLiteralExpression(initializer) ? initializer : undefined;
+}
+function transformRoute(route, context, parentPath) {
+    var _a;
+    const pathProperty = getProperty(route, 'path');
+    const pathInitializer = pathProperty === null || pathProperty === void 0 ? void 0 : pathProperty.getInitializer();
+    const path = getStaticString(pathInitializer);
+    const routeLabel = path === undefined ? parentPath || '<unknown>' : joinRoute(parentPath, path);
+    if (path === undefined) {
+        diagnose(context, 'DYNAMIC_PATH', routeLabel, 'Le path de la route n’est pas une chaîne statique.');
+        return;
+    }
+    if (getProperty(route, 'children')) {
+        diagnose(context, 'ROUTE_SPLIT_RECOMMENDED', routeLabel, 'craftRoute ne prend pas en charge children dans l’API actuelle ; extrayez ces routes dans une collection montée par loadChildren.');
+        return;
+    }
+    const redirect = getProperty(route, 'redirectTo');
+    if (redirect && getStaticString(redirect.getInitializer()) === undefined) {
+        diagnose(context, 'DYNAMIC_REDIRECT', routeLabel, 'Le redirectTo est dynamique et doit être vérifié manuellement.');
+    }
+    const hasComponent = Boolean((_a = getProperty(route, 'component')) !== null && _a !== void 0 ? _a : getProperty(route, 'loadComponent'));
+    if (!hasComponent)
+        return;
+    if (getProperty(route, 'loadChildren')) {
+        diagnose(context, 'ROUTE_SPLIT_RECOMMENDED', routeLabel, 'La route combine un composant et loadChildren ; séparez-la en collections explicites.');
+        return;
+    }
+    if (hasAngularGuard(route, context, routeLabel))
+        return;
+    const component = resolveComponent(route, context.sourceFile);
+    if (!component) {
+        diagnose(context, 'COMPONENT_NOT_RESOLVABLE', routeLabel, 'Le composant routé ou son module ne peut pas être résolu sans ambiguïté.');
+        return;
+    }
+    if (!ensureGeneratedDeps(component, context)) {
+        diagnose(context, 'COMPONENT_NOT_RESOLVABLE', routeLabel, `GenDeps_${component.componentName} ne peut pas être généré de façon sûre.`);
+        return;
+    }
+    if (!getProperty(route, 'componentDeps')) {
+        route.addPropertyAssignment({
+            name: 'componentDeps',
+            initializer: `{} as import(${JSON.stringify(component.moduleSpecifier)}).GenDeps_${component.componentName}`,
+        });
+    }
+    pathProperty === null || pathProperty === void 0 ? void 0 : pathProperty.remove();
+    const definition = route.getText();
+    route.replaceWithText(`craftRoute(${JSON.stringify(path)}, ${definition})`);
+    context.usedCraftRoute = true;
+}
+function hasBlockingAngularRoute(routes, context, parentPath) {
+    var _a;
+    let blocked = false;
+    for (const element of routes.getElements()) {
+        if (!Node.isObjectLiteralExpression(element))
+            continue;
+        const path = getStaticString((_a = getProperty(element, 'path')) === null || _a === void 0 ? void 0 : _a.getInitializer());
+        const routePath = path === undefined ? parentPath || '<unknown>' : joinRoute(parentPath, path);
+        if (getProperty(element, 'children')) {
+            diagnose(context, 'ROUTE_SPLIT_RECOMMENDED', routePath, 'craftRoute ne prend pas en charge children dans l’API actuelle ; extrayez ces routes dans une collection montée par loadChildren.');
+            blocked = true;
+        }
+        if (hasAngularGuard(element, context, routePath))
+            blocked = true;
+    }
+    return blocked;
+}
+function hasAngularGuard(route, context, routePath) {
+    var _a;
+    let found = false;
+    for (const guardName of ['canActivate', 'canMatch']) {
+        const guard = (_a = getProperty(route, guardName)) === null || _a === void 0 ? void 0 : _a.getInitializer();
+        if (!guard)
+            continue;
+        if (Node.isCallExpression(guard) &&
+            guard.getExpression().getText() ===
+                (guardName === 'canActivate' ? 'craftCanActivate' : 'craftCanMatch')) {
+            continue;
+        }
+        found = true;
+        if (Node.isArrayLiteralExpression(guard) && guard.getElements().length > 1) {
+            diagnose(context, 'MULTIPLE_GUARDS_REQUIRE_COMPOSITION', routePath, `${guardName} contient plusieurs guards ; leur composition craft-ng est une décision métier.`);
+        }
+        else {
+            diagnose(context, 'ANGULAR_GUARD_REQUIRES_REWRITE', routePath, `${guardName} doit être réécrit avec craftCanActivate/craftCanMatch.`);
+        }
+    }
+    return found;
+}
+function resolveComponent(route, routeSourceFile) {
+    var _a, _b, _c, _d;
+    const direct = (_a = getProperty(route, 'component')) === null || _a === void 0 ? void 0 : _a.getInitializer();
+    if (Node.isIdentifier(direct)) {
+        const defaultImport = routeSourceFile
+            .getImportDeclarations()
+            .find((candidate) => { var _a; return ((_a = candidate.getDefaultImport()) === null || _a === void 0 ? void 0 : _a.getText()) === direct.getText(); });
+        if (defaultImport) {
+            const componentSourceFile = defaultImport.getModuleSpecifierSourceFile();
+            return {
+                moduleSpecifier: defaultImport.getModuleSpecifierValue(),
+                componentName: (_b = inferSingleComponentName(componentSourceFile)) !== null && _b !== void 0 ? _b : direct.getText(),
+                sourceFile: componentSourceFile,
+            };
+        }
+        const importDeclaration = routeSourceFile
+            .getImportDeclarations()
+            .find((candidate) => candidate.getNamedImports().some((specifier) => {
+            var _a, _b;
+            return ((_b = (_a = specifier.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) !== null && _b !== void 0 ? _b : specifier.getName()) ===
+                direct.getText();
+        }));
+        const namedImport = importDeclaration === null || importDeclaration === void 0 ? void 0 : importDeclaration.getNamedImports().find((specifier) => {
+            var _a, _b;
+            return ((_b = (_a = specifier.getAliasNode()) === null || _a === void 0 ? void 0 : _a.getText()) !== null && _b !== void 0 ? _b : specifier.getName()) ===
+                direct.getText();
+        });
+        if (importDeclaration && namedImport) {
+            return {
+                moduleSpecifier: importDeclaration.getModuleSpecifierValue(),
+                componentName: namedImport.getName(),
+                sourceFile: importDeclaration.getModuleSpecifierSourceFile(),
+            };
+        }
+        return {
+            moduleSpecifier: `./${basename(routeSourceFile.getFilePath(), extname(routeSourceFile.getFilePath()))}`,
+            componentName: direct.getText(),
+            sourceFile: routeSourceFile,
+        };
+    }
+    const lazy = (_c = getProperty(route, 'loadComponent')) === null || _c === void 0 ? void 0 : _c.getInitializer();
+    if (!Node.isArrowFunction(lazy) && !Node.isFunctionExpression(lazy))
+        return undefined;
+    const body = lazy.getBody();
+    const expression = (Node.isBlock(body)
+        ? (_d = body.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0]) === null || _d === void 0 ? void 0 : _d.getExpression()
+        : body);
+    if (!expression)
+        return undefined;
+    return resolveLazyComponent(expression, routeSourceFile);
+}
+function resolveLazyComponent(expression, routeSourceFile) {
+    var _a;
+    if (Node.isAwaitExpression(expression))
+        expression = expression.getExpression();
+    if (Node.isCallExpression(expression)) {
+        const calledExpression = expression.getExpression();
+        if (!Node.isPropertyAccessExpression(calledExpression)) {
+            return resolveBareImport(expression, routeSourceFile);
+        }
+        const propertyAccess = calledExpression;
+        if (propertyAccess.getName() === 'then') {
+            const importCall = propertyAccess.getExpression();
+            const callback = expression.getArguments()[0];
+            if (!Node.isCallExpression(importCall) || importCall.getExpression().getText() !== 'import' || !Node.isArrowFunction(callback))
+                return undefined;
+            const moduleSpecifier = getStaticString(importCall.getArguments()[0]);
+            if (!moduleSpecifier)
+                return undefined;
+            const sourceFile = resolveModuleSourceFile(routeSourceFile, moduleSpecifier);
+            const componentName = resolveThenComponentName(callback);
+            if (!componentName)
+                return undefined;
+            return {
+                moduleSpecifier,
+                componentName: componentName === 'default'
+                    ? ((_a = inferSingleComponentName(sourceFile)) !== null && _a !== void 0 ? _a : componentName)
+                    : componentName,
+                sourceFile,
+            };
+        }
+    }
+    return undefined;
+}
+function resolveThenComponentName(callback) {
+    var _a, _b, _c, _d;
+    if (!Node.isArrowFunction(callback) && !Node.isFunctionExpression(callback)) {
+        return undefined;
+    }
+    const body = callback.getBody();
+    const returnedExpression = Node.isBlock(body)
+        ? (_a = body.getDescendantsOfKind(SyntaxKind.ReturnStatement)[0]) === null || _a === void 0 ? void 0 : _a.getExpression()
+        : body;
+    if (Node.isPropertyAccessExpression(returnedExpression)) {
+        return returnedExpression.getName();
+    }
+    if (!Node.isIdentifier(returnedExpression))
+        return undefined;
+    const parameterName = (_b = callback.getParameters()[0]) === null || _b === void 0 ? void 0 : _b.getNameNode();
+    if (!Node.isObjectBindingPattern(parameterName))
+        return undefined;
+    const binding = parameterName
+        .getElements()
+        .find((element) => element.getName() === returnedExpression.getText());
+    return (_d = (_c = binding === null || binding === void 0 ? void 0 : binding.getPropertyNameNode()) === null || _c === void 0 ? void 0 : _c.getText()) !== null && _d !== void 0 ? _d : binding === null || binding === void 0 ? void 0 : binding.getName();
+}
+function inferSingleComponentName(sourceFile) {
+    if (!sourceFile)
+        return undefined;
+    const genDeps = sourceFile
+        .getTypeAliases()
+        .filter((alias) => alias.isExported() && alias.getName().startsWith('GenDeps_'));
+    if (genDeps.length === 1) {
+        return genDeps[0].getName().slice('GenDeps_'.length);
+    }
+    const angularClass = findAngularDecoratedClass(sourceFile);
+    return angularClass.skipped ? undefined : angularClass.className;
+}
+function resolveBareImport(expression, routeSourceFile) {
+    if (expression.getExpression().getText() === 'import') {
+        const moduleSpecifier = getStaticString(expression.getArguments()[0]);
+        if (!moduleSpecifier)
+            return undefined;
+        const sourceFile = resolveModuleSourceFile(routeSourceFile, moduleSpecifier);
+        if (!sourceFile)
+            return undefined;
+        const componentName = inferSingleComponentName(sourceFile);
+        if (componentName) {
+            return {
+                moduleSpecifier,
+                componentName,
+                sourceFile,
+            };
+        }
+    }
+    return undefined;
+}
+function ensureGeneratedDeps(component, context) {
+    const sourceFile = component.sourceFile;
+    if (!sourceFile)
+        return false;
+    if (sourceFile.getTypeAlias(`GenDeps_${component.componentName}`))
+        return true;
+    const angularClass = findAngularDecoratedClass(sourceFile);
+    if (angularClass.skipped ||
+        angularClass.className !== component.componentName) {
+        return false;
+    }
+    const result = generateAngularDependencies(sourceFile);
+    if (result.changed)
+        context.generatedComponentFiles.add(sourceFile);
+    return Boolean(sourceFile.getTypeAlias(`GenDeps_${component.componentName}`));
+}
+function resolveModuleSourceFile(sourceFile, moduleSpecifier) {
+    if (!moduleSpecifier.startsWith('.'))
+        return undefined;
+    const base = resolve(dirname(sourceFile.getFilePath()), moduleSpecifier);
+    const project = sourceFile.getProject();
+    for (const candidate of [
+        `${base}.ts`,
+        `${base}.tsx`,
+        join(base, 'index.ts'),
+    ]) {
+        const resolved = project.getSourceFile(candidate);
+        if (resolved)
+            return resolved;
+    }
+    return undefined;
+}
+function addDiCheck(sourceFile, routesName, collectionName, parentNames) {
+    ensureTypeImport(sourceFile, 'CanRun');
+    ensureTypeImport(sourceFile, 'ValidateCascadeRoutesFile');
+    ensureTypeImport(sourceFile, 'Router', '@angular/router');
+    const suffix = toPascalCase(collectionName);
+    const names = (parentNames === null || parentNames === void 0 ? void 0 : parentNames.length)
+        ? parentNames.map((name) => JSON.stringify(name)).join(' | ')
+        : 'never';
+    sourceFile.addStatements(`\ntype _Check${suffix}DI = ValidateCascadeRoutesFile<${names}, Router, typeof ${routesName}>;\nexport type _CanRun${suffix} = CanRun<_Check${suffix}DI>;`);
+}
+function ensureValueImport(sourceFile, name, moduleSpecifier = '@craft-ng/core') {
+    let declaration = sourceFile
+        .getImportDeclarations()
+        .find((item) => item.getModuleSpecifierValue() === moduleSpecifier && !item.isTypeOnly());
+    if (!declaration) {
+        declaration = sourceFile.addImportDeclaration({ moduleSpecifier, namedImports: [name] });
+    }
+    else if (!declaration.getNamedImports().some((item) => item.getName() === name)) {
+        declaration.addNamedImport(name);
+    }
+}
+function ensureTypeImport(sourceFile, name, moduleSpecifier = '@craft-ng/core') {
+    const alreadyImported = sourceFile.getImportDeclarations().some((item) => item.getModuleSpecifierValue() === moduleSpecifier &&
+        item.getNamedImports().some((specifier) => specifier.getName() === name));
+    if (alreadyImported)
+        return;
+    const declaration = sourceFile
+        .getImportDeclarations()
+        .find((item) => item.getModuleSpecifierValue() === moduleSpecifier && item.isTypeOnly());
+    if (!declaration) {
+        sourceFile.addImportDeclaration({
+            moduleSpecifier,
+            isTypeOnly: true,
+            namedImports: [name],
+        });
+    }
+    else {
+        declaration.addNamedImport(name);
+    }
+}
+function removeUnusedAngularRoutesImport(sourceFile) {
+    const importDeclaration = sourceFile
+        .getImportDeclarations()
+        .find((item) => item.getModuleSpecifierValue() === '@angular/router');
+    if (!importDeclaration)
+        return;
+    const routesImport = importDeclaration
+        .getNamedImports()
+        .find((item) => item.getName() === 'Routes');
+    if (!routesImport)
+        return;
+    const withoutImports = sourceFile
+        .getFullText()
+        .replace(importDeclaration.getFullText(), '');
+    if (/\bRoutes\b/.test(withoutImports))
+        return;
+    routesImport.remove();
+    if (importDeclaration.getNamedImports().length === 0 &&
+        !importDeclaration.getDefaultImport() &&
+        !importDeclaration.getNamespaceImport()) {
+        importDeclaration.remove();
+    }
+}
+function getProperty(object, name) {
+    const property = object.getProperty(name);
+    return Node.isPropertyAssignment(property) ? property : undefined;
+}
+function getStaticString(node) {
+    if (Node.isStringLiteral(node) || Node.isNoSubstitutionTemplateLiteral(node)) {
+        return node.getLiteralValue();
+    }
+    return undefined;
+}
+function diagnose(context, code, routePath, message) {
+    context.diagnostics.push({
+        code,
+        filePath: context.sourceFile.getFilePath(),
+        routePath,
+        message,
+    });
+}
+function inferCollectionName(sourceFile, declaration) {
+    const variableName = declaration.getName();
+    if (variableName !== 'routes' && variableName.endsWith('Routes')) {
+        return variableName.slice(0, -'Routes'.length);
+    }
+    const fileName = basename(sourceFile.getFilePath()).replace(/\.routes?\.ts$/, '');
+    return toCamelCase(fileName === basename(sourceFile.getFilePath()) ? 'app' : fileName);
+}
+function toCamelCase(value) {
+    return value.replace(/[-_.]+([a-zA-Z0-9])/g, (_, character) => character.toUpperCase());
+}
+function toPascalCase(value) {
+    const camel = toCamelCase(value);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function joinRoute(parent, child) {
+    return [parent, child].filter(Boolean).join('/') || '<root>';
+}
+function createProject(tsConfigFilePath) {
+    return tsConfigFilePath
+        ? new Project({ tsConfigFilePath, skipAddingFilesFromTsConfig: false })
+        : new Project({
+            compilerOptions: {
+                experimentalDecorators: true,
+                module: ts.ModuleKind.Preserve,
+                moduleResolution: ts.ModuleResolutionKind.Node10,
+                target: ts.ScriptTarget.ES2022,
+            },
+        });
+}
+function defaultTsConfig(rootDir) {
+    const path = join(rootDir, 'tsconfig.json');
+    return existsSync(path) ? path : undefined;
+}
+function isInside(filePath, rootDir) {
+    const absolute = isAbsolute(filePath) ? filePath : resolve(filePath);
+    return absolute === rootDir || absolute.startsWith(`${rootDir}/`);
+}
+function setQuoteKind(project) {
+    project.manipulationSettings.set({ quoteKind: QuoteKind.Single });
+}
+function logResult(result, log, wrote) {
+    for (const file of result.files.filter((item) => item.changed)) {
+        log(`✓ ${file.filePath}: ${wrote ? 'migré' : 'migration proposée'}`);
+    }
+    for (const diagnostic of result.diagnostics) {
+        log(`! ${diagnostic.filePath}${diagnostic.routePath ? ` / ${diagnostic.routePath}` : ''}: ${diagnostic.code}\n  ${diagnostic.message}`);
+    }
+    log(`summary changed=${result.changedFiles.length} manual=${result.diagnostics.length} remaining=${result.remainingLegacyCollections}`);
+}
+//# sourceMappingURL=migrate-routes.js.map