@igniteui/angular-schematics 21.1.1490 → 21.1.1492

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@igniteui/angular-schematics",
-  "version": "21.1.1490",
+  "version": "21.1.1492",
   "description": "Ignite UI for Angular Schematics for ng new and ng generate",
   "repository": {
     "type": "git",
@@ -22,8 +22,8 @@
   "dependencies": {
     "@angular-devkit/core": "^21.0.0",
     "@angular-devkit/schematics": "^21.0.0",
-    "@igniteui/angular-templates": "~21.1.1490",
-    "@igniteui/cli-core": "~14.9.0",
+    "@igniteui/angular-templates": "~21.1.1492",
+    "@igniteui/cli-core": "~14.9.2",
     "@schematics/angular": "^21.0.0",
     "minimatch": "^10.0.1",
     "rxjs": "~7.8.1"

package/src/ng-new/index.js

@@ -148,7 +148,7 @@ function newProject(options) {
                     installChain.push(installTask);
                 }
                 if (!options.skipGit) {
-                    const gitTask = context.addTask(new tasks_1.RepositoryInitializerTask(options.name, { message: `Initial commit for project: ${options.name}` }), [...installChain] //copy
+                    const gitTask = context.addTask(new tasks_1.RepositoryInitializerTask(options.name, { message: `Initial commit for project` }), [...installChain] //copy
                     );
                     installChain.push(gitTask);
                 }

package/src/ng-new/index_spec.js

@@ -149,7 +149,7 @@ describe("Schematics ng-new", () => {
                 authorEmail: undefined,
                 authorName: undefined,
                 commit: true,
-                message: `Initial commit for project: ${workingDirectory}`
+                message: `Initial commit for project`
             };
             const expectedStart = {
                 collection: null,
@@ -199,7 +199,7 @@ describe("Schematics ng-new", () => {
                 authorEmail: undefined,
                 authorName: undefined,
                 commit: true,
-                message: `Initial commit for project: ${workingDirectory}`
+                message: `Initial commit for project`
             };
             expect(taskOptions.length).toBe(2);
             expect(mockProject.upgradeIgniteUIPackages).toHaveBeenCalled();

package/src/utils/NgFileSystem.js

@@ -39,7 +39,9 @@ class NgTreeFileSystem {
         return (this.tree.read(filePath) || "").toString();
     }
     writeFile(filePath, text) {
-        return this.tree.overwrite(filePath, text);
+        this.tree.exists(filePath)
+            ? this.tree.overwrite(filePath, text)
+            : this.tree.create(filePath, text);
     }
     directoryExists(dirPath) {
         const dir = this.tree.getDir(dirPath);

package/src/utils/NgFileSystem.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/src/utils/NgFileSystem.spec.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schematics_1 = require("@angular-devkit/schematics");
+const testing_1 = require("@angular-devkit/schematics/testing");
+const NgFileSystem_1 = require("./NgFileSystem");
+describe("NgTreeFileSystem", () => {
+    let tree;
+    let fs;
+    beforeEach(() => {
+        tree = new testing_1.UnitTestTree(new schematics_1.EmptyTree());
+        fs = new NgFileSystem_1.NgTreeFileSystem(tree);
+    });
+    describe("fileExists", () => {
+        it("should return true when the file exists in the tree", () => {
+            tree.create("/src/app/app.component.ts", "content");
+            expect(fs.fileExists("/src/app/app.component.ts")).toBeTrue();
+        });
+        it("should return false when the file does not exist in the tree", () => {
+            expect(fs.fileExists("/src/missing.ts")).toBeFalse();
+        });
+    });
+    describe("readFile", () => {
+        it("should return the file content as a string", () => {
+            tree.create("/src/app/app.component.ts", "export class AppComponent {}");
+            expect(fs.readFile("/src/app/app.component.ts")).toBe("export class AppComponent {}");
+        });
+        it("should return an empty string when the file does not exist", () => {
+            expect(fs.readFile("/src/nonexistent.ts")).toBe("");
+        });
+        it("should ignore the encoding parameter and still return the content", () => {
+            tree.create("/src/file.txt", "hello");
+            expect(fs.readFile("/src/file.txt", "utf-8")).toBe("hello");
+        });
+    });
+    describe("writeFile", () => {
+        it("should create a new file when it does not exist", () => {
+            fs.writeFile("/src/new-file.ts", "new content");
+            expect(tree.readContent("/src/new-file.ts")).toBe("new content");
+        });
+        it("should overwrite an existing file", () => {
+            tree.create("/src/existing.ts", "original content");
+            fs.writeFile("/src/existing.ts", "updated content");
+            expect(tree.readContent("/src/existing.ts")).toBe("updated content");
+        });
+    });
+    describe("directoryExists", () => {
+        it("should return true when the directory contains files", () => {
+            tree.create("/src/app/app.component.ts", "");
+            expect(fs.directoryExists("/src/app")).toBeTrue();
+        });
+        it("should return true when the directory contains subdirectories", () => {
+            tree.create("/src/app/nested/file.ts", "");
+            expect(fs.directoryExists("/src/app")).toBeTrue();
+        });
+        it("should return false for an empty or non-existent directory", () => {
+            expect(fs.directoryExists("/src/nonexistent")).toBeFalse();
+        });
+    });
+    describe("glob", () => {
+        beforeEach(() => {
+            tree.create("/src/app/app.component.ts", "");
+            tree.create("/src/app/app.module.ts", "");
+            tree.create("/src/app/shared/shared.component.ts", "");
+            tree.create("/src/environments/environment.ts", "");
+            tree.create("/src/environments/environment.prod.ts", "");
+        });
+        it("should return all files matching the pattern", () => {
+            const results = fs.glob("/src", "**/*.ts");
+            expect(results).toContain("/src/app/app.component.ts");
+            expect(results).toContain("/src/app/app.module.ts");
+            expect(results).toContain("/src/app/shared/shared.component.ts");
+            expect(results).toContain("/src/environments/environment.ts");
+            expect(results).toContain("/src/environments/environment.prod.ts");
+        });
+        it("should return only files matching a specific pattern", () => {
+            const results = fs.glob("/src", "**/environment*.ts");
+            expect(results).toContain("/src/environments/environment.ts");
+            expect(results).toContain("/src/environments/environment.prod.ts");
+            expect(results).not.toContain("/src/app/app.component.ts");
+        });
+        it("should return an empty array when no files match the pattern", () => {
+            const results = fs.glob("/src", "**/*.html");
+            expect(results).toEqual([]);
+        });
+        it("should skip subdirectories matching ignorePatterns", () => {
+            tree.create("/src/node_modules/lib/index.ts", "");
+            const results = fs.glob("/src", "**/*.ts", ["node_modules"]);
+            expect(results.some(r => r.includes("node_modules"))).toBeFalse();
+        });
+        it("should return an empty array when dirPath does not exist", () => {
+            const results = fs.glob("/nonexistent", "**/*.ts");
+            expect(results).toEqual([]);
+        });
+    });
+});