typia 3.4.21 → 3.4.23

package/src/factories/ExpressionFactory.ts

@@ -1,66 +1,66 @@
-import ts from "typescript";
-
-export namespace ExpressionFactory {
-    export function isRequired(input: ts.Expression): ts.Expression {
-        return ts.factory.createStrictInequality(
-            ts.factory.createIdentifier("undefined"),
-            input,
-        );
-    }
-
-    export function isArray(input: ts.Expression): ts.Expression {
-        return ts.factory.createCallExpression(
-            ts.factory.createIdentifier("Array.isArray"),
-            undefined,
-            [input],
-        );
-    }
-
-    export function isObject(
-        input: ts.Expression,
-        options: {
-            checkNull: boolean;
-            checkArray: boolean;
-        },
-    ): 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 function isInstanceOf(
-        input: ts.Expression,
-        type: string,
-    ): ts.Expression {
-        return ts.factory.createBinaryExpression(
-            input,
-            ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
-            ts.factory.createIdentifier(type),
-        );
-    }
-}
+import ts from "typescript";
+
+export namespace ExpressionFactory {
+    export function isRequired(input: ts.Expression): ts.Expression {
+        return ts.factory.createStrictInequality(
+            ts.factory.createIdentifier("undefined"),
+            input,
+        );
+    }
+
+    export function isArray(input: ts.Expression): ts.Expression {
+        return ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Array.isArray"),
+            undefined,
+            [input],
+        );
+    }
+
+    export function isObject(
+        input: ts.Expression,
+        options: {
+            checkNull: boolean;
+            checkArray: boolean;
+        },
+    ): 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 function isInstanceOf(
+        input: ts.Expression,
+        type: string,
+    ): ts.Expression {
+        return ts.factory.createBinaryExpression(
+            input,
+            ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
+            ts.factory.createIdentifier(type),
+        );
+    }
+}

package/src/factories/IdentifierFactory.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-
-import { Escaper } from "../utils/Escaper";
-
-export namespace IdentifierFactory {
-    export function generate(name: string) {
-        return Escaper.variable(name)
-            ? ts.factory.createIdentifier(name)
-            : ts.factory.createStringLiteral(name);
-    }
-
-    export function join(prefix: ts.Expression, name: string) {
-        const postfix = generate(name);
-        return ts.isStringLiteral(postfix)
-            ? ts.factory.createElementAccessExpression(prefix, postfix)
-            : ts.factory.createPropertyAccessExpression(prefix, postfix);
-    }
-
-    export function postfix(str: string): string {
-        return Escaper.variable(str)
-            ? `".${str}"`
-            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
-    }
-
-    export function parameter(
-        name: string | ts.BindingName,
-        init?: ts.Expression,
-    ) {
-        if (ts.version >= "4.8")
-            return ts.factory.createParameterDeclaration(
-                undefined,
-                undefined,
-                name,
-                undefined,
-                undefined,
-                init,
-            );
-        // eslint-disable-next-line
-        return ts.factory.createParameterDeclaration(
-            undefined,
-            undefined,
-            undefined,
-            name,
-            undefined,
-            undefined,
-            init,
-        );
-    }
-
-    // export function property(
-    //     name: string | ts.PropertyName,
-    //     value: ts.Expression,
-    // ): ts.PropertyDeclaration {
-    //     if (ts.version >= "4.8")
-    //         return ts.factory.createPropertyDeclaration(
-    //             undefined,
-    //             name,
-    //             undefined,
-    //             undefined,
-    //             value,
-    //         );
-    //     // eslint-disable-next-line
-    //     return ts.factory.createPropertyDeclaration(
-    //         undefined,
-    //         undefined,
-    //         name,
-    //         undefined,
-    //         undefined,
-    //         value,
-    //     );
-    // }
-}
+import ts from "typescript";
+
+import { Escaper } from "../utils/Escaper";
+
+export namespace IdentifierFactory {
+    export function generate(name: string) {
+        return Escaper.variable(name)
+            ? ts.factory.createIdentifier(name)
+            : ts.factory.createStringLiteral(name);
+    }
+
+    export function join(prefix: ts.Expression, name: string) {
+        const postfix = generate(name);
+        return ts.isStringLiteral(postfix)
+            ? ts.factory.createElementAccessExpression(prefix, postfix)
+            : ts.factory.createPropertyAccessExpression(prefix, postfix);
+    }
+
+    export function postfix(str: string): string {
+        return Escaper.variable(str)
+            ? `".${str}"`
+            : `"[${JSON.stringify(str).split('"').join('\\"')}]"`;
+    }
+
+    export function parameter(
+        name: string | ts.BindingName,
+        init?: ts.Expression,
+    ) {
+        if (ts.version >= "4.8")
+            return ts.factory.createParameterDeclaration(
+                undefined,
+                undefined,
+                name,
+                undefined,
+                undefined,
+                init,
+            );
+        // eslint-disable-next-line
+        return ts.factory.createParameterDeclaration(
+            undefined,
+            undefined,
+            undefined,
+            name,
+            undefined,
+            undefined,
+            init,
+        );
+    }
+
+    // export function property(
+    //     name: string | ts.PropertyName,
+    //     value: ts.Expression,
+    // ): ts.PropertyDeclaration {
+    //     if (ts.version >= "4.8")
+    //         return ts.factory.createPropertyDeclaration(
+    //             undefined,
+    //             name,
+    //             undefined,
+    //             undefined,
+    //             value,
+    //         );
+    //     // eslint-disable-next-line
+    //     return ts.factory.createPropertyDeclaration(
+    //         undefined,
+    //         undefined,
+    //         name,
+    //         undefined,
+    //         undefined,
+    //         value,
+    //     );
+    // }
+}

