@tsparticles/cli 1.12.0 → 1.13.0

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" }],
+}