@tsparticles/cli 3.0.14 → 3.0.16

package/src/build/build-diststats.ts

@@ -1,10 +1,10 @@
 import fs from "fs-extra";
 
 export interface IDistStats {
-    bundleSize: number;
-    totalFiles: number;
-    totalFolders: number;
-    totalSize: number;
+  bundleSize: number;
+  totalFiles: number;
+  totalFolders: number;
+  totalSize: number;
 }
 
 /**
@@ -13,42 +13,42 @@ export interface IDistStats {
  * @returns the given folder stats;
  */
 async function getFolderStats(folderPath: string, bundlePath?: string): Promise<IDistStats> {
-    const stats: IDistStats = {
-        bundleSize: 0,
-        totalFiles: 0,
-        totalFolders: 0,
-        totalSize: 0,
-    };
+  const stats: IDistStats = {
+    bundleSize: 0,
+    totalFiles: 0,
+    totalFolders: 0,
+    totalSize: 0,
+  };
 
-    if (!(await fs.pathExists(folderPath))) {
-        return stats;
-    }
+  if (!(await fs.pathExists(folderPath))) {
+    return stats;
+  }
 
-    const dir = await fs.promises.opendir(folderPath),
-        path = await import("path");
+  const dir = await fs.promises.opendir(folderPath),
+    path = await import("path");
 
-    for await (const dirent of dir) {
-        const increment = 1;
+  for await (const dirent of dir) {
+    const increment = 1;
 
-        if (dirent.isDirectory()) {
-            const subDirStats = await getFolderStats(path.join(folderPath, dirent.name), bundlePath);
+    if (dirent.isDirectory()) {
+      const subDirStats = await getFolderStats(path.join(folderPath, dirent.name), bundlePath);
 
-            stats.totalFolders += subDirStats.totalFolders + increment;
-            stats.totalFiles += subDirStats.totalFiles;
-            stats.totalSize += subDirStats.totalSize;
-        } else {
-            const fileStats = await fs.stat(path.join(folderPath, dirent.name));
+      stats.totalFolders += subDirStats.totalFolders + increment;
+      stats.totalFiles += subDirStats.totalFiles;
+      stats.totalSize += subDirStats.totalSize;
+    } else {
+      const fileStats = await fs.stat(path.join(folderPath, dirent.name));
 
-            stats.totalFiles++;
-            stats.totalSize += fileStats.size;
+      stats.totalFiles++;
+      stats.totalSize += fileStats.size;
 
-            if (bundlePath && path.join(folderPath, dirent.name) === bundlePath) {
-                stats.bundleSize += fileStats.size;
-            }
-        }
+      if (bundlePath && path.join(folderPath, dirent.name) === bundlePath) {
+        stats.bundleSize += fileStats.size;
+      }
     }
+  }
 
-    return stats;
+  return stats;
 }
 
 /**
@@ -57,15 +57,15 @@ async function getFolderStats(folderPath: string, bundlePath?: string): Promise<
  * @returns the stats for the dist folder
  */
 export async function getDistStats(basePath: string): Promise<IDistStats> {
-    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()) as {
-                  jsdelivr?: string;
-              })
-            : {},
-        bundlePath =
-            (await fs.exists(distFolder)) && pkgInfo.jsdelivr ? path.join(distFolder, pkgInfo.jsdelivr) : undefined;
+  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()) as {
+          jsdelivr?: string;
+        })
+      : {},
+    bundlePath =
+      (await fs.exists(distFolder)) && pkgInfo.jsdelivr ? path.join(distFolder, pkgInfo.jsdelivr) : undefined;
 
-    return await getFolderStats(distFolder, bundlePath);
+  return await getFolderStats(distFolder, bundlePath);
 }

package/src/build/build-eslint.ts

@@ -5,44 +5,42 @@ import { ESLint } from "eslint";
  * @returns true if the linting was successful
  */
 export async function lint(ci: boolean): Promise<boolean> {
-    console.log("ESLint - started on src");
+  console.log("ESLint - started on src");
 
-    let res: boolean;
+  let res: boolean;
 
-    try {
-        const eslint = new ESLint({
-            fix: !ci,
-        });
+  try {
+    const eslint = new ESLint({
+      fix: !ci,
+    });
 
-        const results = await eslint.lintFiles(["src"]),
-            errors = ESLint.getErrorResults(results);
+    const results = await eslint.lintFiles(["src"]),
+      errors = ESLint.getErrorResults(results);
 
-        await ESLint.outputFixes(results);
+    await ESLint.outputFixes(results);
 
-        const formatter = await eslint.loadFormatter("stylish"),
-            resultText = formatter.format(results),
-            minimumLength = 0;
+    const formatter = await eslint.loadFormatter("stylish"),
+      resultText = formatter.format(results),
+      minimumLength = 0;
 
-        if (errors.length > minimumLength) {
-            const messages = errors.map(t =>
-                t.messages
-                    .map(m => `${t.filePath} (${m.line.toString()},${m.column.toString()}): ${m.message}`)
-                    .join("\n"),
-            );
+    if (errors.length > minimumLength) {
+      const messages = errors.map(t =>
+        t.messages.map(m => `${t.filePath} (${m.line.toString()},${m.column.toString()}): ${m.message}`).join("\n"),
+      );
 
-            throw new Error(messages.join("\n"));
-        }
+      throw new Error(messages.join("\n"));
+    }
 
-        console.log(resultText);
+    console.log(resultText);
 
-        res = true;
-    } catch (e) {
-        console.error(e);
+    res = true;
+  } catch (e) {
+    console.error(e);
 
-        res = false;
-    }
+    res = false;
+  }
 
-    console.log("ESLint - done on src");
+  console.log("ESLint - done on src");
 
-    return res;
+  return res;
 }

