typia 4.0.0-dev.20230527 → 4.0.0-dev.20230604

package/src/programmers/helpers/PruneJoiner.ts

@@ -1,156 +1,144 @@
-import type ts from "typescript/lib/tsclibrary";
-
-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 =
-        (tsc: typeof ts) =>
-        (
-            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) =>
-                    tsc.isBlock(entry.expression)
-                        ? [...entry.expression.statements]
-                        : [
-                              tsc.factory.createExpressionStatement(
-                                  entry.expression,
-                              ),
-                          ],
-                ),
-            );
-            if (dynamic.length)
-                statements.push(
-                    tsc.factory.createExpressionStatement(
-                        iterate_dynamic_properties(tsc)({ regular, dynamic })(
-                            input,
-                        ),
-                    ),
-                );
-
-            statements.push(prune_object_properties(tsc)(obj));
-            return tsc.factory.createBlock(statements, true);
-        };
-
-    export const array =
-        (tsc: typeof ts) => (input: ts.Expression, arrow: ts.ArrowFunction) =>
-            tsc.factory.createCallExpression(
-                IdentifierFactory.access(tsc)(input)("forEach"),
-                undefined,
-                [arrow],
-            );
-
-    export const tuple =
-        (tsc: typeof ts) =>
-        (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) =>
-                    tsc.isBlock(elem)
-                        ? [...elem.statements]
-                        : [tsc.factory.createExpressionStatement(elem)],
-                ),
-            );
-            return tsc.factory.createBlock(statements, true);
-        };
-}
-
-const iterate_dynamic_properties =
-    (tsc: typeof ts) =>
-    (props: { regular: IExpressionEntry[]; dynamic: IExpressionEntry[] }) =>
-    (input: ts.Expression) =>
-        tsc.factory.createCallExpression(
-            IdentifierFactory.access(tsc)(
-                tsc.factory.createCallExpression(
-                    tsc.factory.createIdentifier("Object.entries"),
-                    undefined,
-                    [input],
-                ),
-            )("forEach"),
-            undefined,
-            [
-                tsc.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [
-                        IdentifierFactory.parameter(tsc)(
-                            tsc.factory.createArrayBindingPattern(
-                                ["key", "value"].map((l) =>
-                                    tsc.factory.createBindingElement(
-                                        undefined,
-                                        undefined,
-                                        tsc.factory.createIdentifier(l),
-                                        undefined,
-                                    ),
-                                ),
-                            ),
-                        ),
-                    ],
-                    undefined,
-                    undefined,
-                    tsc.factory.createBlock(
-                        [
-                            tsc.factory.createIfStatement(
-                                tsc.factory.createStrictEquality(
-                                    tsc.factory.createIdentifier("undefined"),
-                                    tsc.factory.createIdentifier("value"),
-                                ),
-                                tsc.factory.createReturnStatement(),
-                            ),
-                            ...props.regular.map(({ key }) =>
-                                tsc.factory.createIfStatement(
-                                    tsc.factory.createStrictEquality(
-                                        tsc.factory.createStringLiteral(
-                                            key.getSoleLiteral()!,
-                                        ),
-                                        tsc.factory.createIdentifier("key"),
-                                    ),
-                                    tsc.factory.createReturnStatement(),
-                                ),
-                            ),
-                            ...props.dynamic.map((dynamic) =>
-                                tsc.factory.createIfStatement(
-                                    tsc.factory.createCallExpression(
-                                        tsc.factory.createIdentifier(
-                                            `RegExp(/${metadata_to_pattern(
-                                                true,
-                                            )(dynamic.key)}/).test`,
-                                        ),
-                                        undefined,
-                                        [tsc.factory.createIdentifier("key")],
-                                    ),
-                                    tsc.isBlock(dynamic.expression)
-                                        ? dynamic.expression
-                                        : tsc.factory.createBlock([
-                                              tsc.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.join(
+                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,
+                    ),
+                ),
+            ],
+        );

package/src/programmers/helpers/RandomJoiner.ts

@@ -1,165 +1,173 @@
-import type ts from "typescript/lib/tsclibrary";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { ICommentTag } from "../../metadata/ICommentTag";
-import { IMetadataTag } from "../../metadata/IMetadataTag";
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataObject } from "../../metadata/MetadataObject";
-import { MetadataProperty } from "../../metadata/MetadataProperty";
-
-import { Escaper } from "../../utils/Escaper";
-
-import { get_comment_tags } from "../internal/get_comment_tags";
-import { RandomRanger } from "./RandomRanger";
-
-export namespace RandomJoiner {
-    export type Decoder = (
-        meta: Metadata,
-        tags: IMetadataTag[],
-        comments: ICommentTag[],
-    ) => ts.Expression;
-
-    export const array =
-        (tsc: typeof ts) =>
-        (coalesce: (method: string) => ts.Expression) =>
-        (decoder: Decoder) =>
-        (item: Metadata, tags: IMetadataTag[], comments: ICommentTag[]) => {
-            const tail = RandomRanger.length(tsc)(coalesce)({
-                minimum: 0,
-                maximum: 3,
-                gap: 3,
-            })({
-                fixed: "items",
-                minimum: "minItems",
-                maximum: "maxItems",
-            })(tags);
-            return tsc.factory.createCallExpression(
-                coalesce("array"),
-                undefined,
-                [
-                    tsc.factory.createArrowFunction(
-                        undefined,
-                        undefined,
-                        [],
-                        undefined,
-                        undefined,
-                        decoder(item, tags, comments),
-                    ),
-                    ...(tail ? [tail] : []),
-                ],
-            );
-        };
-
-    export const tuple =
-        (tsc: typeof ts) =>
-        (decoder: Decoder) =>
-        (items: Metadata[], tags: IMetadataTag[], comments: ICommentTag[]) =>
-            tsc.factory.createArrayLiteralExpression(
-                items.map((i) => decoder(i.rest ?? i, tags, comments)),
-                true,
-            );
-
-    export const object =
-        (tsc: typeof ts) =>
-        (coalesce: (method: string) => ts.Expression) =>
-        (decoder: Decoder) =>
-        (obj: MetadataObject): ts.ConciseBody => {
-            if (obj.properties.length === 0)
-                return tsc.factory.createIdentifier("{}");
-
-            // LIST UP PROPERTIES
-            const regular = obj.properties.filter((p) => p.key.isSoleLiteral());
-            const dynamic = obj.properties.filter(
-                (p) => !p.key.isSoleLiteral(),
-            );
-
-            // REGULAR OBJECT
-            const literal: ts.ObjectLiteralExpression =
-                tsc.factory.createObjectLiteralExpression(
-                    regular.map((p) => {
-                        const str: string = p.key.getSoleLiteral()!;
-                        return tsc.factory.createPropertyAssignment(
-                            Escaper.variable(str)
-                                ? str
-                                : tsc.factory.createStringLiteral(str),
-                            decoder(
-                                p.value,
-                                p.tags,
-                                get_comment_tags(false)(p.jsDocTags),
-                            ),
-                        );
-                    }),
-                    true,
-                );
-            if (dynamic.length === 0) return literal;
-
-            const properties: ts.Statement[] = dynamic.map((p) =>
-                tsc.factory.createExpressionStatement(
-                    dynamicProperty(tsc)(coalesce)(decoder)(p),
-                ),
-            );
-            return tsc.factory.createBlock(
-                [
-                    StatementFactory.constant(tsc)(
-                        "output",
-                        tsc.factory.createAsExpression(
-                            literal,
-                            TypeFactory.keyword(tsc)("any"),
-                        ),
-                    ),
-                    ...(obj.recursive
-                        ? [
-                              tsc.factory.createIfStatement(
-                                  tsc.factory.createGreaterThanEquals(
-                                      tsc.factory.createNumericLiteral(5),
-                                      tsc.factory.createIdentifier("_depth"),
-                                  ),
-                                  tsc.factory.createBlock(properties, true),
-                              ),
-                          ]
-                        : properties),
-                    tsc.factory.createReturnStatement(
-                        tsc.factory.createIdentifier("output"),
-                    ),
-                ],
-                true,
-            );
-        };
-
-    const dynamicProperty =
-        (tsc: typeof ts) =>
-        (coalesce: (method: string) => ts.Expression) =>
-        (decoder: Decoder) =>
-        (p: MetadataProperty) =>
-            tsc.factory.createCallExpression(coalesce("array"), undefined, [
-                tsc.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [],
-                    undefined,
-                    undefined,
-                    tsc.factory.createBinaryExpression(
-                        tsc.factory.createElementAccessExpression(
-                            tsc.factory.createIdentifier("output"),
-                            decoder(p.key, [], []),
-                        ),
-                        tsc.factory.createToken(tsc.SyntaxKind.EqualsToken),
-                        decoder(
-                            p.value,
-                            p.tags,
-                            get_comment_tags(false)(p.jsDocTags),
-                        ),
-                    ),
-                ),
-                tsc.factory.createCallExpression(
-                    coalesce("integer"),
-                    undefined,
-                    [
-                        tsc.factory.createNumericLiteral(0),
-                        tsc.factory.createNumericLiteral(3),
-                    ],
-                ),
-            ]);
-}
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { ICommentTag } from "../../metadata/ICommentTag";
+import { IMetadataTag } from "../../metadata/IMetadataTag";
+import { Metadata } from "../../metadata/Metadata";
+import { MetadataObject } from "../../metadata/MetadataObject";
+import { MetadataProperty } from "../../metadata/MetadataProperty";
+
+import { Escaper } from "../../utils/Escaper";
+
+import { get_comment_tags } from "../internal/get_comment_tags";
+
+export namespace RandomJoiner {
+    export type Decoder = (
+        meta: Metadata,
+        tags: IMetadataTag[],
+        comments: ICommentTag[],
+    ) => ts.Expression;
+
+    export const array =
+        (coalesce: (method: string) => ts.Expression) =>
+        (decoder: Decoder) =>
+        (explore: IExplore) =>
+        (length: ts.Expression | undefined) =>
+        (
+            item: Metadata,
+            tags: IMetadataTag[],
+            comments: ICommentTag[],
+        ): ts.Expression => {
+            const generator: ts.Expression = ts.factory.createCallExpression(
+                coalesce("array"),
+                undefined,
+                [
+                    ts.factory.createArrowFunction(
+                        undefined,
+                        undefined,
+                        [],
+                        undefined,
+                        undefined,
+                        decoder(item, tags, comments),
+                    ),
+                    ...(length ? [length] : []),
+                ],
+            );
+            if (explore.recursive === false) return generator;
+            return ts.factory.createConditionalExpression(
+                ts.factory.createGreaterThanEquals(
+                    ts.factory.createNumericLiteral(5),
+                    ts.factory.createIdentifier("_depth"),
+                ),
+                undefined,
+                generator,
+                undefined,
+                ts.factory.createArrayLiteralExpression([]),
+            );
+        };
+
+    export const tuple =
+        (decoder: Decoder) =>
+        (items: Metadata[], tags: IMetadataTag[], comments: ICommentTag[]) =>
+            ts.factory.createArrayLiteralExpression(
+                items.map((i) => decoder(i.rest ?? i, tags, comments)),
+                true,
+            );
+
+    export const object =
+        (coalesce: (method: string) => ts.Expression) =>
+        (decoder: Decoder) =>
+        (obj: MetadataObject): ts.ConciseBody => {
+            if (obj.properties.length === 0)
+                return ts.factory.createIdentifier("{}");
+
+            // LIST UP PROPERTIES
+            const regular = obj.properties.filter((p) => p.key.isSoleLiteral());
+            const dynamic = obj.properties.filter(
+                (p) => !p.key.isSoleLiteral(),
+            );
+
+            // REGULAR OBJECT
+            const literal: ts.ObjectLiteralExpression =
+                ts.factory.createObjectLiteralExpression(
+                    regular.map((p) => {
+                        const str: string = p.key.getSoleLiteral()!;
+                        return ts.factory.createPropertyAssignment(
+                            Escaper.variable(str)
+                                ? str
+                                : ts.factory.createStringLiteral(str),
+                            decoder(
+                                p.value,
+                                p.tags,
+                                get_comment_tags(false)(p.jsDocTags),
+                            ),
+                        );
+                    }),
+                    true,
+                );
+            if (dynamic.length === 0) return literal;
+
+            const properties: ts.Statement[] = dynamic.map((p) =>
+                ts.factory.createExpressionStatement(
+                    dynamicProperty(coalesce)(decoder)(p),
+                ),
+            );
+            return ts.factory.createBlock(
+                [
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createAsExpression(
+                            literal,
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                    ...(obj.recursive
+                        ? [
+                              ts.factory.createIfStatement(
+                                  ts.factory.createGreaterThanEquals(
+                                      ts.factory.createNumericLiteral(5),
+                                      ts.factory.createIdentifier("_depth"),
+                                  ),
+                                  ts.factory.createBlock(properties, true),
+                              ),
+                          ]
+                        : properties),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ],
+                true,
+            );
+        };
+
+    const dynamicProperty =
+        (coalesce: (method: string) => ts.Expression) =>
+        (decoder: Decoder) =>
+        (p: MetadataProperty) =>
+            ts.factory.createCallExpression(coalesce("array"), undefined, [
+                ts.factory.createArrowFunction(
+                    undefined,
+                    undefined,
+                    [],
+                    undefined,
+                    undefined,
+                    ts.factory.createBinaryExpression(
+                        ts.factory.createElementAccessExpression(
+                            ts.factory.createIdentifier("output"),
+                            decoder(p.key, [], []),
+                        ),
+                        ts.factory.createToken(ts.SyntaxKind.EqualsToken),
+                        decoder(
+                            p.value,
+                            p.tags,
+                            get_comment_tags(false)(p.jsDocTags),
+                        ),
+                    ),
+                ),
+                ts.factory.createCallExpression(
+                    coalesce("integer"),
+                    undefined,
+                    [
+                        ts.factory.createNumericLiteral(0),
+                        ts.factory.createNumericLiteral(3),
+                    ],
+                ),
+            ]);
+}
+
+interface IExplore {
+    function: boolean;
+    recursive: boolean;
+}