typia 6.10.0 → 6.10.1-dev.20240919

package/src/programmers/TypiaProgrammer.ts

@@ -1,157 +1,157 @@
-import fs from "fs";
-import path from "path";
-import ts from "typescript";
-
-import { ImportTransformer } from "../transformers/ImportTransformer";
-
-import transform from "../transform";
-
-export namespace TypiaProgrammer {
-  export interface IProps {
-    input: string;
-    output: string;
-    project: string;
-  }
-
-  export const build = async (props: TypiaProgrammer.IProps): Promise<void> => {
-    props.input = path.resolve(props.input);
-    props.output = path.resolve(props.output);
-
-    if ((await is_directory(props.input)) === false)
-      throw new URIError(
-        "Error on TypiaGenerator.generate(): input path is not a directory.",
-      );
-    else if (fs.existsSync(props.output) === false)
-      await fs.promises.mkdir(props.output, { recursive: true });
-    else if ((await is_directory(props.output)) === false) {
-      const parent: string = path.join(props.output, "..");
-      if ((await is_directory(parent)) === false)
-        throw new URIError(
-          "Error on TypiaGenerator.generate(): output path is not a directory.",
-        );
-      await fs.promises.mkdir(props.output);
-    }
-
-    // CREATE PROGRAM
-    const { options: compilerOptions } = ts.parseJsonConfigFileContent(
-      ts.readConfigFile(props.project, ts.sys.readFile).config,
-      {
-        fileExists: ts.sys.fileExists,
-        readFile: ts.sys.readFile,
-        readDirectory: ts.sys.readDirectory,
-        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
-      },
-      path.dirname(props.project),
-    );
-
-    const program: ts.Program = ts.createProgram(
-      await (async () => {
-        const container: string[] = [];
-        await gather(props)(container)(props.input)(props.output);
-        return container;
-      })(),
-      compilerOptions,
-    );
-
-    // DO TRANSFORM
-    const diagnostics: ts.Diagnostic[] = [];
-    const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
-      program
-        .getSourceFiles()
-        .filter(
-          (file) =>
-            !file.isDeclarationFile &&
-            path.resolve(file.fileName).indexOf(props.input) !== -1,
-        ),
-      [
-        ImportTransformer.transform(props.input)(props.output),
-        transform(
-          program,
-          ((compilerOptions.plugins as any[]) ?? []).find(
-            (p: any) =>
-              p.transform === "typia/lib/transform" ||
-              p.transform === "../src/transform.ts",
-          ) ?? {},
-          {
-            addDiagnostic: (diag) => diagnostics.push(diag),
-          },
-        ),
-      ],
-      program.getCompilerOptions(),
-    );
-
-    // TRACE ERRORS
-    for (const diag of diagnostics) {
-      const file: string = diag.file
-        ? path.relative(diag.file.fileName, process.cwd())
-        : "(unknown file)";
-      const category: string =
-        diag.category === ts.DiagnosticCategory.Warning
-          ? "warning"
-          : diag.category === ts.DiagnosticCategory.Error
-            ? "error"
-            : diag.category === ts.DiagnosticCategory.Suggestion
-              ? "suggestion"
-              : diag.category === ts.DiagnosticCategory.Message
-                ? "message"
-                : "unkown";
-      const [line, pos] = diag.file
-        ? (() => {
-            const lines: string[] = diag
-              .file!.text.substring(0, diag.start)
-              .split("\n");
-            if (lines.length === 0) return [0, 0];
-            return [lines.length, lines.at(-1)!.length + 1];
-          })()
-        : [0, 0];
-      console.error(
-        `${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`,
-      );
-    }
-    if (diagnostics.length) process.exit(-1);
-
-    // ARCHIVE TRANSFORMED FILES
-    const printer: ts.Printer = ts.createPrinter({
-      newLine: ts.NewLineKind.LineFeed,
-    });
-    for (const file of result.transformed) {
-      const to: string = path
-        .resolve(file.fileName)
-        .replace(props.input, props.output);
-
-      const content: string = printer.printFile(file);
-      await fs.promises.writeFile(to, content, "utf8");
-    }
-  };
-
-  const is_directory = async (current: string): Promise<boolean> => {
-    const stat: fs.Stats = await fs.promises.stat(current);
-    return stat.isDirectory();
-  };
-
-  const gather =
-    (props: IProps) =>
-    (container: string[]) =>
-    (from: string) =>
-    async (to: string) => {
-      if (from === props.output) return;
-      else if (fs.existsSync(to) === false) await fs.promises.mkdir(to);
-
-      for (const file of await fs.promises.readdir(from)) {
-        const next: string = path.join(from, file);
-        const stat: fs.Stats = await fs.promises.stat(next);
-
-        if (stat.isDirectory()) {
-          await gather(props)(container)(next)(path.join(to, file));
-          continue;
-        } else if (is_supported_extension(file)) container.push(next);
-      }
-    };
-
-  const is_supported_extension = (filename: string): boolean => {
-    return (
-      (filename.endsWith(".ts") && !filename.endsWith(".d.ts")) ||
-      (filename.endsWith(".tsx") && !filename.endsWith(".d.tsx"))
-    );
-  };
-}
+import fs from "fs";
+import path from "path";
+import ts from "typescript";
+
+import { ImportTransformer } from "../transformers/ImportTransformer";
+
+import transform from "../transform";
+
+export namespace TypiaProgrammer {
+  export interface IProps {
+    input: string;
+    output: string;
+    project: string;
+  }
+
+  export const build = async (props: TypiaProgrammer.IProps): Promise<void> => {
+    props.input = path.resolve(props.input);
+    props.output = path.resolve(props.output);
+
+    if ((await is_directory(props.input)) === false)
+      throw new URIError(
+        "Error on TypiaGenerator.generate(): input path is not a directory.",
+      );
+    else if (fs.existsSync(props.output) === false)
+      await fs.promises.mkdir(props.output, { recursive: true });
+    else if ((await is_directory(props.output)) === false) {
+      const parent: string = path.join(props.output, "..");
+      if ((await is_directory(parent)) === false)
+        throw new URIError(
+          "Error on TypiaGenerator.generate(): output path is not a directory.",
+        );
+      await fs.promises.mkdir(props.output);
+    }
+
+    // CREATE PROGRAM
+    const { options: compilerOptions } = ts.parseJsonConfigFileContent(
+      ts.readConfigFile(props.project, ts.sys.readFile).config,
+      {
+        fileExists: ts.sys.fileExists,
+        readFile: ts.sys.readFile,
+        readDirectory: ts.sys.readDirectory,
+        useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
+      },
+      path.dirname(props.project),
+    );
+
+    const program: ts.Program = ts.createProgram(
+      await (async () => {
+        const container: string[] = [];
+        await gather(props)(container)(props.input)(props.output);
+        return container;
+      })(),
+      compilerOptions,
+    );
+
+    // DO TRANSFORM
+    const diagnostics: ts.Diagnostic[] = [];
+    const result: ts.TransformationResult<ts.SourceFile> = ts.transform(
+      program
+        .getSourceFiles()
+        .filter(
+          (file) =>
+            !file.isDeclarationFile &&
+            path.resolve(file.fileName).indexOf(props.input) !== -1,
+        ),
+      [
+        ImportTransformer.transform(props.input)(props.output),
+        transform(
+          program,
+          ((compilerOptions.plugins as any[]) ?? []).find(
+            (p: any) =>
+              p.transform === "typia/lib/transform" ||
+              p.transform === "../src/transform.ts",
+          ) ?? {},
+          {
+            addDiagnostic: (diag) => diagnostics.push(diag),
+          },
+        ),
+      ],
+      program.getCompilerOptions(),
+    );
+
+    // TRACE ERRORS
+    for (const diag of diagnostics) {
+      const file: string = diag.file
+        ? path.relative(diag.file.fileName, process.cwd())
+        : "(unknown file)";
+      const category: string =
+        diag.category === ts.DiagnosticCategory.Warning
+          ? "warning"
+          : diag.category === ts.DiagnosticCategory.Error
+            ? "error"
+            : diag.category === ts.DiagnosticCategory.Suggestion
+              ? "suggestion"
+              : diag.category === ts.DiagnosticCategory.Message
+                ? "message"
+                : "unkown";
+      const [line, pos] = diag.file
+        ? (() => {
+            const lines: string[] = diag
+              .file!.text.substring(0, diag.start)
+              .split("\n");
+            if (lines.length === 0) return [0, 0];
+            return [lines.length, lines.at(-1)!.length + 1];
+          })()
+        : [0, 0];
+      console.error(
+        `${file}:${line}:${pos} - ${category} TS${diag.code}: ${diag.messageText}`,
+      );
+    }
+    if (diagnostics.length) process.exit(-1);
+
+    // ARCHIVE TRANSFORMED FILES
+    const printer: ts.Printer = ts.createPrinter({
+      newLine: ts.NewLineKind.LineFeed,
+    });
+    for (const file of result.transformed) {
+      const to: string = path
+        .resolve(file.fileName)
+        .replace(props.input, props.output);
+
+      const content: string = printer.printFile(file);
+      await fs.promises.writeFile(to, content, "utf8");
+    }
+  };
+
+  const is_directory = async (current: string): Promise<boolean> => {
+    const stat: fs.Stats = await fs.promises.stat(current);
+    return stat.isDirectory();
+  };
+
+  const gather =
+    (props: IProps) =>
+    (container: string[]) =>
+    (from: string) =>
+    async (to: string) => {
+      if (from === props.output) return;
+      else if (fs.existsSync(to) === false) await fs.promises.mkdir(to);
+
+      for (const file of await fs.promises.readdir(from)) {
+        const next: string = path.join(from, file);
+        const stat: fs.Stats = await fs.promises.stat(next);
+
+        if (stat.isDirectory()) {
+          await gather(props)(container)(next)(path.join(to, file));
+          continue;
+        } else if (is_supported_extension(file)) container.push(next);
+      }
+    };
+
+  const is_supported_extension = (filename: string): boolean => {
+    return (
+      (filename.endsWith(".ts") && !filename.endsWith(".d.ts")) ||
+      (filename.endsWith(".tsx") && !filename.endsWith(".d.tsx"))
+    );
+  };
+}

