typia 5.0.4 → 5.0.5-dev.20230921-2

package/src/factories/ExpressionFactory.ts

@@ -1,159 +1,159 @@
-import ts from "typescript";
-
-import { RandomGenerator } from "../utils/RandomGenerator";
-
-export namespace ExpressionFactory {
-    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) =>
-        (input: ts.Expression): ts.Expression => {
-            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.",
-                );
-
-            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 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) =>
+        (input: ts.Expression): ts.Expression => {
+            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.",
+                );
+
+            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,74 +1,74 @@
-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>,
-    ) => {
-        // 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>,
+    ) => {
+        // 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,43 +1,43 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-
-import { TransformerError } from "../transformers/TransformerError";
-
-import { MetadataCollection } from "./MetadataCollection";
-import { MetadataFactory } from "./MetadataFactory";
-
-export namespace JsonMetadataFactory {
-    export const analyze =
-        (method: string) =>
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type): [MetadataCollection, Metadata] => {
-            const collection = new MetadataCollection();
-            const result = MetadataFactory.analyze(checker)({
-                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.");
-        return output;
-    };
-}
+import ts from "typescript";
+
+import { Metadata } from "../schemas/metadata/Metadata";
+
+import { TransformerError } from "../transformers/TransformerError";
+
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+
+export namespace JsonMetadataFactory {
+    export const analyze =
+        (method: string) =>
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type): [MetadataCollection, Metadata] => {
+            const collection = new MetadataCollection();
+            const result = MetadataFactory.analyze(checker)({
+                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.");
+        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
-            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
+            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);
+}