typia 4.0.0-dev.20230520 → 4.0.0-dev.20230603

package/src/programmers/helpers/RandomJoiner.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
@@ -12,7 +12,6 @@ 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 = (
@@ -22,24 +21,20 @@ export namespace RandomJoiner {
     ) => 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(
+        (explore: IExplore) =>
+        (length: ts.Expression | undefined) =>
+        (
+            item: Metadata,
+            tags: IMetadataTag[],
+            comments: ICommentTag[],
+        ): ts.Expression => {
+            const generator: ts.Expression = ts.factory.createCallExpression(
                 coalesce("array"),
                 undefined,
                 [
-                    tsc.factory.createArrowFunction(
+                    ts.factory.createArrowFunction(
                         undefined,
                         undefined,
                         [],
@@ -47,27 +42,36 @@ export namespace RandomJoiner {
                         undefined,
                         decoder(item, tags, comments),
                     ),
-                    ...(tail ? [tail] : []),
+                    ...(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 =
-        (tsc: typeof ts) =>
         (decoder: Decoder) =>
         (items: Metadata[], tags: IMetadataTag[], comments: ICommentTag[]) =>
-            tsc.factory.createArrayLiteralExpression(
+            ts.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("{}");
+                return ts.factory.createIdentifier("{}");
 
             // LIST UP PROPERTIES
             const regular = obj.properties.filter((p) => p.key.isSoleLiteral());
@@ -77,13 +81,13 @@ export namespace RandomJoiner {
 
             // REGULAR OBJECT
             const literal: ts.ObjectLiteralExpression =
-                tsc.factory.createObjectLiteralExpression(
+                ts.factory.createObjectLiteralExpression(
                     regular.map((p) => {
                         const str: string = p.key.getSoleLiteral()!;
-                        return tsc.factory.createPropertyAssignment(
+                        return ts.factory.createPropertyAssignment(
                             Escaper.variable(str)
                                 ? str
-                                : tsc.factory.createStringLiteral(str),
+                                : ts.factory.createStringLiteral(str),
                             decoder(
                                 p.value,
                                 p.tags,
@@ -96,32 +100,32 @@ export namespace RandomJoiner {
             if (dynamic.length === 0) return literal;
 
             const properties: ts.Statement[] = dynamic.map((p) =>
-                tsc.factory.createExpressionStatement(
-                    dynamicProperty(tsc)(coalesce)(decoder)(p),
+                ts.factory.createExpressionStatement(
+                    dynamicProperty(coalesce)(decoder)(p),
                 ),
             );
-            return tsc.factory.createBlock(
+            return ts.factory.createBlock(
                 [
-                    StatementFactory.constant(tsc)(
+                    StatementFactory.constant(
                         "output",
-                        tsc.factory.createAsExpression(
+                        ts.factory.createAsExpression(
                             literal,
-                            TypeFactory.keyword(tsc)("any"),
+                            TypeFactory.keyword("any"),
                         ),
                     ),
                     ...(obj.recursive
                         ? [
-                              tsc.factory.createIfStatement(
-                                  tsc.factory.createGreaterThanEquals(
-                                      tsc.factory.createNumericLiteral(5),
-                                      tsc.factory.createIdentifier("_depth"),
+                              ts.factory.createIfStatement(
+                                  ts.factory.createGreaterThanEquals(
+                                      ts.factory.createNumericLiteral(5),
+                                      ts.factory.createIdentifier("_depth"),
                                   ),
-                                  tsc.factory.createBlock(properties, true),
+                                  ts.factory.createBlock(properties, true),
                               ),
                           ]
                         : properties),
-                    tsc.factory.createReturnStatement(
-                        tsc.factory.createIdentifier("output"),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
                     ),
                 ],
                 true,
@@ -129,23 +133,22 @@ export namespace RandomJoiner {
         };
 
     const dynamicProperty =
-        (tsc: typeof ts) =>
         (coalesce: (method: string) => ts.Expression) =>
         (decoder: Decoder) =>
         (p: MetadataProperty) =>
-            tsc.factory.createCallExpression(coalesce("array"), undefined, [
-                tsc.factory.createArrowFunction(
+            ts.factory.createCallExpression(coalesce("array"), undefined, [
+                ts.factory.createArrowFunction(
                     undefined,
                     undefined,
                     [],
                     undefined,
                     undefined,
-                    tsc.factory.createBinaryExpression(
-                        tsc.factory.createElementAccessExpression(
-                            tsc.factory.createIdentifier("output"),
+                    ts.factory.createBinaryExpression(
+                        ts.factory.createElementAccessExpression(
+                            ts.factory.createIdentifier("output"),
                             decoder(p.key, [], []),
                         ),
-                        tsc.factory.createToken(tsc.SyntaxKind.EqualsToken),
+                        ts.factory.createToken(ts.SyntaxKind.EqualsToken),
                         decoder(
                             p.value,
                             p.tags,
@@ -153,13 +156,18 @@ export namespace RandomJoiner {
                         ),
                     ),
                 ),
-                tsc.factory.createCallExpression(
+                ts.factory.createCallExpression(
                     coalesce("integer"),
                     undefined,
                     [
-                        tsc.factory.createNumericLiteral(0),
-                        tsc.factory.createNumericLiteral(3),
+                        ts.factory.createNumericLiteral(0),
+                        ts.factory.createNumericLiteral(3),
                     ],
                 ),
             ]);
 }
+
+interface IExplore {
+    function: boolean;
+    recursive: boolean;
+}

package/src/programmers/helpers/RandomRanger.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
@@ -10,7 +10,6 @@ export namespace RandomRanger {
     }
 
     export const length =
-        (tsc: typeof ts) =>
         (coalesce: (method: string) => ts.Expression) =>
         (defs: IDefaults) =>
         (acc: length.IAccessors) =>
@@ -21,7 +20,7 @@ export namespace RandomRanger {
                 maximum: getter(tags)(acc.maximum),
             };
             if (props.fixed !== undefined)
-                return tsc.factory.createNumericLiteral(props.fixed);
+                return ts.factory.createNumericLiteral(props.fixed);
             else if (props.minimum === undefined && props.maximum === undefined)
                 return undefined;
 
@@ -30,12 +29,12 @@ export namespace RandomRanger {
             if (props.maximum <= props.minimum)
                 (props.maximum as number) += defs.gap;
 
-            return tsc.factory.createCallExpression(
+            return ts.factory.createCallExpression(
                 coalesce("integer"),
                 undefined,
                 [
-                    tsc.factory.createNumericLiteral(props.minimum),
-                    tsc.factory.createNumericLiteral(props.maximum),
+                    ts.factory.createNumericLiteral(props.minimum),
+                    ts.factory.createNumericLiteral(props.maximum),
                 ],
             );
         };
@@ -48,7 +47,6 @@ export namespace RandomRanger {
     }
 
     export const number =
-        (tsc: typeof ts) =>
         (config: number.IConfig) =>
         (defs: IDefaults) =>
         (tags: IMetadataTag[]): ts.Expression => {
@@ -79,9 +77,9 @@ export namespace RandomRanger {
                 const { intercept, minimum, maximum } = stepper(defs.gap)(
                     range,
                 )(range.step);
-                return tsc.factory.createAdd(
+                return ts.factory.createAdd(
                     config.transform(intercept),
-                    tsc.factory.createMultiply(
+                    ts.factory.createMultiply(
                         config.transform(range.step),
                         config.setter([minimum, maximum]),
                     ),
@@ -92,7 +90,7 @@ export namespace RandomRanger {
                 const { minimum, maximum } = multiplier(defs.gap)(range)(
                     range.multiply,
                 );
-                return tsc.factory.createMultiply(
+                return ts.factory.createMultiply(
                     config.transform(range.multiply),
                     config.setter([minimum, maximum]),
                 );

package/src/programmers/helpers/StringifyJoinder.ts

@@ -1,4 +1,4 @@
-import type ts from "typescript/lib/tsclibrary";
+import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { TemplateFactory } from "../../factories/TemplateFactory";
@@ -10,7 +10,6 @@ import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace StringifyJoiner {
     export const object =
-        (tsc: typeof ts) =>
         (importer: FunctionImporter) =>
         (
             _input: ts.Expression,
@@ -18,7 +17,7 @@ export namespace StringifyJoiner {
         ): ts.Expression => {
             // CHECK AND SORT ENTRIES
             if (entries.length === 0)
-                return tsc.factory.createStringLiteral("{}");
+                return ts.factory.createStringLiteral("{}");
 
             // PROPERTIES
             const regular: IExpressionEntry<ts.Expression>[] = entries.filter(
@@ -28,10 +27,10 @@ export namespace StringifyJoiner {
                 (entry) => !entry.key.isSoleLiteral(),
             );
             const expressions: ts.Expression[] = [
-                ...stringify_regular_properties(tsc)(regular, dynamic),
+                ...stringify_regular_properties(regular, dynamic),
                 ...(dynamic.length
                     ? [
-                          stringify_dynamic_properties(tsc)(
+                          stringify_dynamic_properties(
                               dynamic,
                               regular.map((r) => r.key.getSoleLiteral()!),
                           ),
@@ -47,72 +46,68 @@ export namespace StringifyJoiner {
                 (regular.length === 0 && dynamic.length)
                     ? expressions
                     : [
-                          tsc.factory.createCallExpression(
+                          ts.factory.createCallExpression(
                               importer.use("tail"),
                               undefined,
-                              [TemplateFactory.generate(tsc)(expressions)],
+                              [TemplateFactory.generate(expressions)],
                           ),
                       ];
 
             // RETURNS WITH OBJECT BRACKET
-            return TemplateFactory.generate(tsc)([
-                tsc.factory.createStringLiteral(`{`),
+            return TemplateFactory.generate([
+                ts.factory.createStringLiteral(`{`),
                 ...filtered,
-                tsc.factory.createStringLiteral(`}`),
+                ts.factory.createStringLiteral(`}`),
             ]);
         };
 
-    export const array =
-        (tsc: typeof ts) =>
-        (input: ts.Expression, arrow: ts.ArrowFunction): ts.Expression =>
-            TemplateFactory.generate(tsc)([
-                tsc.factory.createStringLiteral(`[`),
-                tsc.factory.createCallExpression(
-                    tsc.factory.createPropertyAccessExpression(
-                        tsc.factory.createCallExpression(
-                            IdentifierFactory.access(tsc)(input)("map"),
-                            undefined,
-                            [arrow],
-                        ),
-                        tsc.factory.createIdentifier("join"),
+    export const array = (
+        input: ts.Expression,
+        arrow: ts.ArrowFunction,
+    ): ts.Expression =>
+        TemplateFactory.generate([
+            ts.factory.createStringLiteral(`[`),
+            ts.factory.createCallExpression(
+                ts.factory.createPropertyAccessExpression(
+                    ts.factory.createCallExpression(
+                        IdentifierFactory.access(input)("map"),
+                        undefined,
+                        [arrow],
                     ),
-                    undefined,
-                    [tsc.factory.createStringLiteral(`,`)],
+                    ts.factory.createIdentifier("join"),
                 ),
-                tsc.factory.createStringLiteral(`]`),
-            ]);
+                undefined,
+                [ts.factory.createStringLiteral(`,`)],
+            ),
+            ts.factory.createStringLiteral(`]`),
+        ]);
 
-    export const tuple =
-        (tsc: typeof ts) =>
-        (
-            children: ts.Expression[],
-            rest: ts.Expression | null,
-        ): ts.Expression => {
-            if (children.length === 0)
-                return tsc.factory.createStringLiteral("[]");
-            if (
-                rest === null &&
-                children.every((child) => tsc.isStringLiteral(child))
-            )
-                return tsc.factory.createStringLiteral(
-                    "[" +
-                        children
-                            .map((child) => (child as ts.StringLiteral).text)
-                            .join(",") +
-                        "]",
-                );
+    export const tuple = (
+        children: ts.Expression[],
+        rest: ts.Expression | null,
+    ): ts.Expression => {
+        if (children.length === 0) return ts.factory.createStringLiteral("[]");
+        if (
+            rest === null &&
+            children.every((child) => ts.isStringLiteral(child))
+        )
+            return ts.factory.createStringLiteral(
+                "[" +
+                    children
+                        .map((child) => (child as ts.StringLiteral).text)
+                        .join(",") +
+                    "]",
+            );
 
-            const elements: ts.Expression[] = [
-                tsc.factory.createStringLiteral(`[`),
-            ];
-            children.forEach((child, i) => {
-                elements.push(child);
-                if (i !== children.length - 1)
-                    elements.push(tsc.factory.createStringLiteral(`,`));
-            });
-            if (rest !== null) elements.push(rest);
+        const elements: ts.Expression[] = [ts.factory.createStringLiteral(`[`)];
+        children.forEach((child, i) => {
+            elements.push(child);
+            if (i !== children.length - 1)
+                elements.push(ts.factory.createStringLiteral(`,`));
+        });
+        if (rest !== null) elements.push(rest);
 
-            elements.push(tsc.factory.createStringLiteral(`]`));
-            return TemplateFactory.generate(tsc)(elements);
-        };
+        elements.push(ts.factory.createStringLiteral(`]`));
+        return TemplateFactory.generate(elements);
+    };
 }