@simplysm/sd-cli 6.4.3 → 7.0.6

package/dist-node/build-tools/SdCliNgModuleFilesGenerator.js

@@ -1,675 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SdCliNgModuleFilesGenerator = void 0;
-const sd_core_common_1 = require("@simplysm/sd-core-common");
-const ts = require("typescript");
-const sd_core_node_1 = require("@simplysm/sd-core-node");
-const path = require("path");
-const jsdom_1 = require("jsdom");
-const os = require("os");
-const SdMyMetadataReader_1 = require("./metadata/SdMyMetadataReader");
-const SdAotMetadataReader_1 = require("./metadata/SdAotMetadataReader");
-const SdIvyMetadataReader_1 = require("./metadata/SdIvyMetadataReader");
-const SdMetadataError_1 = require("./metadata/SdMetadataError");
-class SdCliNgModuleFilesGenerator {
-    constructor(_rootDir) {
-        this._rootDir = _rootDir;
-        this._fileCache = new Map();
-        this._sourceDirPath = path.resolve(this._rootDir, "src");
-        this._moduleDistDirPath = path.resolve(this._rootDir, "src/_modules");
-    }
-    deleteFileCaches(filePaths) {
-        for (const filePath of filePaths) {
-            this._fileCache.delete(sd_core_node_1.PathUtil.posix(filePath));
-        }
-    }
-    async reloadSourceFilesAsync(dirtyFilePaths, compilerHost, moduleResolutionCache, ngProgram) {
-        this._compilerHost = compilerHost;
-        this._moduleResolutionCache = moduleResolutionCache;
-        this._program = ngProgram.getTsProgram();
-        const result = [];
-        let changed = false;
-        for (const dirtyFilePath of dirtyFilePaths) {
-            try {
-                if (sd_core_node_1.PathUtil.isChildPath(dirtyFilePath, this._moduleDistDirPath))
-                    continue;
-                this._fileCache.delete(dirtyFilePath);
-                if (dirtyFilePath.endsWith(".ts") && !dirtyFilePath.endsWith(".d.ts")) {
-                    const sourceFile = this._program.getSourceFile(dirtyFilePath);
-                    if (!sourceFile) {
-                        changed = true;
-                        continue;
-                    }
-                    this._fileCache.set(dirtyFilePath, {
-                        type: "my",
-                        sourceFile,
-                        metadata: new SdMyMetadataReader_1.SdMyMetadataReader(sourceFile, this._program).getMetadatas()
-                    });
-                    changed = true;
-                }
-                else if (dirtyFilePath.endsWith(".d.ts")) {
-                    const sourceFile = this._program.getSourceFile(dirtyFilePath);
-                    if (!sourceFile) {
-                        changed = true;
-                        continue;
-                    }
-                    const metadataFilePath = dirtyFilePath.replace(/\.d\.ts$/, ".metadata.json");
-                    const sdMetadataFilePath = dirtyFilePath.replace(/\.d\.ts$/, ".sd-metadata.json");
-                    if (sd_core_node_1.FsUtil.exists(metadataFilePath)) {
-                        const metadataRoot = await sd_core_node_1.FsUtil.readJsonAsync(metadataFilePath);
-                        this._fileCache.set(dirtyFilePath, {
-                            type: "aot",
-                            sourceFile,
-                            ...new SdAotMetadataReader_1.SdAotMetadataReader(metadataRoot).getMetadatas()
-                        });
-                        changed = true;
-                    }
-                    else if (sd_core_node_1.FsUtil.exists(sdMetadataFilePath)) {
-                        const metadataRoot = await sd_core_node_1.FsUtil.readJsonAsync(sdMetadataFilePath);
-                        this._fileCache.set(dirtyFilePath, {
-                            type: "aot",
-                            sourceFile,
-                            ...new SdAotMetadataReader_1.SdAotMetadataReader(metadataRoot).getMetadatas()
-                        });
-                        changed = true;
-                    }
-                    else {
-                        this._fileCache.set(dirtyFilePath, {
-                            type: "ivy",
-                            sourceFile,
-                            ...new SdIvyMetadataReader_1.SdIvyMetadataReader(sourceFile, ngProgram).getMetadatas()
-                        });
-                        changed = true;
-                    }
-                }
-            }
-            catch (err) {
-                if (err instanceof SdMetadataError_1.SdMetadataError) {
-                    result.push({
-                        filePath: err.fileName,
-                        severity: "error",
-                        message: `${err.fileName}(0, 0): error ${err.message}`
-                    });
-                }
-                else {
-                    if (err instanceof Error) {
-                        throw new sd_core_common_1.SdError(err, "'" + dirtyFilePath + "' 메타데이터 로딩중 에러");
-                    }
-                    else {
-                        throw err;
-                    }
-                }
-            }
-        }
-        return { result, changed };
-    }
-    async generateAsync() {
-        try {
-            let moduleInfoMap = this._getModuleInfoMap();
-            moduleInfoMap = this._mergeCircularModuleInfoMap(moduleInfoMap);
-            const routingModuleMap = await this._getRoutingModuleInfoMapAsync();
-            const changedFilePaths = [
-                ...await this._writeNgModuleFileAsync(moduleInfoMap),
-                ...await this._writeRoutingModuleFileAsync(moduleInfoMap, routingModuleMap)
-            ];
-            const genFilePaths = [...moduleInfoMap.keys(), ...routingModuleMap.keys()].distinct();
-            const delFilePaths = (await sd_core_node_1.FsUtil.globAsync(path.resolve(this._moduleDistDirPath, "**", "*")))
-                .filter((item) => (!genFilePaths.includes(sd_core_node_1.PathUtil.posix(item))
-                && !genFilePaths.some((item1) => sd_core_node_1.PathUtil.isChildPath(item1, item))))
-                .map((item) => sd_core_node_1.PathUtil.posix(item));
-            for (const delFilePath of delFilePaths) {
-                changedFilePaths.push(delFilePath);
-                await sd_core_node_1.FsUtil.removeAsync(delFilePath);
-            }
-            return { result: [], changedFilePaths: changedFilePaths.distinct() };
-        }
-        catch (err) {
-            if (err instanceof SdMetadataError_1.SdMetadataError) {
-                return {
-                    result: [{
-                            filePath: err.fileName,
-                            severity: "error",
-                            message: `${err.fileName}(0, 0): error ${err.message}`
-                        }],
-                    changedFilePaths: []
-                };
-            }
-            else if (err instanceof Error) {
-                throw new sd_core_common_1.SdError(err, "메타데이터 생성중 에러");
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    _getModuleInfoMap() {
-        const moduleInfoMap = new Map();
-        const ngModuleExportInfos = this._getAllNgModuleExportInfos();
-        const ngModuleExportMap = ngModuleExportInfos.groupBy((item) => item.exportModuleFilePath + "#" + item.exportName)
-            .toMap((item) => item.key, (item) => item.values);
-        for (const filePath of Array.from(this._fileCache.keys())) {
-            const fileCache = this._fileCache.get(filePath);
-            if (fileCache.type !== "my")
-                continue;
-            for (const metadata of fileCache.metadata) {
-                if ((metadata.type === "Injectable"
-                    && (metadata.className.endsWith("Provider")
-                        && metadata.providedIn !== "root"))
-                    || (metadata.type === "Directive"
-                        && metadata.className.endsWith("Directive"))
-                    || (metadata.type === "Pipe"
-                        && metadata.className.endsWith("Pipe"))
-                    || (metadata.type === "Component"
-                        && (metadata.className.endsWith("Page")
-                            || metadata.className.endsWith("Component")
-                            || metadata.className.endsWith("Modal")
-                            || metadata.className.endsWith("Control")
-                            || metadata.className.endsWith("PrintTemplate")
-                            || metadata.className.endsWith("Toast")))) {
-                    const newModuleInfo = {
-                        moduleImportMap: new Map(),
-                        imports: [],
-                        exports: [],
-                        providers: [],
-                        className: metadata.className + "Module"
-                    };
-                    if (metadata.type === "Injectable") {
-                        newModuleInfo.providers.push({ moduleFilePath: filePath, name: metadata.className });
-                    }
-                    else {
-                        newModuleInfo.exports.push({ moduleFilePath: filePath, name: metadata.className });
-                    }
-                    const moduleImport = newModuleInfo.moduleImportMap.getOrCreate(filePath, []);
-                    moduleImport.push(metadata.className);
-                    const ngModuleImportInfos = this._getNgModuleImportInfos(metadata, ngModuleExportMap);
-                    for (const ngModuleImportInfo of ngModuleImportInfos) {
-                        newModuleInfo.imports.push({ moduleFilePath: ngModuleImportInfo.filePath, name: ngModuleImportInfo.name });
-                        const moduleImportMapValues = newModuleInfo.moduleImportMap.getOrCreate(ngModuleImportInfo.filePath, []);
-                        moduleImportMapValues.push(ngModuleImportInfo.name);
-                    }
-                    moduleInfoMap.set(this._getNgModulePath(filePath, metadata.className), {
-                        moduleImportMap: Array.from(newModuleInfo.moduleImportMap.entries())
-                            .toMap((item) => item[0], (item) => item[1].distinct()),
-                        className: newModuleInfo.className,
-                        imports: newModuleInfo.imports.distinct(),
-                        exports: newModuleInfo.exports.distinct(),
-                        providers: newModuleInfo.providers.distinct()
-                    });
-                }
-            }
-        }
-        const changed = this._reloadModuleInfoFileCache(moduleInfoMap);
-        if (changed) {
-            return this._getModuleInfoMap();
-        }
-        return moduleInfoMap;
-    }
-    _reloadModuleInfoFileCache(moduleInfoMap) {
-        let changed = false;
-        for (const moduleInfoMapEntry of moduleInfoMap.entries()) {
-            const moduleFilePath = moduleInfoMapEntry[0];
-            const moduleInfo = moduleInfoMapEntry[1];
-            const newFileCache = {
-                type: "my",
-                sourceFile: undefined,
-                metadata: [
-                    {
-                        type: "NgModule",
-                        className: moduleInfo.className,
-                        exports: moduleInfo.exports,
-                        providers: moduleInfo.providers
-                    }
-                ]
-            };
-            const prevFileCache = this._fileCache.get(moduleFilePath);
-            if (!prevFileCache) {
-                this._fileCache.set(moduleFilePath, newFileCache);
-                changed = true;
-            }
-            else if (!sd_core_common_1.ObjectUtil.equal(prevFileCache.metadata, newFileCache.metadata, { ignoreArrayIndex: true })) {
-                prevFileCache.metadata = newFileCache.metadata;
-                changed = true;
-            }
-        }
-        return changed;
-    }
-    _mergeCircularModuleInfoMap(moduleInfoMap) {
-        const result = sd_core_common_1.ObjectUtil.clone(moduleInfoMap);
-        const fnMerge = () => {
-            const moduleFilePaths = Array.from(result.keys()).orderBy().orderBy((item) => item.length);
-            for (const moduleFilePath of moduleFilePaths) {
-                const circularFilePaths = this._getModuleInfoMapExportCircular(result, [moduleFilePath]);
-                if (circularFilePaths.length === 0)
-                    continue;
-                for (const circularFilePath of circularFilePaths) {
-                    const thisModuleInfo = result.get(moduleFilePath);
-                    const circularModuleInfo = result.get(circularFilePath);
-                    const mergedModuleInfo = sd_core_common_1.ObjectUtil.merge(circularModuleInfo, thisModuleInfo, { arrayProcess: "concat" });
-                    mergedModuleInfo.moduleImportMap.delete(moduleFilePath);
-                    mergedModuleInfo.moduleImportMap.delete(circularFilePath);
-                    mergedModuleInfo.imports.remove((item) => item.moduleFilePath === moduleFilePath && item.name === thisModuleInfo.className);
-                    mergedModuleInfo.imports.remove((item) => item.moduleFilePath === circularFilePath && item.name === circularModuleInfo.className);
-                    result.set(moduleFilePath, mergedModuleInfo);
-                    result.delete(circularFilePath);
-                    this._fileCache.delete(circularFilePath);
-                    for (const otherModuleInfoFilePath of result.keys()) {
-                        const otherModuleInfo = result.get(otherModuleInfoFilePath);
-                        if (otherModuleInfo.moduleImportMap.has(circularFilePath)) {
-                            otherModuleInfo.moduleImportMap.set(moduleFilePath, [
-                                ...otherModuleInfo.moduleImportMap.get(moduleFilePath) ?? [],
-                                thisModuleInfo.className
-                            ].distinct());
-                            otherModuleInfo.moduleImportMap.delete(circularFilePath);
-                            otherModuleInfo.imports.remove((item) => item.moduleFilePath === circularFilePath && item.name === circularModuleInfo.className);
-                        }
-                    }
-                }
-                return true;
-            }
-            return false;
-        };
-        while (fnMerge()) {
-        }
-        return result;
-    }
-    async _writeNgModuleFileAsync(moduleInfoMap) {
-        const changedDistFilePaths = [];
-        for (const distFilePath of moduleInfoMap.keys()) {
-            const moduleInfo = moduleInfoMap.get(distFilePath);
-            const moduleImportMap = Array.from(moduleInfo.moduleImportMap.entries())
-                .map((item) => ({
-                moduleName: this._getModuleModuleImportName(path.dirname(distFilePath), item[0]),
-                targetNames: item[1]
-            }))
-                .groupBy((item) => item.moduleName)
-                .toMap((item) => item.key, (item) => item.values.mapMany((v) => v.targetNames).distinct());
-            moduleImportMap.getOrCreate("@angular/core", []).push("NgModule");
-            moduleImportMap.getOrCreate("@angular/common", []).push("CommonModule");
-            const moduleImportTexts = [];
-            for (const moduleImportName of Array.from(moduleImportMap.keys()).orderBy()) {
-                const moduleImportInfo = moduleImportMap.get(moduleImportName).distinct();
-                if (moduleImportInfo.length === 0)
-                    continue;
-                moduleImportTexts.push(`import { ${moduleImportInfo.join(", ")} } from "${moduleImportName}";`);
-            }
-            const content = `
-${moduleImportTexts.join(os.EOL)}
-
-@NgModule({
-  imports: [${moduleInfo.imports.map((item) => item.name).concat(["CommonModule"]).distinct().orderBy().join(", ")}],
-  declarations: [${moduleInfo.exports.map((item) => item.name).distinct().orderBy().join(", ")}],
-  exports: [${moduleInfo.exports.map((item) => item.name).distinct().orderBy().join(", ")}],
-  providers: [${moduleInfo.providers.map((item) => item.name).distinct().orderBy().join(", ")}]
-})
-export class ${moduleInfo.className} {
-}`.split("\n").map((item) => item.trimEnd()).join(os.EOL).trim();
-            if (!sd_core_node_1.FsUtil.exists(distFilePath) || await sd_core_node_1.FsUtil.readFileAsync(distFilePath) !== content) {
-                await sd_core_node_1.FsUtil.writeFileAsync(distFilePath, content);
-                changedDistFilePaths.push(distFilePath);
-            }
-        }
-        return changedDistFilePaths;
-    }
-    _getNgModuleImportInfos(metadata, ngModuleExportMap) {
-        const importTargets = [];
-        for (const metadataModuleImport of metadata.moduleImports) {
-            importTargets.push({
-                filePath: metadataModuleImport.moduleFilePath,
-                name: metadataModuleImport.name
-            });
-        }
-        if ("template" in metadata && !sd_core_common_1.StringUtil.isNullOrEmpty(metadata.template)) {
-            const selectorInfos = this._getAllSelectorInfos();
-            const templateDOM = new jsdom_1.JSDOM(metadata.template);
-            for (const selectorInfo of selectorInfos) {
-                if (templateDOM.window.document.querySelector([
-                    selectorInfo.selector,
-                    selectorInfo.selector.replace(/\[/g, "[\\[").replace(/]/g, "\\]]"),
-                    selectorInfo.selector.replace(/\[/g, "[\\(").replace(/]/g, "\\)]")
-                ].join(", ")) != null) {
-                    importTargets.push({ filePath: selectorInfo.filePath, name: selectorInfo.className });
-                }
-            }
-            const pipeInfos = this._getAllPipeInfos();
-            for (const pipeInfo of pipeInfos) {
-                if (new RegExp("| *" + pipeInfo.name + "[^\\w]").test(metadata.template)) {
-                    importTargets.push({ filePath: pipeInfo.filePath, name: pipeInfo.className });
-                }
-            }
-        }
-        const result = [];
-        for (const importTarget of importTargets) {
-            const ngModules = ngModuleExportMap.get(importTarget.filePath + "#" + importTarget.name);
-            if (ngModules) {
-                if (ngModules.length !== 1)
-                    throw new sd_core_common_1.NeverEntryError();
-                result.push({ filePath: ngModules[0].filePath, name: ngModules[0].className });
-            }
-        }
-        return result;
-    }
-    _getAllNgModuleExportInfos() {
-        const result = [];
-        for (const filePath of this._fileCache.keys()) {
-            const fileCache = this._fileCache.get(filePath);
-            if (fileCache.type === "my") {
-                const ngModules = fileCache.metadata.filter((item) => item.type === "NgModule");
-                for (const ngModule of ngModules) {
-                    for (const exp of ngModule.exports.concat(ngModule.providers)) {
-                        result.push({
-                            moduleName: undefined,
-                            filePath,
-                            className: ngModule.className,
-                            exportModuleFilePath: exp.moduleFilePath,
-                            exportName: exp.name
-                        });
-                    }
-                }
-            }
-            else if (fileCache.type === "aot") {
-                const ngModules = fileCache.metadata.filter((item) => item.type === "NgModule");
-                for (const ngModule of ngModules) {
-                    for (const exp of ngModule.exports.concat(ngModule.providers)) {
-                        if (!sd_core_common_1.StringUtil.isNullOrEmpty(exp.moduleName)) {
-                            const newExp = this._getAotReferenceLastFilePath(filePath, exp.moduleName, exp.name);
-                            if (!newExp)
-                                throw new sd_core_common_1.NeverEntryError();
-                            result.push({
-                                moduleName: fileCache.moduleName,
-                                filePath,
-                                className: ngModule.className,
-                                exportModuleFilePath: newExp.moduleFilePath,
-                                exportName: newExp.name
-                            });
-                        }
-                        else {
-                            if (!fileCache.exports.some((item) => (item.as ?? item.name) === exp.name))
-                                throw new sd_core_common_1.NeverEntryError();
-                            result.push({
-                                moduleName: fileCache.moduleName,
-                                filePath,
-                                className: ngModule.className,
-                                exportModuleFilePath: filePath,
-                                exportName: exp.name
-                            });
-                        }
-                    }
-                }
-            }
-            else {
-                const ngModules = fileCache.metadata.filter((item) => item.type === "NgModule");
-                for (const ngModule of ngModules) {
-                    for (const exp of ngModule.exports) {
-                        result.push({
-                            moduleName: fileCache.moduleName,
-                            filePath,
-                            className: ngModule.className,
-                            exportModuleFilePath: exp.moduleFilePath,
-                            exportName: exp.name
-                        });
-                    }
-                }
-            }
-        }
-        return result.distinct();
-    }
-    _getModuleInfoMapExportCircular(moduleInfoMap, arr) {
-        if (moduleInfoMap.has(arr.last())) {
-            const moduleInfo = moduleInfoMap.get(arr.last());
-            const result = [];
-            for (const moduleImportFilePath of moduleInfo.moduleImportMap.keys()) {
-                if (arr.includes(moduleImportFilePath)) {
-                    if (arr[0] === moduleImportFilePath) {
-                        result.push(...arr.slice(1));
-                    }
-                }
-                else {
-                    result.push(...this._getModuleInfoMapExportCircular(moduleInfoMap, arr.concat([moduleImportFilePath])));
-                }
-            }
-            return result.distinct();
-        }
-        else {
-            return [];
-        }
-    }
-    _getNgModulePath(pageFilePath, pageClassName) {
-        return sd_core_node_1.PathUtil.posix(this._getGenNgModuleDistPath(pageFilePath), pageClassName + "Module.ts");
-    }
-    _getAotReferenceLastFilePath(filePath, moduleName, targetName) {
-        const expFilePath = this._getResolvedFilePath(filePath, moduleName);
-        if (sd_core_common_1.StringUtil.isNullOrEmpty(expFilePath))
-            throw new sd_core_common_1.NeverEntryError();
-        const expFileCache = this._fileCache.get(expFilePath);
-        if (!expFileCache) {
-            this._fileCache.get(expFilePath.replace(/[\\/]/g, "\\"));
-            throw new SdMetadataError_1.SdMetadataError(filePath, `'${moduleName}'에 대한 파일 '${expFilePath}'을 찾을 수 없습니다.`);
-        }
-        if (expFileCache.type !== "aot")
-            throw new sd_core_common_1.NeverEntryError();
-        const newExp = expFileCache.exports.single((item) => (item.as ?? item.name) === targetName);
-        if (!newExp)
-            throw new sd_core_common_1.NeverEntryError();
-        if (!sd_core_common_1.StringUtil.isNullOrEmpty(newExp.moduleName)) {
-            return this._getAotReferenceLastFilePath(expFilePath, newExp.moduleName, newExp.name);
-        }
-        else {
-            return {
-                moduleFilePath: expFilePath,
-                name: newExp.as ?? newExp.name
-            };
-        }
-    }
-    _getAllSelectorInfos() {
-        const result = [];
-        for (const filePath of this._fileCache.keys()) {
-            const fileCache = this._fileCache.get(filePath);
-            const selectorMetadata = fileCache.metadata
-                .filter((item) => item.type === "Component" || item.type === "Directive");
-            for (const selectorMetadataItem of selectorMetadata) {
-                if (sd_core_common_1.StringUtil.isNullOrEmpty(selectorMetadataItem.selector))
-                    continue;
-                result.push(({
-                    selector: selectorMetadataItem.selector,
-                    className: selectorMetadataItem.className,
-                    filePath
-                }));
-            }
-        }
-        return result;
-    }
-    _getAllPipeInfos() {
-        const result = [];
-        for (const filePath of this._fileCache.keys()) {
-            const fileCache = this._fileCache.get(filePath);
-            const pipeMetadata = fileCache.metadata
-                .filter((item) => item.type === "Component" || item.type === "Directive");
-            for (const pipeMetadataItem of pipeMetadata) {
-                if (sd_core_common_1.StringUtil.isNullOrEmpty(pipeMetadataItem.name))
-                    continue;
-                result.push(({
-                    name: pipeMetadataItem.name,
-                    className: pipeMetadataItem.className,
-                    filePath
-                }));
-            }
-        }
-        return result;
-    }
-    _getModuleModuleImportName(distDirPath, filePath) {
-        const fileCache = this._fileCache.get(filePath);
-        const presetModuleName = !fileCache || fileCache.type === "my" ? undefined : fileCache.moduleName;
-        if (!sd_core_common_1.StringUtil.isNullOrEmpty(presetModuleName))
-            return presetModuleName;
-        const relativeFilePath = sd_core_node_1.PathUtil.posix(path.relative(distDirPath, filePath));
-        return (relativeFilePath.startsWith(".") ? relativeFilePath : "./" + relativeFilePath)
-            .replace(/\.ts$/, "")
-            .replace(/\\/g, "/");
-    }
-    _getResolvedFilePath(sourceFilePath, moduleName) {
-        const resolvedModule = ts.resolveModuleName(moduleName, sourceFilePath, this._program.getCompilerOptions(), this._compilerHost, this._moduleResolutionCache).resolvedModule;
-        if (resolvedModule) {
-            return sd_core_node_1.PathUtil.posix(resolvedModule.resolvedFileName);
-        }
-        return undefined;
-    }
-    _getGenNgModuleDistPath(filePath) {
-        return path.resolve(this._moduleDistDirPath, path.relative(this._sourceDirPath, path.dirname(filePath)));
-    }
-    async _getRoutingModuleInfoMapAsync() {
-        const result = new Map();
-        for (const filePath of Array.from(this._fileCache.keys())) {
-            const fileCache = this._fileCache.get(filePath);
-            if (fileCache.type !== "my")
-                continue;
-            for (const metadata of fileCache.metadata) {
-                if (!metadata.className.endsWith("Page"))
-                    continue;
-                const newRoutingModuleInfo = {
-                    path: "",
-                    page: {
-                        moduleFilePath: filePath,
-                        name: metadata.className
-                    },
-                    children: []
-                };
-                const childDirName = sd_core_common_1.StringUtil.toKebabCase(path.basename(filePath, path.extname(filePath)).replace(/Page$/, ""));
-                const childDirPath = path.resolve(path.dirname(filePath), childDirName);
-                if (sd_core_node_1.FsUtil.exists(childDirPath)) {
-                    newRoutingModuleInfo.children = await this._getRoutingModuleChildInfoAsync(childDirPath);
-                }
-                result.set(this._getRoutingModulePath(filePath, metadata.className), newRoutingModuleInfo);
-            }
-        }
-        return result;
-    }
-    async _getRoutingModuleChildInfoAsync(childDirPath) {
-        const result = [];
-        const childDirChildPaths = (await sd_core_node_1.FsUtil.readdirAsync(childDirPath)).map((item) => path.resolve(childDirPath, item));
-        const ignoreDirPaths = [];
-        for (const childDirChildPath of childDirChildPaths) {
-            if (childDirChildPath.endsWith("Page.ts")) {
-                const childDirChildDirName = sd_core_common_1.StringUtil.toKebabCase(path.basename(childDirChildPath, path.extname(childDirChildPath)).replace(/Page$/, ""));
-                result.push({
-                    path: childDirChildDirName,
-                    page: {
-                        moduleFilePath: childDirChildPath,
-                        name: path.basename(childDirChildPath, path.extname(childDirChildPath))
-                    }
-                });
-                ignoreDirPaths.push(path.resolve(path.dirname(childDirChildPath), childDirChildDirName));
-            }
-        }
-        for (const childDirChildPath of childDirChildPaths) {
-            if (sd_core_node_1.FsUtil.isDirectory(childDirChildPath) && !ignoreDirPaths.includes(childDirChildPath)) {
-                result.push({
-                    path: path.basename(childDirChildPath),
-                    children: await this._getRoutingModuleChildInfoAsync(childDirChildPath)
-                });
-            }
-        }
-        return result;
-    }
-    async _writeRoutingModuleFileAsync(moduleInfoMap, routingModuleInfoMap) {
-        const changedDistFilePaths = [];
-        for (const distFilePath of routingModuleInfoMap.keys()) {
-            const routingModuleInfo = routingModuleInfoMap.get(distFilePath);
-            const routingModuleText = this._getRoutingModuleText(routingModuleInfo, distFilePath);
-            const moduleImportTexts = [];
-            const pageFilePath = this._getModuleModuleImportName(path.dirname(distFilePath), routingModuleInfo.page.moduleFilePath);
-            let content;
-            if (path.basename(distFilePath) === "_routes.ts") {
-                moduleImportTexts.push(`import { Routes } from "@angular/router";`);
-                content = `
-${moduleImportTexts.join(os.EOL)}
-
-export const routes: Routes = [
-  ${routingModuleText.replace(/\r\n/g, "\r\n  ")}
-];`.split("\n").map((item) => item.trimEnd()).join(os.EOL).trim();
-            }
-            else {
-                moduleImportTexts.push(`import { NgModule } from "@angular/core";`);
-                moduleImportTexts.push(`import { RouterModule } from "@angular/router";`);
-                if (path.basename(distFilePath) !== "_routes.ts") {
-                    moduleImportTexts.push(`import { SdCanDeactivateGuardProvider } from "@simplysm/sd-angular";`);
-                }
-                moduleImportTexts.push(`import { ${routingModuleInfo.page.name} } from "${pageFilePath}";`);
-                const thisPageModuleInfoEntry = Array.from(moduleInfoMap.entries())
-                    .single((item) => item[1].exports.some((exp) => exp.moduleFilePath === routingModuleInfo.page.moduleFilePath && exp.name === routingModuleInfo.page.name));
-                if (!thisPageModuleInfoEntry)
-                    throw new sd_core_common_1.NeverEntryError();
-                const thisPageModuleInfo = {
-                    filePath: thisPageModuleInfoEntry[0],
-                    className: thisPageModuleInfoEntry[1].className
-                };
-                const pageNgModuleFilePath = this._getModuleModuleImportName(path.dirname(distFilePath), thisPageModuleInfo.filePath);
-                moduleImportTexts.push(`import { ${thisPageModuleInfo.className} } from "${pageNgModuleFilePath}";`);
-                content = `
-${moduleImportTexts.join(os.EOL)}
-
-@NgModule({
-  imports: [
-    ${thisPageModuleInfo.className},
-    RouterModule.forChild([
-      ${routingModuleText.replace(/\r\n/g, "\r\n      ")}
-    ])
-  ]
-})
-export class ${routingModuleInfo.page.name}RoutingModule {
-}`.split("\n").map((item) => item.trimEnd()).join(os.EOL).trim();
-            }
-            if (!sd_core_node_1.FsUtil.exists(distFilePath) || await sd_core_node_1.FsUtil.readFileAsync(distFilePath) !== content) {
-                await sd_core_node_1.FsUtil.writeFileAsync(distFilePath, content);
-                changedDistFilePaths.push(distFilePath);
-            }
-        }
-        return changedDistFilePaths;
-    }
-    _getRoutingModulePath(pageFilePath, pageClassName) {
-        if (pageFilePath === sd_core_node_1.PathUtil.posix(this._sourceDirPath, "AppPage.ts")) {
-            return sd_core_node_1.PathUtil.posix(this._sourceDirPath, "_routes.ts");
-        }
-        else {
-            return sd_core_node_1.PathUtil.posix(this._getGenNgModuleDistPath(pageFilePath), pageClassName + "RoutingModule.ts");
-        }
-    }
-    _getRoutingModuleText(routingModuleInfo, distFilePath) {
-        let content = "{\r\n";
-        content += `  path: "${routingModuleInfo.path}",\r\n`;
-        if (path.basename(distFilePath) !== "_routes.ts") {
-            content += `  component: ${routingModuleInfo.page.name},\r\n`;
-            content += `  canDeactivate: [SdCanDeactivateGuardProvider],\r\n`;
-        }
-        if (routingModuleInfo.children.length > 0) {
-            content += `  children: [\r\n`;
-            for (const child of routingModuleInfo.children) {
-                const childText = this._getRoutingModuleChildText(child, path.dirname(distFilePath));
-                content += "    " + childText.replace(/\r\n/g, "\r\n    ") + ",\r\n";
-            }
-            content = content.slice(0, -3) + "\r\n";
-            content += `  ],\r\n`;
-        }
-        return content.slice(0, -3) + "\r\n}";
-    }
-    _getRoutingModuleChildText(routingModuleChildInfo, distDirPath) {
-        let content = "{\r\n";
-        content += `  path: "${routingModuleChildInfo.path}",\r\n`;
-        if (routingModuleChildInfo.page) {
-            const routingModuleFilePath = this._getRoutingModulePath(routingModuleChildInfo.page.moduleFilePath, routingModuleChildInfo.page.name);
-            const moduleDirPath = "./" + sd_core_node_1.PathUtil.posix(path.dirname(path.relative(distDirPath, routingModuleFilePath)));
-            content += `  loadChildren: async () => await import("${moduleDirPath}/${routingModuleChildInfo.page.name}RoutingModule").then((m) => m.${routingModuleChildInfo.page.name}RoutingModule),\r\n`;
-        }
-        else if (routingModuleChildInfo.children && routingModuleChildInfo.children.length > 0) {
-            content += `  children: [\r\n`;
-            for (const child of routingModuleChildInfo.children) {
-                const childText = this._getRoutingModuleChildText(child, distDirPath);
-                content += "  " + childText.replace(/\r\n/g, "\r\n  ") + ",\r\n";
-            }
-            content = content.slice(0, -3) + "\r\n";
-            content += `  ],\r\n`;
-        }
-        return content.slice(0, -3) + "\r\n}";
-    }
-}
-exports.SdCliNgModuleFilesGenerator = SdCliNgModuleFilesGenerator;
-//# sourceMappingURL=SdCliNgModuleFilesGenerator.js.map