typia 5.5.8 → 5.5.9-dev.20240402

package/src/factories/ExpressionFactory.ts

@@ -1,150 +1,150 @@
-import ts from "typescript";
-
-import { RandomGenerator } from "../utils/RandomGenerator";
-
-export namespace ExpressionFactory {
-  export const number = (value: number) =>
-    value < 0
-      ? ts.factory.createPrefixUnaryExpression(
-          ts.SyntaxKind.MinusToken,
-          ts.factory.createNumericLiteral(Math.abs(value)),
-        )
-      : ts.factory.createNumericLiteral(value);
-
-  export const bigint = (value: number | bigint) =>
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier("BigInt"),
-      undefined,
-      [ts.factory.createIdentifier(value.toString())],
-    );
-
-  export const isRequired = (input: ts.Expression): ts.Expression =>
-    ts.factory.createStrictInequality(
-      ts.factory.createIdentifier("undefined"),
-      input,
-    );
-
-  export const isArray = (input: ts.Expression): ts.Expression =>
-    ts.factory.createCallExpression(
-      ts.factory.createIdentifier("Array.isArray"),
-      undefined,
-      [input],
-    );
-
-  export const isObject =
-    (options: { checkNull: boolean; checkArray: boolean }) =>
-    (input: ts.Expression): ts.Expression => {
-      const conditions: ts.Expression[] = [
-        ts.factory.createStrictEquality(
-          ts.factory.createStringLiteral("object"),
-          ts.factory.createTypeOfExpression(input),
-        ),
-      ];
-      if (options.checkNull === true)
-        conditions.push(
-          ts.factory.createStrictInequality(ts.factory.createNull(), input),
-        );
-      if (options.checkArray === true)
-        conditions.push(
-          ts.factory.createStrictEquality(
-            ts.factory.createFalse(),
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Array.isArray"),
-              undefined,
-              [input],
-            ),
-          ),
-        );
-
-      return conditions.length === 1
-        ? conditions[0]!
-        : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
-
-  export const isInstanceOf =
-    (type: string) =>
-    (input: ts.Expression): ts.Expression => {
-      return ts.factory.createBinaryExpression(
-        input,
-        ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
-        ts.factory.createIdentifier(type),
-      );
-    };
-
-  export const coalesce =
-    (x: ts.Expression) =>
-    (y: ts.Expression): ts.Expression =>
-      ts.factory.createBinaryExpression(
-        x,
-        ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-        y,
-      );
-
-  export const currying =
-    (target: ts.Expression) => (parameters: ts.Expression[]) => {
-      if (parameters.length === 0)
-        return ts.factory.createCallExpression(target, undefined, undefined);
-      let prev: ts.CallExpression = ts.factory.createCallExpression(
-        target,
-        undefined,
-        [parameters[0]!],
-      );
-      for (const param of parameters.slice(1))
-        prev = ts.factory.createCallExpression(prev, undefined, [param]);
-      return prev;
-    };
-
-  export const selfCall = (body: ts.ConciseBody) =>
-    ts.isCallExpression(body)
-      ? body
-      : ts.factory.createCallExpression(
-          ts.factory.createParenthesizedExpression(
-            ts.factory.createArrowFunction(
-              undefined,
-              undefined,
-              [],
-              undefined,
-              undefined,
-              body,
-            ),
-          ),
-          undefined,
-          undefined,
-        );
-
-  export const getEscapedText =
-    (printer: ts.Printer) =>
-    (input: ts.Expression): string =>
-      printer.printNode(ts.EmitHint.Expression, input, input.getSourceFile());
-
-  export const transpile =
-    (context: ts.TransformationContext) => (script: string) => {
-      const file: ts.SourceFile = ts.createSourceFile(
-        `${RandomGenerator.uuid()}.ts`,
-        script,
-        ts.ScriptTarget.ESNext,
-        true,
-        ts.ScriptKind.TS,
-      );
-      const statement: ts.Statement | undefined = file.statements[0];
-      if (statement === undefined)
-        throw new ReferenceError(
-          "Error on ExpressionFactory.transpile(): no statement exists.",
-        );
-      else if (!ts.isExpressionStatement(statement))
-        throw new TypeError(
-          "Error on ExpressionFactory.transpile(): statement is not an expression statement.",
-        );
-      return (input: ts.Expression): ts.Expression => {
-        const visitor = (node: ts.Node): ts.Node => {
-          if (ts.isIdentifier(node) && node.text === "$input") return input;
-          return ts.visitEachChild(
-            (ts.factory as any).cloneNode(node),
-            visitor,
-            context,
-          );
-        };
-        return visitor(statement.expression) as ts.Expression;
-      };
-    };
-}
+import ts from "typescript";
+
+import { RandomGenerator } from "../utils/RandomGenerator";
+
+export namespace ExpressionFactory {
+  export const number = (value: number) =>
+    value < 0
+      ? ts.factory.createPrefixUnaryExpression(
+          ts.SyntaxKind.MinusToken,
+          ts.factory.createNumericLiteral(Math.abs(value)),
+        )
+      : ts.factory.createNumericLiteral(value);
+
+  export const bigint = (value: number | bigint) =>
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier("BigInt"),
+      undefined,
+      [ts.factory.createIdentifier(value.toString())],
+    );
+
+  export const isRequired = (input: ts.Expression): ts.Expression =>
+    ts.factory.createStrictInequality(
+      ts.factory.createIdentifier("undefined"),
+      input,
+    );
+
+  export const isArray = (input: ts.Expression): ts.Expression =>
+    ts.factory.createCallExpression(
+      ts.factory.createIdentifier("Array.isArray"),
+      undefined,
+      [input],
+    );
+
+  export const isObject =
+    (options: { checkNull: boolean; checkArray: boolean }) =>
+    (input: ts.Expression): ts.Expression => {
+      const conditions: ts.Expression[] = [
+        ts.factory.createStrictEquality(
+          ts.factory.createStringLiteral("object"),
+          ts.factory.createTypeOfExpression(input),
+        ),
+      ];
+      if (options.checkNull === true)
+        conditions.push(
+          ts.factory.createStrictInequality(ts.factory.createNull(), input),
+        );
+      if (options.checkArray === true)
+        conditions.push(
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("Array.isArray"),
+              undefined,
+              [input],
+            ),
+          ),
+        );
+
+      return conditions.length === 1
+        ? conditions[0]!
+        : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };
+
+  export const isInstanceOf =
+    (type: string) =>
+    (input: ts.Expression): ts.Expression => {
+      return ts.factory.createBinaryExpression(
+        input,
+        ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
+        ts.factory.createIdentifier(type),
+      );
+    };
+
+  export const coalesce =
+    (x: ts.Expression) =>
+    (y: ts.Expression): ts.Expression =>
+      ts.factory.createBinaryExpression(
+        x,
+        ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+        y,
+      );
+
+  export const currying =
+    (target: ts.Expression) => (parameters: ts.Expression[]) => {
+      if (parameters.length === 0)
+        return ts.factory.createCallExpression(target, undefined, undefined);
+      let prev: ts.CallExpression = ts.factory.createCallExpression(
+        target,
+        undefined,
+        [parameters[0]!],
+      );
+      for (const param of parameters.slice(1))
+        prev = ts.factory.createCallExpression(prev, undefined, [param]);
+      return prev;
+    };
+
+  export const selfCall = (body: ts.ConciseBody) =>
+    ts.isCallExpression(body)
+      ? body
+      : ts.factory.createCallExpression(
+          ts.factory.createParenthesizedExpression(
+            ts.factory.createArrowFunction(
+              undefined,
+              undefined,
+              [],
+              undefined,
+              undefined,
+              body,
+            ),
+          ),
+          undefined,
+          undefined,
+        );
+
+  export const getEscapedText =
+    (printer: ts.Printer) =>
+    (input: ts.Expression): string =>
+      printer.printNode(ts.EmitHint.Expression, input, input.getSourceFile());
+
+  export const transpile =
+    (context: ts.TransformationContext) => (script: string) => {
+      const file: ts.SourceFile = ts.createSourceFile(
+        `${RandomGenerator.uuid()}.ts`,
+        script,
+        ts.ScriptTarget.ESNext,
+        true,
+        ts.ScriptKind.TS,
+      );
+      const statement: ts.Statement | undefined = file.statements[0];
+      if (statement === undefined)
+        throw new ReferenceError(
+          "Error on ExpressionFactory.transpile(): no statement exists.",
+        );
+      else if (!ts.isExpressionStatement(statement))
+        throw new TypeError(
+          "Error on ExpressionFactory.transpile(): statement is not an expression statement.",
+        );
+      return (input: ts.Expression): ts.Expression => {
+        const visitor = (node: ts.Node): ts.Node => {
+          if (ts.isIdentifier(node) && node.text === "$input") return input;
+          return ts.visitEachChild(
+            (ts.factory as any).cloneNode(node),
+            visitor,
+            context,
+          );
+        };
+        return visitor(statement.expression) as ts.Expression;
+      };
+    };
+}

