@tsparticles/cli 3.3.1 → 3.3.2

package/.planning/codebase/TESTING.md

@@ -1,138 +1,156 @@
 # Testing Patterns
 
-**Analysis Date:** 2026-03-08
+**Analysis Date:** 2026-03-10
 
 ## Test Framework
 
-**Runner:**
+Runner:
 
-- Vitest (`vitest`) - configured in `vitest.config.ts` with `environment: "node"` and `include: ["tests/**/*.test.ts"]`.
-
-Config: `vitest.config.ts`
+- Vitest (see `package.json` devDependencies `vitest` and `vitest.config.ts`).
+- Config file: `vitest.config.ts` (sets `globals: true`, `environment: "node"`, `include: ["tests/**/*.test.ts"]`).
 
 Run Commands:
 
 ```bash
-pnpm test              # Run all tests (runs `vitest run` as defined in package.json)
-pnpm test --watch      # Run in watch mode (Vitest supports --watch)
-pnpm test --coverage   # Coverage if configured via vitest options (not explicitly configured here)
+pnpm test              # Runs: `vitest run` (non-watch)
+pnpm run test          # Alias to the same command
 ```
 
 ## Test File Organization
 
 Location:
 
-- Tests live under `tests/` at the repo root: `tests/*.test.ts` (e.g., `tests/create-shape.test.ts`, `tests/file-utils.test.ts`).
+- Tests live in the `tests/` directory at project root.
+  - Files: `tests/create-shape.test.ts`, `tests/create-preset.test.ts`, `tests/create-plugin.test.ts`, `tests/file-utils.test.ts`, `tests/string-utils.test.ts`.
+- Pattern: tests are colocated under a top-level `tests/` folder rather than next to source files.
 
 Naming:
 
-- Test files use the pattern `<feature>.test.ts` (Vitest `include` config picks `tests/**/*.test.ts`).
+- Pattern: `*.test.ts` suffix for test files (see `vitest.config.ts` include pattern).
 
 Structure:
 
 ```
 tests/
-├── create-shape.test.ts
-├── create-preset.test.ts
-├── create-plugin.test.ts
-├── file-utils.test.ts
-└── string-utils.test.ts
+├── <feature>.test.ts   # top-level test file for a single module/feature
 ```
 
-## Test Structure
+## Test Structure and Patterns
 
-Suite Organization (example from `tests/create-shape.test.ts`):
+Suite Organization:
 