package/src/programmers/helpers/AtomicPredicator.ts

@@ -1,24 +1,24 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace AtomicPredicator {
-  export const constant =
-    (meta: Metadata) =>
-    (name: Atomic.Literal): boolean =>
-      !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === name);
-
-  export const atomic =
-    (meta: Metadata) =>
-    (name: Atomic.Literal): boolean =>
-      !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === name);
-
-  export const native = (name: string) => LIKE.has(name.toLowerCase());
-
-  export const template = (meta: Metadata): boolean =>
-    !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === "string");
-}
-
-const LIKE = new Set(["boolean", "bigint", "number", "string"]);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace AtomicPredicator {
+  export const constant =
+    (meta: Metadata) =>
+    (name: Atomic.Literal): boolean =>
+      !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === name);
+
+  export const atomic =
+    (meta: Metadata) =>
+    (name: Atomic.Literal): boolean =>
+      !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === name);
+
+  export const native = (name: string) => LIKE.has(name.toLowerCase());
+
+  export const template = (meta: Metadata): boolean =>
+    !ArrayUtil.has(meta.natives, (native) => native.toLowerCase() === "string");
+}
+
+const LIKE = new Set(["boolean", "bigint", "number", "string"]);

package/src/programmers/helpers/CloneJoiner.ts