package/src/factories/IdentifierFactory.ts

@@ -1,70 +1,70 @@
-import ts from "typescript";
-
-import { Escaper } from "../utils/Escaper";
-
-import { TypeFactory } from "./TypeFactory";
-
-export namespace IdentifierFactory {
-  export const identifier = (name: string) =>
-    Escaper.variable(name)
-      ? ts.factory.createIdentifier(name)
-      : ts.factory.createStringLiteral(name);
-
-  export const access = (target: ts.Expression) => (property: string) => {
-    const postfix = identifier(property);
-    return ts.isStringLiteral(postfix)
-      ? ts.factory.createElementAccessExpression(target, postfix)
-      : ts.factory.createPropertyAccessExpression(target, postfix);
-  };
-
-  export const getName = (input: ts.Expression): string => {
-    const value: any = (input as any).escapedText?.toString();
-    if (typeof value === "string") return value;
-
-    if (ts.isPropertyAccessExpression(input))
-      return `${getName(
-        input.expression,
-      )}.${input.name.escapedText.toString()}`;
-    else if (ts.isElementAccessExpression(input))
-      return `${getName(input.expression)}[${getName(
-        input.argumentExpression,
-      )}]`;
-    return "uknown";
-  };
-
-  export const postfix = (str: string): string =>
-    Escaper.variable(str)
-      ? `".${str}"`
-      : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
-
-  export const parameter = (
-    name: string | ts.BindingName,
-    type?: ts.TypeNode,
-    init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
-  ): ts.ParameterDeclaration => {
-    // instead of ts.version >= "4.8"
-    if (ts.getDecorators !== undefined)
-      return ts.factory.createParameterDeclaration(
-        undefined,
-        undefined,
-        name,
-        init?.kind === ts.SyntaxKind.QuestionToken
-          ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-          : undefined,
-        type ?? TypeFactory.keyword("any"),
-        init && init.kind !== ts.SyntaxKind.QuestionToken ? init : undefined,
-      );
-    // eslint-disable-next-line
-    return (ts.factory.createParameterDeclaration as any)(
-      undefined,
-      undefined,
-      undefined,
-      name,
-      init?.kind === ts.SyntaxKind.QuestionToken
-        ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
-        : undefined,
-      type,
-      init && init.kind !== ts.SyntaxKind.QuestionToken ? init : undefined,
-    );
-  };
-}
+import ts from "typescript";
+
+import { Escaper } from "../utils/Escaper";
+
+import { TypeFactory } from "./TypeFactory";
+
+export namespace IdentifierFactory {
+  export const identifier = (name: string) =>
+    Escaper.variable(name)
+      ? ts.factory.createIdentifier(name)
+      : ts.factory.createStringLiteral(name);
+
+  export const access = (target: ts.Expression) => (property: string) => {
+    const postfix = identifier(property);
+    return ts.isStringLiteral(postfix)
+      ? ts.factory.createElementAccessExpression(target, postfix)
+      : ts.factory.createPropertyAccessExpression(target, postfix);
+  };
+
+  export const getName = (input: ts.Expression): string => {
+    const value: any = (input as any).escapedText?.toString();
+    if (typeof value === "string") return value;
+
+    if (ts.isPropertyAccessExpression(input))
+      return `${getName(
+        input.expression,
+      )}.${input.name.escapedText.toString()}`;
+    else if (ts.isElementAccessExpression(input))
+      return `${getName(input.expression)}[${getName(
+        input.argumentExpression,
+      )}]`;
+    return "uknown";
+  };
+
+  export const postfix = (str: string): string =>
+    Escaper.variable(str)
+      ? `".${str}"`
+      : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+
+  export const parameter = (
+    name: string | ts.BindingName,
+    type?: ts.TypeNode,
+    init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
+  ): ts.ParameterDeclaration => {
+    // instead of ts.version >= "4.8"
+    if (ts.getDecorators !== undefined)
+      return ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        name,
+        init?.kind === ts.SyntaxKind.QuestionToken
+          ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+          : undefined,
+        type ?? TypeFactory.keyword("any"),
+        init && init.kind !== ts.SyntaxKind.QuestionToken ? init : undefined,
+      );
+    // eslint-disable-next-line
+    return (ts.factory.createParameterDeclaration as any)(
+      undefined,
+      undefined,
+      undefined,
+      name,
+      init?.kind === ts.SyntaxKind.QuestionToken
+        ? ts.factory.createToken(ts.SyntaxKind.QuestionToken)
+        : undefined,
+      type,
+      init && init.kind !== ts.SyntaxKind.QuestionToken ? init : undefined,
+    );
+  };
+}