-```ts
-import { describe, it, expect } from "vitest";
-import { createShapeTemplate } from "../src/create/shape/create-shape.js";
+- Tests use `describe` blocks to group scenarios and `it` for assertions (Vitest globals enabled). Example: `tests/file-utils.test.ts`.
 
-describe("create-shape", () => {
-  it("should have created the shape project", async () => {
-    // arrange: compute destDir
-    // act: call createShapeTemplate
-    // assert: read package.json and assert properties using fs-extra
-  });
+Setup / Teardown:
+
+- Tests frequently perform async setup at the top-level of `describe` by awaiting operations before `it` blocks. Example: in `tests/file-utils.test.ts` the `baseDir` is created with `await fs.ensureDir(baseDir)` before assertions.
+- Teardown uses `afterAll` to remove temporary test artifacts. Example: `afterAll(async () => { await fs.remove(baseDir); });` in `tests/file-utils.test.ts`.
+
+Assertions:
+
+- Vitest's `expect` is used with matchers like `toBe`.
+
+Async Tests:
+
+- Most IO-heavy tests are `async` and use `await`. Pattern:
+
+```typescript
+it("does something async", async () => {
+  const result = await someAsyncFunction();
+  expect(result).toBe(...);
 });
 ```
 
-Patterns:
+Error Testing Pattern:
 
-- Tests create temporary directories under `tests/tmp-files` and remove them after assertions (`fs-extra` used to clean up).
-- Tests use actual file system operations to verify template creation (integration-style unit tests).
+- When verifying exceptions, tests use try/catch with a boolean flag and assert the flag at the end. Example in `tests/file-utils.test.ts`:
 
-Setup/Teardown:
+```typescript
+let ex = false;
+try {
+  await getDestinationDir(path.join("tmp-files", "baz"));
+} catch {
+  ex = true;
+}
+expect(ex).toBe(true);
+```
 
-- Tests manually create and remove directories within each test case (no global setup file detected).
+Prefer using `await expect(...).rejects.toThrow()` for clearer intent when adding tests.
 
 ## Mocking
 
-Framework: Vitest built-in mocking utilities are available but not heavily used in current tests.
-
-Patterns:
+Framework:
 
-- Tests primarily exercise filesystem operations without mocking `fs-extra` or child processes. When external commands are invoked, the code checks for the presence of `npm` using `lookpath` before running `exec` which avoids executing if not present.
+- No mocking libraries observed; tests perform filesystem operations against a temporary directory (`tests/tmp-files`) and rely on actual `fs-extra` operations.
 
-What to Mock:
+Patterns:
 
-- When adding unit tests for functions that call `exec` or modify the environment, mock `child_process.exec` or `lookpath` to avoid running external processes.
+- Tests use real file operations (create files, write content, call functions under test, assert file contents). Example: `tests/file-utils.test.ts` writes files into `tmp-files` and later reads them.
 
-What NOT to Mock:
+What to mock / not to mock:
 
-- For integration-style tests that verify file scaffolding, prefer real `fs` operations in a temporary directory to validate end-to-end behavior.
+- Current tests intentionally avoid mocking to validate filesystem interactions. Continue to avoid mocking for these utilities unless external network/long-running processes are involved (e.g., `exec` calls in `template-utils.ts` could be mocked if tests should not run `npm install` or `npm run build`).
 
 ## Fixtures and Factories
 
 Test Data:
 
-- Tests programmatically generate temporary directories under `tests/tmp-files` and use template functions to create artifacts. No centralized fixtures directory is present.
+- Tests create temporary files under `tests/tmp-files` using `fs-extra`. Example: `tests/create-shape.test.ts` writes to `tests/tmp-files/foo-shape` and later removes it.
 
 Location:
 
-- Temporary test artifacts are created in `tests/tmp-files` during tests and cleaned up by tests (see `tests/create-shape.test.ts`).
+- Temporary test artifacts are written under `tests/tmp-files/` and removed by test code or CI before/after runs (CI workflow runs `rm -rf tests/tmp-files`). See `.github/workflows/node.js-ci.yml`.
 
 ## Coverage
 
-Requirements: None enforced in repo. CI runs `pnpm test` but coverage thresholds are not configured.
-
-View Coverage:
-
-```bash
+Coverage tool: Not enforced in repo (no explicit coverage script), but `.nyc_output` directory exists suggesting past use of NYC. No CI step collects coverage.
 
-```
+To run coverage (suggested): add a script using `vitest run --coverage` and configure thresholds in `package.json` if required.
 
 ## Test Types
 
 Unit Tests:
 
-- Small utilities tested (e.g., `tests/file-utils.test.ts`, `tests/string-utils.test.ts`).
+- Scope: small, deterministic units that interact with filesystem helpers and template generation functions. Examples: `tests/string-utils.test.ts`, `tests/file-utils.test.ts`.
 
-Integration Tests:
+Integration-ish Tests:
 
-- Template creation tests behave like integration tests, performing file operations and validating outputs (`tests/create-*.test.ts`).
+- Scope: template creation tests (`tests/create-*.test.ts`) copy files and run `runInstall`/`runBuild` indirectly; these can execute `npm` commands if present (templating functions call `runInstall` and `runBuild` which execute `npm` if `lookpath('npm')` returns true). These tests currently run in CI where `pnpm install` is executed and `npm` may be present.
 
 E2E Tests:
 
 - Not used.
 
-## Common Patterns
+## Common Patterns and Recommendations
 
-Async Testing:
+1. Use `afterAll` to clean up filesystem artifacts (example: `tests/file-utils.test.ts` removes `baseDir`).
+2. Prefer `await expect(promise).rejects.toThrow()` for negative tests instead of boolean-flag try/catch pattern.
+3. Keep filesystem-based tests under `tests/tmp-files` and ensure CI cleans them before runs (CI step already removes `tests/tmp-files`). See `.github/workflows/node.js-ci.yml` lines 44-46 and 84-86.
+4. If tests should avoid running `npm install`/`npm run build` during template creation, add a test flag or mock `lookpath`/`exec` in `src/utils/template-utils.ts` to bypass `runInstall`/`runBuild` during tests.
 
-```ts
-it("does async work", async () => {
-  await expect(someAsyncFn()).resolves.toBeTruthy();
-});
-```
+## Example Test Template (observed pattern)
+
+```typescript
+import { describe, it, expect } from "vitest";
+import fs from "fs-extra";
+import path from "node:path";
+import { someFunction } from "../src/utils/some.ts";
 
