typia 3.8.2 → 3.8.3

package/src/programmers/internal/check_union_array_like.ts

@@ -1,271 +1,271 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-
-import { CheckerProgrammer } from "../CheckerProgrammer";
-import { FeatureProgrammer } from "../FeatureProgrammer";
-import { UnionExplorer } from "../helpers/UnionExplorer";
-
-/**
- * @internal
- */
-export const check_union_array_like =
-    <T>(accessor: check_union_array_like.IAccessor<T>) =>
-    (props: check_union_array_like.IProps<T>) =>
-    (
-        input: ts.Expression,
-        targets: T[],
-        explore: FeatureProgrammer.IExplore,
-        tags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
-    ) => {
-        // ONLY ONE TYPE
-        if (targets.length === 1)
-            return props.decoder(
-                accessor.array(input),
-                targets[0]!,
-                explore,
-                tags,
-                jsDocTags,
-            );
-
-        //----
-        // LIST UP VARIABLES
-        //----
-        // TUPLES
-        const tupleListVariable: ts.VariableStatement =
-            StatementFactory.constant(
-                "tupleList",
-                ts.factory.createArrayLiteralExpression(
-                    targets.map((meta) =>
-                        ts.factory.createArrayLiteralExpression([
-                            ts.factory.createArrowFunction(
-                                undefined,
-                                undefined,
-                                [
-                                    IdentifierFactory.parameter(
-                                        "top",
-                                        TypeFactory.keyword("any"),
-                                    ),
-                                ],
-                                undefined,
-                                undefined,
-                                props.checker(
-                                    ts.factory.createIdentifier("top"),
-                                    meta,
-                                    {
-                                        ...explore,
-                                        tracable: false,
-                                        postfix: `"[0]"`,
-                                    },
-                                    tags,
-                                    jsDocTags,
-                                    input,
-                                ),
-                            ),
-                            ts.factory.createArrowFunction(
-                                undefined,
-                                undefined,
-                                [
-                                    IdentifierFactory.parameter(
-                                        "top",
-                                        TypeFactory.keyword("any"),
-                                    ),
-                                ],
-                                undefined,
-                                undefined,
-                                props.decoder(
-                                    ts.factory.createIdentifier("top"),
-                                    meta,
-                                    {
-                                        ...explore,
-                                        tracable: true,
-                                    },
-                                    tags,
-                                    jsDocTags,
-                                ),
-                            ),
-                        ]),
-                    ),
-                ),
-            );
-
-        // FILTERED TUPLES
-        const filteredVariable = StatementFactory.constant(
-            "filtered",
-            ts.factory.createCallExpression(
-                ts.factory.createIdentifier("tupleList.filter"),
-                undefined,
-                [
-                    ts.factory.createArrowFunction(
-                        undefined,
-                        undefined,
-                        [IdentifierFactory.parameter("tuple")],
-                        undefined,
-                        undefined,
-                        ts.factory.createStrictEquality(
-                            props.success,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("tuple[0]"),
-                                undefined,
-                                [ts.factory.createIdentifier("front")],
-                            ),
-                        ),
-                    ),
-                ],
-            ),
-        );
-
-        //----
-        // STATEMENTS
-        //----
-        // ONLY ONE TYPE
-        const uniqueStatement = ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-                ts.factory.createNumericLiteral(1),
-                ts.factory.createIdentifier("filtered.length"),
-            ),
-            ts.factory.createReturnStatement(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(`filtered[0][1]`),
-                    undefined,
-                    [accessor.array(input)],
-                ),
-            ),
-        );
-
-        // UNION TYPE
-        const forOfStatement = ts.factory.createForOfStatement(
-            undefined,
-            ts.factory.createVariableDeclarationList(
-                [ts.factory.createVariableDeclaration("tuple")],
-                ts.NodeFlags.Const,
-            ),
-            // StatementFactory.variable(ts.NodeFlags.Const, "tuple"),
-            ts.factory.createIdentifier("filtered"),
-            ts.factory.createIfStatement(
-                ts.factory.createCallExpression(
-                    IdentifierFactory.access(
-                        ts.factory.createIdentifier("array"),
-                    )("every"),
-                    undefined,
-                    [
-                        ts.factory.createArrowFunction(
-                            undefined,
-                            undefined,
-                            [
-                                IdentifierFactory.parameter(
-                                    "value",
-                                    TypeFactory.keyword("any"),
-                                ),
-                            ],
-                            undefined,
-                            undefined,
-                            ts.factory.createStrictEquality(
-                                props.success,
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("tuple[0]"),
-                                    undefined,
-                                    [ts.factory.createIdentifier("value")],
-                                ),
-                            ),
-                        ),
-                    ],
-                ),
-                ts.factory.createReturnStatement(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier(`tuple[1]`),
-                        undefined,
-                        [ts.factory.createIdentifier("array")],
-                    ),
-                ),
-            ),
-        );
-        const unionStatement = ts.factory.createIfStatement(
-            ts.factory.createLessThan(
-                ts.factory.createNumericLiteral(1),
-                ts.factory.createIdentifier("filtered.length"),
-            ),
-            forOfStatement,
-        );
-
-        const block = [
-            // ARRAY.LENGTH := 0
-            ...(accessor.size !== null
-                ? [
-                      ts.factory.createIfStatement(
-                          ts.factory.createStrictEquality(
-                              ts.factory.createNumericLiteral(0),
-                              accessor.size(input),
-                          ),
-                          ts.isReturnStatement(props.empty)
-                              ? props.empty
-                              : ts.factory.createReturnStatement(props.empty),
-                      ),
-                  ]
-                : []),
-
-            // UNION PREDICATORS
-            tupleListVariable,
-            StatementFactory.constant("front", accessor.front(input)),
-            filteredVariable,
-            uniqueStatement,
-
-            // CONDITIONAL STATEMENTS
-            StatementFactory.constant("array", accessor.array(input)),
-            unionStatement,
-            props.failure(
-                input,
-                `(${targets.map((t) => accessor.name(t)).join(" | ")})`,
-                explore,
-            ),
-        ];
-
-        return ts.factory.createCallExpression(
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [],
-                undefined,
-                undefined,
-                ts.factory.createBlock(block, true),
-            ),
-            undefined,
-            undefined,
-        );
-    };
-
-/**
- * @internal
- */
-export namespace check_union_array_like {
-    export interface IProps<T> {
-        checker(
-            front: ts.Expression,
-            target: T,
-            explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-            jsDocTags: ts.JSDocTagInfo[],
-            array: ts.Expression,
-        ): ts.Expression;
-        decoder: UnionExplorer.Decoder<T>;
-        empty: ts.ReturnStatement | ts.Expression;
-        success: ts.Expression;
-        failure(
-            input: ts.Expression,
-            expected: string,
-            explore: CheckerProgrammer.IExplore,
-        ): ts.Statement;
-    }
-
-    export interface IAccessor<T> {
-        name(target: T): string;
-        front(input: ts.Expression): ts.Expression;
-        array(input: ts.Expression): ts.Expression;
-        size: null | ((input: ts.Expression) => ts.Expression);
-    }
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+
+import { CheckerProgrammer } from "../CheckerProgrammer";
+import { FeatureProgrammer } from "../FeatureProgrammer";
+import { UnionExplorer } from "../helpers/UnionExplorer";
+
+/**
+ * @internal
+ */
+export const check_union_array_like =
+    <T>(accessor: check_union_array_like.IAccessor<T>) =>
+    (props: check_union_array_like.IProps<T>) =>
+    (
+        input: ts.Expression,
+        targets: T[],
+        explore: FeatureProgrammer.IExplore,
+        tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
+    ) => {
+        // ONLY ONE TYPE
+        if (targets.length === 1)
+            return props.decoder(
+                accessor.array(input),
+                targets[0]!,
+                explore,
+                tags,
+                jsDocTags,
+            );
+
+        //----
+        // LIST UP VARIABLES
+        //----
+        // TUPLES
+        const tupleListVariable: ts.VariableStatement =
+            StatementFactory.constant(
+                "tupleList",
+                ts.factory.createArrayLiteralExpression(
+                    targets.map((meta) =>
+                        ts.factory.createArrayLiteralExpression([
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [
+                                    IdentifierFactory.parameter(
+                                        "top",
+                                        TypeFactory.keyword("any"),
+                                    ),
+                                ],
+                                undefined,
+                                undefined,
+                                props.checker(
+                                    ts.factory.createIdentifier("top"),
+                                    meta,
+                                    {
+                                        ...explore,
+                                        tracable: false,
+                                        postfix: `"[0]"`,
+                                    },
+                                    tags,
+                                    jsDocTags,
+                                    input,
+                                ),
+                            ),
+                            ts.factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [
+                                    IdentifierFactory.parameter(
+                                        "top",
+                                        TypeFactory.keyword("any"),
+                                    ),
+                                ],
+                                undefined,
+                                undefined,
+                                props.decoder(
+                                    ts.factory.createIdentifier("top"),
+                                    meta,
+                                    {
+                                        ...explore,
+                                        tracable: true,
+                                    },
+                                    tags,
+                                    jsDocTags,
+                                ),
+                            ),
+                        ]),
+                    ),
+                ),
+            );
+
+        // FILTERED TUPLES
+        const filteredVariable = StatementFactory.constant(
+            "filtered",
+            ts.factory.createCallExpression(
+                ts.factory.createIdentifier("tupleList.filter"),
+                undefined,
+                [
+                    ts.factory.createArrowFunction(
+                        undefined,
+                        undefined,
+                        [IdentifierFactory.parameter("tuple")],
+                        undefined,
+                        undefined,
+                        ts.factory.createStrictEquality(
+                            props.success,
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("tuple[0]"),
+                                undefined,
+                                [ts.factory.createIdentifier("front")],
+                            ),
+                        ),
+                    ),
+                ],
+            ),
+        );
+
+        //----
+        // STATEMENTS
+        //----
+        // ONLY ONE TYPE
+        const uniqueStatement = ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+                ts.factory.createNumericLiteral(1),
+                ts.factory.createIdentifier("filtered.length"),
+            ),
+            ts.factory.createReturnStatement(
+                ts.factory.createCallExpression(
+                    ts.factory.createIdentifier(`filtered[0][1]`),
+                    undefined,
+                    [accessor.array(input)],
+                ),
+            ),
+        );
+
+        // UNION TYPE
+        const forOfStatement = ts.factory.createForOfStatement(
+            undefined,
+            ts.factory.createVariableDeclarationList(
+                [ts.factory.createVariableDeclaration("tuple")],
+                ts.NodeFlags.Const,
+            ),
+            // StatementFactory.variable(ts.NodeFlags.Const, "tuple"),
+            ts.factory.createIdentifier("filtered"),
+            ts.factory.createIfStatement(
+                ts.factory.createCallExpression(
+                    IdentifierFactory.access(
+                        ts.factory.createIdentifier("array"),
+                    )("every"),
+                    undefined,
+                    [
+                        ts.factory.createArrowFunction(
+                            undefined,
+                            undefined,
+                            [
+                                IdentifierFactory.parameter(
+                                    "value",
+                                    TypeFactory.keyword("any"),
+                                ),
+                            ],
+                            undefined,
+                            undefined,
+                            ts.factory.createStrictEquality(
+                                props.success,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("tuple[0]"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("value")],
+                                ),
+                            ),
+                        ),
+                    ],
+                ),
+                ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier(`tuple[1]`),
+                        undefined,
+                        [ts.factory.createIdentifier("array")],
+                    ),
+                ),
+            ),
+        );
+        const unionStatement = ts.factory.createIfStatement(
+            ts.factory.createLessThan(
+                ts.factory.createNumericLiteral(1),
+                ts.factory.createIdentifier("filtered.length"),
+            ),
+            forOfStatement,
+        );
+
+        const block = [
+            // ARRAY.LENGTH := 0
+            ...(accessor.size !== null
+                ? [
+                      ts.factory.createIfStatement(
+                          ts.factory.createStrictEquality(
+                              ts.factory.createNumericLiteral(0),
+                              accessor.size(input),
+                          ),
+                          ts.isReturnStatement(props.empty)
+                              ? props.empty
+                              : ts.factory.createReturnStatement(props.empty),
+                      ),
+                  ]
+                : []),
+
+            // UNION PREDICATORS
+            tupleListVariable,
+            StatementFactory.constant("front", accessor.front(input)),
+            filteredVariable,
+            uniqueStatement,
+
+            // CONDITIONAL STATEMENTS
+            StatementFactory.constant("array", accessor.array(input)),
+            unionStatement,
+            props.failure(
+                input,
+                `(${targets.map((t) => accessor.name(t)).join(" | ")})`,
+                explore,
+            ),
+        ];
+
+        return ts.factory.createCallExpression(
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [],
+                undefined,
+                undefined,
+                ts.factory.createBlock(block, true),
+            ),
+            undefined,
+            undefined,
+        );
+    };
+
+/**
+ * @internal
+ */
+export namespace check_union_array_like {
+    export interface IProps<T> {
+        checker(
+            front: ts.Expression,
+            target: T,
+            explore: FeatureProgrammer.IExplore,
+            tags: IMetadataTag[],
+            jsDocTags: ts.JSDocTagInfo[],
+            array: ts.Expression,
+        ): ts.Expression;
+        decoder: UnionExplorer.Decoder<T>;
+        empty: ts.ReturnStatement | ts.Expression;
+        success: ts.Expression;
+        failure(
+            input: ts.Expression,
+            expected: string,
+            explore: CheckerProgrammer.IExplore,
+        ): ts.Statement;
+    }
+
+    export interface IAccessor<T> {
+        name(target: T): string;
+        front(input: ts.Expression): ts.Expression;
+        array(input: ts.Expression): ts.Expression;
+        size: null | ((input: ts.Expression) => ts.Expression);
+    }
+}

