Merge branch 'v5.3' into fix-typia-home-link

Author: samchon

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
-  "editor.tabSize": 4,
+  "editor.tabSize": 2,
   "[typescript]": {
     "editor.defaultFormatter": "esbenp.prettier-vscode",
     "editor.formatOnSave": true,

benchmark/generate/BenchmarkProgrammer.ts

@@ -1,72 +1,71 @@
 import fs from "fs";
 
 export namespace BenchmarkProgrammer {
-    export interface ICategory {
-        name: string;
-        libraries: ILibrary[];
-        features: string[];
-    }
-    export interface ILibrary {
-        name: string;
-        body: (input: string) => string;
-    }
+  export interface ICategory {
+    name: string;
+    libraries: ILibrary[];
+    features: string[];
+  }
+  export interface ILibrary {
+    name: string;
+    body: (input: string) => string;
+  }
 
-    export async function generate(
-        category: ICategory,
-        filter: (p: { library: string; feature: string }) => boolean = (p) =>
-            (p.library === "class-transformer" ||
-                p.library === "class-validator") &&
-            p.feature === "UltimateUnion",
-    ): Promise<void> {
-        for (const library of category.libraries) {
-            const location: string = [
-                __dirname,
-                "..",
-                "programs",
-                emend(category.name),
-                emend(library.name),
-            ].join("/");
-            try {
-                await fs.promises.mkdir(location, { recursive: true });
-            } catch {}
-            for (const file of await fs.promises.readdir(location))
-                if (!file.includes("create"))
-                    await fs.promises.rm(`${location}/${file}`);
+  export async function generate(
+    category: ICategory,
+    filter: (p: { library: string; feature: string }) => boolean = (p) =>
+      (p.library === "class-transformer" || p.library === "class-validator") &&
+      p.feature === "UltimateUnion",
+  ): Promise<void> {
+    for (const library of category.libraries) {
+      const location: string = [
+        __dirname,
+        "..",
+        "programs",
+        emend(category.name),
+        emend(library.name),
+      ].join("/");
+      try {
+        await fs.promises.mkdir(location, { recursive: true });
+      } catch {}
+      for (const file of await fs.promises.readdir(location))
+        if (!file.includes("create"))
+          await fs.promises.rm(`${location}/${file}`);
 
-            for (const feature of category.features) {
-                if (
-                    filter({
-                        feature,
-                        library: library.name,
-                    })
-                )
-                    continue;
+      for (const feature of category.features) {
+        if (
+          filter({
+            feature,
+            library: library.name,
+          })
+        )
+          continue;
 
-                const file: string = [
-                    "benchmark",
-                    emend(category.name.split("/")[0]),
-                    emend(library.name),
-                    feature,
-                ].join("-");
+        const file: string = [
+          "benchmark",
+          emend(category.name.split("/")[0]),
+          emend(library.name),
+          feature,
+        ].join("-");
 
-                await fs.promises.writeFile(
-                    `${location}/${file}.ts`,
-                    library.body(feature),
-                    "utf8",
-                );
-            }
-        }
+        await fs.promises.writeFile(
+          `${location}/${file}.ts`,
+          library.body(feature),
+          "utf8",
+        );
+      }
     }
+  }
 
-    export const emend = (name: string) =>
-        name
-            .replace("(", "")
-            .replaceAll(")", "")
-            .replaceAll(" ", "-")
-            .toLowerCase();
-    export const pascal = (name: string) =>
-        name
-            .split("-")
-            .map((str) => str[0].toUpperCase() + str.slice(1))
-            .join("");
+  export const emend = (name: string) =>
+    name
+      .replace("(", "")
+      .replaceAll(")", "")
+      .replaceAll(" ", "-")
+      .toLowerCase();
+  export const pascal = (name: string) =>
+    name
+      .split("-")
+      .map((str) => str[0].toUpperCase() + str.slice(1))
+      .join("");
 }

benchmark/generate/assert-error.ts

@@ -1,84 +1,84 @@
 import { BenchmarkProgrammer } from "./BenchmarkProgrammer";
 
 const FEATURES: string[] = [
-    "ObjectSimple",
-    "ObjectHierarchical",
-    "ObjectRecursive",
-    "ObjectUnionExplicit",
-    "ObjectUnionImplicit",
-    "ArrayRecursive",
-    "ArrayRecursiveUnionExplicit",
-    "ArrayRecursiveUnionImplicit",
-    "UltimateUnion",
+  "ObjectSimple",
+  "ObjectHierarchical",
+  "ObjectRecursive",
+  "ObjectUnionExplicit",
+  "ObjectUnionImplicit",
+  "ArrayRecursive",
+  "ArrayRecursiveUnionExplicit",
+  "ArrayRecursiveUnionImplicit",
+  "UltimateUnion",
 ];
 
 const LIBRARIES = (category: string): BenchmarkProgrammer.ILibrary[] => [
-    {
-        name: "typia",
-        body: (type) => {
-            const program = `create${BenchmarkProgrammer.pascal(
-                category,
-            )}BenchmarkProgram`;
-            return [
-                `import typia from "typia";`,
-                ``,
-                `import { ${type} } from "../../../../test/structures/${type}";`,
-                `import { ${program} } from "../${program}";`,
-                ``,
-                `${program}(`,
-                `    typia.create${BenchmarkProgrammer.pascal(category).replace(
-                    "Error",
-                    "",
-                )}<${BenchmarkProgrammer.pascal(type)}[]>()`,
-                `);`,
-            ].join("\n");
-        },
+  {
+    name: "typia",
+    body: (type) => {
+      const program = `create${BenchmarkProgrammer.pascal(
+        category,
+      )}BenchmarkProgram`;
+      return [
+        `import typia from "typia";`,
+        ``,
+        `import { ${type} } from "../../../../test/structures/${type}";`,
+        `import { ${program} } from "../${program}";`,
+        ``,
+        `${program}(`,
+        `    typia.create${BenchmarkProgrammer.pascal(category).replace(
+          "Error",
+          "",
+        )}<${BenchmarkProgrammer.pascal(type)}[]>()`,
+        `);`,
+      ].join("\n");
     },
-    {
-        name: "typebox",
-        body: (type) => {
-            const schema: string = `Typebox${type}`;
-            const program: string = `create${BenchmarkProgrammer.pascal(
-                category,
-            )}TypeboxBenchmarkProgram`;
+  },
+  {
+    name: "typebox",
+    body: (type) => {
+      const schema: string = `Typebox${type}`;
+      const program: string = `create${BenchmarkProgrammer.pascal(
+        category,
+      )}TypeboxBenchmarkProgram`;
 
-            return [
-                `import { __${schema} } from "../../../structures/typebox/${schema}";`,
-                ``,
-                `import { ${program} } from "./${program}";`,
-                ``,
-                `${program}(__${schema});`,
-            ].join("\n");
-        },
+      return [
+        `import { __${schema} } from "../../../structures/typebox/${schema}";`,
+        ``,
+        `import { ${program} } from "./${program}";`,
+        ``,
+        `${program}(__${schema});`,
+      ].join("\n");
     },
-    ...["io-ts", "zod", "class-validator"].map((name) => ({
-        name,
-        body: (type: string) => {
-            const schema: string = `${BenchmarkProgrammer.pascal(name)}${type}`;
-            const program: string = `create${BenchmarkProgrammer.pascal(
-                category,
-            )}${BenchmarkProgrammer.pascal(name)}BenchmarkProgram`;
+  },
+  ...["io-ts", "zod", "class-validator"].map((name) => ({
+    name,
+    body: (type: string) => {
+      const schema: string = `${BenchmarkProgrammer.pascal(name)}${type}`;
+      const program: string = `create${BenchmarkProgrammer.pascal(
+        category,
+      )}${BenchmarkProgrammer.pascal(name)}BenchmarkProgram`;
 
-            return [
-                `import { ${schema} } from "../../../structures/${name}/${schema}";`,
-                ``,
-                `import { ${program} } from "./${program}";`,
-                ``,
-                `${program}(${schema});`,
-            ].join("\n");
-        },
-    })),
+      return [
+        `import { ${schema} } from "../../../structures/${name}/${schema}";`,
+        ``,
+        `import { ${program} } from "./${program}";`,
+        ``,
+        `${program}(${schema});`,
+      ].join("\n");
+    },
+  })),
 ];
 
 async function main(): Promise<void> {
-    await BenchmarkProgrammer.generate({
-        name: "assert-error",
-        libraries: LIBRARIES("assert-error"),
-        features: FEATURES,
-    });
+  await BenchmarkProgrammer.generate({
+    name: "assert-error",
+    libraries: LIBRARIES("assert-error"),
+    features: FEATURES,
+  });
 }
 
 main().catch((exp) => {
-    console.error(exp);
-    process.exit(-1);
+  console.error(exp);
+  process.exit(-1);
 });