package/src/factories/LiteralFactory.ts

@@ -1,44 +1,44 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "./IdentifierFactory";
-
-export namespace LiteralFactory {
-    export function 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_value(input);
-        else throw new Error("Unknown type.");
-    }
-
-    function generate_object(obj: object): ts.ObjectLiteralExpression {
-        const properties = Object.entries(obj)
-            .filter((tuple) => tuple[1] !== undefined)
-            .map(([key, value]) =>
-                ts.factory.createPropertyAssignment(
-                    IdentifierFactory.generate(key),
-                    generate(value),
-                ),
-            );
-        return ts.factory.createObjectLiteralExpression(properties, true);
-    }
-
-    function generate_array(array: any[]): ts.ArrayLiteralExpression {
-        return ts.factory.createArrayLiteralExpression(
-            array.map(generate),
-            true,
-        );
-    }
-
-    function generate_value(value: number | boolean | bigint): ts.Identifier {
-        return ts.factory.createIdentifier(value.toString());
-    }
-
-    function generate_string(value: string): ts.StringLiteral {
-        return ts.factory.createStringLiteral(value);
-    }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "./IdentifierFactory";
+
+export namespace LiteralFactory {
+    export function 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_value(input);
+        else throw new Error("Unknown type.");
+    }
+
+    function generate_object(obj: object): ts.ObjectLiteralExpression {
+        const properties = Object.entries(obj)
+            .filter((tuple) => tuple[1] !== undefined)
+            .map(([key, value]) =>
+                ts.factory.createPropertyAssignment(
+                    IdentifierFactory.generate(key),
+                    generate(value),
+                ),
+            );
+        return ts.factory.createObjectLiteralExpression(properties, true);
+    }
+
+    function generate_array(array: any[]): ts.ArrayLiteralExpression {
+        return ts.factory.createArrayLiteralExpression(
+            array.map(generate),
+            true,
+        );
+    }
+
+    function generate_value(value: number | boolean | bigint): ts.Identifier {
+        return ts.factory.createIdentifier(value.toString());
+    }
+
+    function generate_string(value: string): ts.StringLiteral {
+        return ts.factory.createStringLiteral(value);
+    }
+}

package/src/factories/StatementFactory.ts

@@ -1,60 +1,60 @@
-import ts from "typescript";
-
-export namespace StatementFactory {
-    export function constant(name: string, initializer?: ts.Expression) {
-        return ts.factory.createVariableStatement(
-            undefined,
-            ts.factory.createVariableDeclarationList(
-                [
-                    ts.factory.createVariableDeclaration(
-                        name,
-                        undefined,
-                        undefined,
-                        initializer,
-                    ),
-                ],
-                ts.NodeFlags.Const,
-            ),
-        );
-    }
-
-    export function transpile(script: string) {
-        return ts.factory.createExpressionStatement(
-            ts.factory.createIdentifier(ts.transpile(script)),
-        );
-    }
-
-    // export function require(variable: string, location: string) {
-    //     return ts.factory.createImportDeclaration(
-    //         undefined,
-    //         undefined,
-    //         ts.factory.createImportClause(
-    //             false,
-    //             undefined,
-    //             ts.factory.createNamespaceImport(
-    //                 ts.factory.createIdentifier(variable),
-    //             ),
-    //         ),
-    //         ts.factory.createStringLiteral(location),
-    //     );
-    // }
-
-    // export function importModulo(variable: string, location: string) {
-    //     return ts.factory.createImportDeclaration(
-    //         undefined,
-    //         undefined,
-    //         ts.factory.createImportClause(
-    //             false,
-    //             undefined,
-    //             ts.factory.createNamedImports([
-    //                 ts.factory.createImportSpecifier(
-    //                     false,
-    //                     undefined,
-    //                     ts.factory.createIdentifier(variable),
-    //                 ),
-    //             ]),
-    //         ),
-    //         ts.factory.createStringLiteral(location),
-    //     );
-    // }
-}
+import ts from "typescript";
+
+export namespace StatementFactory {
+    export function constant(name: string, initializer?: ts.Expression) {
+        return ts.factory.createVariableStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [
+                    ts.factory.createVariableDeclaration(
+                        name,
+                        undefined,
+                        undefined,
+                        initializer,
+                    ),
+                ],
+                ts.NodeFlags.Const,
+            ),
+        );
+    }
+
+    export function transpile(script: string) {
+        return ts.factory.createExpressionStatement(
+            ts.factory.createIdentifier(ts.transpile(script)),
+        );
+    }
+
+    // export function require(variable: string, location: string) {
+    //     return ts.factory.createImportDeclaration(
+    //         undefined,
+    //         undefined,
+    //         ts.factory.createImportClause(
+    //             false,
+    //             undefined,
+    //             ts.factory.createNamespaceImport(
+    //                 ts.factory.createIdentifier(variable),
+    //             ),
+    //         ),
+    //         ts.factory.createStringLiteral(location),
+    //     );
+    // }
+
+    // export function importModulo(variable: string, location: string) {
+    //     return ts.factory.createImportDeclaration(
+    //         undefined,
+    //         undefined,
+    //         ts.factory.createImportClause(
+    //             false,
+    //             undefined,
+    //             ts.factory.createNamedImports([
+    //                 ts.factory.createImportSpecifier(
+    //                     false,
+    //                     undefined,
+    //                     ts.factory.createIdentifier(variable),
+    //                 ),
+    //             ]),
+    //         ),
+    //         ts.factory.createStringLiteral(location),
+    //     );
+    // }
+}