package/src/programmers/internal/check_union_tuple.ts

@@ -1,33 +1,33 @@
-import ts from "typescript";
-
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-import { Metadata } from "../../metadata/Metadata";
-
-import { IProject } from "../../transformers/IProject";
-
-import { CheckerProgrammer } from "../CheckerProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-
-/**
- * @internal
- * @todo Faster union checking logic is required
- */
-export const check_union_tuple =
-    (project: IProject) =>
-    (config: CheckerProgrammer.IConfig) =>
-    (importer: FunctionImporter) =>
-    (
-        _front: ts.Expression,
-        elements: Metadata[],
-        explore: CheckerProgrammer.IExplore,
-        tags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
-        array: ts.Expression,
-    ) =>
-        CheckerProgrammer.decode_tuple(project)(config)(importer)(true)(
-            array,
-            elements,
-            explore,
-            tags,
-            jsDocTags,
-        );
+import ts from "typescript";
+
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+
+import { IProject } from "../../transformers/IProject";
+
+import { CheckerProgrammer } from "../CheckerProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+
+/**
+ * @internal
+ * @todo Faster union checking logic is required
+ */
+export const check_union_tuple =
+    (project: IProject) =>
+    (config: CheckerProgrammer.IConfig) =>
+    (importer: FunctionImporter) =>
+    (
+        _front: ts.Expression,
+        elements: Metadata[],
+        explore: CheckerProgrammer.IExplore,
+        tags: IMetadataTag[],
+        jsDocTags: ts.JSDocTagInfo[],
+        array: ts.Expression,
+    ) =>
+        CheckerProgrammer.decode_tuple(project)(config)(importer)(true)(
+            array,
+            elements,
+            explore,
+            tags,
+            jsDocTags,
+        );