@@ -1,130 +1,130 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace CloneJoiner {
-  export const object = (
-    input: ts.Expression,
-    entries: IExpressionEntry<ts.Expression>[],
-  ): ts.ConciseBody => {
-    if (entries.length === 0) return ts.factory.createIdentifier("{}");
-
-    const regular = entries.filter((e) => e.key.isSoleLiteral());
-    const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
-    const literal = ts.factory.createObjectLiteralExpression(
-      regular.map((entry) => {
-        const str: string = entry.key.getSoleLiteral()!;
-        return ts.factory.createPropertyAssignment(
-          Escaper.variable(str) ? str : ts.factory.createStringLiteral(str),
-          entry.expression,
-        );
-      }),
-      true,
-    );
-    if (dynamic.length === 0) return literal;
-
-    const key = ts.factory.createIdentifier("key");
-    const output = ts.factory.createIdentifier("output");
-
-    const statements: ts.Statement[] = [];
-    if (regular.length !== 0)
-      statements.push(
-        ts.factory.createIfStatement(
-          ts.factory.createCallExpression(
-            IdentifierFactory.access(
-              ts.factory.createArrayLiteralExpression(
-                regular.map((r) =>
-                  ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
-                ),
-              ),
-            )("some"),
-            undefined,
-            [
-              ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [IdentifierFactory.parameter("regular")],
-                undefined,
-                undefined,
-                ts.factory.createStrictEquality(
-                  ts.factory.createIdentifier("regular"),
-                  ts.factory.createIdentifier("key"),
-                ),
-              ),
-            ],
-          ),
-          ts.factory.createContinueStatement(),
-        ),
-      );
-    statements.push(
-      ...dynamic.map((entry) =>
-        ts.factory.createIfStatement(
-          ts.factory.createCallExpression(
-            ts.factory.createIdentifier(
-              `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
-            ),
-            undefined,
-            [key],
-          ),
-          ts.factory.createBlock([
-            ts.factory.createExpressionStatement(
-              ts.factory.createBinaryExpression(
-                ts.factory.createElementAccessExpression(output, key),
-                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                entry.expression,
-              ),
-            ),
-            ts.factory.createContinueStatement(),
-          ]),
-        ),
-      ),
-    );
-
-    return ts.factory.createBlock([
-      StatementFactory.constant(
-        "output",
-        ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
-      ),
-      ts.factory.createForOfStatement(
-        undefined,
-        StatementFactory.entry("key")("value"),
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier("Object.entries"),
-          undefined,
-          [input],
-        ),
-        ts.factory.createBlock(statements),
-      ),
-      ts.factory.createReturnStatement(output),
-    ]);
-  };
-
-  export const tuple = (
-    children: ts.Expression[],
-    rest: ts.Expression | null,
-  ): ts.Expression => {
-    return ts.factory.createAsExpression(
-      ts.factory.createArrayLiteralExpression(
-        rest === null
-          ? children
-          : [...children, ts.factory.createSpreadElement(rest)],
-        true,
-      ),
-      TypeFactory.keyword("any"),
-    );
-  };
-
-  export const array = (input: ts.Expression, arrow: ts.Expression) =>
-    ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(input, "map"),
-      undefined,
-      [arrow],
-    );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace CloneJoiner {
+  export const object = (
+    input: ts.Expression,
+    entries: IExpressionEntry<ts.Expression>[],
+  ): ts.ConciseBody => {
+    if (entries.length === 0) return ts.factory.createIdentifier("{}");
+
+    const regular = entries.filter((e) => e.key.isSoleLiteral());
+    const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+    const literal = ts.factory.createObjectLiteralExpression(
+      regular.map((entry) => {
+        const str: string = entry.key.getSoleLiteral()!;
+        return ts.factory.createPropertyAssignment(
+          Escaper.variable(str) ? str : ts.factory.createStringLiteral(str),
+          entry.expression,
+        );
+      }),
+      true,
+    );
+    if (dynamic.length === 0) return literal;
+
+    const key = ts.factory.createIdentifier("key");
+    const output = ts.factory.createIdentifier("output");
+
+    const statements: ts.Statement[] = [];
+    if (regular.length !== 0)
+      statements.push(
+        ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(
+              ts.factory.createArrayLiteralExpression(
+                regular.map((r) =>
+                  ts.factory.createStringLiteral(r.key.getSoleLiteral()!),
+                ),
+              ),
+            )("some"),
+            undefined,
+            [
+              ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [IdentifierFactory.parameter("regular")],
+                undefined,
+                undefined,
+                ts.factory.createStrictEquality(
+                  ts.factory.createIdentifier("regular"),
+                  ts.factory.createIdentifier("key"),
+                ),
+              ),
+            ],
+          ),
+          ts.factory.createContinueStatement(),
+        ),
+      );
+    statements.push(
+      ...dynamic.map((entry) =>
+        ts.factory.createIfStatement(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier(
+              `RegExp(/${metadata_to_pattern(true)(entry.key)}/).test`,
+            ),
+            undefined,
+            [key],
+          ),
+          ts.factory.createBlock([
+            ts.factory.createExpressionStatement(
+              ts.factory.createBinaryExpression(
+                ts.factory.createElementAccessExpression(output, key),
+                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                entry.expression,
+              ),
+            ),
+            ts.factory.createContinueStatement(),
+          ]),
+        ),
+      ),
+    );
+
+    return ts.factory.createBlock([
+      StatementFactory.constant(
+        "output",
+        ts.factory.createAsExpression(literal, TypeFactory.keyword("any")),
+      ),
+      ts.factory.createForOfStatement(
+        undefined,
+        StatementFactory.entry("key")("value"),
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("Object.entries"),
+          undefined,
+          [input],
+        ),
+        ts.factory.createBlock(statements),
+      ),
+      ts.factory.createReturnStatement(output),
+    ]);
+  };
+
+  export const tuple = (
+    children: ts.Expression[],
+    rest: ts.Expression | null,
+  ): ts.Expression => {
+    return ts.factory.createAsExpression(
+      ts.factory.createArrayLiteralExpression(
+        rest === null
+          ? children
+          : [...children, ts.factory.createSpreadElement(rest)],
+        true,
+      ),
+      TypeFactory.keyword("any"),
+    );
+  };
+
+  export const array = (input: ts.Expression, arrow: ts.Expression) =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(input, "map"),
+      undefined,
+      [arrow],
+    );
+}

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1 +1 @@
-export * from "./FunctionImporter";
+export * from "./FunctionImporter";

package/src/programmers/helpers/HttpMetadataUtil.ts

@@ -1,21 +1,21 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-export namespace HttpMetadataUtil {
-  export const atomics = (
-    meta: Metadata,
-  ): Set<"boolean" | "bigint" | "number" | "string"> =>
-    new Set([
-      ...meta.atomics.map((a) => a.type),
-      ...meta.constants.map((c) => c.type),
-      ...(meta.templates.length ? (["string"] as const) : []),
-    ]);
-
-  export const isUnion = (meta: Metadata): boolean =>
-    atomics(meta).size +
-      meta.arrays.length +
-      meta.tuples.length +
-      meta.natives.length +
-      meta.maps.length +
-      meta.objects.length >
-    1;
-}
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+export namespace HttpMetadataUtil {
+  export const atomics = (
+    meta: Metadata,
+  ): Set<"boolean" | "bigint" | "number" | "string"> =>
+    new Set([
+      ...meta.atomics.map((a) => a.type),
+      ...meta.constants.map((c) => c.type),
+      ...(meta.templates.length ? (["string"] as const) : []),
+    ]);
+
+  export const isUnion = (meta: Metadata): boolean =>
+    atomics(meta).size +
+      meta.arrays.length +
+      meta.tuples.length +
+      meta.natives.length +
+      meta.maps.length +
+      meta.objects.length >
+    1;
+}