typia 4.0.0-dev.20230520 → 4.0.0-dev.20230527

package/src/programmers/helpers/CloneJoiner.ts

@@ -1,138 +1,138 @@
-import type ts from "typescript/lib/tsclibrary";
-
-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 =
-        (tsc: typeof ts) =>
-        (
-            input: ts.Expression,
-            entries: IExpressionEntry<ts.Expression>[],
-        ): ts.ConciseBody => {
-            if (entries.length === 0) return tsc.factory.createIdentifier("{}");
-
-            const regular = entries.filter((e) => e.key.isSoleLiteral());
-            const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
-            const literal = tsc.factory.createObjectLiteralExpression(
-                regular.map((entry) => {
-                    const str: string = entry.key.getSoleLiteral()!;
-                    return tsc.factory.createPropertyAssignment(
-                        Escaper.variable(str)
-                            ? str
-                            : tsc.factory.createStringLiteral(str),
-                        entry.expression,
-                    );
-                }),
-                true,
-            );
-            if (dynamic.length === 0) return literal;
-
-            const key = tsc.factory.createIdentifier("key");
-            const value = tsc.factory.createIdentifier("value");
-            const output = tsc.factory.createIdentifier("output");
-
-            const statements: ts.Statement[] = dynamic.map((entry) =>
-                tsc.factory.createIfStatement(
-                    tsc.factory.createCallExpression(
-                        tsc.factory.createIdentifier(
-                            `RegExp(/${metadata_to_pattern(true)(
-                                entry.key,
-                            )}/).test`,
-                        ),
-                        undefined,
-                        [key],
-                    ),
-                    tsc.factory.createBlock([
-                        tsc.factory.createExpressionStatement(
-                            tsc.factory.createBinaryExpression(
-                                tsc.factory.createElementAccessExpression(
-                                    output,
-                                    key,
-                                ),
-                                tsc.factory.createToken(
-                                    tsc.SyntaxKind.EqualsToken,
-                                ),
-                                entry.expression,
-                            ),
-                        ),
-                        tsc.factory.createContinueStatement(),
-                    ]),
-                ),
-            );
-
-            return tsc.factory.createBlock([
-                StatementFactory.constant(tsc)(
-                    "output",
-                    tsc.factory.createAsExpression(
-                        literal,
-                        TypeFactory.keyword(tsc)("any"),
-                    ),
-                ),
-                tsc.factory.createForOfStatement(
-                    undefined,
-                    tsc.factory.createVariableDeclarationList(
-                        [
-                            tsc.factory.createVariableDeclaration(
-                                tsc.factory.createArrayBindingPattern([
-                                    tsc.factory.createBindingElement(
-                                        undefined,
-                                        undefined,
-                                        key,
-                                        undefined,
-                                    ),
-                                    tsc.factory.createBindingElement(
-                                        undefined,
-                                        undefined,
-                                        value,
-                                        undefined,
-                                    ),
-                                ]),
-                                undefined,
-                                undefined,
-                                undefined,
-                            ),
-                        ],
-                        tsc.NodeFlags.Const,
-                    ),
-                    tsc.factory.createCallExpression(
-                        tsc.factory.createIdentifier("Object.entries"),
-                        undefined,
-                        [input],
-                    ),
-                    tsc.factory.createBlock(statements),
-                ),
-                tsc.factory.createReturnStatement(output),
-            ]);
-        };
-
-    export const tuple =
-        (tsc: typeof ts) =>
-        (
-            children: ts.Expression[],
-            rest: ts.Expression | null,
-        ): ts.Expression => {
-            return tsc.factory.createAsExpression(
-                tsc.factory.createArrayLiteralExpression(
-                    rest === null
-                        ? children
-                        : [...children, tsc.factory.createSpreadElement(rest)],
-                    true,
-                ),
-                TypeFactory.keyword(tsc)("any"),
-            );
-        };
-
-    export const array =
-        (tsc: typeof ts) => (input: ts.Expression, arrow: ts.Expression) =>
-            tsc.factory.createCallExpression(
-                tsc.factory.createPropertyAccessExpression(input, "map"),
-                undefined,
-                [arrow],
-            );
-}
+import type ts from "typescript/lib/tsclibrary";
+
+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 =
+        (tsc: typeof ts) =>
+        (
+            input: ts.Expression,
+            entries: IExpressionEntry<ts.Expression>[],
+        ): ts.ConciseBody => {
+            if (entries.length === 0) return tsc.factory.createIdentifier("{}");
+
+            const regular = entries.filter((e) => e.key.isSoleLiteral());
+            const dynamic = entries.filter((e) => !e.key.isSoleLiteral());
+            const literal = tsc.factory.createObjectLiteralExpression(
+                regular.map((entry) => {
+                    const str: string = entry.key.getSoleLiteral()!;
+                    return tsc.factory.createPropertyAssignment(
+                        Escaper.variable(str)
+                            ? str
+                            : tsc.factory.createStringLiteral(str),
+                        entry.expression,
+                    );
+                }),
+                true,
+            );
+            if (dynamic.length === 0) return literal;
+
+            const key = tsc.factory.createIdentifier("key");
+            const value = tsc.factory.createIdentifier("value");
+            const output = tsc.factory.createIdentifier("output");
+
+            const statements: ts.Statement[] = dynamic.map((entry) =>
+                tsc.factory.createIfStatement(
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier(
+                            `RegExp(/${metadata_to_pattern(true)(
+                                entry.key,
+                            )}/).test`,
+                        ),
+                        undefined,
+                        [key],
+                    ),
+                    tsc.factory.createBlock([
+                        tsc.factory.createExpressionStatement(
+                            tsc.factory.createBinaryExpression(
+                                tsc.factory.createElementAccessExpression(
+                                    output,
+                                    key,
+                                ),
+                                tsc.factory.createToken(
+                                    tsc.SyntaxKind.EqualsToken,
+                                ),
+                                entry.expression,
+                            ),
+                        ),
+                        tsc.factory.createContinueStatement(),
+                    ]),
+                ),
+            );
+
+            return tsc.factory.createBlock([
+                StatementFactory.constant(tsc)(
+                    "output",
+                    tsc.factory.createAsExpression(
+                        literal,
+                        TypeFactory.keyword(tsc)("any"),
+                    ),
+                ),
+                tsc.factory.createForOfStatement(
+                    undefined,
+                    tsc.factory.createVariableDeclarationList(
+                        [
+                            tsc.factory.createVariableDeclaration(
+                                tsc.factory.createArrayBindingPattern([
+                                    tsc.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        key,
+                                        undefined,
+                                    ),
+                                    tsc.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        value,
+                                        undefined,
+                                    ),
+                                ]),
+                                undefined,
+                                undefined,
+                                undefined,
+                            ),
+                        ],
+                        tsc.NodeFlags.Const,
+                    ),
+                    tsc.factory.createCallExpression(
+                        tsc.factory.createIdentifier("Object.entries"),
+                        undefined,
+                        [input],
+                    ),
+                    tsc.factory.createBlock(statements),
+                ),
+                tsc.factory.createReturnStatement(output),
+            ]);
+        };
+
+    export const tuple =
+        (tsc: typeof ts) =>
+        (
+            children: ts.Expression[],
+            rest: ts.Expression | null,
+        ): ts.Expression => {
+            return tsc.factory.createAsExpression(
+                tsc.factory.createArrayLiteralExpression(
+                    rest === null
+                        ? children
+                        : [...children, tsc.factory.createSpreadElement(rest)],
+                    true,
+                ),
+                TypeFactory.keyword(tsc)("any"),
+            );
+        };
+
+    export const array =
+        (tsc: typeof ts) => (input: ts.Expression, arrow: ts.Expression) =>
+            tsc.factory.createCallExpression(
+                tsc.factory.createPropertyAccessExpression(input, "map"),
+                undefined,
+                [arrow],
+            );
+}

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,56 +1,56 @@
-import type ts from "typescript/lib/tsclibrary";
-
-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 sequence_: number = 0;
-
-    public constructor(private readonly tsc_: typeof ts) {}
-
-    public empty(): boolean {
-        return this.used_.size === 0;
-    }
-
-    public use(name: string): ts.Identifier {
-        this.used_.add(name);
-        return this.tsc_.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): ts.Statement[] {
-        return [...this.used_].map((name) =>
-            StatementFactory.constant(this.tsc_)(
-                "$" + name,
-                IdentifierFactory.access(this.tsc_)(
-                    this.tsc_.factory.createParenthesizedExpression(
-                        this.tsc_.factory.createAsExpression(
-                            modulo,
-                            TypeFactory.keyword(this.tsc_)("any"),
-                        ),
-                    ),
-                )(name),
-            ),
-        );
-    }
-
-    public increment(): number {
-        return ++this.sequence_;
-    }
-
-    public trace(): void {
-        console.log(...this.used_);
-        console.log(...this.local_);
-    }
-}
+import type ts from "typescript/lib/tsclibrary";
+
+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 sequence_: number = 0;
+
+    public constructor(private readonly tsc_: typeof ts) {}
+
+    public empty(): boolean {
+        return this.used_.size === 0;
+    }
+
+    public use(name: string): ts.Identifier {
+        this.used_.add(name);
+        return this.tsc_.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): ts.Statement[] {
+        return [...this.used_].map((name) =>
+            StatementFactory.constant(this.tsc_)(
+                "$" + name,
+                IdentifierFactory.access(this.tsc_)(
+                    this.tsc_.factory.createParenthesizedExpression(
+                        this.tsc_.factory.createAsExpression(
+                            modulo,
+                            TypeFactory.keyword(this.tsc_)("any"),
+                        ),
+                    ),
+                )(name),
+            ),
+        );
+    }
+
+    public increment(): number {
+        return ++this.sequence_;
+    }
+
+    public trace(): void {
+        console.log(...this.used_);
+        console.log(...this.local_);
+    }
+}

