@tsparticles/cli 3.0.1 → 3.0.3

package/src/create/shape/create-shape.ts

@@ -1,4 +1,4 @@
-import { camelize, capitalize, dash } from "../../utils/string-utils";
+import { camelize, capitalize, dash } from "../../utils/string-utils.js";
 import {
     copyEmptyTemplateFiles,
     copyFilter,
@@ -7,10 +7,10 @@ import {
     updatePackageDistFile,
     updatePackageFile,
     updateWebpackFile,
-} from "../../utils/template-utils";
+} from "../../utils/template-utils.js";
 import fs from "fs-extra";
 import path from "path";
-import { replaceTokensInFile } from "../../utils/file-utils";
+import { replaceTokensInFile } from "../../utils/file-utils.js";
 
 /**
  * Updates the index file with the correct function name

package/src/create/shape/shape.ts

@@ -1,8 +1,8 @@
-import { getDestinationDir, getRepositoryUrl } from "../../utils/file-utils";
+import { getDestinationDir, getRepositoryUrl } from "../../utils/file-utils.js";
 import prompts, { type PromptObject } from "prompts";
 import { Command } from "commander";
-import { capitalize } from "../../utils/string-utils";
-import { createShapeTemplate } from "./create-shape";
+import { capitalize } from "../../utils/string-utils.js";
+import { createShapeTemplate } from "./create-shape.js";
 import path from "path";
 
 const shapeCommand = new Command("shape");

package/src/tsconfig.json

@@ -27,7 +27,7 @@
         // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
 
         /* Modules */
-        "module": "commonjs",
+        "module": "es2020",
         /* Specify what module code is generated. */
         "rootDir": ".",
         /* Specify the root folder within your source files. */

package/src/utils/template-utils.ts

@@ -2,7 +2,7 @@ import { exec } from "child_process";
 import fs from "fs-extra";
 import { lookpath } from "lookpath";
 import path from "path";
