@tsparticles/cli-create-utils 4.0.0-beta.12

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@tsparticles/cli-create-utils",
+  "version": "4.0.0-beta.12",
+  "license": "MIT",
+  "type": "module",
+  "publishConfig": {
+    "access": "public",
+    "tagVersionPrefix": "v"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tsparticles/tsparticles.git",
+    "directory": "cli/commands/create-utils"
+  },
+  "prettier": "@tsparticles/prettier-config",
+  "dependencies": {
+    "@swc/core": "^1.15.32",
+    "commander": "^14.0.3",
+    "eslint": "^10.3.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-jsdoc": "^62.9.0",
+    "eslint-plugin-prettier": "^5.5.5",
+    "eslint-plugin-tsdoc": "^0.5.2",
+    "klaw": "^4.1.0",
+    "lookpath": "^1.2.3",
+    "dependency-cruiser": "^17.3.10",
+    "path-scurry": "^2.0.2",
+    "prettier": "^3.8.3",
+    "prettier-plugin-multiline-arrays": "^4.1.7",
+    "prompts": "^2.4.2",
+    "rimraf": "^6.1.3",
+    "swc-loader": "^0.2.7",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.59.1",
+    "webpack": "^5.106.2",
+    "@tsparticles/depcruise-config": "^4.0.0-beta.12",
+    "@tsparticles/prettier-config": "^4.0.0-beta.12",
+    "@tsparticles/eslint-config": "^4.0.0-beta.12",
+    "@tsparticles/webpack-plugin": "^4.0.0-beta.12",
+    "@tsparticles/tsconfig": "^4.0.0-beta.12"
+  },
+  "devDependencies": {
+    "@types/estree": "^1.0.8",
+    "@types/klaw": "^3.0.7",
+    "@types/node": "^25.6.0",
+    "@types/prompts": "^2.4.9",
+    "@types/webpack-env": "^1.18.8",
+    "browserslist": "^4.28.2",
+    "copyfiles": "^2.4.1",
+    "cross-env": "^10.1.0",
+    "terser-webpack-plugin": "^5.5.0",
+    "ts-node": "^10.9.2",
+    "vitest": "^4.1.5",
+    "webpack-bundle-analyzer": "^5.3.0",
+    "webpack-cli": "^7.0.2"
+  },
+  "description": "tsParticles CLI Utils",
+  "main": "dist/index.js",
+  "author": "Matteo Bruni <matteo.bruni@me.com>",
+  "scripts": {
+    "prettify:ci:src": "prettier --check ./src/*",
+    "prettify:ci:readme": "prettier --check ./README.md",
+    "prettify:src": "prettier --write ./src/*",
+    "prettify:readme": "prettier --write ./README.md",
+    "lint": "eslint src --ext .js,.jsx,.ts,.tsx --cache --cache-location .cache/eslint/.eslintcache --cache-strategy metadata --fix",
+    "lint:ci": "eslint src --ext .js,.jsx,.ts,.tsx --cache --cache-location .cache/eslint/.eslintcache --cache-strategy metadata",
+    "circular-deps": "depcruise src --include-only '^src' --validate --output-type err-long",
+    "compile": "pnpm run build:ts",
+    "compile:ci": "pnpm run build:ts",
+    "build:ts": "pnpm run build:ts:cjs",
+    "build:ts:cjs": "tsc -p src",
+    "test": "vitest run",
+    "build": "pnpm run clear:dist && pnpm run prettify:src && pnpm run lint && pnpm run compile && pnpm run circular-deps && pnpm run prettify:readme",
+    "build:ci": "pnpm run clear:dist && pnpm run prettify:ci:src && pnpm run lint:ci && pnpm run compile:ci && pnpm run prettify:ci:readme",
+    "clear:dist": "rimraf ./dist"
+  }
+}

package/renovate.json

@@ -0,0 +1,9 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
+  "baseBranches": [
+    "dev"
+  ],
+  "extends": [
+    "config:base"
+  ]
+}

package/src/file-utils.ts