package/src/programmers/helpers/ICheckEntry.ts

@@ -1,12 +1,12 @@
-import type ts from "typescript/lib/tsclibrary";
-
-export interface ICheckEntry {
-    expression: ts.Expression;
-    tags: ICheckEntry.ITag[];
-}
-export namespace ICheckEntry {
-    export interface ITag {
-        expected: string;
-        expression: ts.Expression;
-    }
-}
+import type ts from "typescript/lib/tsclibrary";
+
+export interface ICheckEntry {
+    expression: ts.Expression;
+    tags: ICheckEntry.ITag[];
+}
+export namespace ICheckEntry {
+    export interface ITag {
+        expected: string;
+        expression: ts.Expression;
+    }
+}

package/src/programmers/helpers/IExpressionEntry.ts

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

package/src/programmers/helpers/OptionPredicator.ts

@@ -1,15 +1,15 @@
-import { ITransformOptions } from "../../transformers/ITransformOptions";
-
-export namespace OptionPredicator {
-    export const numeric = (options: ITransformOptions): boolean =>
-        finite(options) || options.numeric === true;
-
-    export const functional = (options: ITransformOptions): boolean =>
-        options.functional === true;
-
-    export const finite = (options: ITransformOptions): boolean =>
-        options.finite === true;
-
-    export const undefined = (options: ITransformOptions): boolean =>
-        options.undefined !== false;
-}
+import { ITransformOptions } from "../../transformers/ITransformOptions";
+
+export namespace OptionPredicator {
+    export const numeric = (options: ITransformOptions): boolean =>
+        finite(options) || options.numeric === true;
+
+    export const functional = (options: ITransformOptions): boolean =>
+        options.functional === true;
+
+    export const finite = (options: ITransformOptions): boolean =>
+        options.finite === true;
+
+    export const undefined = (options: ITransformOptions): boolean =>
+        options.undefined !== false;
+}