@abp/ng.schematics 9.2.0-rc.2 → 9.2.0-rc.3

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/.eslintrc.json.template

@@ -0,0 +1,44 @@
+{
+  "extends": "../../.eslintrc.json",
+  "ignorePatterns": [
+    "!**/*"
+  ],
+  "overrides": [
+    {
+      "files": [
+        "*.ts"
+      ],
+      "parserOptions": {
+        "project": [
+          "projects/<%= kebab(libraryName) %>/tsconfig.lib.json",
+          "projects/<%= kebab(libraryName) %>/tsconfig.spec.json"
+        ],
+        "createDefaultProgram": true
+      },
+      "rules": {
+        "@angular-eslint/directive-selector": [
+          "error",
+          {
+            "type": "attribute",
+            "prefix": "lib",
+            "style": "camelCase"
+          }
+        ],
+        "@angular-eslint/component-selector": [
+          "error",
+          {
+            "type": "element",
+            "prefix": "lib",
+            "style": "kebab-case"
+          }
+        ]
+      }
+    },
+    {
+      "files": [
+        "*.html"
+      ],
+      "rules": {}
+    }
+  ]
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/config/ng-package.json.template

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-entrypoint.schema.json",
+  "dest": "../../dist/<%= kebab(libraryName) %>/config",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/config/src/enums/index.ts.template

@@ -0,0 +1 @@
+export * from './route-names';

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/config/src/enums/route-names.ts.template

@@ -0,0 +1,3 @@
+export const enum e<%= pascal(libraryName) %>RouteNames {
+  <%= pascal(libraryName) %> = '<%= pascal(libraryName) %>',
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/config/src/providers/index.ts.template

@@ -0,0 +1 @@
+export * from './route.provider';

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/config/src/providers/route.provider.ts.template

@@ -0,0 +1,30 @@
+import { eLayoutType, RoutesService } from '@abp/ng.core';
+import { e<%= pascal(libraryName) %>RouteNames } from '../enums/route-names';
+import { makeEnvironmentProviders, provideAppInitializer, inject, EnvironmentProviders } from '@angular/core';
+
+export const <%= macro(libraryName) %>_ROUTE_PROVIDERS = [
+  provideAppInitializer(() => {
+    configureRoutes();
+  }),
+];
+
+export function configureRoutes() {
+  const routes = inject(RoutesService);
+  routes.add([
+      {
+        path: '/<%= kebab(libraryName) %>',
+        name: e<%= pascal(libraryName) %>RouteNames.<%= pascal(libraryName) %>,
+        iconClass: 'fas fa-book',
+        layout: eLayoutType.application,
+        order: 3,
+      },
+  ]);
+}
+
+export const <%= macro(libraryName) %>_PROVIDERS: EnvironmentProviders[] = [
+  ...<%= macro(libraryName) %>_ROUTE_PROVIDERS,
+];
+
+export function provide<%= pascal(libraryName) %>Config() {
+  return makeEnvironmentProviders(<%= macro(libraryName) %>_PROVIDERS);
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/config/src/public-api.ts.template

@@ -0,0 +1,2 @@
+export * from './enums';
+export * from './providers';

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/karma.conf.js.template

@@ -0,0 +1,44 @@
+// Karma configuration file, see link for more information
+// https://karma-runner.github.io/1.0/config/configuration-file.html
+
+module.exports = function (config) {
+  config.set({
+    basePath: '',
+    frameworks: ['jasmine', '@angular-devkit/build-angular'],
+    plugins: [
+      require('karma-jasmine'),
+      require('karma-chrome-launcher'),
+      require('karma-jasmine-html-reporter'),
+      require('karma-coverage'),
+      require('@angular-devkit/build-angular/plugins/karma')
+    ],
+    client: {
+      jasmine: {
+        // you can add configuration options for Jasmine here
+        // the possible options are listed at https://jasmine.github.io/api/edge/Configuration.html
+        // for example, you can disable the random execution with `random: false`
+        // or set a specific seed with `seed: 4321`
+      },
+      clearContext: false // leave Jasmine Spec Runner output visible in browser
+    },
+    jasmineHtmlReporter: {
+      suppressAll: true // removes the duplicated traces
+    },
+    coverageReporter: {
+      dir: require('path').join(__dirname, '../../coverage/<%= kebab(libraryName) %>'),
+      subdir: '.',
+      reporters: [
+        { type: 'html' },
+        { type: 'text-summary' }
+      ]
+    },
+    reporters: ['progress', 'kjhtml'],
+    port: 9876,
+    colors: true,
+    logLevel: config.LOG_INFO,
+    autoWatch: true,
+    browsers: ['Chrome'],
+    singleRun: false,
+    restartOnFileChange: true
+  });
+};

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/ng-package.json.template

@@ -0,0 +1,7 @@
+{
+  "$schema": "../../node_modules/ng-packagr/ng-package.schema.json",
+  "dest": "../../dist/<%= kebab(libraryName) %>",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/package.json.template

@@ -0,0 +1,11 @@
+{
+  "name": "@<%= kebab(libraryName) %>/<%= kebab(libraryName) %>",
+  "version": "0.0.1",
+  "peerDependencies": {
+    "@abp/ng.core": "<%= abpVersion %>",
+    "@abp/ng.theme.shared": "<%= abpVersion %>"
+  },
+  "dependencies": {
+    "tslib": "^2.1.0"
+  }
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/src/lib/__libraryName@kebab__.component.ts.template

@@ -0,0 +1,11 @@
+import { Component } from '@angular/core';
+import {CoreModule} from "@abp/ng.core";
+import {ThemeSharedModule} from "@abp/ng.theme.shared";
+
+@Component({
+  standalone: true,
+  selector: '<%= camel(libraryName) %>-home',
+  template: `<h1>Lazy Loaded Test Component</h1>`,
+  imports: [CoreModule, ThemeSharedModule],
+})
+export class <%= pascal(libraryName) %>Component {}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/src/lib/__libraryName@kebab__.routes.ts.template

@@ -0,0 +1,9 @@
+import { Routes } from '@angular/router';
+
+export const <%= macro(libraryName) %>_ROUTES: Routes = [
+  {
+    path: '',
+    loadComponent: () =>
+      import('./<%= kebab(libraryName) %>.component').then(m => m.<%= pascal(libraryName) %>Component),
+  },
+];

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/src/lib/index.ts.template

@@ -0,0 +1 @@
+export * from './<%= kebab(libraryName) %>.routes';

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/src/public-api.ts.template

@@ -0,0 +1,4 @@
+/*
+ * Public API Surface of my-project-name
+ */
+export * from './lib';

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/src/test.ts.template

@@ -0,0 +1,26 @@
+// This file is required by karma.conf.js and loads recursively all the .spec and framework files
+
+import 'zone.js';
+import 'zone.js/testing';
+import { getTestBed } from '@angular/core/testing';
+import {
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting
+} from '@angular/platform-browser-dynamic/testing';
+
+declare const require: {
+  context(path: string, deep?: boolean, filter?: RegExp): {
+    keys(): string[];
+    <T>(id: string): T;
+  };
+};
+
+// First, initialize the Angular testing environment.
+getTestBed().initTestEnvironment(
+  BrowserDynamicTestingModule,
+  platformBrowserDynamicTesting()
+);
+// Then we find all the tests.
+const context = require.context('./', true, /\.spec\.ts$/);
+// And load the modules.
+context.keys().map(context);

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/tsconfig.lib.json.template

@@ -0,0 +1,20 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/lib",
+    "target": "es2020",
+    "declaration": true,
+    "declarationMap": true,
+    "inlineSources": true,
+    "types": [],
+    "lib": [
+      "dom",
+      "es2018"
+    ]
+  },
+  "exclude": [
+    "src/test.ts",
+    "**/*.spec.ts"
+  ]
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/tsconfig.lib.prod.json.template

@@ -0,0 +1,10 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "./tsconfig.lib.json",
+  "compilerOptions": {
+    "declarationMap": false
+  },
+  "angularCompilerOptions": {
+    "compilationMode": "partial"
+  }
+}

package/commands/create-lib/files-package-standalone/__libraryName@kebab__/tsconfig.spec.json.template

@@ -0,0 +1,17 @@
+/* To learn more about this file see: https://angular.io/config/tsconfig. */
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../out-tsc/spec",
+    "types": [
+      "jasmine"
+    ]
+  },
+  "files": [
+    "src/test.ts"
+  ],
+  "include": [
+    "**/*.spec.ts",
+    "**/*.d.ts"
+  ]
+}

package/commands/create-lib/files-secondary-entrypoint-standalone/__libraryName@kebab__/ng-package.json.template

@@ -0,0 +1,6 @@
+{
+  "$schema": "../../../node_modules/ng-packagr/ng-entrypoint.schema.json",
+  "lib": {
+    "entryFile": "src/public-api.ts"
+  }
+}

package/commands/create-lib/files-secondary-entrypoint-standalone/__libraryName@kebab__/src/lib/__target@kebab__-__libraryName@kebab__.ts.template

@@ -0,0 +1,7 @@
+import { Provider } from '@angular/core';
+
+export function provide<%= pascal(target) %><%= pascal(libraryName) %>(): Provider[] {
+  return [
+    // Add your providers here
+  ];
+}

package/commands/create-lib/files-secondary-entrypoint-standalone/__libraryName@kebab__/src/lib/index.ts.template

@@ -0,0 +1 @@
+export * from './<%= kebab(target) %>-<%= kebab(libraryName) %>';

package/commands/create-lib/files-secondary-entrypoint-standalone/__libraryName@kebab__/src/public-api.ts.template

@@ -0,0 +1 @@
+export * from './lib/index';

package/commands/create-lib/index.d.ts

@@ -1,9 +1,13 @@
 import { Rule, Tree } from '@angular-devkit/schematics';
+import * as ts from 'typescript';
+import { InsertChange } from '../../utils';
 import { WorkspaceDefinition } from '../../utils/angular/workspace';
 import { GenerateLibSchema } from './models/generate-lib-schema';
 export default function (schema: GenerateLibSchema): (tree: Tree) => Promise<Rule | undefined>;
-export declare function addLibToWorkspaceIfNotExist(name: string, packagesDir: string): Rule;
+export declare function addLibToWorkspaceIfNotExist(options: GenerateLibSchema, packagesDir: string): Rule;
 export declare function updateTsConfig(packageName: string, path: string): (host: Tree) => import("@angular-devkit/schematics/src/tree/interface").Tree | undefined;
 export declare function createLibSecondaryEntry(tree: Tree, options: GenerateLibSchema): Promise<Rule>;
-export declare function importConfigModuleToDefaultProjectAppModule(workspace: WorkspaceDefinition, packageName: string): (tree: Tree) => void;
-export declare function addRoutingToAppRoutingModule(workspace: WorkspaceDefinition, packageName: string): (tree: Tree) => void;
+export declare function createLibSecondaryEntryWithStandaloneTemplate(tree: Tree, options: GenerateLibSchema): Promise<Rule>;
+export declare function importConfigModuleToDefaultProjectAppModule(packageName: string, options: GenerateLibSchema): (tree: Tree) => Promise<Rule | undefined>;
+export declare function addRoutingToAppRoutingModule(workspace: WorkspaceDefinition, packageName: string, options: GenerateLibSchema): Rule;
+export declare function addRouteToRoutesArray(source: ts.SourceFile, arrayName: string, routeToAdd: string): InsertChange | null;

package/commands/create-lib/index.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addRoutingToAppRoutingModule = exports.importConfigModuleToDefaultProjectAppModule = exports.createLibSecondaryEntry = exports.updateTsConfig = exports.addLibToWorkspaceIfNotExist = void 0;
+exports.addRouteToRoutesArray = exports.addRoutingToAppRoutingModule = exports.importConfigModuleToDefaultProjectAppModule = exports.createLibSecondaryEntryWithStandaloneTemplate = exports.createLibSecondaryEntry = exports.updateTsConfig = exports.addLibToWorkspaceIfNotExist = void 0;
 const schematics_1 = require("@angular-devkit/schematics");
 const ts = require("typescript");
 const core_1 = require("@angular-devkit/core");
 const utils_1 = require("../../utils");
 const generate_lib_1 = require("../../utils/angular-schematic/generate-lib");
 const cases = require("../../utils/text");
+const generate_lib_schema_1 = require("./models/generate-lib-schema");
+const util_1 = require("../../utils/angular/standalone/util");
 function default_1(schema) {
     return async (tree) => {
         if (schema.override || !(await checkLibExist(schema, tree))) {
@@ -36,11 +38,19 @@ function createLibrary(options) {
     return async (tree) => {
         const target = await (0, utils_1.resolveProject)(tree, options.packageName, null);
         if (!target || options.override) {
-            if (options.isModuleTemplate) {
+            if (options.isSecondaryEntrypoint) {
+                if (options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Standalone) {
+                    return createLibSecondaryEntryWithStandaloneTemplate(tree, options);
+                }
+                else {
+                    return createLibSecondaryEntry(tree, options);
+                }
+            }
+            if (options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Module) {
                 return createLibFromModuleTemplate(tree, options);
             }
-            if (options.isSecondaryEntrypoint) {
-                return createLibSecondaryEntry(tree, options);
+            else {
+                return createLibFromModuleStandaloneTemplate(tree, options);
             }
         }
         else {
@@ -71,13 +81,29 @@ async function createLibFromModuleTemplate(tree, options) {
             }),
             (0, schematics_1.move)((0, core_1.normalize)(packagesDir)),
         ]),
-        addLibToWorkspaceIfNotExist(options.packageName, packagesDir),
+        addLibToWorkspaceIfNotExist(options, packagesDir),
+    ]);
+}
+async function createLibFromModuleStandaloneTemplate(tree, options) {
+    const packagesDir = await resolvePackagesDirFromAngularJson(tree);
+    const packageJson = JSON.parse(tree.read('./package.json').toString());
+    const abpVersion = packageJson.dependencies['@abp/ng.core'];
+    return (0, schematics_1.chain)([
+        (0, utils_1.applyWithOverwrite)((0, schematics_1.url)('./files-package-standalone'), [
+            (0, schematics_1.applyTemplates)({
+                ...cases,
+                libraryName: options.packageName,
+                abpVersion,
+            }),
+            (0, schematics_1.move)((0, core_1.normalize)(packagesDir)),
+        ]),
+        addLibToWorkspaceIfNotExist(options, packagesDir),
     ]);
 }
-function addLibToWorkspaceIfNotExist(name, packagesDir) {
+function addLibToWorkspaceIfNotExist(options, packagesDir) {
     return async (tree) => {
         const workspace = await (0, utils_1.getWorkspace)(tree);
-        const packageName = (0, utils_1.kebab)(name);
+        const packageName = (0, utils_1.kebab)(options.packageName);
         const isProjectExist = workspace.projects.has(packageName);
         const projectRoot = (0, core_1.join)((0, core_1.normalize)(packagesDir), packageName);
         const pathImportLib = `${packagesDir}/${packageName}`;
@@ -89,8 +115,8 @@ function addLibToWorkspaceIfNotExist(name, packagesDir) {
                 : (0, schematics_1.noop)(),
             (0, generate_lib_1.addLibToWorkspaceFile)(projectRoot, packageName),
             updateTsConfig(packageName, pathImportLib),
-            importConfigModuleToDefaultProjectAppModule(workspace, packageName),
-            addRoutingToAppRoutingModule(workspace, packageName),
+            importConfigModuleToDefaultProjectAppModule(packageName, options),
+            addRoutingToAppRoutingModule(workspace, packageName, options),
         ]);
     };
 }
@@ -127,67 +153,144 @@ async function createLibSecondaryEntry(tree, options) {
     ]);
 }
 exports.createLibSecondaryEntry = createLibSecondaryEntry;
-function importConfigModuleToDefaultProjectAppModule(workspace, packageName) {
-    return (tree) => {
-        const projectName = (0, utils_1.readWorkspaceSchema)(tree).defaultProject || (0, utils_1.getFirstApplication)(tree).name;
-        const project = workspace.projects.get(projectName);
-        const appModulePath = `${project?.sourceRoot}/app/app.module.ts`;
-        const appModule = tree.read(appModulePath);
-        if (!appModule) {
-            return;
-        }
-        const appModuleContent = appModule.toString();
-        if (appModuleContent.includes(`${(0, utils_1.camel)(packageName)}ConfigModule`)) {
-            return;
-        }
-        const forRootStatement = `${(0, utils_1.pascal)(packageName)}ConfigModule.forRoot()`;
-        const text = tree.read(appModulePath);
-        if (!text) {
+async function createLibSecondaryEntryWithStandaloneTemplate(tree, options) {
+    const targetLib = await (0, utils_1.resolveProject)(tree, options.target);
+    const packageName = `${(0, utils_1.kebab)(targetLib.name)}/${(0, utils_1.kebab)(options.packageName)}`;
+    const importPath = `${targetLib.definition.root}/${(0, utils_1.kebab)(options.packageName)}`;
+    return (0, schematics_1.chain)([
+        (0, utils_1.applyWithOverwrite)((0, schematics_1.url)('./files-secondary-entrypoint-standalone'), [
+            (0, schematics_1.applyTemplates)({
+                ...cases,
+                libraryName: options.packageName,
+                target: targetLib.name,
+            }),
+            (0, schematics_1.move)((0, core_1.normalize)(targetLib.definition.root)),
+            updateTsConfig(packageName, importPath),
+        ]),
+    ]);
+}
+exports.createLibSecondaryEntryWithStandaloneTemplate = createLibSecondaryEntryWithStandaloneTemplate;
+function importConfigModuleToDefaultProjectAppModule(packageName, options) {
+    return async (tree) => {
+        const projectName = (0, utils_1.getFirstApplication)(tree).name;
+        const mainFilePath = await (0, util_1.getMainFilePath)(tree, projectName);
+        const isSourceStandalone = (0, utils_1.isStandaloneApp)(tree, mainFilePath);
+        const rules = [];
+        const providerAlreadyExists = isSourceStandalone
+            ? await (0, utils_1.hasProviderInStandaloneAppConfig)(tree, projectName, `provide${(0, utils_1.pascal)(packageName)}Config`)
+            : await (0, utils_1.hasImportInNgModule)(tree, projectName, options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Standalone
+                ? `provide${(0, utils_1.pascal)(packageName)}Config`
+                : `${(0, utils_1.pascal)(packageName)}ConfigModule`, options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Standalone ? 'providers' : 'imports');
+        if (providerAlreadyExists) {
             return;
         }
-        const sourceText = text.toString();
-        if (sourceText.includes(forRootStatement)) {
-            return;
+        if (options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Standalone) {
+            rules.push((0, utils_1.addRootProvider)(projectName, code => {
+                const configFn = code.external(`provide${(0, utils_1.pascal)(packageName)}Config`, `${(0, utils_1.kebab)(packageName)}/config`);
+                return code.code `${configFn}()`;
+            }));
         }
-        const source = ts.createSourceFile(appModulePath, sourceText, ts.ScriptTarget.Latest, true);
-        const changes = (0, utils_1.addImportToModule)(source, appModulePath, forRootStatement, `${(0, utils_1.kebab)(packageName)}/config`);
-        const recorder = tree.beginUpdate(appModulePath);
-        for (const change of changes) {
-            if (change instanceof utils_1.InsertChange) {
-                recorder.insertLeft(change.pos, change.toAdd);
-            }
+        else {
+            rules.push((0, utils_1.addRootImport)(projectName, code => {
+                const configFn = code.external(`${(0, utils_1.pascal)(packageName)}ConfigModule`, `${(0, utils_1.kebab)(packageName)}/config`);
+                return code.code `${configFn}.forRoot()`;
+            }));
         }
-        tree.commitUpdate(recorder);
-        return;
+        return (0, schematics_1.chain)(rules);
     };
 }
 exports.importConfigModuleToDefaultProjectAppModule = importConfigModuleToDefaultProjectAppModule;
-function addRoutingToAppRoutingModule(workspace, packageName) {
-    return (tree) => {
-        const projectName = (0, utils_1.readWorkspaceSchema)(tree).defaultProject || (0, utils_1.getFirstApplication)(tree).name;
+function addRoutingToAppRoutingModule(workspace, packageName, options) {
+    return async (tree) => {
+        const projectName = (0, utils_1.getFirstApplication)(tree).name;
         const project = workspace.projects.get(projectName);
-        const appRoutingModulePath = `${project?.sourceRoot}/app/app-routing.module.ts`;
-        const appRoutingModule = tree.read(appRoutingModulePath);
-        if (!appRoutingModule) {
-            return;
-        }
-        const appRoutingModuleContent = appRoutingModule.toString();
-        const moduleName = `${(0, utils_1.pascal)(packageName)}Module`;
-        if (appRoutingModuleContent.includes(moduleName)) {
-            return;
+        const mainFilePath = await (0, util_1.getMainFilePath)(tree, projectName);
+        const isSourceStandalone = (0, utils_1.isStandaloneApp)(tree, mainFilePath);
+        const pascalName = (0, utils_1.pascal)(packageName);
+        const macroName = (0, utils_1.macro)(packageName);
+        const routePath = `${(0, utils_1.kebab)(packageName)}`;
+        const moduleName = `${pascalName}Module`;
+        if (isSourceStandalone) {
+            const appRoutesPath = (0, utils_1.findAppRoutesPath)(tree, mainFilePath) || `${project?.sourceRoot}/app/app.routes.ts`;
+            const buffer = tree.read(appRoutesPath);
+            if (!buffer) {
+                throw new schematics_1.SchematicsException(`Cannot find routes file: ${appRoutesPath}`);
+            }
+            const content = buffer.toString();
+            const source = ts.createSourceFile(appRoutesPath, content, ts.ScriptTarget.Latest, true);
+            const routeExpr = options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Standalone
+                ? `() => import('${routePath}').then(m => m.${macroName}_ROUTES)`
+                : `() => import('${routePath}').then(m => m.${moduleName}.forLazy())`;
+            const routeToAdd = `{ path: '${routePath}', loadChildren: ${routeExpr} }`;
+            const change = addRouteToRoutesArray(source, 'APP_ROUTES', routeToAdd);
+            if (change instanceof utils_1.InsertChange) {
+                const recorder = tree.beginUpdate(appRoutesPath);
+                recorder.insertLeft(change.pos, change.toAdd);
+                tree.commitUpdate(recorder);
+            }
         }
-        const source = ts.createSourceFile(appRoutingModulePath, appRoutingModuleContent, ts.ScriptTarget.Latest, true);
-        const importPath = `${(0, utils_1.kebab)(packageName)}`;
-        const importStatement = `() => import('${importPath}').then(m => m.${moduleName}.forLazy())`;
-        const routeDefinition = `{ path: '${(0, utils_1.kebab)(packageName)}', loadChildren: ${importStatement} }`;
-        const change = (0, utils_1.addRouteDeclarationToModule)(source, `${(0, utils_1.kebab)(packageName)}`, routeDefinition);
-        const recorder = tree.beginUpdate(appRoutingModulePath);
-        if (change instanceof utils_1.InsertChange) {
-            recorder.insertLeft(change.pos, change.toAdd);
+        else {
+            const appRoutingModulePath = await (0, utils_1.findAppRoutesModulePath)(tree, mainFilePath);
+            if (!appRoutingModulePath) {
+                throw new schematics_1.SchematicsException(`Cannot find routing module: ${appRoutingModulePath}`);
+            }
+            const appRoutingModule = tree.read(appRoutingModulePath);
+            if (!appRoutingModule) {
+                return;
+            }
+            const appRoutingModuleContent = appRoutingModule.toString();
+            const routeExpr = options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Standalone
+                ? `${macroName}_ROUTES`
+                : moduleName;
+            if (appRoutingModuleContent.includes(routeExpr)) {
+                return;
+            }
+            const source = ts.createSourceFile(appRoutingModulePath, appRoutingModuleContent, ts.ScriptTarget.Latest, true);
+            const importStatement = options.templateType === generate_lib_schema_1.GenerateLibTemplateType.Standalone
+                ? `() => import('${routePath}').then(m => m.${macroName}_ROUTES)`
+                : `() => import('${routePath}').then(m => m.${moduleName}.forLazy())`;
+            const routeDefinition = `{ path: '${routePath}', loadChildren: ${importStatement} }`;
+            const change = (0, utils_1.addRouteDeclarationToModule)(source, routePath, routeDefinition);
+            const recorder = tree.beginUpdate(appRoutingModulePath);
+            if (change instanceof utils_1.InsertChange) {
+                recorder.insertLeft(change.pos, change.toAdd);
+            }
+            tree.commitUpdate(recorder);
         }
-        tree.commitUpdate(recorder);
         return;
     };
 }
 exports.addRoutingToAppRoutingModule = addRoutingToAppRoutingModule;
+function addRouteToRoutesArray(source, arrayName, routeToAdd) {
+    const routesVar = source.statements.find(stmt => ts.isVariableStatement(stmt) &&
+        stmt.declarationList.declarations.some(decl => ts.isVariableDeclaration(decl) &&
+            (decl.name.getText() === arrayName || decl.name.getText() === arrayName.toUpperCase()) &&
+            decl.initializer !== undefined &&
+            ts.isArrayLiteralExpression(decl.initializer)));
+    if (!routesVar || !ts.isVariableStatement(routesVar)) {
+        throw new Error(`Could not find routes array named "${arrayName}".`);
+    }
+    const declaration = routesVar.declarationList.declarations.find(decl => decl.name.getText() === arrayName);
+    const arrayLiteral = declaration.initializer;
+    const getPathValue = (routeText) => {
+        const match = routeText.match(/path:\s*['"`](.+?)['"`]/);
+        return match?.[1] ?? null;
+    };
+    const newPath = getPathValue(routeToAdd);
+    const alreadyExists = arrayLiteral.elements.some(el => {
+        const existingPath = getPathValue(el.getText());
+        return existingPath === newPath;
+    });
+    if (alreadyExists) {
+        return null;
+    }
+    const hasTrailingComma = arrayLiteral.elements.hasTrailingComma ?? false;
+    const insertPos = hasTrailingComma || arrayLiteral.elements.length === 0
+        ? arrayLiteral.getEnd() - 1
+        : arrayLiteral.elements[arrayLiteral.elements.length - 1].getEnd();
+    const prefix = arrayLiteral.elements.length > 0 && !hasTrailingComma ? ',\n  ' : '  ';
+    const toAdd = `${prefix}${routeToAdd}`;
+    return new utils_1.InsertChange(source.fileName, insertPos, toAdd);
+}
+exports.addRouteToRoutesArray = addRouteToRoutesArray;
 //# sourceMappingURL=index.js.map