@tsparticles/cli 1.11.0 → 1.13.0

package/src/utils/template-utils.ts

@@ -1,6 +1,7 @@
 import { execSync } from "child_process";
 import fs from "fs-extra";
 import path from "path";
+import { replaceTokensInFile } from "./file-utils";
 
 /**
  * Updates the package.json file
@@ -17,22 +18,35 @@ export async function updatePackageFile(
     fileName: string,
     repoUrl: string,
 ): Promise<void> {
-    const packagePath = path.resolve(destPath, "package.json"),
-        packageContents = await fs.readFile(packagePath, "utf-8"),
-        descriptionRegex = /"tsParticles empty template"/g,
-        replacedDescriptionText = packageContents.replace(descriptionRegex, `"${description}"`),
-        fileRegex = /"tsparticles.empty.template.min.js"/g,
-        replacedFileText = replacedDescriptionText.replace(fileRegex, fileName),
-        privateRegex = /\s{4}"private": true,\r?\n?/g,
-        replacedPrivateText = replacedFileText.replace(privateRegex, ""),
-        nameRegex = /"@tsparticles\/empty-template"/g,
-        nameReplacedText = replacedPrivateText.replace(nameRegex, packageName),
-        repoUrlRegex = /"url": "git\+https:\/\/github\.com\/tsparticles\/empty-template\.git"/g,
-        repoUrlReplacedText = nameReplacedText.replace(repoUrlRegex, `"url": "git+${repoUrl}"`),
-        issuesUrlRegex = /"url": "https:\/\/github\.com\/tsparticles\/empty-template\/issues"/g,
-        replacedText = repoUrlReplacedText.replace(issuesUrlRegex, `"url": "${repoUrl.replace(".git", "/issues")}"`);
-
-    await fs.writeFile(packagePath, replacedText);
+    await replaceTokensInFile({
+        path: path.resolve(destPath, "package.json"),
+        tokens: [
+            {
+                from: /"tsParticles empty template"/g,
+                to: `"${description}"`,
+            },
+            {
+                from: /"tsparticles.empty.template.min.js"/g,
+                to: `"${fileName}"`,
+            },
+            {
+                from: /\s{4}"private": true,\r?\n?/g,
+                to: "",
+            },
+            {
+                from: /"@tsparticles\/empty-template"/g,
+                to: `"${packageName}"`,
+            },
+            {
+                from: /"url": "git\+https:\/\/github\.com\/tsparticles\/empty-template\.git"/g,
+                to: `"url": "git+${repoUrl}"`,
+            },
+            {
+                from: /"url": "https:\/\/github\.com\/tsparticles\/empty-template\/issues"/g,
+                to: `"url": "${repoUrl.replace(".git", "/issues")}"`,
+            },
+        ],
+    });
 }
 
 /**
@@ -50,22 +64,35 @@ export async function updatePackageDistFile(
     fileName: string,
     repoUrl: string,
 ): Promise<void> {
-    const packagePath = path.resolve(destPath, "package.dist.json"),
-        packageContents = await fs.readFile(packagePath, "utf-8"),
-        descriptionRegex = /"tsParticles empty template"/g,
-        replacedDescriptionText = packageContents.replace(descriptionRegex, `"${description}"`),
-        fileRegex = /"tsparticles.empty.template.min.js"/g,
-        replacedFileText = replacedDescriptionText.replace(fileRegex, fileName),
-        privateRegex = /\s{4}"private": true,\r?\n?/g,
-        replacedPrivateText = replacedFileText.replace(privateRegex, ""),
-        nameRegex = /"@tsparticles\/empty-template"/g,
-        nameReplacedText = replacedPrivateText.replace(nameRegex, packageName),
-        repoUrlRegex = /"url": "git\+https:\/\/github\.com\/tsparticles\/empty-template\.git"/g,
-        repoUrlReplacedText = nameReplacedText.replace(repoUrlRegex, `"url": "git+${repoUrl}"`),
-        issuesUrlRegex = /"url": "https:\/\/github\.com\/tsparticles\/empty-template\/issues"/g,
-        replacedText = repoUrlReplacedText.replace(issuesUrlRegex, `"url": "${repoUrl.replace(".git", "/issues")}"`);
-
-    await fs.writeFile(packagePath, replacedText);
+    await replaceTokensInFile({
+        path: path.resolve(destPath, "package.dist.json"),
+        tokens: [
+            {
+                from: /"tsParticles empty template"/g,
+                to: `"${description}"`,
+            },
+            {
+                from: /"tsparticles.empty.template.min.js"/g,
+                to: `"${fileName}"`,
+            },
+            {
+                from: /\s{4}"private": true,\r?\n?/g,
+                to: "",
+            },
+            {
+                from: /"@tsparticles\/empty-template"/g,
+                to: `"${packageName}"`,
+            },
+            {
+                from: /"url": "git\+https:\/\/github\.com\/tsparticles\/empty-template\.git"/g,
+                to: `"url": "git+${repoUrl}"`,
+            },
+            {
+                from: /"url": "https:\/\/github\.com\/tsparticles\/empty-template\/issues"/g,
+                to: `"url": "${repoUrl.replace(".git", "/issues")}"`,
+            },
+        ],
+    });
 }
 
 /**
@@ -81,16 +108,23 @@ export async function updateWebpackFile(
     description: string,
     fnName: string,
 ): Promise<void> {
-    const webpackPath = path.resolve(destPath, "webpack.config.js"),
-        webpack = await fs.readFile(webpackPath, "utf-8"),
-        webpackDescriptionRegex = /tsParticles Empty Template/g,
-        replacedDescriptionText = webpack.replace(webpackDescriptionRegex, description),
-        webpackEntryRegex = /"template(\.bundle)?"/g,
-        replacedNameText = replacedDescriptionText.replace(webpackEntryRegex, `"${name}$1"`),
-        webpackFunctionNameRegex = /loadParticlesTemplate/g,
-        replacedFunctionNameText = replacedNameText.replace(webpackFunctionNameRegex, fnName);
-
-    await fs.writeFile(webpackPath, replacedFunctionNameText);
+    await replaceTokensInFile({
+        path: path.resolve(destPath, "webpack.config.js"),
+        tokens: [
+            {
+                from: /"Empty"/g,
+                to: `"${description}"`,
+            },
+            {
+                from: /"empty"/g,
+                to: `"${name}"`,
+            },
+            {
+                from: /loadParticlesTemplate/g,
+                to: fnName,
+            },
+        ],
+    });
 }
 
 /**
@@ -98,9 +132,7 @@ export async function updateWebpackFile(
  * @param destPath - The path where the project will be created
  */
 export async function copyEmptyTemplateFiles(destPath: string): Promise<void> {
-    const emptyPath = path.resolve(__dirname, "..", "..", "files", "empty-project");
-
-    await fs.copy(emptyPath, destPath, {
+    await fs.copy(path.resolve(__dirname, "..", "..", "files", "empty-project"), destPath, {
         overwrite: true,
         filter: copyFilter,
     });

package/tests/create-plugin.test.ts

@@ -0,0 +1,31 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { createPluginTemplate } from "../src/create/plugin/create-plugin";
+import path from "path";
+import fs from "fs-extra";
+
+describe("create-plugin", async () => {
+    it("should have created the plugin project", async () => {
+        const destDir = path.resolve(path.join(__dirname, "tmp-files", "foo-plugin"));
+
+        await createPluginTemplate("foo", "Foo", "", destDir);
+
+        const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
+
+        expect(pkgInfo.name).to.be.equal("tsparticles-plugin-foo");
+
+        await fs.remove(destDir);
+    });
+
+    it("should have created the plugin project, w/ repo", async () => {
+        const destDir = path.resolve(path.join(__dirname, "tmp-files", "bar-plugin"));
+
+        await createPluginTemplate("bar", "Bar", "https://github.com/matteobruni/tsparticles", destDir);
+
+        const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
+
+        expect(pkgInfo.name).to.be.equal("tsparticles-plugin-bar");
+
+        await fs.remove(destDir);
+    });
+});

package/tests/create-preset.test.ts

@@ -0,0 +1,31 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { createPresetTemplate } from "../src/create/preset/create-preset";
+import path from "path";
+import fs from "fs-extra";
+
+describe("create-plugin", async () => {
+    it("should have created the preset project", async () => {
+        const destDir = path.resolve(path.join(__dirname, "tmp-files", "foo-preset"));
+
+        await createPresetTemplate("foo", "Foo", "", destDir);
+
+        const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
+
+        expect(pkgInfo.name).to.be.equal("tsparticles-preset-foo");
+
+        await fs.remove(destDir);
+    });
+
+    it("should have created the preset project, w/ repo", async () => {
+        const destDir = path.resolve(path.join(__dirname, "tmp-files", "bar-preset"));
+
+        await createPresetTemplate("bar", "Bar", "https://github.com/matteobruni/tsparticles", destDir);
+
+        const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
+
+        expect(pkgInfo.name).to.be.equal("tsparticles-preset-bar");
+
+        await fs.remove(destDir);
+    });
+});

package/tests/create-shape.test.ts

@@ -0,0 +1,31 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import { createShapeTemplate } from "../src/create/shape/create-shape";
+import path from "path";
+import fs from "fs-extra";
+
+describe("create-shape", async () => {
+    it("should have created the shape project", async () => {
+        const destDir = path.resolve(path.join(__dirname, "tmp-files", "foo-shape"));
+
+        await createShapeTemplate("foo", "Foo", "", destDir);
+
+        const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
+
+        expect(pkgInfo.name).to.be.equal("tsparticles-shape-foo");
+
+        await fs.remove(destDir);
+    });
+
+    it("should have created the shape project, w/ repo", async () => {
+        const destDir = path.resolve(path.join(__dirname, "tmp-files", "bar-shape"));
+
+        await createShapeTemplate("bar", "Bar", "https://github.com/matteobruni/tsparticles", destDir);
+
+        const pkgInfo = await fs.readJSON(path.join(destDir, "package.json"));
+
+        expect(pkgInfo.name).to.be.equal("tsparticles-shape-bar");
+
+        await fs.remove(destDir);
+    });
+});

package/tests/file-utils.test.ts

@@ -0,0 +1,101 @@
+import { describe, it } from "mocha";
+import { expect } from "chai";
+import fs from "fs-extra";
+import path from "path";
+import {
+    getDestinationDir,
+    getRepositoryUrl,
+    replaceTokensInFile,
+    replaceTokensInFiles,
+} from "../src/utils/file-utils";
+
+describe("file-utils", async () => {
+    const baseDir = path.join(__dirname, "tmp-files");
+
+    await fs.ensureDir(baseDir);
+
+    describe("replace tokens in files", async () => {
+        fs.writeFileSync(path.join(baseDir, "files1.txt"), "test");
+        fs.writeFileSync(path.join(baseDir, "files2.txt"), "test");
+
+        await replaceTokensInFiles([{
+            path: path.join(baseDir, "files1.txt"),
+            tokens: [{
+                from: "test",
+                to: "test1",
+            }],
+        }, {
+            path: path.join(baseDir, "files2.txt"),
+            tokens: [{
+                from: "test",
+                to: "test2",
+            }],
+        }]);
+
+        it("should replace tokens in files", 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");
+        });
+    });
+
+    describe("replace tokens in file", async () => {
+        fs.writeFileSync(path.join(baseDir, "file1.txt"), "test");
+
+        await replaceTokensInFile({
+            path: path.join(baseDir, "file1.txt"),
+            tokens: [{
+                from: "test",
+                to: "test1",
+            }],
+        });
+
+        it("should replace tokens in files", async () => {
+            const data = await fs.readFile(path.join(baseDir, "file1.txt"), "utf8");
+
+            expect(data).to.be.equal("test1");
+        });
+    });
+
+    describe("get destination dir", async () => {
+        const destDir = await getDestinationDir(path.join(baseDir, "baz"));
+
+        it("should return the destination dir", () => {
+            expect(destDir).to.be.equal(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"));
+        });
+
+        it("should throw exception", async () => {
+            await fs.writeFile(path.join(baseDir, "baz", "tmp.txt"), "");
+
+            let ex = false;
+
+            try {
+                await getDestinationDir(path.join(baseDir, "baz"));
+
+                console.log("never");
+            } catch {
+                ex = true;
+            }
+
+            expect(ex).to.be.equal(true);
+        });
+    });
+
+    describe("get repository url", () => {
+        it("should return the repository url", () => {
+            expect(getRepositoryUrl()).to.be.not.equal("");
+        });
+    });
+
+    after(async () => {
+        await fs.remove(baseDir);
+    });
+});

package/tests/string-utils.test.ts

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

package/tests/tsconfig.json

@@ -0,0 +1,24 @@
+{
+    "compilerOptions": {
+        "target": "ES2021",
+        "module": "commonjs",
+        "lib": ["ESNext", "ES2022", "ES2021", "ES2020", "ES2019", "ES2018", "ES2017", "ES2016", "ES2015", "DOM"],
+        "types": ["jsdom", "mocha", "chai", "node"],
+        "allowJs": true,
+        "rootDir": ".",
+        "declaration": false,
+        "removeComments": true,
+        "importHelpers": false,
+        "strict": true,
+        "noImplicitAny": true,
+        "strictNullChecks": true,
+        "alwaysStrict": true,
+        "noFallthroughCasesInSwitch": true,
+        "moduleResolution": "node",
+        "allowSyntheticDefaultImports": true,
+        "esModuleInterop": true,
+        "experimentalDecorators": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "references": [{ "path": "../src" }],
+}