package/src/factories/TemplateFactory.ts

@@ -1,56 +1,56 @@
-import ts from "typescript";
-
-export namespace TemplateFactory {
-    export function generate(expressions: ts.Expression[]): ts.Expression {
-        if (expressions.every((exp) => ts.isStringLiteral(exp)))
-            return ts.factory.createStringLiteral(
-                (expressions as ts.StringLiteral[])
-                    .map((str) => str.text)
-                    .join(""),
-            );
-
-        const it: IIerator = {
-            value: "",
-            index: 0,
-        };
-        gather(expressions, it);
-
-        const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
-        const spans: ts.TemplateSpan[] = [];
-
-        while (true) {
-            const elem: ts.Expression = expressions[it.index++]!;
-            gather(expressions, it);
-
-            const broken: boolean = it.index === expressions.length;
-            spans.push(
-                ts.factory.createTemplateSpan(
-                    elem,
-                    broken
-                        ? ts.factory.createTemplateTail(it.value)
-                        : ts.factory.createTemplateMiddle(it.value),
-                ),
-            );
-            if (broken === true) break;
-        }
-        return ts.factory.createTemplateExpression(head, spans);
-    }
-
-    function gather(expressions: ts.Expression[], it: IIerator): void {
-        const found: number = expressions.findIndex(
-            (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
-        );
-
-        const last: number = found !== -1 ? found : expressions.length;
-        it.value = expressions
-            .slice(it.index, last)
-            .map((elem) => (elem as ts.StringLiteral).text)
-            .reduce((x, y) => x + y, "");
-        it.index = last;
-    }
-
-    interface IIerator {
-        value: string;
-        index: number;
-    }
-}
+import ts from "typescript";
+
+export namespace TemplateFactory {
+    export function generate(expressions: ts.Expression[]): ts.Expression {
+        if (expressions.every((exp) => ts.isStringLiteral(exp)))
+            return ts.factory.createStringLiteral(
+                (expressions as ts.StringLiteral[])
+                    .map((str) => str.text)
+                    .join(""),
+            );
+
+        const it: IIerator = {
+            value: "",
+            index: 0,
+        };
+        gather(expressions, it);
+
+        const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
+        const spans: ts.TemplateSpan[] = [];
+
+        while (true) {
+            const elem: ts.Expression = expressions[it.index++]!;
+            gather(expressions, it);
+
+            const broken: boolean = it.index === expressions.length;
+            spans.push(
+                ts.factory.createTemplateSpan(
+                    elem,
+                    broken
+                        ? ts.factory.createTemplateTail(it.value)
+                        : ts.factory.createTemplateMiddle(it.value),
+                ),
+            );
+            if (broken === true) break;
+        }
+        return ts.factory.createTemplateExpression(head, spans);
+    }
+
+    function gather(expressions: ts.Expression[], it: IIerator): void {
+        const found: number = expressions.findIndex(
+            (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
+        );
+
+        const last: number = found !== -1 ? found : expressions.length;
+        it.value = expressions
+            .slice(it.index, last)
+            .map((elem) => (elem as ts.StringLiteral).text)
+            .reduce((x, y) => x + y, "");
+        it.index = last;
+    }
+
+    interface IIerator {
+        value: string;
+        index: number;
+    }
+}