typia 6.10.2-dev.20240920 → 6.10.2

package/src/programmers/functional/FunctionalValidateReturnProgrammer.ts

@@ -1,126 +1,126 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalValidateReturnProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.CallExpression => {
-      const result = decompose(project)(modulo)(equals)(
-        expression,
-        declaration,
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            ...result.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                result.async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                FunctionalValidateFunctionProgrammer.getReturnTypeNode(
-                  declaration,
-                  result.async,
-                ),
-                undefined,
-                ts.factory.createBlock(result.statements, true),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): {
-      async: boolean;
-      functions: ts.Statement[];
-      statements: ts.Statement[];
-    } => {
-      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      const caller: ts.CallExpression = ts.factory.createCallExpression(
-        expression,
-        undefined,
-        declaration.parameters.map((p) =>
-          ts.factory.createIdentifier(p.name.getText()),
-        ),
-      );
-
-      const name: string = StringUtil.escapeDuplicate(
-        declaration.parameters.map((p) => p.name.getText()),
-      )("result");
-      return {
-        async,
-        functions: [
-          StatementFactory.constant(
-            "__validate_return",
-            ValidateProgrammer.write(project)(modulo)(equals)(type),
-          ),
-        ],
-        statements: [
-          StatementFactory.constant(
-            name,
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__validate_return"),
-              undefined,
-              [async ? ts.factory.createAwaitExpression(caller) : caller],
-            ),
-          ),
-          ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-              ts.factory.createFalse(),
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier(name),
-                ts.factory.createIdentifier("success"),
-              ),
-            ),
-            ts.factory.createExpressionStatement(
-              ts.factory.createBinaryExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier(name),
-                  ts.factory.createIdentifier("errors"),
-                ),
-                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
-                FunctionalValidateFunctionProgrammer.hookErrors({
-                  expression: ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier(name),
-                    ts.factory.createIdentifier("errors"),
-                  ),
-                  replacer: ts.factory.createStringLiteral("$input.return"),
-                }),
-              ),
-            ),
-          ),
-          ts.factory.createReturnStatement(
-            ts.factory.createIdentifier("result"),
-          ),
-        ],
-      };
-    };
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalValidateReturnProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.CallExpression => {
+      const result = decompose(project)(modulo)(equals)(
+        expression,
+        declaration,
+      );
+      return ExpressionFactory.selfCall(
+        ts.factory.createBlock(
+          [
+            ...result.functions,
+            ts.factory.createReturnStatement(
+              ts.factory.createArrowFunction(
+                result.async
+                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                  : undefined,
+                undefined,
+                declaration.parameters,
+                FunctionalValidateFunctionProgrammer.getReturnTypeNode(
+                  declaration,
+                  result.async,
+                ),
+                undefined,
+                ts.factory.createBlock(result.statements, true),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const decompose =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): {
+      async: boolean;
+      functions: ts.Statement[];
+      statements: ts.Statement[];
+    } => {
+      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      const caller: ts.CallExpression = ts.factory.createCallExpression(
+        expression,
+        undefined,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
+      );
+
+      const name: string = StringUtil.escapeDuplicate(
+        declaration.parameters.map((p) => p.name.getText()),
+      )("result");
+      return {
+        async,
+        functions: [
+          StatementFactory.constant(
+            "__validate_return",
+            ValidateProgrammer.write(project)(modulo)(equals)(type),
+          ),
+        ],
+        statements: [
+          StatementFactory.constant(
+            name,
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__validate_return"),
+              undefined,
+              [async ? ts.factory.createAwaitExpression(caller) : caller],
+            ),
+          ),
+          ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+              ts.factory.createFalse(),
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(name),
+                ts.factory.createIdentifier("success"),
+              ),
+            ),
+            ts.factory.createExpressionStatement(
+              ts.factory.createBinaryExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier(name),
+                  ts.factory.createIdentifier("errors"),
+                ),
+                ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                FunctionalValidateFunctionProgrammer.hookErrors({
+                  expression: ts.factory.createPropertyAccessExpression(
+                    ts.factory.createIdentifier(name),
+                    ts.factory.createIdentifier("errors"),
+                  ),
+                  replacer: ts.factory.createStringLiteral("$input.return"),
+                }),
+              ),
+            ),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("result"),
+          ),
+        ],
+      };
+    };
+}

package/src/programmers/functional/internal/FunctionalGeneralProgrammer.ts

@@ -1,34 +1,34 @@
-import ts from "typescript";
-
-import { TypeFactory } from "../../../factories/TypeFactory";
-
-export namespace FunctionalGeneralProgrammer {
-  export interface IOutput {
-    type: ts.Type;
-    async: boolean;
-  }
-  export const getReturnType =
-    (checker: ts.TypeChecker) =>
-    (
-      declaration: ts.FunctionDeclaration | ts.SignatureDeclaration,
-    ): IOutput => {
-      const signature: ts.Signature | undefined =
-        checker.getSignatureFromDeclaration(declaration);
-      const type: ts.Type =
-        signature?.getReturnType() ??
-        checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
-
-      if (type.symbol?.name === "Promise") {
-        const generic: readonly ts.Type[] = checker.getTypeArguments(
-          type as ts.TypeReference,
-        );
-        return generic.length === 1
-          ? { type: generic[0]!, async: true }
-          : {
-              type: checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
-              async: false,
-            };
-      }
-      return { type, async: false };
-    };
-}
+import ts from "typescript";
+
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+export namespace FunctionalGeneralProgrammer {
+  export interface IOutput {
+    type: ts.Type;
+    async: boolean;
+  }
+  export const getReturnType =
+    (checker: ts.TypeChecker) =>
+    (
+      declaration: ts.FunctionDeclaration | ts.SignatureDeclaration,
+    ): IOutput => {
+      const signature: ts.Signature | undefined =
+        checker.getSignatureFromDeclaration(declaration);
+      const type: ts.Type =
+        signature?.getReturnType() ??
+        checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
+
+      if (type.symbol?.name === "Promise") {
+        const generic: readonly ts.Type[] = checker.getTypeArguments(
+          type as ts.TypeReference,
+        );
+        return generic.length === 1
+          ? { type: generic[0]!, async: true }
+          : {
+              type: checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+              async: false,
+            };
+      }
+      return { type, async: false };
+    };
+}

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";