@@ -0,0 +1,87 @@
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { existsSync } from "node:fs";
+import { lookpath } from "lookpath";
+import path from "node:path";
+
+export interface ReplaceTokensOptions {
+  path: string;
+  tokens: ReplaceTokensData[];
+}
+
+export interface ReplaceTokensData {
+  from: string | RegExp;
+  to: string;
+}
+
+/**
+ *
+ * @param options -
+ */
+export async function replaceTokensInFiles(options: ReplaceTokensOptions[]): Promise<void> {
+  for (const item of options) {
+    const filePath = item.path;
+
+    let data = await readFile(filePath, "utf-8");
+
+    for (const token of item.tokens) {
+      const regex = token.from instanceof RegExp ? token.from : new RegExp(token.from, "g");
+
+      data = data.replace(regex, token.to);
+    }
+
+    await writeFile(filePath, data);
+  }
+}
+
+/**
+ *
+ * @param options -
+ */
+export async function replaceTokensInFile(options: ReplaceTokensOptions): Promise<void> {
+  await replaceTokensInFiles([options]);
+}
+
+/**
+ *
+ * @param destination -
+ * @returns the destination directory path
+ */
+export async function getDestinationDir(destination: string): Promise<string> {
+  const destPath = path.join(process.cwd(), destination),
+    destExists = existsSync(destPath);
+
+  if (destExists) {
+    const destContents = await readdir(destPath),
+      destContentsNoGit = destContents.filter(t => t !== ".git" && t !== ".gitignore");
+
+    if (destContentsNoGit.length) {
+      throw new Error("Destination folder already exists and is not empty");
+    }
+  }
+
+  await mkdir(destPath, { recursive: true });
+
+  return destPath;
+}
+
+/**
+ * @returns the repository URL
+ */
+export async function getRepositoryUrl(): Promise<string> {
+  if (!(await lookpath("git"))) {
+    return "";
+  }
+
+  return new Promise<string>((resolve, reject) => {
+    exec("git config --get remote.origin.url", (error, stdout) => {
+      if (error) {
+        reject(error);
+
+        return;
+      }
+
+      resolve(stdout);
+    });
+  });
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from "./file-utils.js";
+export * from "./string-utils.js";
+export * from "./template-utils.js";

package/src/string-utils.ts

@@ -0,0 +1,41 @@
+/**
+ * This function is used to capitalize a string.
+ * @param str - the string to capitalize (e.g. "my-string" -\> "MyString")
+ * @param splits - the characters used to split the string, if not provided the string will be considered a single word
+ * @returns the capitalized string
+ */
+export function capitalize(str: string, ...splits: string[]): string {
+  let res = str.replace(/./, c => c.toUpperCase());
+
+  for (const split of splits) {
+    res = res
+      .split(split)
+      .map(w => w.replace(/./, c => c.toUpperCase()))
+      .join("");
+  }
+
+  return res;
+}
+
+/**
+ * This function is used to camelcase a string.
+ * @param str - the string to camelcase (e.g. "my-string" -\> "myString")
+ * @param splits - the characters used to split the string, if not provided the string will be considered a single word
+ * @returns the camelized string
+ */
+export function camelize(str: string, ...splits: string[]): string {
+  return capitalize(str, ...splits).replace(/./, c => c.toLowerCase());
+}
+
+/**
+ * This function is used to dash a string.
+ * @param str - the string to dash (e.g. "myString" -\> "my-string")
+ * @returns the dashed string
+ */
+export function dash(str: string): string {
+  const index = 0,
+    dashed = str.replace(/([A-Z])/g, g => `-${g[index]?.toLowerCase() ?? ""}`),
+    startPos = 1;
+
+  return dashed.startsWith("-") ? dashed.substring(startPos) : dashed;
+}

package/src/template-utils.ts

@@ -0,0 +1,206 @@
+import { cp } from "node:fs/promises";
+import { exec } from "node:child_process";
+import { lookpath } from "lookpath";
+import path from "node:path";
+import { replaceTokensInFile } from "./file-utils.js";
+
+/**
+ * Updates the package.json file
+ * @param destPath - The path where the package.json file is located
+ * @param packageName - The name of the package
+ * @param description - The description of the package
+ * @param fileName - The name of the output file
+ * @param repoUrl - The repository URL
+ */
+export async function updatePackageFile(
+  destPath: string,
+  packageName: string,
+  description: string,
+  fileName: string,
+  repoUrl: string,
+): Promise<void> {
+  await replaceTokensInFile({
+    path: path.join(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")}"`,
+      },
+    ],
+  });
+}
+
+/**
+ * Updates the package.dist.json file with the new project name and description
+ * @param destPath - The path where the package.dist.json file is located
+ * @param packageName - The name of the package
+ * @param description - The description of the package
+ * @param fileName - The name of the output file
+ * @param repoUrl - The url of the repository
+ */
+export async function updatePackageDistFile(
+  destPath: string,
+  packageName: string,
+  description: string,
+  fileName: string,
+  repoUrl: string,
+): Promise<void> {
+  await replaceTokensInFile({
+    path: path.join(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")}"`,
+      },
+    ],
+  });
+}
+
+/**
+ * Updates the webpack file with the new project name and description
+ * @param destPath - The path where the project will be created
+ * @param name - The name of the project
+ * @param description - The description of the project
+ * @param fnName - The name of the function to load the template
+ */
+export async function updateWebpackFile(
+  destPath: string,
+  name: string,
+  description: string,
+  fnName: string,
+): Promise<void> {
+  await replaceTokensInFile({
+    path: path.join(destPath, "webpack.config.js"),
+    tokens: [
+      {
+        from: /"Empty"/g,
+        to: `"${description}"`,
+      },
+      {
+        from: /"empty"/g,
+        to: `"${name}"`,
+      },
+      {
+        from: /loadParticlesTemplate/g,
+        to: fnName,
+      },
+    ],
+  });
+}
+
+/**
+ * Copies the empty template files to the destination path
+ * @param destPath - The path where the project will be created
+ */
+export async function copyEmptyTemplateFiles(destPath: string): Promise<void> {
+  await cp(path.join(__dirname, "..", "files", "empty-project"), destPath, {
+    recursive: true,
+    force: true,
+    filter: copyFilter,
+  });
+}
+
+/**
+ * Filters the files to copy
+ * @param src - The source file path
+ * @returns true if the file should be copied
+ */
+export function copyFilter(src: string): boolean {
+  return !(src.endsWith("node_modules") || src.endsWith("dist"));
+}
+
+/**
+ * Runs npm install in the given path
+ * @param destPath - The path where the project will be created
+ */
+export async function runInstall(destPath: string): Promise<void> {
+  if (!(await lookpath("npm"))) {
+    return;
+  }
+
+  return new Promise((resolve, reject) => {
+    exec(
+      "npm install",
+      {
+        cwd: destPath,
+      },
+      error => {
+        if (error) {
+          reject(error);
+
+          return;
+        }
+
+        resolve();
+      },
+    );
+  });
+}
+
+/**
+ * Runs npm run build in the given path
+ * @param destPath - The path where the project will be build
+ */
+export async function runBuild(destPath: string): Promise<void> {
+  if (!(await lookpath("npm"))) {
+    return;
+  }
+
+  return new Promise((resolve, reject) => {
+    exec(
+      "npm run build",
+      {
+        cwd: destPath,
+      },
+      error => {
+        if (error) {
+          reject(error);
+
+          return;
+        }
+
+        resolve();
+      },
+    );
+  });
+}