-Error Testing:
+describe("someFunction", () => {
+  it("behaves correctly", async () => {
+    const dest = path.join(__dirname, "tmp-files", "some");
+    await fs.ensureDir(dest);
 
-```ts
-it("throws on bad input", async () => {
-  await expect(badAsync()).rejects.toThrow();
+    await someFunction(dest);
+
+    const data = await fs.readFile(path.join(dest, "file.txt"), "utf8");
+    expect(data).toBe("expected");
+
+    await fs.remove(dest);
+  });
 });
 ```
 
 ---
 
-_Testing analysis: 2026-03-08_
+_Testing analysis: 2026-03-10_

package/dist/build/build-distfiles.js

@@ -1,4 +1,5 @@
-import fs from "fs-extra";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import klaw from "klaw";
 import path from "node:path";
 /**
@@ -12,7 +13,7 @@ export async function buildDistFiles(basePath, silent) {
     }
     let res;
     try {
-        const pkgInfo = JSON.parse((await fs.readFile(path.join(basePath, "package.json"))).toString()), libPackage = path.join(basePath, "package.dist.json"), distPath = path.join(basePath, pkgInfo.publishConfig?.directory ?? "dist"), data = await fs.readFile(libPackage), text = data.toString(), libObj = JSON.parse(text);
+        const pkgInfo = JSON.parse((await readFile(path.join(basePath, "package.json"))).toString()), libPackage = path.join(basePath, "package.dist.json"), distPath = path.join(basePath, pkgInfo.publishConfig?.directory ?? "dist"), data = await readFile(libPackage), text = data.toString(), libObj = JSON.parse(text);
         libObj["version"] = pkgInfo.version;
         if (pkgInfo.dependencies) {
             libObj["dependencies"] = JSON.parse(JSON.stringify(pkgInfo.dependencies).replaceAll("workspace:", ""));
@@ -21,7 +22,7 @@ export async function buildDistFiles(basePath, silent) {
             libObj["peerDependencies"] = JSON.parse(JSON.stringify(pkgInfo.peerDependencies).replaceAll("workspace:", ""));
         }
         const jsonIndent = 2;
-        await fs.writeFile(libPackage, `${JSON.stringify(libObj, undefined, jsonIndent)}\n`, "utf8");
+        await writeFile(libPackage, `${JSON.stringify(libObj, undefined, jsonIndent)}\n`, "utf8");
         if (!silent) {
             console.log(`package.dist.json updated successfully to version ${pkgInfo.version}`);
         }
@@ -35,22 +36,22 @@ export async function buildDistFiles(basePath, silent) {
         ];
         for (const file of rootFilesToCopy) {
             const src = path.join(basePath, typeof file === "string" ? file : file.source), dest = path.join(distPath, typeof file === "string" ? file : file.destination);
-            await fs.copyFile(src, dest);
+            await copyFile(src, dest);
         }
         const scriptsPath = path.join(basePath, "scripts"), distScriptsPath = path.join(distPath, "scripts");
-        if ((await fs.exists(scriptsPath)) && !(await fs.exists(distScriptsPath))) {
-            await fs.mkdir(distScriptsPath);
+        if (existsSync(scriptsPath) && !existsSync(distScriptsPath)) {
+            await mkdir(distScriptsPath);
             const installPath = path.join(scriptsPath, "install.js");
-            if (await fs.exists(installPath)) {
-                await fs.copyFile(installPath, path.join(distScriptsPath, "install.js"));
+            if (existsSync(installPath)) {
+                await copyFile(installPath, path.join(distScriptsPath, "install.js"));
             }
         }
         for await (const file of klaw(distPath)) {
             if (file.stats.isDirectory()) {
                 continue;
             }
-            const contents = await fs.readFile(file.path, "utf8");
-            await fs.writeFile(file.path, contents.replaceAll("__VERSION__", `"${pkgInfo.version}"`), "utf8");
+            const contents = await readFile(file.path, "utf8");
+            await writeFile(file.path, contents.replaceAll("__VERSION__", `"${pkgInfo.version}"`), "utf8");
         }
         /* for await (const file of klaw(path.join(distPath, "cjs"))) {
                 await fs.rename(file.path, file.path.replace(/\.js$/, ".cjs"));
@@ -59,9 +60,9 @@ export async function buildDistFiles(basePath, silent) {
             for await (const file of klaw(path.join(distPath, "esm"))) {
                 await fs.rename(file.path, file.path.replace(/\.js$/, ".mjs"));
             } */
-        await fs.writeFile(path.join(distPath, "cjs", "package.json"), `{ "type": "commonjs" }`);
-        await fs.writeFile(path.join(distPath, "esm", "package.json"), `{ "type": "module" }`);
-        await fs.writeFile(path.join(distPath, "browser", "package.json"), `{ "type": "module" }`);
+        await writeFile(path.join(distPath, "cjs", "package.json"), `{ "type": "commonjs" }`);
+        await writeFile(path.join(distPath, "esm", "package.json"), `{ "type": "module" }`);
+        await writeFile(path.join(distPath, "browser", "package.json"), `{ "type": "module" }`);
         res = true;
     }
     catch (e) {

package/dist/build/build-diststats.js

@@ -1,4 +1,5 @@
-import fs from "fs-extra";
+import { opendir, readFile, stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
 /**
  * @param folderPath - the path to the folder to get the stats for
  * @param bundlePath - the bundle path to get the bundle size for
@@ -11,10 +12,10 @@ async function getFolderStats(folderPath, bundlePath) {
         totalFolders: 0,
         totalSize: 0,
     };
-    if (!(await fs.pathExists(folderPath))) {
+    if (!existsSync(folderPath)) {
         return stats;
     }
-    const dir = await fs.promises.opendir(folderPath), path = await import("path");
+    const dir = await opendir(folderPath), path = await import("path");
     for await (const dirent of dir) {
         const increment = 1;
         if (dirent.isDirectory()) {
@@ -24,7 +25,7 @@ async function getFolderStats(folderPath, bundlePath) {
             stats.totalSize += subDirStats.totalSize;
         }
         else {
-            const fileStats = await fs.stat(path.join(folderPath, dirent.name));
+            const fileStats = await stat(path.join(folderPath, dirent.name));
             stats.totalFiles++;
             stats.totalSize += fileStats.size;
             if (bundlePath && path.join(folderPath, dirent.name) === bundlePath) {
@@ -40,8 +41,8 @@ async function getFolderStats(folderPath, bundlePath) {
  * @returns the stats for the dist folder
  */
 export async function getDistStats(basePath) {
-    const path = await import("path"), distFolder = path.join(basePath, "dist"), pkgInfo = (await fs.exists(path.join(distFolder, "package.json")))
-        ? JSON.parse((await fs.readFile(path.join(distFolder, "package.json"))).toString())
-        : {}, bundlePath = (await fs.exists(distFolder)) && pkgInfo.jsdelivr ? path.join(distFolder, pkgInfo.jsdelivr) : undefined;
+    const path = await import("path"), distFolder = path.join(basePath, "dist"), pkgInfo = existsSync(path.join(distFolder, "package.json"))
+        ? JSON.parse((await readFile(path.join(distFolder, "package.json"))).toString())
+        : {}, bundlePath = existsSync(distFolder) && pkgInfo.jsdelivr ? path.join(distFolder, pkgInfo.jsdelivr) : undefined;
     return await getFolderStats(distFolder, bundlePath);
 }

package/dist/build/build-prettier.js

@@ -1,4 +1,5 @@
-import fs from "fs-extra";
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
 import klaw from "klaw";
 import path from "node:path";
 import prettier from "prettier";
@@ -19,7 +20,7 @@ export async function prettifySrc(basePath, srcPath, ci, silent) {
             if (file.stats.isDirectory()) {
                 continue;
             }
-            const contents = await fs.readFile(file.path, "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
+            const contents = await readFile(file.path, "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
             options.printWidth = 120;
             options.endOfLine = "lf";
             options.parser = "typescript";
@@ -32,7 +33,7 @@ export async function prettifySrc(basePath, srcPath, ci, silent) {
             }
             else {
                 const formatted = await prettier.format(contents, options);
-                await fs.writeFile(file.path, formatted, "utf8");
+                await writeFile(file.path, formatted, "utf8");
             }
         }
         res = true;
@@ -58,7 +59,7 @@ export async function prettifyPackageJson(basePath, ci, silent) {
     }
     let res;
     try {
-        const contents = await fs.readFile("package.json", "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
+        const contents = await readFile("package.json", "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
         options.tabWidth = 2;
         options.printWidth = 120;
         options.endOfLine = "lf";
@@ -70,7 +71,7 @@ export async function prettifyPackageJson(basePath, ci, silent) {
         }
         else {
             const formatted = await prettier.format(contents, options);
-            await fs.writeFile("package.json", formatted, "utf8");
+            await writeFile("package.json", formatted, "utf8");
         }
         res = true;
     }
@@ -95,7 +96,7 @@ export async function prettifyPackageDistJson(basePath, ci, silent) {
     }
     let res;
     try {
-        const contents = await fs.readFile("package.dist.json", "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
+        const contents = await readFile("package.dist.json", "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
         options.tabWidth = 2;
         options.printWidth = 120;
         options.endOfLine = "lf";
@@ -107,7 +108,7 @@ export async function prettifyPackageDistJson(basePath, ci, silent) {
         }
         else {
             const formatted = await prettier.format(contents, options);
-            await fs.writeFile("package.dist.json", formatted, "utf8");
+            await writeFile("package.dist.json", formatted, "utf8");
         }
         res = true;
     }
@@ -132,7 +133,7 @@ export async function prettifyReadme(basePath, ci, silent) {
     }
     let res;
     try {
-        const contents = await fs.readFile("README.md", "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
+        const contents = await readFile("README.md", "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
         options.printWidth = 120;
         options.endOfLine = "lf";
         options.parser = "markdown";
@@ -143,7 +144,7 @@ export async function prettifyReadme(basePath, ci, silent) {
         }
         else {
             const formatted = await prettier.format(contents, options);
-            await fs.writeFile("README.md", formatted, "utf8");
+            await writeFile("README.md", formatted, "utf8");
         }
         res =
             (await prettifyTraductions(basePath, ci, silent)) && (await prettifyMarkdownTypeDocFiles(basePath, ci, silent));
@@ -170,7 +171,7 @@ async function prettifyTraductions(basePath, ci, silent) {
     let res = false;
     try {
         const folder = "traduction", folderPath = path.join(basePath, folder);
-        if (!fs.existsSync(folderPath)) {
+        if (!existsSync(folderPath)) {
             res = true;
         }
         if (!res) {
@@ -178,7 +179,7 @@ async function prettifyTraductions(basePath, ci, silent) {
                 if (file.stats.isDirectory()) {
                     continue;
                 }
-                const contents = await fs.readFile(file.path, "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
+                const contents = await readFile(file.path, "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
                 options.printWidth = 120;
                 options.endOfLine = "lf";
                 options.parser = "markdown";
@@ -189,7 +190,7 @@ async function prettifyTraductions(basePath, ci, silent) {
                 }
                 else {
                     const formatted = await prettier.format(contents, options);
-                    await fs.writeFile(file.path, formatted, "utf8");
+                    await writeFile(file.path, formatted, "utf8");
                 }
             }
             res = true;
@@ -217,7 +218,7 @@ async function prettifyMarkdownTypeDocFiles(basePath, ci, silent) {
     let res = false;
     try {
         const folder = "markdown", folderPath = path.join(basePath, folder);
-        if (!fs.existsSync(folderPath)) {
+        if (!existsSync(folderPath)) {
             res = true;
         }
         if (!res) {
@@ -225,7 +226,7 @@ async function prettifyMarkdownTypeDocFiles(basePath, ci, silent) {
                 if (file.stats.isDirectory()) {
                     continue;
                 }
-                const contents = await fs.readFile(file.path, "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
+                const contents = await readFile(file.path, "utf8"), options = (await prettier.resolveConfig(basePath)) ?? {};
                 options.printWidth = 120;
                 options.endOfLine = "lf";
                 options.parser = "markdown";
@@ -236,7 +237,7 @@ async function prettifyMarkdownTypeDocFiles(basePath, ci, silent) {
                 }
                 else {
                     const formatted = await prettier.format(contents, options);
-                    await fs.writeFile(file.path, formatted, "utf8");
+                    await writeFile(file.path, formatted, "utf8");
                 }
             }
             res = true;

package/dist/build/build-tsc.js

@@ -1,5 +1,6 @@
-import fs from "fs-extra";
+import { existsSync } from "node:fs";
 import path from "node:path";
+import { readFile } from "node:fs/promises";
 var ExitCodes;
 (function (ExitCodes) {
     ExitCodes[ExitCodes["OK"] = 0] = "OK";
@@ -15,8 +16,8 @@ var ExitCodes;
  */
 async function readConfig(basePath, file) {
     const tsconfigPath = path.join(basePath, file);
-    if (await fs.pathExists(tsconfigPath)) {
-        const data = await fs.readFile(path.join(basePath, file));
+    if (existsSync(tsconfigPath)) {
+        const data = await readFile(path.join(basePath, file));
         return data.toString();
     }
     return undefined;

package/dist/build/build.js

@@ -1,4 +1,6 @@
 import { Command } from "commander";
+import { existsSync } from "node:fs";
+import path from "node:path";
 const buildCommand = new Command("build");
 buildCommand.description("Build the tsParticles library using TypeScript");
 buildCommand.option("-a, --all", "Do all build steps (default if no flags are specified) (same as -b -c -d -l -p -t)", false);
@@ -19,8 +21,8 @@ buildCommand.action(async (argPath) => {
         const { clearDist } = await import("./build-clear.js");
         await clearDist(basePath, silent);
     }
-    const path = await import("path"), srcPath = path.join(basePath, argPath), fs = await import("fs-extra");
-    if (!(await fs.pathExists(srcPath))) {
+    const srcPath = path.join(basePath, argPath);
+    if (!existsSync(srcPath)) {
         throw new Error("Provided path does not exist");
     }
     let canContinue = true;
@@ -63,12 +65,12 @@ buildCommand.action(async (argPath) => {
         const newStats = await getDistStats(basePath), diffSize = newStats.totalSize - oldStats.totalSize, bundleDiffSize = newStats.bundleSize - oldStats.bundleSize, minSize = 0, bundleSizeIncreased = bundleDiffSize > minSize, bundleSizeIncreasedText = bundleSizeIncreased ? "increased" : "decreased", diffSizeIncreasedText = diffSize > minSize ? "increased" : "decreased";
         outputFunc = bundleSizeIncreased ? console.warn : console.info;
         texts = [
-            !bundleDiffSize
-                ? "Bundle size unchanged"
-                : `Bundle size ${bundleSizeIncreasedText} from ${oldStats.bundleSize.toString()} to ${newStats.bundleSize.toString()} (${Math.abs(bundleDiffSize).toString()}B)`,
-            !diffSize
-                ? "Size unchanged"
-                : `Size ${diffSizeIncreasedText} from ${oldStats.totalSize.toString()} to ${newStats.totalSize.toString()} (${Math.abs(diffSize).toString()}B)`,
+            bundleDiffSize
+                ? `Bundle size ${bundleSizeIncreasedText} from ${oldStats.bundleSize.toString()} to ${newStats.bundleSize.toString()} (${Math.abs(bundleDiffSize).toString()}B)`
+                : "Bundle size unchanged",
+            diffSize
+                ? `Size ${diffSizeIncreasedText} from ${oldStats.totalSize.toString()} to ${newStats.totalSize.toString()} (${Math.abs(diffSize).toString()}B)`
+                : "Size unchanged",
             `Files count changed from ${oldStats.totalFiles.toString()} to ${newStats.totalFiles.toString()} (${(newStats.totalFiles - oldStats.totalFiles).toString()})`,
             `Folders count changed from ${oldStats.totalFolders.toString()} to ${newStats.totalFolders.toString()} (${(newStats.totalFolders - oldStats.totalFolders).toString()})`,
         ];

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { buildCommand } from "./build/build.js";
 import { createCommand } from "./create/create.js";
-import { fileURLToPath } from "url";
-import fs from "fs-extra";
+import { fileURLToPath } from "node:url";
 import path from "node:path";
 import { program } from "commander";
-const __filename = fileURLToPath(import.meta.url), __dirname = path.dirname(__filename), rootPkgPath = path.join(__dirname, "..", "package.json"), pkg = (await fs.readJson(rootPkgPath));
+import { readFile } from "node:fs/promises";
+const __filename = fileURLToPath(import.meta.url), __dirname = path.dirname(__filename), rootPkgPath = path.join(__dirname, "..", "package.json"), pkg = JSON.parse(await readFile(rootPkgPath, "utf-8"));
 program.name("tsparticles-cli");
 program.description("tsParticles CLI");
 program.version(pkg.version, "-v, --version", "output the current version");

package/dist/create/plugin/create-plugin.js

@@ -1,6 +1,6 @@
 import { camelize, capitalize, dash } from "../../utils/string-utils.js";
 import { copyEmptyTemplateFiles, copyFilter, runBuild, runInstall, updatePackageDistFile, updatePackageFile, updateWebpackFile, } from "../../utils/template-utils.js";
-import fs from "fs-extra";
+import { cp } from "node:fs/promises";
 import path from "node:path";
 import { replaceTokensInFile } from "../../utils/file-utils.js";
 /**
@@ -110,8 +110,9 @@ async function updatePluginWebpackFile(destPath, name, description) {
 export async function createPluginTemplate(name, description, repoUrl, destPath) {
     const sourcePath = path.join(__dirname, "..", "..", "..", "files", "create-plugin");
     await copyEmptyTemplateFiles(destPath);
-    await fs.copy(sourcePath, destPath, {
-        overwrite: true,
+    await cp(sourcePath, destPath, {
+        recursive: true,
+        force: true,
         filter: copyFilter,
     });
     await updateIndexFile(destPath, name);

package/dist/create/preset/create-preset.js

@@ -1,6 +1,6 @@
 import { camelize, capitalize, dash } from "../../utils/string-utils.js";
 import { copyEmptyTemplateFiles, copyFilter, runBuild, runInstall, updatePackageDistFile, updatePackageFile, updateWebpackFile, } from "../../utils/template-utils.js";
-import fs from "fs-extra";
+import { cp } from "node:fs/promises";
 import path from "node:path";
 import { replaceTokensInFile } from "../../utils/file-utils.js";
 /**
@@ -127,8 +127,9 @@ async function updatePresetWebpackFile(destPath, name, description) {
 export async function createPresetTemplate(name, description, repoUrl, destPath) {
     const sourcePath = path.join(__dirname, "..", "..", "..", "files", "create-preset");
     await copyEmptyTemplateFiles(destPath);
-    await fs.copy(sourcePath, destPath, {
-        overwrite: true,
+    await cp(sourcePath, destPath, {
+        recursive: true,
+        force: true,
         filter: copyFilter,
     });
     await updateBundleFile(destPath, name);

package/dist/create/shape/create-shape.js

@@ -1,6 +1,6 @@
 import { camelize, capitalize, dash } from "../../utils/string-utils.js";
 import { copyEmptyTemplateFiles, copyFilter, runBuild, runInstall, updatePackageDistFile, updatePackageFile, updateWebpackFile, } from "../../utils/template-utils.js";
-import fs from "fs-extra";
+import { cp } from "node:fs/promises";
 import path from "node:path";
 import { replaceTokensInFile } from "../../utils/file-utils.js";
 /**
@@ -115,8 +115,9 @@ async function updateShapeWebpackFile(destPath, name, description) {
 export async function createShapeTemplate(name, description, repoUrl, destPath) {
     const sourcePath = path.join(__dirname, "..", "..", "..", "files", "create-shape");
     await copyEmptyTemplateFiles(destPath);
-    await fs.copy(sourcePath, destPath, {
-        overwrite: true,
+    await cp(sourcePath, destPath, {
+        recursive: true,
+        force: true,
         filter: copyFilter,
     });
     await updateIndexFile(destPath, name);