-import { replaceTokensInFile } from "./file-utils";
+import { replaceTokensInFile } from "./file-utils.js";
 
 /**
  * Updates the package.json file

package/tests/create-plugin.test.ts

@@ -1,10 +1,9 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
+import { describe, it, expect } from "vitest";
 import { createPluginTemplate } from "../src/create/plugin/create-plugin";
 import path from "path";
 import fs from "fs-extra";
 
-describe("create-plugin", async () => {
+describe("create-plugin", () => {
     it("should have created the plugin project", async () => {
         const destDir = path.resolve(path.join(__dirname, "tmp-files", "foo-plugin"));
 
@@ -12,7 +11,7 @@ describe("create-plugin", async () => {
 
         const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
 
-        expect(pkgInfo.name).to.be.equal("tsparticles-plugin-foo");
+        expect(pkgInfo.name).toBe("tsparticles-plugin-foo");
 
         await fs.remove(destDir);
     });
@@ -24,7 +23,7 @@ describe("create-plugin", async () => {
 
         const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
 
-        expect(pkgInfo.name).to.be.equal("tsparticles-plugin-bar");
+        expect(pkgInfo.name).toBe("tsparticles-plugin-bar");
 
         await fs.remove(destDir);
     });

package/tests/create-preset.test.ts

@@ -1,10 +1,9 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
+import { describe, it, expect } from "vitest";
 import { createPresetTemplate } from "../src/create/preset/create-preset";
 import path from "path";
 import fs from "fs-extra";
 
-describe("create-preset", async () => {
+describe("create-preset", () => {
     it("should have created the preset project", async () => {
         const destDir = path.resolve(path.join(__dirname, "tmp-files", "foo-preset"));
 
@@ -12,7 +11,7 @@ describe("create-preset", async () => {
 
         const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
 
-        expect(pkgInfo.name).to.be.equal("tsparticles-preset-foo");
+        expect(pkgInfo.name).toBe("tsparticles-preset-foo");
 
         await fs.remove(destDir);
     });
@@ -24,7 +23,7 @@ describe("create-preset", async () => {
 
         const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
 
-        expect(pkgInfo.name).to.be.equal("tsparticles-preset-bar");
+        expect(pkgInfo.name).toBe("tsparticles-preset-bar");
 
         await fs.remove(destDir);
     });

package/tests/create-shape.test.ts

@@ -1,10 +1,9 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
+import { describe, it, expect } from "vitest";
 import { createShapeTemplate } from "../src/create/shape/create-shape";
 import path from "path";
 import fs from "fs-extra";
 
-describe("create-shape", async () => {
+describe("create-shape", () => {
     it("should have created the shape project", async () => {
         const destDir = path.resolve(path.join(__dirname, "tmp-files", "foo-shape"));
 
@@ -12,7 +11,7 @@ describe("create-shape", async () => {
 
         const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
 
-        expect(pkgInfo.name).to.be.equal("tsparticles-shape-foo");
+        expect(pkgInfo.name).toBe("tsparticles-shape-foo");
 
         await fs.remove(destDir);
     });
@@ -24,7 +23,7 @@ describe("create-shape", async () => {
 
         const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
 
-        expect(pkgInfo.name).to.be.equal("tsparticles-shape-bar");
+        expect(pkgInfo.name).toBe("tsparticles-shape-bar");
 
         await fs.remove(destDir);
     });

package/tests/file-utils.test.ts

@@ -1,5 +1,4 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
+import { describe, it, expect, after } from "vitest";
 import fs from "fs-extra";
 import path from "path";
 import {
@@ -36,8 +35,8 @@ describe("file-utils", async () => {
             const data1 = await fs.readFile(path.join(baseDir, "files1.txt"), "utf8"),
                 data2 = await fs.readFile(path.join(baseDir, "files2.txt"), "utf8");
 
-            expect(data1).to.be.equal("test1");
-            expect(data2).to.be.equal("test2");
+            expect(data1).toBe("test1");
+            expect(data2).toBe("test2");
         });
     });
 
@@ -55,7 +54,7 @@ describe("file-utils", async () => {
         it("should replace tokens in files", async () => {
             const data = await fs.readFile(path.join(baseDir, "file1.txt"), "utf8");
 
-            expect(data).to.be.equal("test1");
+            expect(data).toBe("test1");
         });
     });
 
@@ -63,13 +62,13 @@ describe("file-utils", async () => {
         const destDir = await getDestinationDir(path.join(baseDir, "baz"));
 
         it("should return the destination dir", () => {
-            expect(destDir).to.be.equal(path.join(baseDir, "baz"));
+            expect(destDir).toBe(path.join(baseDir, "baz"));
         });
 
         it("should return the destination dir", async () => {
             const destDir2 = await getDestinationDir(path.join(baseDir, "baz"));
 
-            expect(destDir2).to.be.equal(path.join(baseDir, "baz"));
+            expect(destDir2).toBe(path.join(baseDir, "baz"));
         });
 
         it("should throw exception", async () => {
@@ -85,13 +84,13 @@ describe("file-utils", async () => {
                 ex = true;
             }
 
-            expect(ex).to.be.equal(true);
+            expect(ex).toBe(true);
         });
     });
 
     describe("get repository url", () => {
         it("should return the repository url", async () => {
-            expect(await getRepositoryUrl()).to.be.not.equal("");
+            expect(await getRepositoryUrl()).not.toBe("");
         });
     });
 

package/tests/string-utils.test.ts

@@ -1,125 +1,124 @@
-import { describe, it } from "mocha";
-import { expect } from "chai";
+import { describe, it, expect } from "vitest";
 import { camelize, capitalize, dash } from "../src/utils/string-utils";
 
 describe("capitalize", () => {
     describe("empty string", () => {
-        expect(capitalize("")).to.be.equal("");
+        expect(capitalize("")).toBe("");
     });
 
     describe("lowercase string", () => {
         it("should return capitalized string", () => {
-            expect(capitalize("test")).to.be.equal("Test");
+            expect(capitalize("test")).toBe("Test");
         });
     });
 
     describe("capitalized string", () => {
         it("should return capitalized string", () => {
-            expect(capitalize("Test")).to.be.equal("Test");
+            expect(capitalize("Test")).toBe("Test");
         });
     });
 
     describe("multiple lowercase words string", () => {
         it("should return capitalized string, no split", () => {
-            expect(capitalize("test test")).to.be.equal("Test test");
+            expect(capitalize("test test")).toBe("Test test");
         });
 
         it("should return capitalized string, split", () => {
-            expect(capitalize("test test", " ")).to.be.equal("TestTest");
+            expect(capitalize("test test", " ")).toBe("TestTest");
         });
 
         it("should return capitalized string, wrong split", () => {
-            expect(capitalize("test test", ";")).to.be.equal("Test test");
+            expect(capitalize("test test", ";")).toBe("Test test");
         });
     });
 
     describe("multiple uppercase words string", () => {
         it("should return capitalized string, no split", () => {
-            expect(capitalize("Test Test")).to.be.equal("Test Test");
+            expect(capitalize("Test Test")).toBe("Test Test");
         });
 
         it("should return capitalized string, split", () => {
-            expect(capitalize("Test Test", " ")).to.be.equal("TestTest");
+            expect(capitalize("Test Test", " ")).toBe("TestTest");
         });
 
         it("should return capitalized string, wrong split", () => {
-            expect(capitalize("Test Test", ";")).to.be.equal("Test Test");
+            expect(capitalize("Test Test", ";")).toBe("Test Test");
         });
     });
 });
 
 describe("camelize", () => {
     describe("empty string", () => {
-        expect(camelize("")).to.be.equal("");
+        expect(camelize("")).toBe("");
     });
 
     describe("lowercase string", () => {
         it("should return camelized string", () => {
-            expect(camelize("test")).to.be.equal("test");
+            expect(camelize("test")).toBe("test");
         });
     });
 
     describe("uppercase string", () => {
         it("should return camelized string", () => {
-            expect(camelize("Test")).to.be.equal("test");
+            expect(camelize("Test")).toBe("test");
         });
     });
 
     describe("multiple lowercase words string", () => {
         it("should return camelized string, no split", () => {
-            expect(camelize("test test")).to.be.equal("test test");
+            expect(camelize("test test")).toBe("test test");
         });
 
         it("should return camelized string, split", () => {
-            expect(camelize("test test", " ")).to.be.equal("testTest");
+            expect(camelize("test test", " ")).toBe("testTest");
         });
 
         it("should return camelized string, wrong split", () => {
-            expect(camelize("test test", ";")).to.be.equal("test test");
+            expect(camelize("test test", ";")).toBe("test test");
         });
     });
 
     describe("multiple uppercase words string", () => {
         it("should return camelized string, no split", () => {
-            expect(camelize("Test Test")).to.be.equal("test Test");
+            expect(camelize("Test Test")).toBe("test Test");
         });
 
         it("should return camelized string, split", () => {
-            expect(camelize("Test Test", " ")).to.be.equal("testTest");
+            expect(camelize("Test Test", " ")).toBe("testTest");
         });
 
         it("should return camelized string, wrong split", () => {
-            expect(camelize("Test Test", ";")).to.be.equal("test Test");
+            expect(camelize("Test Test", ";")).toBe("test Test");
         });
     });
 });
 
 describe("dash", () => {
     describe("empty string", () => {
-        expect(dash("")).to.be.equal("");
+        expect(dash("")).toBe("");
     });
 
     describe("lowercase string", () => {
         it("should return dashed string", () => {
-            expect(dash("test")).to.be.equal("test");
+            expect(dash("test")).toBe("test");
         });
     });
 
     describe("uppercase string", () => {
         it("should return dashed string", () => {
-            expect(dash("Test")).to.be.equal("test");
+            expect(dash("Test")).toBe("test");
         });
     });
 
     describe("capitalized word string", () => {
         it("should return dashed string", () => {
-            expect(dash("TestTest")).to.be.equal("test-test");
+            expect(dash("TestTest")).toBe("test-test");
         });
     });
 
     describe("camelized word string", () => {
         it("should return dashed string", () => {
-            expect(dash("testTest")).to.be.equal("test-test");
+            expect(dash("testTest")).toBe("test-test");
         });
     });
 });

package/tests/tsconfig.json

@@ -3,7 +3,7 @@
         "target": "ES2021",
         "module": "commonjs",
         "lib": ["ESNext", "ES2022", "ES2021", "ES2020", "ES2019", "ES2018", "ES2017", "ES2016", "ES2015", "DOM"],
-        "types": ["jsdom", "mocha", "chai", "node"],
+        "types": ["jsdom", "vitest", "node"],
         "allowJs": true,
         "rootDir": ".",
         "declaration": false,
@@ -21,4 +21,5 @@
         "forceConsistentCasingInFileNames": true
     },
     "references": [{ "path": "../src" }],
+    "include": ["**/*.ts"]
 }

package/vitest.config.ts

@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/**/*.test.ts"],
+    testTimeout: 30000
+  }
+});
+

package/files/empty-project/.eslintignore

@@ -1,2 +0,0 @@
-dist
-node_modules

package/files/empty-project/.eslintrc.js

@@ -1,5 +0,0 @@
-module.exports = {
-    extends: [
-        "@tsparticles/eslint-config",
-    ]
-};