package/src/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "../dist"
+  },
+  "references": [{ "path": "../" }],
+  "include": ["**/*"]
+}

package/tests/file-utils.test.ts

@@ -0,0 +1,109 @@
+import { afterAll, describe, it, expect } from "vitest";
+import {
+  getDestinationDir,
+  getRepositoryUrl,
+  replaceTokensInFile,
+  replaceTokensInFiles,
+} from "../src";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+describe("file-utils", async () => {
+  const baseDir = path.resolve("tmp-files");
+
+  await mkdir(baseDir, { recursive: true });
+
+  describe("replace tokens in files", async () => {
+    await writeFile(path.join(baseDir, "files1.txt"), "test");
+    await writeFile(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 readFile(path.join(baseDir, "files1.txt"), "utf8"),
+        data2 = await readFile(path.join(baseDir, "files2.txt"), "utf8");
+
+      expect(data1).toBe("test1");
+      expect(data2).toBe("test2");
+    });
+  });
+
+  describe("replace tokens in file", async () => {
+    await writeFile(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 readFile(path.join(baseDir, "file1.txt"), "utf8");
+
+      expect(data).toBe("test1");
+    });
+  });
+
+  describe("get destination dir", async () => {
+    const destDir = await getDestinationDir(path.join("tmp-files", "baz"));
+
+    it("should return the destination dir", () => {
+      expect(destDir).toBe(path.join(baseDir, "baz"));
+    });
+
+    it("should return the destination dir", async () => {
+      const destDir2 = await getDestinationDir(path.join("tmp-files", "baz"));
+
+      expect(destDir2).toBe(path.join(baseDir, "baz"));
+    });
+
+    it("should throw exception", async () => {
+      await writeFile(path.join(baseDir, "baz", "tmp.txt"), "");
+
+      let ex = false;
+
+      try {
+        await getDestinationDir(path.join("tmp-files", "baz"));
+
+        console.log("never");
+      } catch {
+        ex = true;
+      }
+
+      expect(ex).toBe(true);
+    });
+  });
+
+  describe("get repository url", () => {
+    it("should return the repository url", async () => {
+      expect(await getRepositoryUrl()).not.toBe("");
+    });
+  });
+
+  afterAll(async () => {
+    await rm(baseDir, { recursive: true, force: true });
+  });
+});

