@tsparticles/cli 3.0.14 → 3.0.15

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 = 4;
+      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;
 }