typia 5.5.8 → 5.5.9-dev.20240402

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

@@ -1,32 +1,32 @@
-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): 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): 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";

package/src/programmers/helpers/FunctionImporter.ts

@@ -1,87 +1,87 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-export class FunctionImporter {
-  private readonly used_: Set<string> = new Set();
-  private readonly local_: Set<string> = new Set();
-  private readonly unions_: Map<string, [string, ts.ArrowFunction]> = new Map();
-  private sequence_: number = 0;
-
-  public constructor(public readonly method: string) {}
-
-  public empty(): boolean {
-    return this.used_.size === 0;
-  }
-
-  public use(name: string): ts.Identifier {
-    this.used_.add(name);
-    return ts.factory.createIdentifier("$" + name);
-  }
-
-  public useLocal(name: string): string {
-    this.local_.add(name);
-    return name;
-  }
-
-  public hasLocal(name: string): boolean {
-    return this.local_.has(name);
-  }
-
-  public declare(
-    modulo: ts.LeftHandSideExpression,
-    includeUnions: boolean = true,
-  ): ts.Statement[] {
-    return [
-      ...[...this.used_].map((name) =>
-        StatementFactory.constant(
-          "$" + name,
-          IdentifierFactory.access(
-            ts.factory.createParenthesizedExpression(
-              ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
-            ),
-          )(name),
-        ),
-      ),
-      ...(includeUnions === true
-        ? [...this.unions_.values()].map(([key, arrow]) =>
-            StatementFactory.constant(key, arrow),
-          )
-        : []),
-    ];
-  }
-
-  public declareUnions(): ts.Statement[] {
-    return [...this.unions_.values()].map(([key, arrow]) =>
-      StatementFactory.constant(key, arrow),
-    );
-  }
-
-  public increment(): number {
-    return ++this.sequence_;
-  }
-
-  public emplaceUnion(
-    prefix: string,
-    name: string,
-    factory: () => ts.ArrowFunction,
-  ): string {
-    const oldbie = this.unions_.get(name);
-    if (oldbie) return oldbie[0];
-
-    const index: number = this.unions_.size;
-    const accessor: string = `${prefix}p${index}`;
-
-    const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
-    this.unions_.set(name, tuple);
-    tuple[1] = factory();
-    return accessor;
-  }
-
-  public trace(): void {
-    console.log(...this.used_);
-    console.log(...this.local_);
-  }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+export class FunctionImporter {
+  private readonly used_: Set<string> = new Set();
+  private readonly local_: Set<string> = new Set();
+  private readonly unions_: Map<string, [string, ts.ArrowFunction]> = new Map();
+  private sequence_: number = 0;
+
+  public constructor(public readonly method: string) {}
+
+  public empty(): boolean {
+    return this.used_.size === 0;
+  }
+
+  public use(name: string): ts.Identifier {
+    this.used_.add(name);
+    return ts.factory.createIdentifier("$" + name);
+  }
+
+  public useLocal(name: string): string {
+    this.local_.add(name);
+    return name;
+  }
+
+  public hasLocal(name: string): boolean {
+    return this.local_.has(name);
+  }
+
+  public declare(
+    modulo: ts.LeftHandSideExpression,
+    includeUnions: boolean = true,
+  ): ts.Statement[] {
+    return [
+      ...[...this.used_].map((name) =>
+        StatementFactory.constant(
+          "$" + name,
+          IdentifierFactory.access(
+            ts.factory.createParenthesizedExpression(
+              ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
+            ),
+          )(name),
+        ),
+      ),
+      ...(includeUnions === true
+        ? [...this.unions_.values()].map(([key, arrow]) =>
+            StatementFactory.constant(key, arrow),
+          )
+        : []),
+    ];
+  }
+
+  public declareUnions(): ts.Statement[] {
+    return [...this.unions_.values()].map(([key, arrow]) =>
+      StatementFactory.constant(key, arrow),
+    );
+  }
+
+  public increment(): number {
+    return ++this.sequence_;
+  }
+
+  public emplaceUnion(
+    prefix: string,
+    name: string,
+    factory: () => ts.ArrowFunction,
+  ): string {
+    const oldbie = this.unions_.get(name);
+    if (oldbie) return oldbie[0];
+
+    const index: number = this.unions_.size;
+    const accessor: string = `${prefix}p${index}`;
+
+    const tuple: [string, ReturnType<typeof factory>] = [accessor, null!];
+    this.unions_.set(name, tuple);
+    tuple[1] = factory();
+    return accessor;
+  }
+
+  public trace(): void {
+    console.log(...this.used_);
+    console.log(...this.local_);
+  }
+}

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

package/src/programmers/helpers/ICheckEntry.ts

@@ -1,13 +1,13 @@
-import ts from "typescript";
-
-export interface ICheckEntry {
-  expected: string;
-  expression: ts.Expression | null;
-  conditions: ICheckEntry.ICondition[][];
-}
-export namespace ICheckEntry {
-  export interface ICondition {
-    expected: string;
-    expression: ts.Expression;
-  }
-}
+import ts from "typescript";
+
+export interface ICheckEntry {
+  expected: string;
+  expression: ts.Expression | null;
+  conditions: ICheckEntry.ICondition[][];
+}
+export namespace ICheckEntry {
+  export interface ICondition {
+    expected: string;
+    expression: ts.Expression;
+  }
+}

package/src/programmers/helpers/IExpressionEntry.ts

@@ -1,12 +1,12 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-export interface IExpressionEntry<
-  Expression extends ts.ConciseBody = ts.ConciseBody,
-> {
-  input: ts.Expression;
-  key: Metadata;
-  meta: Metadata;
-  expression: Expression;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+export interface IExpressionEntry<
+  Expression extends ts.ConciseBody = ts.ConciseBody,
+> {
+  input: ts.Expression;
+  key: Metadata;
+  meta: Metadata;
+  expression: Expression;
+}