package/tests/string-utils.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect } from "vitest";
+import { camelize, capitalize, dash } from "../src";
+
+describe("capitalize", () => {
+    describe("empty string", () => {
+        it("should successfully compare empty strings", () => {
+            expect(capitalize("")).toBe("");
+        });
+    });
+
+    describe("lowercase string", () => {
+        it("should return capitalized string", () => {
+            expect(capitalize("test")).toBe("Test");
+        });
+    });
+
+    describe("capitalized string", () => {
+        it("should return capitalized string", () => {
+            expect(capitalize("Test")).toBe("Test");
+        });
+    });
+
+    describe("multiple lowercase words string", () => {
+        it("should return capitalized string, no split", () => {
+            expect(capitalize("test test")).toBe("Test test");
+        });
+
+        it("should return capitalized string, split", () => {
+            expect(capitalize("test test", " ")).toBe("TestTest");
+        });
+
+        it("should return capitalized string, wrong split", () => {
+            expect(capitalize("test test", ";")).toBe("Test test");
+        });
+    });
+
+    describe("multiple uppercase words string", () => {
+        it("should return capitalized string, no split", () => {
+            expect(capitalize("Test Test")).toBe("Test Test");
+        });
+
+        it("should return capitalized string, split", () => {
+            expect(capitalize("Test Test", " ")).toBe("TestTest");
+        });
+
+        it("should return capitalized string, wrong split", () => {
+            expect(capitalize("Test Test", ";")).toBe("Test Test");
+        });
+    });
+});
+
+describe("camelize", () => {
+    describe("empty string", () => {
+        it("should successfully compare empty strings", () => {
+            expect(camelize("")).toBe("");
+        });
+    });
+
+    describe("lowercase string", () => {
+        it("should return camelized string", () => {
+            expect(camelize("test")).toBe("test");
+        });
+    });
+
+    describe("uppercase string", () => {
+        it("should return camelized string", () => {
+            expect(camelize("Test")).toBe("test");
+        });
+    });
+
+    describe("multiple lowercase words string", () => {
+        it("should return camelized string, no split", () => {
+            expect(camelize("test test")).toBe("test test");
+        });
+
+        it("should return camelized string, split", () => {
+            expect(camelize("test test", " ")).toBe("testTest");
+        });
+
+        it("should return camelized string, wrong split", () => {
+            expect(camelize("test test", ";")).toBe("test test");
+        });
+    });
+
+    describe("multiple uppercase words string", () => {
+        it("should return camelized string, no split", () => {
+            expect(camelize("Test Test")).toBe("test Test");
+        });
+
+        it("should return camelized string, split", () => {
+            expect(camelize("Test Test", " ")).toBe("testTest");
+        });
+
+        it("should return camelized string, wrong split", () => {
+            expect(camelize("Test Test", ";")).toBe("test Test");
+        });
+    });
+});
+
+describe("dash", () => {
+    describe("empty string", () => {
+        it("should successfully compare empty strings", () => {
+            expect(dash("")).toBe("");
+        });
+    });
+
+    describe("lowercase string", () => {
+        it("should return dashed string", () => {
+            expect(dash("test")).toBe("test");
+        });
+    });
+
+    describe("uppercase string", () => {
+        it("should return dashed string", () => {
+            expect(dash("Test")).toBe("test");
+        });
+    });
+
+    describe("capitalized word string", () => {
+        it("should return dashed string", () => {
+            expect(dash("TestTest")).toBe("test-test");
+        });
+    });
+
+    describe("camelized word string", () => {
+        it("should return dashed string", () => {
+            expect(dash("testTest")).toBe("test-test");
+        });
+    });
+});

package/tests/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "target": "ES2021",
+    "types": ["node", "vitest"],
+    "allowJs": true,
+    "declaration": false,
+    "removeComments": true,
+    "importHelpers": false,
+    "esModuleInterop": true
+  },
+  "references": [{ "path": "../src" }],
+  "include": ["**/*.ts"]
+}