package/src/factories/JsonMetadataFactory.ts

@@ -1,53 +1,53 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-
-import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
-
-import { TransformerError } from "../transformers/TransformerError";
-
-import { MetadataCollection } from "./MetadataCollection";
-import { MetadataFactory } from "./MetadataFactory";
-
-export namespace JsonMetadataFactory {
-  export const analyze =
-    (method: string) =>
-    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
-    (type: ts.Type): [MetadataCollection, Metadata] => {
-      const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        checker,
-        context,
-      )({
-        escape: true,
-        constant: true,
-        absorb: true,
-        validate,
-      })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from(method)(result.errors);
-      return [collection, result.data];
-    };
-
-  export const validate = (meta: Metadata) => {
-    const output: string[] = [];
-    if (
-      meta.atomics.some((a) => a.type === "bigint") ||
-      meta.constants.some((c) => c.type === "bigint")
-    )
-      output.push("JSON does not support bigint type.");
-    if (
-      meta.tuples.some((t) =>
-        t.type.elements.some((e) => e.isRequired() === false),
-      ) ||
-      meta.arrays.some((a) => a.type.value.isRequired() === false)
-    )
-      output.push("JSON does not support undefined type in array.");
-    if (meta.maps.length) output.push("JSON does not support Map type.");
-    if (meta.sets.length) output.push("JSON does not support Set type.");
-    for (const native of meta.natives)
-      if (AtomicPredicator.native(native) === false && native !== "Date")
-        output.push(`JSON does not support ${native} type.`);
-    return output;
-  };
-}
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+
+import { AtomicPredicator } from "../programmers/helpers/AtomicPredicator";
+
+import { TransformerError } from "../transformers/TransformerError";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+
+export namespace JsonMetadataFactory {
+  export const analyze =
+    (method: string) =>
+    (checker: ts.TypeChecker, context?: ts.TransformationContext) =>
+    (type: ts.Type): [MetadataCollection, Metadata] => {
+      const collection = new MetadataCollection();
+      const result = MetadataFactory.analyze(
+        checker,
+        context,
+      )({
+        escape: true,
+        constant: true,
+        absorb: true,
+        validate,
+      })(collection)(type);
+      if (result.success === false)
+        throw TransformerError.from(method)(result.errors);
+      return [collection, result.data];
+    };
+
+  export const validate = (meta: Metadata) => {
+    const output: string[] = [];
+    if (
+      meta.atomics.some((a) => a.type === "bigint") ||
+      meta.constants.some((c) => c.type === "bigint")
+    )
+      output.push("JSON does not support bigint type.");
+    if (
+      meta.tuples.some((t) =>
+        t.type.elements.some((e) => e.isRequired() === false),
+      ) ||
+      meta.arrays.some((a) => a.type.value.isRequired() === false)
+    )
+      output.push("JSON does not support undefined type in array.");
+    if (meta.maps.length) output.push("JSON does not support Map type.");
+    if (meta.sets.length) output.push("JSON does not support Set type.");
+    for (const native of meta.natives)
+      if (AtomicPredicator.native(native) === false && native !== "Date")
+        output.push(`JSON does not support ${native} type.`);
+    return output;
+  };
+}