package/src/programmers/internal/random_custom.ts

@@ -1,29 +1,29 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { LiteralFactory } from "../../factories/LiteralFactory";
-
-import { ICommentTag } from "../../metadata/ICommentTag";
-
-import { Customizable } from "../../typings/Customizable";
-
-/**
- * @internal
- */
-export const random_custom =
-    (accessor: (name: string) => ts.Expression) =>
-    (type: keyof Customizable) =>
-    (comments: ICommentTag[]) =>
-    (expression: ts.Expression) =>
-        ExpressionFactory.coalesce(
-            ts.factory.createCallChain(
-                ts.factory.createPropertyAccessChain(
-                    accessor("customs"),
-                    ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                    ts.factory.createIdentifier(type),
-                ),
-                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-                undefined,
-                [LiteralFactory.generate(comments)],
-            ),
-        )(expression);
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { LiteralFactory } from "../../factories/LiteralFactory";
+
+import { ICommentTag } from "../../metadata/ICommentTag";
+
+import { Customizable } from "../../typings/Customizable";
+
+/**
+ * @internal
+ */
+export const random_custom =
+    (accessor: (name: string) => ts.Expression) =>
+    (type: keyof Customizable) =>
+    (comments: ICommentTag[]) =>
+    (expression: ts.Expression) =>
+        ExpressionFactory.coalesce(
+            ts.factory.createCallChain(
+                ts.factory.createPropertyAccessChain(
+                    accessor("customs"),
+                    ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                    ts.factory.createIdentifier(type),
+                ),
+                ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+                undefined,
+                [LiteralFactory.generate(comments)],
+            ),
+        )(expression);