package/src/build/build-prettier.ts

@@ -10,46 +10,46 @@ import prettier from "prettier";
  * @returns true if the prettify src process was successful
  */
 export async function prettifySrc(basePath: string, srcPath: string, ci: boolean): Promise<boolean> {
-    console.log("Prettier - started on src");
+  console.log("Prettier - started on src");
 
-    let res: boolean;
+  let res: boolean;
 
-    try {
-        for await (const file of klaw(srcPath)) {
-            if (file.stats.isDirectory()) {
-                continue;
-            }
-
-            const contents = await fs.readFile(file.path, "utf8"),
-                options = (await prettier.resolveConfig(basePath)) ?? {};
+  try {
+    for await (const file of klaw(srcPath)) {
+      if (file.stats.isDirectory()) {
+        continue;
+      }
 
-            options.printWidth = 120;
-            options.endOfLine = "lf";
-            options.parser = "typescript";
-            options.tabWidth = 4;
-            options.arrowParens = "avoid" as const;
+      const contents = await fs.readFile(file.path, "utf8"),
+        options = (await prettier.resolveConfig(basePath)) ?? {};
 
-            if (ci) {
-                if (!(await prettier.check(contents, options))) {
-                    throw new Error(`${file.path} is not formatted correctly`);
-                }
-            } else {
-                const formatted = await prettier.format(contents, options);
+      options.printWidth = 120;
+      options.endOfLine = "lf";
+      options.parser = "typescript";
+      options.tabWidth = 2;
+      options.arrowParens = "avoid" as const;
 
-                await fs.writeFile(file.path, formatted, "utf8");
-            }
+      if (ci) {
+        if (!(await prettier.check(contents, options))) {
+          throw new Error(`${file.path} is not formatted correctly`);
         }
+      } else {
+        const formatted = await prettier.format(contents, options);
 
-        res = true;
-    } catch (e) {
-        console.error(e);
-
-        res = false;
+        await fs.writeFile(file.path, formatted, "utf8");
+      }
     }
 
-    console.log("Prettier - done on src");
+    res = true;
+  } catch (e) {
+    console.error(e);
+
+    res = false;
+  }
+
+  console.log("Prettier - done on src");
 
-    return res;
+  return res;
 }
 
 /**
@@ -58,39 +58,39 @@ export async function prettifySrc(basePath: string, srcPath: string, ci: boolean
  * @returns true if the prettify package.json process was successful
  */
 export async function prettifyPackageJson(basePath: string, ci: boolean): Promise<boolean> {
-    console.log("Prettier - started on package.json");
+  console.log("Prettier - started on package.json");
 
-    let res: boolean;
+  let res: boolean;
 
-    try {
-        const contents = await fs.readFile("package.json", "utf8"),
-            options = (await prettier.resolveConfig(basePath)) ?? {};
+  try {
+    const contents = await fs.readFile("package.json", "utf8"),
+      options = (await prettier.resolveConfig(basePath)) ?? {};
 
-        options.tabWidth = 2;
-        options.printWidth = 120;
-        options.endOfLine = "lf";
-        options.parser = "json";
+    options.tabWidth = 2;
+    options.printWidth = 120;
+    options.endOfLine = "lf";
+    options.parser = "json";
 
-        if (ci) {
-            if (!(await prettier.check(contents, options))) {
-                throw new Error(`package.json is not formatted correctly`);
-            }
-        } else {
-            const formatted = await prettier.format(contents, options);
+    if (ci) {
+      if (!(await prettier.check(contents, options))) {
+        throw new Error(`package.json is not formatted correctly`);
+      }
+    } else {
+      const formatted = await prettier.format(contents, options);
 
-            await fs.writeFile("package.json", formatted, "utf8");
-        }
+      await fs.writeFile("package.json", formatted, "utf8");
+    }
 
-        res = true;
-    } catch (e) {
-        console.error(e);
+    res = true;
+  } catch (e) {
+    console.error(e);
 
-        res = false;
-    }
+    res = false;
+  }
 
-    console.log("Prettier - done on package.json");
+  console.log("Prettier - done on package.json");
 
-    return res;
+  return res;
 }
 
 /**
@@ -99,41 +99,41 @@ export async function prettifyPackageJson(basePath: string, ci: boolean): Promis
  * @returns true if the prettify package.dist.json process was successful
  */
 export async function prettifyPackageDistJson(basePath: string, _ci: boolean): Promise<boolean> {
-    console.log("Prettier - started on package.dist.json");
+  console.log("Prettier - started on package.dist.json");
 
-    let res: boolean;
+  let res: boolean;
 
-    try {
-        const contents = await fs.readFile("package.dist.json", "utf8"),
-            options = (await prettier.resolveConfig(basePath)) ?? {};
+  try {
+    const contents = await fs.readFile("package.dist.json", "utf8"),
+      options = (await prettier.resolveConfig(basePath)) ?? {};
 
-        options.tabWidth = 2;
-        options.printWidth = 120;
-        options.endOfLine = "lf";
-        options.parser = "json";
+    options.tabWidth = 2;
+    options.printWidth = 120;
+    options.endOfLine = "lf";
+    options.parser = "json";
 
-        // TODO: disabled this check until "prettier-plugin-multiline-arrays" package is compatible with Prettier 3.0.0
+    // TODO: disabled this check until "prettier-plugin-multiline-arrays" package is compatible with Prettier 3.0.0
 
-        /* if (ci) {
+    /* if (ci) {
             if (!(await prettier.check(contents, options))) {
                 throw new Error(`package.dist.json is not formatted correctly`);
             }
         } else { */
-        const formatted = await prettier.format(contents, options);
+    const formatted = await prettier.format(contents, options);
 
-        await fs.writeFile("package.dist.json", formatted, "utf8");
-        // }
+    await fs.writeFile("package.dist.json", formatted, "utf8");
+    // }
 
-        res = true;
-    } catch (e) {
-        console.error(e);
+    res = true;
+  } catch (e) {
+    console.error(e);
 
-        res = false;
-    }
+    res = false;
+  }
 
-    console.log("Prettier - done on package.dist.json");
+  console.log("Prettier - done on package.dist.json");
 
-    return res;
+  return res;
 }
 
 /**
@@ -142,38 +142,38 @@ export async function prettifyPackageDistJson(basePath: string, _ci: boolean): P
  * @returns true if the prettify readme process was successful
  */
 export async function prettifyReadme(basePath: string, ci: boolean): Promise<boolean> {
-    console.log("Prettier - started on README.md");
+  console.log("Prettier - started on README.md");
 
-    let res: boolean;
+  let res: boolean;
 
-    try {
-        const contents = await fs.readFile("README.md", "utf8"),
-            options = (await prettier.resolveConfig(basePath)) ?? {};
+  try {
+    const contents = await fs.readFile("README.md", "utf8"),
+      options = (await prettier.resolveConfig(basePath)) ?? {};
 
-        options.printWidth = 120;
-        options.endOfLine = "lf";
-        options.parser = "markdown";
+    options.printWidth = 120;
+    options.endOfLine = "lf";
+    options.parser = "markdown";
 
-        if (ci) {
-            if (!(await prettier.check(contents, options))) {
-                throw new Error(`README.md is not formatted correctly`);
-            }
-        } else {
-            const formatted = await prettier.format(contents, options);
+    if (ci) {
+      if (!(await prettier.check(contents, options))) {
+        throw new Error(`README.md is not formatted correctly`);
+      }
+    } else {
+      const formatted = await prettier.format(contents, options);
 
-            await fs.writeFile("README.md", formatted, "utf8");
-        }
+      await fs.writeFile("README.md", formatted, "utf8");
+    }
 
-        res = (await prettifyTraductions(basePath, ci)) && (await prettifyMarkdownTypeDocFiles(basePath, ci));
-    } catch (e) {
-        console.error(e);
+    res = (await prettifyTraductions(basePath, ci)) && (await prettifyMarkdownTypeDocFiles(basePath, ci));
+  } catch (e) {
+    console.error(e);
 
-        res = false;
-    }
+    res = false;
+  }
 
-    console.log("Prettier - done on README.md");
+  console.log("Prettier - done on README.md");
 
-    return res;
+  return res;
 }
 
 /**
@@ -182,53 +182,53 @@ export async function prettifyReadme(basePath: string, ci: boolean): Promise<boo
  * @returns true if the prettify traductions process was successful
  */
 async function prettifyTraductions(basePath: string, ci: boolean): Promise<boolean> {
-    console.log("Prettier - started on traductions");
+  console.log("Prettier - started on traductions");
 
-    let res = false;
+  let res = false;
 
-    try {
-        const folder = "traduction",
-            folderPath = path.join(basePath, folder);
+  try {
+    const folder = "traduction",
+      folderPath = path.join(basePath, folder);
 
-        if (!fs.existsSync(folderPath)) {
-            res = true;
-        }
-
-        if (!res) {
-            for await (const file of klaw(folderPath)) {
-                if (file.stats.isDirectory()) {
-                    continue;
-                }
+    if (!fs.existsSync(folderPath)) {
+      res = true;
+    }
 
-                const contents = await fs.readFile(file.path, "utf8"),
-                    options = (await prettier.resolveConfig(basePath)) ?? {};
+    if (!res) {
+      for await (const file of klaw(folderPath)) {
+        if (file.stats.isDirectory()) {
+          continue;
+        }
 
-                options.printWidth = 120;
-                options.endOfLine = "lf";
-                options.parser = "markdown";
+        const contents = await fs.readFile(file.path, "utf8"),
+          options = (await prettier.resolveConfig(basePath)) ?? {};
 
-                if (ci) {
-                    if (!(await prettier.check(contents, options))) {
-                        throw new Error(`${file.path} is not formatted correctly`);
-                    }
-                } else {
-                    const formatted = await prettier.format(contents, options);
+        options.printWidth = 120;
+        options.endOfLine = "lf";
+        options.parser = "markdown";
 
-                    await fs.writeFile(file.path, formatted, "utf8");
-                }
-            }
+        if (ci) {
+          if (!(await prettier.check(contents, options))) {
+            throw new Error(`${file.path} is not formatted correctly`);
+          }
+        } else {
+          const formatted = await prettier.format(contents, options);
 
-            res = true;
+          await fs.writeFile(file.path, formatted, "utf8");
         }
-    } catch (e) {
-        console.error(e);
+      }
 
-        res = false;
+      res = true;
     }
+  } catch (e) {
+    console.error(e);
+
+    res = false;
+  }
 
-    console.log("Prettier - done on traductions");
+  console.log("Prettier - done on traductions");
 
-    return res;
+  return res;
 }
 
 /**
@@ -237,51 +237,51 @@ async function prettifyTraductions(basePath: string, ci: boolean): Promise<boole
  * @returns true if the prettify markdown typedoc files process was successful
  */
 async function prettifyMarkdownTypeDocFiles(basePath: string, ci: boolean): Promise<boolean> {
-    console.log("Prettier - started on markdown");
+  console.log("Prettier - started on markdown");
 
-    let res = false;
+  let res = false;
 
-    try {
-        const folder = "markdown",
-            folderPath = path.join(basePath, folder);
-
-        if (!fs.existsSync(folderPath)) {
-            res = true;
-        }
+  try {
+    const folder = "markdown",
+      folderPath = path.join(basePath, folder);
 
-        if (!res) {
-            for await (const file of klaw(folderPath)) {
-                if (file.stats.isDirectory()) {
-                    continue;
-                }
+    if (!fs.existsSync(folderPath)) {
+      res = true;
+    }
 
-                const contents = await fs.readFile(file.path, "utf8"),
-                    options = (await prettier.resolveConfig(basePath)) ?? {};
+    if (!res) {
+      for await (const file of klaw(folderPath)) {
+        if (file.stats.isDirectory()) {
+          continue;
+        }
 
-                options.printWidth = 120;
-                options.endOfLine = "lf";
-                options.parser = "markdown";
+        const contents = await fs.readFile(file.path, "utf8"),
+          options = (await prettier.resolveConfig(basePath)) ?? {};
 
-                if (ci) {
-                    if (!(await prettier.check(contents, options))) {
-                        throw new Error(`${file.path} is not formatted correctly`);
-                    }
-                } else {
-                    const formatted = await prettier.format(contents, options);
+        options.printWidth = 120;
+        options.endOfLine = "lf";
+        options.parser = "markdown";
 
-                    await fs.writeFile(file.path, formatted, "utf8");
-                }
-            }
+        if (ci) {
+          if (!(await prettier.check(contents, options))) {
+            throw new Error(`${file.path} is not formatted correctly`);
+          }
+        } else {
+          const formatted = await prettier.format(contents, options);
 
-            res = true;
+          await fs.writeFile(file.path, formatted, "utf8");
         }
-    } catch (e) {
-        console.error(e);
+      }
 
-        res = false;
+      res = true;
     }
+  } catch (e) {
+    console.error(e);
+
+    res = false;
+  }
 
-    console.log("Prettier - done on markdown");
+  console.log("Prettier - done on markdown");
 
-    return res;
+  return res;
 }