typia 4.2.3-dev.20230814 → 4.3.0-dev.20230821

package/src/programmers/helpers/FunctionImporeter.ts

@@ -1,78 +1,78 @@
-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 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): ts.Statement[] {
-        return [
-            ...[...this.used_].map((name) =>
-                StatementFactory.constant(
-                    "$" + name,
-                    IdentifierFactory.access(
-                        ts.factory.createParenthesizedExpression(
-                            ts.factory.createAsExpression(
-                                modulo,
-                                TypeFactory.keyword("any"),
-                            ),
-                        ),
-                    )(name),
-                ),
-            ),
-            ...[...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 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): ts.Statement[] {
+        return [
+            ...[...this.used_].map((name) =>
+                StatementFactory.constant(
+                    "$" + name,
+                    IdentifierFactory.access(
+                        ts.factory.createParenthesizedExpression(
+                            ts.factory.createAsExpression(
+                                modulo,
+                                TypeFactory.keyword("any"),
+                            ),
+                        ),
+                    )(name),
+                ),
+            ),
+            ...[...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/ICheckEntry.ts

@@ -1,12 +1,12 @@
-import ts from "typescript";
-
-export interface ICheckEntry {
-    expression: ts.Expression;
-    tags: ICheckEntry.ITag[];
-}
-export namespace ICheckEntry {
-    export interface ITag {
-        expected: string;
-        expression: ts.Expression;
-    }
-}
+import ts from "typescript";
+
+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 ts from "typescript";
-
-import { Metadata } from "../../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 "../../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;
+}

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,143 +1,143 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { MetadataObject } from "../../metadata/MetadataObject";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-import { metadata_to_pattern } from "../internal/metadata_to_pattern";
-import { prune_object_properties } from "../internal/prune_object_properties";
-import { IExpressionEntry } from "./IExpressionEntry";
-
-export namespace PruneJoiner {
-    export const object = (
-        input: ts.Expression,
-        entries: IExpressionEntry[],
-        obj: MetadataObject,
-    ): ts.ConciseBody => {
-        // PREPARE ASSETS
-        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
-        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
-
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            regular.map((entry) =>
-                ts.isBlock(entry.expression)
-                    ? [...entry.expression.statements]
-                    : [ts.factory.createExpressionStatement(entry.expression)],
-            ),
-        );
-        if (dynamic.length)
-            statements.push(
-                ts.factory.createExpressionStatement(
-                    iterate_dynamic_properties({ regular, dynamic })(input),
-                ),
-            );
-
-        statements.push(prune_object_properties(obj));
-        return ts.factory.createBlock(statements, true);
-    };
-
-    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
-        ts.factory.createCallExpression(
-            IdentifierFactory.access(input)("forEach"),
-            undefined,
-            [arrow],
-        );
-
-    export const tuple = (
-        children: ts.ConciseBody[],
-        rest: ts.ConciseBody | null,
-    ): ts.Block => {
-        const entire: ts.ConciseBody[] = [...children];
-        if (rest !== null) entire.push(rest);
-
-        const statements: ts.Statement[] = ArrayUtil.flat(
-            entire.map((elem) =>
-                ts.isBlock(elem)
-                    ? [...elem.statements]
-                    : [ts.factory.createExpressionStatement(elem)],
-            ),
-        );
-        return ts.factory.createBlock(statements, true);
-    };
-}
-
-const iterate_dynamic_properties =
-    (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
-    (input: ts.Expression) =>
-        ts.factory.createCallExpression(
-            IdentifierFactory.access(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [input],
-                ),
-            )("forEach"),
-            undefined,
-            [
-                ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [
-                        IdentifierFactory.parameter(
-                            ts.factory.createArrayBindingPattern(
-                                ["key", "value"].map((l) =>
-                                    ts.factory.createBindingElement(
-                                        undefined,
-                                        undefined,
-                                        ts.factory.createIdentifier(l),
-                                        undefined,
-                                    ),
-                                ),
-                            ),
-                        ),
-                    ],
-                    undefined,
-                    undefined,
-                    ts.factory.createBlock(
-                        [
-                            ts.factory.createIfStatement(
-                                ts.factory.createStrictEquality(
-                                    ts.factory.createIdentifier("undefined"),
-                                    ts.factory.createIdentifier("value"),
-                                ),
-                                ts.factory.createReturnStatement(),
-                            ),
-                            ...props.regular.map(({ key }) =>
-                                ts.factory.createIfStatement(
-                                    ts.factory.createStrictEquality(
-                                        ts.factory.createStringLiteral(
-                                            key.getSoleLiteral()!,
-                                        ),
-                                        ts.factory.createIdentifier("key"),
-                                    ),
-                                    ts.factory.createReturnStatement(),
-                                ),
-                            ),
-                            ...props.dynamic.map((dynamic) =>
-                                ts.factory.createIfStatement(
-                                    ts.factory.createCallExpression(
-                                        ts.factory.createIdentifier(
-                                            `RegExp(/${metadata_to_pattern(
-                                                true,
-                                            )(dynamic.key)}/).test`,
-                                        ),
-                                        undefined,
-                                        [ts.factory.createIdentifier("key")],
-                                    ),
-                                    ts.isBlock(dynamic.expression)
-                                        ? dynamic.expression
-                                        : ts.factory.createBlock([
-                                              ts.factory.createExpressionStatement(
-                                                  dynamic.expression,
-                                              ),
-                                          ]),
-                                ),
-                            ),
-                        ],
-                        true,
-                    ),
-                ),
-            ],
-        );
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { MetadataObject } from "../../metadata/MetadataObject";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+import { metadata_to_pattern } from "../internal/metadata_to_pattern";
+import { prune_object_properties } from "../internal/prune_object_properties";
+import { IExpressionEntry } from "./IExpressionEntry";
+
+export namespace PruneJoiner {
+    export const object = (
+        input: ts.Expression,
+        entries: IExpressionEntry[],
+        obj: MetadataObject,
+    ): ts.ConciseBody => {
+        // PREPARE ASSETS
+        const regular = entries.filter((entry) => entry.key.isSoleLiteral());
+        const dynamic = entries.filter((entry) => !entry.key.isSoleLiteral());
+
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            regular.map((entry) =>
+                ts.isBlock(entry.expression)
+                    ? [...entry.expression.statements]
+                    : [ts.factory.createExpressionStatement(entry.expression)],
+            ),
+        );
+        if (dynamic.length)
+            statements.push(
+                ts.factory.createExpressionStatement(
+                    iterate_dynamic_properties({ regular, dynamic })(input),
+                ),
+            );
+
+        statements.push(prune_object_properties(obj));
+        return ts.factory.createBlock(statements, true);
+    };
+
+    export const array = (input: ts.Expression, arrow: ts.ArrowFunction) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.access(input)("forEach"),
+            undefined,
+            [arrow],
+        );
+
+    export const tuple = (
+        children: ts.ConciseBody[],
+        rest: ts.ConciseBody | null,
+    ): ts.Block => {
+        const entire: ts.ConciseBody[] = [...children];
+        if (rest !== null) entire.push(rest);
+
+        const statements: ts.Statement[] = ArrayUtil.flat(
+            entire.map((elem) =>
+                ts.isBlock(elem)
+                    ? [...elem.statements]
+                    : [ts.factory.createExpressionStatement(elem)],
+            ),
+        );
+        return ts.factory.createBlock(statements, true);
+    };
+}
+
+const iterate_dynamic_properties =
+    (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
+    (input: ts.Expression) =>
+        ts.factory.createCallExpression(
+            IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier("Object.entries"),
+                    undefined,
+                    [input],
+                ),
+            )("forEach"),
+            undefined,
+            [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [
+                        IdentifierFactory.parameter(
+                            ts.factory.createArrayBindingPattern(
+                                ["key", "value"].map((l) =>
+                                    ts.factory.createBindingElement(
+                                        undefined,
+                                        undefined,
+                                        ts.factory.createIdentifier(l),
+                                        undefined,
+                                    ),
+                                ),
+                            ),
+                        ),
+                    ],
+                    undefined,
+                    undefined,
+                    ts.factory.createBlock(
+                        [
+                            ts.factory.createIfStatement(
+                                ts.factory.createStrictEquality(
+                                    ts.factory.createIdentifier("undefined"),
+                                    ts.factory.createIdentifier("value"),
+                                ),
+                                ts.factory.createReturnStatement(),
+                            ),
+                            ...props.regular.map(({ key }) =>
+                                ts.factory.createIfStatement(
+                                    ts.factory.createStrictEquality(
+                                        ts.factory.createStringLiteral(
+                                            key.getSoleLiteral()!,
+                                        ),
+                                        ts.factory.createIdentifier("key"),
+                                    ),
+                                    ts.factory.createReturnStatement(),
+                                ),
+                            ),
+                            ...props.dynamic.map((dynamic) =>
+                                ts.factory.createIfStatement(
+                                    ts.factory.createCallExpression(
+                                        ts.factory.createIdentifier(
+                                            `RegExp(/${metadata_to_pattern(
+                                                true,
+                                            )(dynamic.key)}/).test`,
+                                        ),
+                                        undefined,
+                                        [ts.factory.createIdentifier("key")],
+                                    ),
+                                    ts.isBlock(dynamic.expression)
+                                        ? dynamic.expression
+                                        : ts.factory.createBlock([
+                                              ts.factory.createExpressionStatement(
+                                                  dynamic.expression,
+                                              ),
+                                          ]),
+                                ),
+                            ),
+                        ],
+                        true,
+                    ),
+                ),
+            ],
+        );