package/src/factories/LiteralFactory.ts

@@ -1,47 +1,47 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "./ExpressionFactory";
-import { IdentifierFactory } from "./IdentifierFactory";
-
-export namespace LiteralFactory {
-  export const generate = (input: any): ts.Expression => {
-    if (input === null) return ts.factory.createNull();
-    else if (ts.isIdentifier(input)) return input;
-    else if (input instanceof Array) return generate_array(input);
-    else if (typeof input === "object") return generate_object(input);
-    else if (typeof input === "string") return generate_string(input);
-    else if (typeof input === "boolean") return generate_value(input);
-    else if (typeof input === "number") return generate_value(input);
-    else if (typeof input === "bigint") return generate_bigint(input);
-    // unreachable code
-    else if (typeof input === "function")
-      return ts.factory.createIdentifier("undefined");
-    else
-      throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
-  };
-
-  const generate_object = (obj: object): ts.ObjectLiteralExpression =>
-    ts.factory.createObjectLiteralExpression(
-      Object.entries(obj)
-        .filter((tuple) => tuple[1] !== undefined)
-        .map(([key, value]) =>
-          ts.factory.createPropertyAssignment(
-            IdentifierFactory.identifier(key),
-            generate(value),
-          ),
-        ),
-      true,
-    );
-
-  const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
-    ts.factory.createArrayLiteralExpression(array.map(generate), true);
-
-  const generate_value = (value: number | boolean | bigint): ts.Expression =>
-    ts.factory.createIdentifier(value.toString());
-
-  const generate_bigint = (value: bigint): ts.Expression =>
-    ExpressionFactory.bigint(value);
-
-  const generate_string = (value: string): ts.StringLiteral =>
-    ts.factory.createStringLiteral(value);
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "./ExpressionFactory";
+import { IdentifierFactory } from "./IdentifierFactory";
+
+export namespace LiteralFactory {
+  export const generate = (input: any): ts.Expression => {
+    if (input === null) return ts.factory.createNull();
+    else if (ts.isIdentifier(input)) return input;
+    else if (input instanceof Array) return generate_array(input);
+    else if (typeof input === "object") return generate_object(input);
+    else if (typeof input === "string") return generate_string(input);
+    else if (typeof input === "boolean") return generate_value(input);
+    else if (typeof input === "number") return generate_value(input);
+    else if (typeof input === "bigint") return generate_bigint(input);
+    // unreachable code
+    else if (typeof input === "function")
+      return ts.factory.createIdentifier("undefined");
+    else
+      throw new TypeError("Error on LiteralFactory.generate(): unknown type.");
+  };
+
+  const generate_object = (obj: object): ts.ObjectLiteralExpression =>
+    ts.factory.createObjectLiteralExpression(
+      Object.entries(obj)
+        .filter((tuple) => tuple[1] !== undefined)
+        .map(([key, value]) =>
+          ts.factory.createPropertyAssignment(
+            IdentifierFactory.identifier(key),
+            generate(value),
+          ),
+        ),
+      true,
+    );
+
+  const generate_array = (array: any[]): ts.ArrayLiteralExpression =>
+    ts.factory.createArrayLiteralExpression(array.map(generate), true);
+
+  const generate_value = (value: number | boolean | bigint): ts.Expression =>
+    ts.factory.createIdentifier(value.toString());
+
+  const generate_bigint = (value: bigint): ts.Expression =>
+    ExpressionFactory.bigint(value);
+
+  const generate_string = (value: string): ts.StringLiteral =>
+    ts.factory.createStringLiteral(value);
+}